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

Diff for /texi2mdoc/main.c between version 1.51 and 1.65

version 1.51, 2015/02/27 19:28:55 version 1.65, 2015/03/09 18:54:38
Line 26 
Line 26 
 #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>
   
 #include "extern.h"  #include "extern.h"
Line 43  static void doaccent(struct texi *, enum texicmd, size
Line 42  static void doaccent(struct texi *, enum texicmd, size
 static  void doblock(struct texi *, enum texicmd, size_t *);  static  void doblock(struct texi *, enum texicmd, size_t *);
 static  void dobracket(struct texi *, enum texicmd, size_t *);  static  void dobracket(struct texi *, enum texicmd, size_t *);
 static  void dobye(struct texi *, enum texicmd, size_t *);  static  void dobye(struct texi *, enum texicmd, size_t *);
   static  void docopying(struct texi *, enum texicmd, size_t *);
 static  void dodefindex(struct texi *, enum texicmd, size_t *);  static  void dodefindex(struct texi *, enum texicmd, size_t *);
 static  void dodefn(struct texi *, enum texicmd, size_t *);  static  void dodefn(struct texi *, enum texicmd, size_t *);
 static  void dodisplay(struct texi *, enum texicmd, size_t *);  static  void dodisplay(struct texi *, enum texicmd, size_t *);
Line 55  static void doignbracket(struct texi *, enum texicmd, 
Line 55  static void doignbracket(struct texi *, enum texicmd, 
 static  void doignline(struct texi *, enum texicmd, size_t *);  static  void doignline(struct texi *, enum texicmd, size_t *);
 static  void doinline(struct texi *, enum texicmd, size_t *);  static  void doinline(struct texi *, enum texicmd, size_t *);
 static  void doinclude(struct texi *, enum texicmd, size_t *);  static  void doinclude(struct texi *, enum texicmd, size_t *);
   static  void doinsertcopying(struct texi *, enum texicmd, size_t *);
 static  void doitem(struct texi *, enum texicmd, size_t *);  static  void doitem(struct texi *, enum texicmd, size_t *);
 static  void doitemize(struct texi *, enum texicmd, size_t *);  static  void doitemize(struct texi *, enum texicmd, size_t *);
 static  void dolink(struct texi *, enum texicmd, size_t *);  static  void dolink(struct texi *, enum texicmd, size_t *);
 static  void domacro(struct texi *, enum texicmd, size_t *);  static  void domacro(struct texi *, enum texicmd, size_t *);
 static  void domath(struct texi *, enum texicmd, size_t *);  static  void domath(struct texi *, enum texicmd, size_t *);
   #if 0
   static  void domenu(struct texi *, enum texicmd, size_t *);
   #endif
 static  void domultitable(struct texi *, enum texicmd, size_t *);  static  void domultitable(struct texi *, enum texicmd, size_t *);
   #if 0
   static  void donode(struct texi *, enum texicmd, size_t *);
   #endif
 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 dotop(struct texi *, enum texicmd, size_t *);
Line 95  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 102  static const struct texitok __texitoks[TEXICMD__MAX] =
         { dosymbol, "*", 1 }, /* TEXICMD_ASTERISK */          { dosymbol, "*", 1 }, /* TEXICMD_ASTERISK */
         { dosymbol, "@", 1 }, /* TEXICMD_AT */          { dosymbol, "@", 1 }, /* TEXICMD_AT */
         { doignline, "author", 6 }, /* TEXICMD_AUTHOR */          { doignline, "author", 6 }, /* TEXICMD_AUTHOR */
         { doinline, "b", 1 }, /* TEXICMD_BOLD */          { doinline, "b", 1 }, /* TEXICMD_B */
           { dosymbol, "\\", 1 }, /* TEXICMD_BACKSLASH */
         { dosymbol, "!", 1 }, /* TEXICMD_BANG */          { dosymbol, "!", 1 }, /* TEXICMD_BANG */
         { dosymbol, "bullet", 6 }, /* TEXICMD_BULLET */          { dosymbol, "bullet", 6 }, /* TEXICMD_BULLET */
         { dobye, "bye", 3 }, /* TEXICMD_BYE */          { dobye, "bye", 3 }, /* TEXICMD_BYE */
Line 115  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 123  static const struct texitok __texitoks[TEXICMD__MAX] =
         { doignline, "c", 1 }, /* TEXICMD_COMMENT */          { doignline, "c", 1 }, /* TEXICMD_COMMENT */
         { doignline, "comment", 7 }, /* TEXICMD_COMMENT_LONG */          { doignline, "comment", 7 }, /* TEXICMD_COMMENT_LONG */
         { doignline, "contents", 8 }, /* TEXICMD_CONTENTS */          { doignline, "contents", 8 }, /* TEXICMD_CONTENTS */
         { doignblock, "copying", 7 }, /* TEXICMD_COPYING */          { docopying, "copying", 7 }, /* TEXICMD_COPYING */
         { dosymbol, "copyright", 9 }, /* TEXICMD_COPYRIGHT */          { dosymbol, "copyright", 9 }, /* TEXICMD_COPYRIGHT */
         { dodefindex, "defcodeindex", 12 }, /* TEXICMD_DEFCODEINDEX */          { dodefindex, "defcodeindex", 12 }, /* TEXICMD_DEFCODEINDEX */
         { dodefn, "deffn", 5 }, /* TEXICMD_DEFFN */          { dodefn, "deffn", 5 }, /* TEXICMD_DEFFN */
Line 214  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 222  static const struct texitok __texitoks[TEXICMD__MAX] =
         { dodisplay, "indentblock", 11 }, /* TEXICMD_INDENTBLOCK */          { dodisplay, "indentblock", 11 }, /* TEXICMD_INDENTBLOCK */
         { dolink, "indicateurl", 11 }, /* TEXICMD_INDICATEURL */          { dolink, "indicateurl", 11 }, /* TEXICMD_INDICATEURL */
         { dolink, "inforef", 7 }, /* TEXICMD_INFOREF */          { dolink, "inforef", 7 }, /* TEXICMD_INFOREF */
         { doignline, "insertcopying", 13 }, /* TEXICMD_INSERTCOPYING */          { doinsertcopying, "insertcopying", 13 }, /* TEXICMD_INSERTCOPYING */
         { doitem, "item", 4 }, /* TEXICMD_ITEM */          { doitem, "item", 4 }, /* TEXICMD_ITEM */
         { doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */          { doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */
         { doitem, "itemx", 5 }, /* TEXICMD_ITEMX */          { doitem, "itemx", 5 }, /* TEXICMD_ITEMX */
Line 229  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 237  static const struct texitok __texitoks[TEXICMD__MAX] =
         { domacro, "macro", 5 }, /* TEXICMD_MACRO */          { domacro, "macro", 5 }, /* TEXICMD_MACRO */
         { doaccent, "=", 1 }, /* TEXICMD_MACRON */          { doaccent, "=", 1 }, /* TEXICMD_MACRON */
         { domath, "math", 4 }, /* TEXICMD_MATH */          { domath, "math", 4 }, /* TEXICMD_MATH */
   #if 0
           { domenu, "menu", 4 }, /* TEXICMD_MENU */
   #else
         { doignblock, "menu", 4 }, /* TEXICMD_MENU */          { doignblock, "menu", 4 }, /* TEXICMD_MENU */
   #endif
         { dosymbol, "minus", 5 }, /* TEXICMD_MINUS */          { dosymbol, "minus", 5 }, /* TEXICMD_MINUS */
         { domultitable, "multitable", 10 }, /* TEXICMD_MULTITABLE */          { domultitable, "multitable", 10 }, /* TEXICMD_MULTITABLE */
         { doignline, "need", 4 }, /* TEXICMD_NEED */          { doignline, "need", 4 }, /* TEXICMD_NEED */
         { dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */          { dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */
   #if 0
           { donode, "node", 4 }, /* TEXICMD_NODE */
   #else
         { doignline, "node", 4 }, /* TEXICMD_NODE */          { doignline, "node", 4 }, /* TEXICMD_NODE */
   #endif
         { doignline, "noindent", 8 }, /* TEXICMD_NOINDENT */          { doignline, "noindent", 8 }, /* TEXICMD_NOINDENT */
         { dosymbol, "O", 1 }, /* TEXICMD_O */          { dosymbol, "O", 1 }, /* TEXICMD_O */
         { dosymbol, "OE", 2 }, /* TEXICMD_OE */          { dosymbol, "OE", 2 }, /* TEXICMD_OE */
Line 269  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 285  static const struct texitok __texitoks[TEXICMD__MAX] =
         { doaccent, "ringaccent", 10 }, /* TEXICMD_RINGACCENT */          { doaccent, "ringaccent", 10 }, /* TEXICMD_RINGACCENT */
         { doinline, "samp", 4 }, /* TEXICMD_SAMP */          { doinline, "samp", 4 }, /* TEXICMD_SAMP */
         { doinline, "sansserif", 9 }, /* TEXICMD_SANSSERIF */          { doinline, "sansserif", 9 }, /* TEXICMD_SANSSERIF */
         { dobracket, "sc", 2 }, /* TEXICMD_SC */          { doinline, "sc", 2 }, /* TEXICMD_SC */
         { dosection, "section", 7 }, /* TEXICMD_SECTION */          { dosection, "section", 7 }, /* TEXICMD_SECTION */
         { dovalue, "set", 3 }, /* TEXICMD_SET */          { dovalue, "set", 3 }, /* TEXICMD_SET */
         { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */          { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */
Line 342  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 358  static const struct texitok __texitoks[TEXICMD__MAX] =
   
 const   struct texitok *const texitoks = __texitoks;  const   struct texitok *const texitoks = __texitoks;
   
   /*
    * Texinfo has lots of indexes.
    * You can add new ones in a variety of ways.
    * We maintain an array of all of these index names (usually a few
    * letters) and pass unknown commands through the array list.
    */
 static void  static void
 dodefindex(struct texi *p, enum texicmd cmd, size_t *pos)  dodefindex(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
Line 350  dodefindex(struct texi *p, enum texicmd cmd, size_t *p
Line 372  dodefindex(struct texi *p, enum texicmd cmd, size_t *p
   
         while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                 advance(p, pos);                  advance(p, pos);
   
         start = end = *pos;          start = end = *pos;
         while (end < BUFSZ(p) && ! ismspace(BUF(p)[end]))          while (end < BUFSZ(p) && ! ismspace(BUF(p)[end]))
                 end++;                  end++;
Line 358  dodefindex(struct texi *p, enum texicmd cmd, size_t *p
Line 379  dodefindex(struct texi *p, enum texicmd cmd, size_t *p
         if (start == end) {          if (start == end) {
                 advanceeoln(p, pos, 1);                  advanceeoln(p, pos, 1);
                 return;                  return;
         } else if (NULL == (cp = malloc(end - start + 1)))          }
   
           if (NULL == (cp = malloc(end - start + 1)))
                 texiabort(p, NULL);                  texiabort(p, NULL);
   
         memcpy(cp, &BUF(p)[start], end - start);          memcpy(cp, &BUF(p)[start], end - start);
         cp[end - start] = '\0';          cp[end - start] = '\0';
   
           /* FIXME: use reallocarray(). */
         p->indexs = realloc(p->indexs,          p->indexs = realloc(p->indexs,
                 sizeof(char *) * (p->indexsz + 1));                  sizeof(char *) * (p->indexsz + 1));
   
         if (NULL == p->indexs)          if (NULL == p->indexs)
                 texiabort(p, NULL);                  texiabort(p, NULL);
         p->indexs[p->indexsz++] = cp;          p->indexs[p->indexsz++] = cp;
   
           advanceeoln(p, pos, 1);
 }  }
   
 static void  static void
Line 498  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
Line 522  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
                 abort();                  abort();
         }          }
   
         texivspace(p);          if (NULL == blk)
         if (NULL != blk)                  return;
   
           /*
            * All "block" definitions have their block bodies indented
            * unless they have the "x" form of the command following.
            * E.g.,
            *   @deffn some function
            *   @deffnx another
            *   An explanation.
            *   @end deffn
            * With this loop, we delay opening the indented block until we
            * skipped past conformant macros.
            */
           for (;;) {
                   switch (peekcmd(p, *pos)) {
                   case (TEXICMD_DEFFNX):
                   case (TEXICMD_DEFMACX):
                   case (TEXICMD_DEFTPX):
                   case (TEXICMD_DEFTYPEFNX):
                   case (TEXICMD_DEFTYPEFUNX):
                   case (TEXICMD_DEFTYPEMETHODX):
                   case (TEXICMD_DEFTYPEVARX):
                   case (TEXICMD_DEFTYPEVRX):
                   case (TEXICMD_DEFUNX):
                   case (TEXICMD_DEFVARX):
                   case (TEXICMD_DEFVRX):
                           texivspace(p);
                           parseeoln(p, pos);
                           continue;
                   default:
                           break;
                   }
                   break;
           }
   
           if (TEXICMD_END == peekcmd(p, *pos)) {
                 parseto(p, pos, blk);                  parseto(p, pos, blk);
                   return;
           }
   
           teximacro(p, "Bd -filled -offset indent");
           parseto(p, pos, blk);
           teximacro(p, "Ed");
           p->seenvs = 1;
 }  }
   
 static void  static void
Line 614  doignblock(struct texi *p, enum texicmd cmd, size_t *p
Line 680  doignblock(struct texi *p, enum texicmd cmd, size_t *p
          * Thus, we keep track of scopes for matching "end" blocks.           * Thus, we keep track of scopes for matching "end" blocks.
          */           */
         while (stack > 0 && *pos < BUFSZ(p)) {          while (stack > 0 && *pos < BUFSZ(p)) {
                 if (stack > 10)                  if (stack > 64)
                         abort();                          texierr(p, "run-away nested stack?");
                 endt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, esz);                  endt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, esz);
                 startt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, start, ssz);                  startt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, start, ssz);
                 if (NULL == endt) {                  if (NULL == endt) {
Line 690  doinline(struct texi *p, enum texicmd cmd, size_t *pos
Line 756  doinline(struct texi *p, enum texicmd cmd, size_t *pos
         }          }
   
         if (NULL == macro || p->literal || TEXILIST_TABLE == p->list) {          if (NULL == macro || p->literal || TEXILIST_TABLE == p->list) {
                 parsebracket(p, pos);                  if (TEXICMD_SC == cmd)
                           p->uppercase++;
                   parsebracket(p, pos, 0);
                   if (TEXICMD_SC == cmd)
                           p->uppercase--;
                 return;                  return;
         }          }
   
           /*
            * If we haven't seen any whitespace, then we don't want the
            * subsequent macro to insert any whitespace.
            */
           if (p->outmacro && 0 == p->seenws) {
                   teximacroopen(p, "Ns");
                   teximacroclose(p);
           }
   
         teximacroopen(p, macro);          teximacroopen(p, macro);
         p->seenws = 0;          p->seenws = 0;
         parsebracket(p, pos);          if (TEXICMD_CODE == cmd)
                   p->literal++;
           if (TEXICMD_SC == cmd)
                   p->uppercase++;
           parsebracket(p, pos, 0);
           if (TEXICMD_SC == cmd)
                   p->uppercase--;
           if (TEXICMD_CODE == cmd)
                   p->literal--;
         texipunctuate(p, pos);          texipunctuate(p, pos);
         teximacroclose(p);          teximacroclose(p);
 }  }
Line 740  doverb(struct texi *p, enum texicmd cmd, size_t *pos)
Line 827  doverb(struct texi *p, enum texicmd cmd, size_t *pos)
 }  }
   
 static void  static void
   doinsertcopying(struct texi *p, enum texicmd cmd, size_t *pos)
   {
   
           advanceeoln(p, pos, 0);
           if (NULL == p->copying)
                   return;
           texisplice(p, p->copying, p->copyingsz, *pos);
   }
   
   static void
   docopying(struct texi *p, enum texicmd cmd, size_t *pos)
   {
           const char      *end, *term;
           size_t           endsz, endpos;
   
           /* We retain our starting (but not ending) newlines. */
           end = "\n@end copying\n";
           endsz = strlen(end);
           advanceeoln(p, pos, 0);
           if (*pos == BUFSZ(p)) {
                   texiwarn(p, "unterminated \"%s\"", texitoks[cmd].tok);
                   return;
           }
   
           term = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, endsz);
           if (NULL == term) {
                   texiwarn(p, "unterminated \"%s\"", texitoks[cmd].tok);
                   endpos = BUFSZ(p);
           } else
                   endpos = *pos + (size_t)(term - &BUF(p)[*pos]);
   
           assert(endpos <= BUFSZ(p));
           assert('\n' == BUF(p)[*pos]);
           advance(p, pos);
   
           p->copying = malloc(endpos - *pos + 1);
           p->copyingsz = endpos - *pos;
           memcpy(p->copying, &BUF(p)[*pos], p->copyingsz);
           p->copying[endpos - *pos] = '\0';
   
           while (*pos < endpos)
                   advance(p, pos);
           if (*pos < BUFSZ(p))
                   advanceto(p, pos, endpos + endsz);
   }
   
   static void
 doverbatim(struct texi *p, enum texicmd cmd, size_t *pos)  doverbatim(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
         const char      *end, *term;          const char      *end, *term;
Line 750  doverbatim(struct texi *p, enum texicmd cmd, size_t *p
Line 884  doverbatim(struct texi *p, enum texicmd cmd, size_t *p
         endsz = strlen(end);          endsz = strlen(end);
         advanceeoln(p, pos, 0);          advanceeoln(p, pos, 0);
         if (*pos == BUFSZ(p)) {          if (*pos == BUFSZ(p)) {
                 texiwarn(p, "unexpected end of file");                  texiwarn(p, "unterminated \"%s\"", texitoks[cmd].tok);
                 return;                  return;
         }          }
   
         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 verbatim block");                  texiwarn(p, "unterminated \"%s\"", texitoks[cmd].tok);
                 endpos = BUFSZ(p);                  endpos = BUFSZ(p);
         } else          } else
                 endpos = *pos + (size_t)(term - &BUF(p)[*pos]);                  endpos = *pos + (size_t)(term - &BUF(p)[*pos]);
Line 770  doverbatim(struct texi *p, enum texicmd cmd, size_t *p
Line 904  doverbatim(struct texi *p, enum texicmd cmd, size_t *p
                 advance(p, pos);                  advance(p, pos);
         }          }
         teximacro(p, "Ed");          teximacro(p, "Ed");
           p->seenvs = 1;
         if (*pos < BUFSZ(p))          if (*pos < BUFSZ(p))
                 advanceto(p, pos, endpos + endsz);                  advanceto(p, pos, endpos + endsz);
 }  }
Line 900  static void
Line 1035  static void
 dobracket(struct texi *p, enum texicmd cmd, size_t *pos)  dobracket(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
   
         parsebracket(p, pos);          parsebracket(p, pos, 0);
 }  }
   
 static void  static void
 dodisplay(struct texi *p, enum texicmd cmd, size_t *pos)  dodisplay(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
   
           advanceeoln(p, pos, 1);
   
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_FORMAT):          case (TEXICMD_FORMAT):
         case (TEXICMD_SMALLFORMAT):          case (TEXICMD_SMALLFORMAT):
Line 917  dodisplay(struct texi *p, enum texicmd cmd, size_t *po
Line 1054  dodisplay(struct texi *p, enum texicmd cmd, size_t *po
                 break;                  break;
         }          }
   
         p->seenvs = 1;  
         /* FIXME: ignore and parseeoln. */  
         advanceeoln(p, pos, 1);  
         parseto(p, pos, texitoks[cmd].tok);          parseto(p, pos, texitoks[cmd].tok);
         teximacro(p, "Ed");          teximacro(p, "Ed");
           p->seenvs = 1;
 }  }
   
 static void  static void
 doexample(struct texi *p, enum texicmd cmd, size_t *pos)  doexample(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
   
         teximacro(p, "Bd -literal -offset indent");  
         /* FIXME: ignore and parseeoln. */  
         advanceeoln(p, pos, 1);          advanceeoln(p, pos, 1);
   
           teximacro(p, "Bd -literal -offset indent");
         p->literal++;          p->literal++;
         parseto(p, pos, texitoks[cmd].tok);          parseto(p, pos, texitoks[cmd].tok);
         p->literal--;          p->literal--;
         teximacro(p, "Ed");          teximacro(p, "Ed");
           p->seenvs = 1;
 }  }
   
 static void  static void
Line 948  dobye(struct texi *p, enum texicmd cmd, size_t *pos)
Line 1084  dobye(struct texi *p, enum texicmd cmd, size_t *pos)
 static void  static void
 dotitle(struct texi *p, enum texicmd cmd, size_t *pos)  dotitle(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
         size_t   start, end;          size_t   start;
   
         while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                 advance(p, pos);                  advance(p, pos);
         start = end = *pos;  
         while (end < BUFSZ(p) && '\n' != BUF(p)[end])          /* We want to suck down the entire line, inclusive \n. */
                 end++;          start = *pos;
         advanceeoln(p, pos, 1);          while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {
                   if ('@' == BUF(p)[*pos])
                           advance(p, pos);
                   advance(p, pos);
           }
           if (*pos < BUFSZ(p))
                   advance(p, pos);
   
           /* Copy this into a buffer. */
         free(p->subtitle);          free(p->subtitle);
         p->subtitle = malloc(end - start + 1);          if (NULL == (p->subtitle = malloc(*pos - start + 1)))
         if (NULL == p->subtitle)  
                 texiabort(p, NULL);                  texiabort(p, NULL);
         memcpy(p->subtitle, &BUF(p)[start], end - start);          memcpy(p->subtitle, &BUF(p)[start], *pos - start);
         p->subtitle[end - start] = '\0';          p->subtitle[*pos - start] = '\0';
 }  }
   
 static void  static void
Line 1154  dosymbol(struct texi *p, enum texicmd cmd, size_t *pos
Line 1297  dosymbol(struct texi *p, enum texicmd cmd, size_t *pos
         case (TEXICMD_AT):          case (TEXICMD_AT):
                 texiputchar(p, '@');                  texiputchar(p, '@');
                 break;                  break;
           case (TEXICMD_BACKSLASH):
                   texiputchar(p, '\\');
                   break;
         case (TEXICMD_BANG):          case (TEXICMD_BANG):
                 texiputchar(p, '!');                  texiputchar(p, '!');
                 break;                  break;
Line 1325  doquotation(struct texi *p, enum texicmd cmd, size_t *
Line 1471  doquotation(struct texi *p, enum texicmd cmd, size_t *
         teximacro(p, "Qc");          teximacro(p, "Qc");
 }  }
   
   #if 0
 static void  static void
 domath(struct texi *p, enum texicmd cmd, size_t *pos)  donode(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
         size_t   nest, start;  
   
         /*          teximacroopen(p, "Ix");
          * Math handling is different from everything else.          texiputchars(p, "Node");
          * We don't allow any subcomponents, and we ignore the rules in          while (*pos < BUFSZ(p) && isspace(BUF(p)[*pos]))
          * terms of @-commands.  
          * This departs from GNU's rules, but whatever.  
          */  
         while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))  
                 advance(p, pos);                  advance(p, pos);
         if (*pos == BUFSZ(p) || '{' != BUF(p)[*pos])          while (*pos < BUFSZ(p)) {
                 return;                  if (BUF(p)[*pos] == ',')
         advance(p, pos);                          break;
         if (p->seenws && p->outcol && 0 == p->literal)                  else if (BUF(p)[*pos] == '\n')
                 texiputchar(p, ' ');                          break;
         p->seenws = 0;                  texiputchar(p, BUF(p)[*pos]);
         for (nest = 1, start = *pos; *pos < BUFSZ(p) && nest > 0; ) {  
                 if ('{' == BUF(p)[*pos])  
                         nest++;  
                 else if ('}' == BUF(p)[*pos])  
                         if (0 == --nest)  
                                 continue;  
                 advance(p, pos);                  advance(p, pos);
         }          }
         if (*pos == BUFSZ(p))  
           teximacroclose(p);
           advanceeoln(p, pos, 1);
   }
   
   static void
   domenu(struct texi *p, enum texicmd cmd, size_t *pos)
   {
           size_t   start, sv;
   
           if (NULL != p->chapters) {
                   doignblock(p, cmd, pos);
                 return;                  return;
         assert('}' == BUF(p)[*pos]);          }
         texiputbuf(p, start, *pos);  
         advance(p, pos);          advanceeoln(p, pos, 1);
   
           texivspace(p);
           teximacro(p, "Bl -tag -width Ds -compact");
           while (*pos < BUFSZ(p)) {
                   /* Read to next menu item. */
                   while (*pos < BUFSZ(p) && ismspace(BUF(p)[*pos]))
                           advance(p, pos);
                   if ('*' != BUF(p)[*pos])
                           break;
   
                   assert('*' == BUF(p)[*pos]);
                   advance(p, pos);
                   while (*pos < BUFSZ(p) && ismspace(BUF(p)[*pos]))
                           advance(p, pos);
                   sv = start = *pos;
                   while (*pos < BUFSZ(p) && ':' != BUF(p)[*pos])
                           advance(p, pos);
                   if (*pos == BUFSZ(p) || *pos == start) {
                           texiwarn(p, "empty menu name");
                           break;
                   }
                   teximacroopen(p, "It");
                   teximacroopen(p, "Lkx");
                   texiputchar(p, '"');
                   texiputchars(p, "Node");
                   for (start = sv; start < *pos; start++)
                           texiputchar(p, BUF(p)[start]);
                   texiputchars(p, "\" \"");
                   for (start = sv; start < *pos; start++)
                           texiputchar(p, BUF(p)[start]);
                   texiputchar(p, '"');
                   teximacroclose(p);
                   teximacroclose(p);
   
                   advance(p, pos);
                   if (*pos == BUFSZ(p)) {
                           texiwarn(p, "bad menu syntax");
                           break;
                   } else if (':' != BUF(p)[*pos]) {
                           while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                                   advance(p, pos);
                           start = *pos;
                           while (*pos < BUFSZ(p)) {
                                   switch (BUF(p)[*pos]) {
                                   case ('\t'):
                                   case ('\n'):
                                   case (','):
                                           break;
                                   case ('.'):
                                           if (*pos + 1 == BUFSZ(p)) {
                                                   advance(p, pos);
                                                   continue;
                                           }
                                           if (' ' == BUF(p)[*pos + 1]) {
                                                   advance(p, pos);
                                                   break;
                                           }
                                           /* FALLTHROUGH */
                                   default:
                                           advance(p, pos);
                                           continue;
                                   }
                                   advance(p, pos);
                                   break;
                           }
                   } else
                           advance(p, pos);
   
                   while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                           advance(p, pos);
   
                   if (*pos == BUFSZ(p)) {
                           texiwarn(p, "bad menu syntax");
                           break;
                   }
   
                   while (*pos < BUFSZ(p)) {
                           if ('*' == BUF(p)[*pos])
                                   break;
                           if ('\n' != BUF(p)[*pos]) {
                                   texiputchar(p, BUF(p)[*pos]);
                                   advance(p, pos);
                                   continue;
                           }
                           advance(p, pos);
                           while (*pos == BUFSZ(p)) {
                                   texiwarn(p, "bad menu syntax");
                                   break;
                           }
                           if ('\n' == BUF(p)[*pos]) {
                                   advance(p, pos);
                                   break;
                           } else if ('*' == BUF(p)[*pos]) {
                                   continue;
                           } else if ('@' == BUF(p)[*pos])
                                   break;
                           texiputchar(p, ' ');
                   }
           }
   
           teximacro(p, "El");
   
           doignblock(p, cmd, pos);
 }  }
   #endif
   
 static void  static void
   domath(struct texi *p, enum texicmd cmd, size_t *pos)
   {
   
           parsebracket(p, pos, 1);
   }
   
   static void
 dovalue(struct texi *p, enum texicmd cmd, size_t *pos)  dovalue(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
         size_t           start, end;          size_t           start, end;
Line 1402  dovalue(struct texi *p, enum texicmd cmd, size_t *pos)
Line 1660  dovalue(struct texi *p, enum texicmd cmd, size_t *pos)
                         texiputchar(p, ' ');                          texiputchar(p, ' ');
                 p->seenws = 0;                  p->seenws = 0;
                 if (NULL != (cp = valueblookup(p, pos)))                  if (NULL != (cp = valueblookup(p, pos)))
                         texisplice(p, cp, strlen(cp), pos);                          texisplice(p, cp, strlen(cp), *pos);
                 else                  else
                         texiputchars(p, "{No value}");                          texiputchars(p, "{No value}");
         } else if (TEXICMD_IFCLEAR == cmd) {          } else if (TEXICMD_IFCLEAR == cmd) {
Line 1544  dosection(struct texi *p, enum texicmd cmd, size_t *po
Line 1802  dosection(struct texi *p, enum texicmd cmd, size_t *po
         int              sec;          int              sec;
   
         switch (cmd) {          switch (cmd) {
           case (TEXICMD_TOP):
                   sec = 0;
                   break;
         case (TEXICMD_APPENDIX):          case (TEXICMD_APPENDIX):
         case (TEXICMD_CHAPTER):          case (TEXICMD_CHAPTER):
         case (TEXICMD_TOP):  
         case (TEXICMD_UNNUMBERED):          case (TEXICMD_UNNUMBERED):
                 sec = sectioner(p, 0);                  sec = sectioner(p, 0);
                 break;                  break;
Line 1565  dosection(struct texi *p, enum texicmd cmd, size_t *po
Line 1825  dosection(struct texi *p, enum texicmd cmd, size_t *po
         else if (p->literal)          else if (p->literal)
                 texierr(p, "\"%s\" in a literal scope!?", sects[sec]);                  texierr(p, "\"%s\" in a literal scope!?", sects[sec]);
   
           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);
         p->seenvs = 1;  
 }  }
   
 static void  static void
 dosp(struct texi *p, enum texicmd cmd, size_t *pos)  
 {  
   
         if (p->literal)  
                 texiputchar(p, '\n');  
         else  
                 texivspace(p);  
         /* FIXME: ignore and parseeoln. */  
         advanceeoln(p, pos, 1);  
 }  
   
 static void  
 dotop(struct texi *p, enum texicmd cmd, size_t *pos)  dotop(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
         const char      *cp;  
         time_t           t;  
         char             date[32];  
   
         if (--p->ign)          if (--p->ign)
                 texierr(p, "@top command while ignoring");                  texierr(p, "@top command while ignoring");
   
         /*          if (NULL == p->chapters)
          * Here we print our standard mdoc(7) prologue.                  teximdocopen(p, pos);
          * We use the title set with @settitle for the `Nd' description          dosection(p, cmd, pos);
          * and the source document filename (the first one as invoked on  }
          * the command line) for the title.  
          * The date is set to the current date.  
          */  
         t = time(NULL);  
         strftime(date, sizeof(date), "%F", localtime(&t));  
   
         teximacroopen(p, "Dd");  static void
         texiputchars(p, date);  dosp(struct texi *p, enum texicmd cmd, size_t *pos)
         teximacroclose(p);  {
         teximacroopen(p, "Dt");  
         for (cp = p->title; '\0' != *cp; cp++)          advanceeoln(p, pos, 1);
                 texiputchar(p, toupper((unsigned int)*cp));          if (p->literal)
         texiputchars(p, " 7");                  texiputchar(p, '\n');
         teximacroclose(p);  
         teximacro(p, "Os");  
         teximacro(p, "Sh NAME");  
         teximacroopen(p, "Nm");  
         for (cp = p->title; '\0' != *cp; cp++)  
                 texiputchar(p, *cp);  
         teximacroclose(p);  
         teximacroopen(p, "Nd");  
         if (NULL != p->subtitle)  
                 for (cp = p->subtitle; '\0' != *cp; cp++)  
                         texiputchar(p, *cp);  
         else          else
                 texiputchars(p, "Unknown description");                  texivspace(p);
         teximacroclose(p);  
         p->seenvs = 1;  
         dosection(p, cmd, pos);  
 }  }
   
 static void  static void
Line 1634  doitem(struct texi *p, enum texicmd cmd, size_t *pos)
Line 1864  doitem(struct texi *p, enum texicmd cmd, size_t *pos)
   
         /* Multitable is using raw tbl(7). */          /* Multitable is using raw tbl(7). */
         if (TEXILIST_TABLE == p->list) {          if (TEXILIST_TABLE == p->list) {
                 texiputchar(p, '\n');                  if (p->outcol > 0)
                           texiputchar(p, '\n');
                 return;                  return;
         }          }
   
Line 1656  doitem(struct texi *p, enum texicmd cmd, size_t *pos)
Line 1887  doitem(struct texi *p, enum texicmd cmd, size_t *pos)
         }          }
   
         /* Trick so we don't start with Pp. */          /* Trick so we don't start with Pp. */
         p->seenvs = 1;  
         parseeoln(p, pos);          parseeoln(p, pos);
   
         if (TEXILIST_ITEM == p->list)          if (TEXILIST_ITEM == p->list)
Line 1670  dotab(struct texi *p, enum texicmd cmd, size_t *pos)
Line 1900  dotab(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
   
         /* This command is only useful in @multitable. */          /* This command is only useful in @multitable. */
         if (TEXILIST_TABLE == p->list)          if (TEXILIST_TABLE == p->list && p->outcol)
                 texiputchar(p, '\t');                  texiputchar(p, '\t');
 }  }
   
Line 1682  domultitable(struct texi *p, enum texicmd cmd, size_t 
Line 1912  domultitable(struct texi *p, enum texicmd cmd, size_t 
         enum texicmd    type;          enum texicmd    type;
         size_t          i, end, columns;          size_t          i, end, columns;
   
           texivspace(p);
         p->list = TEXILIST_TABLE;          p->list = TEXILIST_TABLE;
         /*          /*
          * TS/TE blocks aren't "in mdoc(7)", so we can disregard the           * TS/TE blocks aren't "in mdoc(7)", so we can disregard the
Line 1697  domultitable(struct texi *p, enum texicmd cmd, size_t 
Line 1928  domultitable(struct texi *p, enum texicmd cmd, size_t 
   
         /* Make sure we don't print anything when scanning. */          /* Make sure we don't print anything when scanning. */
         p->ign++;          p->ign++;
         if ('@' == BUF(p)[*pos]) {          if (*pos < BUFSZ(p) && '@' == BUF(p)[*pos]) {
                 /*                  /*
                  * Look for @columnfractions.                   * Look for @columnfractions.
                  * We ignore these, but we do use the number of                   * We ignore these, but we do use the number of
Line 1735  domultitable(struct texi *p, enum texicmd cmd, size_t 
Line 1966  domultitable(struct texi *p, enum texicmd cmd, size_t 
                         texiputchar(p, ' ');                          texiputchar(p, ' ');
                 texiputchar(p, 'l');                  texiputchar(p, 'l');
         }          }
         texiputchars(p, ".\n");  
           texiputchar(p, '.');
           texiputchar(p, '\n');
         p->outmacro++;          p->outmacro++;
         parseto(p, pos, texitoks[cmd].tok);          parseto(p, pos, texitoks[cmd].tok);
         p->outmacro--;          p->outmacro--;
Line 1749  dotable(struct texi *p, enum texicmd cmd, size_t *pos)
Line 1982  dotable(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
         enum texilist   sv = p->list;          enum texilist   sv = p->list;
   
           advanceeoln(p, pos, 1);
   
         p->list = TEXILIST_ITEM;          p->list = TEXILIST_ITEM;
         teximacro(p, "Bl -tag -width Ds");          teximacro(p, "Bl -tag -width Ds");
         /* FIXME: ignore and parseeoln. */  
         advanceeoln(p, pos, 1);  
         p->seenvs = 1;  
         parseto(p, pos, texitoks[cmd].tok);          parseto(p, pos, texitoks[cmd].tok);
         teximacro(p, "El");          teximacro(p, "El");
           p->seenvs = 1;
         p->list = sv;          p->list = sv;
 }  }
   
Line 1770  doend(struct texi *p, enum texicmd cmd, size_t *pos)
Line 2003  doend(struct texi *p, enum texicmd cmd, size_t *pos)
         while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])          while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])
                 advance(p, pos);                  advance(p, pos);
   
         texiwarn(p, "unexpected \"end\": %.*s", (int)(*pos - start), &BUF(p)[start]);          texiwarn(p, "unexpected \"end\": %.*s",
                   (int)(*pos - start), &BUF(p)[start]);
         advanceeoln(p, pos, 1);          advanceeoln(p, pos, 1);
 }  }
   
Line 1779  doenumerate(struct texi *p, enum texicmd cmd, size_t *
Line 2013  doenumerate(struct texi *p, enum texicmd cmd, size_t *
 {  {
         enum texilist    sv = p->list;          enum texilist    sv = p->list;
   
           advanceeoln(p, pos, 1);
   
         p->list = TEXILIST_NOITEM;          p->list = TEXILIST_NOITEM;
         teximacro(p, "Bl -enum");          teximacro(p, "Bl -enum");
         p->seenvs = 1;          parseto(p, pos, texitoks[cmd].tok);
         /* FIXME: ignore and parseeoln. */  
         advanceeoln(p, pos, 1);  
         parseto(p, pos, "enumerate");  
         teximacro(p, "El");          teximacro(p, "El");
           p->seenvs = 1;
         p->list = sv;          p->list = sv;
 }  }
   
Line 1794  doitemize(struct texi *p, enum texicmd cmd, size_t *po
Line 2028  doitemize(struct texi *p, enum texicmd cmd, size_t *po
 {  {
         enum texilist   sv = p->list;          enum texilist   sv = p->list;
   
           advanceeoln(p, pos, 1);
   
         p->list = TEXILIST_NOITEM;          p->list = TEXILIST_NOITEM;
         teximacro(p, "Bl -bullet");          teximacro(p, "Bl -bullet");
         p->seenvs = 1;          parseto(p, pos, texitoks[cmd].tok);
         /* FIXME: ignore and parseeoln. */  
         advanceeoln(p, pos, 1);  
         parseto(p, pos, "itemize");  
         teximacro(p, "El");          teximacro(p, "El");
           p->seenvs = 1;
         p->list = sv;          p->list = sv;
 }  }
   
Line 1809  doignbracket(struct texi *p, enum texicmd cmd, size_t 
Line 2043  doignbracket(struct texi *p, enum texicmd cmd, size_t 
 {  {
   
         p->ign++;          p->ign++;
         parsebracket(p, pos);          parsebracket(p, pos, 0);
         p->ign--;          p->ign--;
 }  }
   
Line 1817  static void
Line 2051  static void
 doignline(struct texi *p, enum texicmd cmd, size_t *pos)  doignline(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
   
         /* FIXME: ignore and parseeoln. */          advanceeoln(p, pos, 1);
         advanceeoln(p,  pos, 1);  
 }  }
   
 /*  /*
Line 1876  main(int argc, char *argv[])
Line 2109  main(int argc, char *argv[])
   
         memset(&texi, 0, sizeof(struct texi));          memset(&texi, 0, sizeof(struct texi));
         texi.ign = 1;          texi.ign = 1;
           texi.outfile = stdout;
         Idir = NULL;          Idir = NULL;
   
         while (-1 != (c = getopt(argc, argv, "I:")))          while (-1 != (c = getopt(argc, argv, "C:I:")))
                 switch (c) {                  switch (c) {
                   case ('C'):
                           texi.chapters = optarg;
                           break;
                 case ('I'):                  case ('I'):
                         Idir = optarg;                          Idir = optarg;
                         break;                          break;
Line 1913  main(int argc, char *argv[])
Line 2150  main(int argc, char *argv[])
         }          }
   
         texiexit(&texi);          texiexit(&texi);
         return(EXIT_FAILURE);          exit(EXIT_SUCCESS);
 usage:  usage:
         fprintf(stderr, "usage: %s [-Idirs] [file]\n", progname);          fprintf(stderr, "usage: %s [-Cdir] [-Idirs] [file]\n", progname);
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
 }  }
Legend:
Removed from v.1.51  
changed lines
  Added in v.1.65
CVSweb