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

Diff for /texi2mdoc/main.c between version 1.25 and 1.32

version 1.25, 2015/02/20 12:25:25 version 1.32, 2015/02/23 12:28:20
Line 44  static void doaccent(struct texi *, enum texicmd, cons
Line 44  static void doaccent(struct texi *, enum texicmd, cons
 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 *);
 static  void dobye(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dobye(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void dodefindex(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dodefn(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dodefn(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dodisplay(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dodisplay(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doenumerate(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doenumerate(struct texi *, enum texicmd, const char *, size_t, size_t *);
Line 57  static void doinclude(struct texi *, enum texicmd, con
Line 58  static void doinclude(struct texi *, enum texicmd, con
 static  void doitem(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doitem(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doitemize(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doitemize(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dolink(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dolink(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void domacro(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void domath(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void domath(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void domultitable(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void domultitable(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doquotation(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doquotation(struct texi *, enum texicmd, const char *, size_t, size_t *);
Line 107  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 109  static const struct texitok __texitoks[TEXICMD__MAX] =
         { doignline, "contents", 8 }, /* TEXICMD_CONTENTS */          { doignline, "contents", 8 }, /* TEXICMD_CONTENTS */
         { doignblock, "copying", 7 }, /* TEXICMD_COPYING */          { doignblock, "copying", 7 }, /* TEXICMD_COPYING */
         { dosymbol, "copyright", 9 }, /* TEXICMD_COPYRIGHT */          { dosymbol, "copyright", 9 }, /* TEXICMD_COPYRIGHT */
           { dodefindex, "defcodeindex", 12 }, /* TEXICMD_DEFCODEINDEX */
         { dodefn, "deffn", 5 }, /* TEXICMD_DEFFN */          { dodefn, "deffn", 5 }, /* TEXICMD_DEFFN */
         { dodefn, "deffnx", 6 }, /* TEXICMD_DEFFNX */          { dodefn, "deffnx", 6 }, /* TEXICMD_DEFFNX */
           { 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, "deftp", 5 }, /* TEXICMD_DEFTP */          { dodefn, "deftp", 5 }, /* TEXICMD_DEFTP */
Line 132  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 136  static const struct texitok __texitoks[TEXICMD__MAX] =
         { doignline, "dircategory", 11 }, /* TEXICMD_DIRCATEGORY */          { doignline, "dircategory", 11 }, /* TEXICMD_DIRCATEGORY */
         { doignblock, "direntry", 8 }, /* TEXICMD_DIRENTRY */          { doignblock, "direntry", 8 }, /* TEXICMD_DIRENTRY */
         { dodisplay, "display", 7 }, /* TEXICMD_DISPLAY */          { dodisplay, "display", 7 }, /* TEXICMD_DISPLAY */
           { doignbracket, "dmn", 3 }, /* TEXICMD_DMN */
         { dosymbol, "dots", 4 }, /* TEXICMD_DOTS */          { dosymbol, "dots", 4 }, /* TEXICMD_DOTS */
         { dolink, "email", 5 }, /* TEXICMD_EMAIL */          { dolink, "email", 5 }, /* TEXICMD_EMAIL */
         { doinline, "emph", 4 }, /* TEXICMD_EMPH */          { doinline, "emph", 4 }, /* TEXICMD_EMPH */
         { NULL, "end", 3 }, /* TEXICMD_END */          { NULL, "end", 3 }, /* TEXICMD_END */
         { doenumerate, "enumerate", 9 }, /* TEXICMD_ENUMERATE */          { doenumerate, "enumerate", 9 }, /* TEXICMD_ENUMERATE */
         { doinline, "env", 3 }, /* TEXICMD_ENV */          { doinline, "env", 3 }, /* TEXICMD_ENV */
           { dosymbol, "equiv", 5 }, /* TEXICMD_EQUIV */
         { dosymbol, "error", 5 }, /* TEXICMD_ERROR */          { dosymbol, "error", 5 }, /* TEXICMD_ERROR */
         { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */          { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */
         { doignline, "exdent", 6 }, /* TEXICMD_EXDENT */          { doignline, "exdent", 6 }, /* TEXICMD_EXDENT */
Line 145  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 151  static const struct texitok __texitoks[TEXICMD__MAX] =
         { doinline, "file", 4 }, /* TEXICMD_FILE */          { doinline, "file", 4 }, /* TEXICMD_FILE */
         { doignline, "finalout", 8 }, /* TEXICMD_FINALOUT */          { doignline, "finalout", 8 }, /* TEXICMD_FINALOUT */
         { doignline, "findex", 6 }, /* TEXICMD_FINDEX */          { doignline, "findex", 6 }, /* TEXICMD_FINDEX */
           { doignbracket, "footnote", 8 }, /* TEXICMD_FOOTNOTE */
         { dotable, "ftable", 6 }, /* TEXICMD_FTABLE */          { dotable, "ftable", 6 }, /* TEXICMD_FTABLE */
         { dodisplay, "format", 6 }, /* TEXICMD_FORMAT */          { dodisplay, "format", 6 }, /* TEXICMD_FORMAT */
         { doaccent, "`", 1 }, /* TEXICMD_GRAVE */          { doaccent, "`", 1 }, /* TEXICMD_GRAVE */
Line 158  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 165  static const struct texitok __texitoks[TEXICMD__MAX] =
         { dovalue, "ifclear", 7 }, /* TEXICMD_IFCLEAR */          { dovalue, "ifclear", 7 }, /* TEXICMD_IFCLEAR */
         { doignblock, "ifdocbook", 9 }, /* TEXICMD_IFDOCBOOK */          { doignblock, "ifdocbook", 9 }, /* TEXICMD_IFDOCBOOK */
         { doignblock, "ifhtml", 6 }, /* TEXICMD_IFHTML */          { doignblock, "ifhtml", 6 }, /* TEXICMD_IFHTML */
         { doignblock, "ifinfo", 6 }, /* TEXICMD_IFINFO */          { doblock, "ifinfo", 6 }, /* TEXICMD_IFINFO */
         { doblock, "ifnotdocbook", 12 }, /* TEXICMD_IFNOTDOCBOOK */          { doblock, "ifnotdocbook", 12 }, /* TEXICMD_IFNOTDOCBOOK */
         { doblock, "ifnothtml", 9 }, /* TEXICMD_IFNOTHTML */          { doblock, "ifnothtml", 9 }, /* TEXICMD_IFNOTHTML */
         { doblock, "ifnotinfo", 9 }, /* TEXICMD_IFNOTINFO */          { doblock, "ifnotinfo", 9 }, /* TEXICMD_IFNOTINFO */
Line 167  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 174  static const struct texitok __texitoks[TEXICMD__MAX] =
         { doblock, "ifnotxml", 8 }, /* TEXICMD_IFNOTXML */          { doblock, "ifnotxml", 8 }, /* TEXICMD_IFNOTXML */
         { doblock, "ifplaintext", 11 }, /* TEXICMD_IFPLAINTEXT */          { doblock, "ifplaintext", 11 }, /* TEXICMD_IFPLAINTEXT */
         { doignblock, "iftex", 5 }, /* TEXICMD_IFTEX */          { doignblock, "iftex", 5 }, /* TEXICMD_IFTEX */
         { doignblock, "ifset", 5 }, /* TEXICMD_IFSET */          { dovalue, "ifset", 5 }, /* TEXICMD_IFSET */
         { doignblock, "ifxml", 5 }, /* TEXICMD_IFXML */          { doignblock, "ifxml", 5 }, /* TEXICMD_IFXML */
         { doignblock, "ignore", 6 }, /* TEXICMD_IGNORE */          { doignblock, "ignore", 6 }, /* TEXICMD_IGNORE */
         { doignbracket, "image", 5 }, /* TEXICMD_IMAGE */          { doignbracket, "image", 5 }, /* TEXICMD_IMAGE */
         { doinclude, "include", 7 }, /* TEXICMD_INCLUDE */          { doinclude, "include", 7 }, /* TEXICMD_INCLUDE */
         { dodisplay, "indentblock", 11 }, /* TEXICMD_INDENTBLOCK */          { dodisplay, "indentblock", 11 }, /* TEXICMD_INDENTBLOCK */
           { doignline, "", 0 }, /* TEXICMD_USER_INDEX */
         { doignline, "insertcopying", 13 }, /* TEXICMD_INSERTCOPYING */          { doignline, "insertcopying", 13 }, /* TEXICMD_INSERTCOPYING */
         { doitem, "item", 4 }, /* TEXICMD_ITEM */          { doitem, "item", 4 }, /* TEXICMD_ITEM */
         { doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */          { doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */
Line 182  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 190  static const struct texitok __texitoks[TEXICMD__MAX] =
         { doignline, "kindex", 6 }, /* TEXICMD_KINDEX */          { doignline, "kindex", 6 }, /* TEXICMD_KINDEX */
         { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */          { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */
         { dosecoffs, "lowersections", 13 }, /* TEXICMD_LOWERSECTIONS */          { dosecoffs, "lowersections", 13 }, /* TEXICMD_LOWERSECTIONS */
           { domacro, "macro", 5 }, /* TEXICMD_MACRO */
         { domath, "math", 4 }, /* TEXICMD_MATH */          { domath, "math", 4 }, /* TEXICMD_MATH */
         { doignblock, "menu", 4 }, /* TEXICMD_MENU */          { doignblock, "menu", 4 }, /* TEXICMD_MENU */
         { dosymbol, "minus", 5 }, /* TEXICMD_MINUS */          { dosymbol, "minus", 5 }, /* TEXICMD_MINUS */
Line 197  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 206  static const struct texitok __texitoks[TEXICMD__MAX] =
         { doignline, "page", 4 }, /* TEXICMD_PAGE */          { doignline, "page", 4 }, /* TEXICMD_PAGE */
         { doignline, "paragraphindent", 15 }, /* TEXICMD_PARINDENT */          { doignline, "paragraphindent", 15 }, /* TEXICMD_PARINDENT */
         { dosymbol, ".", 1 }, /* TEXICMD_PERIOD */          { dosymbol, ".", 1 }, /* TEXICMD_PERIOD */
           { doignline, "pindex", 6 }, /* TEXICMD_PINDEX */
         { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */          { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */
         { doinline, "r", 1 }, /* TEXICMD_R */          { doinline, "r", 1 }, /* TEXICMD_R */
         { dosecoffs, "raisesections", 13 }, /* TEXICMD_RAISESECTIONS */          { dosecoffs, "raisesections", 13 }, /* TEXICMD_RAISESECTIONS */
         { dobracket, "ref", 3 }, /* TEXICMD_REF */          { dobracket, "ref", 3 }, /* TEXICMD_REF */
           { doignline, "refill", 6 }, /* TEXICMD_REFILL */
         { dosymbol, "result", 6 }, /* TEXICMD_RESULT */          { dosymbol, "result", 6 }, /* TEXICMD_RESULT */
         { doinline, "samp", 4 }, /* TEXICMD_SAMP */          { doinline, "samp", 4 }, /* TEXICMD_SAMP */
         { doinline, "sansserif", 9 }, /* TEXICMD_SANSSERIF */          { doinline, "sansserif", 9 }, /* TEXICMD_SANSSERIF */
Line 224  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 235  static const struct texitok __texitoks[TEXICMD__MAX] =
         { doinline, "strong", 6 }, /* TEXICMD_STRONG */          { doinline, "strong", 6 }, /* TEXICMD_STRONG */
         { dosubsection, "subheading", 10 }, /* TEXICMD_SUBHEADING */          { dosubsection, "subheading", 10 }, /* TEXICMD_SUBHEADING */
         { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */          { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */
           { dosubsubsection, "subsubheading", 13 }, /* TEXICMD_SUBSUBHEADING */
         { dosubsubsection, "subsubsection", 13 }, /* TEXICMD_SUBSUBSECTION */          { dosubsubsection, "subsubsection", 13 }, /* TEXICMD_SUBSUBSECTION */
         { doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */          { doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */
         { doignline, "summarycontents", 15 }, /* TEXICMD_SUMMARYCONTENTS */          { doignline, "summarycontents", 15 }, /* TEXICMD_SUMMARYCONTENTS */
           { doignline, "synindex", 8 }, /* TEXICMD_SYNINDEX */
         { doignline, "syncodeindex", 12 }, /* TEXICMD_SYNCODEINDEX */          { doignline, "syncodeindex", 12 }, /* TEXICMD_SYNCODEINDEX */
         { doinline, "t", 1 }, /* TEXICMD_T */          { doinline, "t", 1 }, /* TEXICMD_T */
         { dotab, "tab", 3 }, /* TEXICMD_TAB */          { dotab, "tab", 3 }, /* TEXICMD_TAB */
Line 262  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 275  static const struct texitok __texitoks[TEXICMD__MAX] =
 const   struct texitok *const texitoks = __texitoks;  const   struct texitok *const texitoks = __texitoks;
   
 static void  static void
   dodefindex(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           size_t   start, end;
           char    *cp;
   
           while (*pos < sz && isws(buf[*pos]))
                   advance(p, buf, pos);
   
           start = end = *pos;
           while (end < sz && ! ismspace(buf[end]))
                   end++;
   
           if (start == end) {
                   advanceeoln(p, buf, sz, pos, 1);
                   return;
           } else if (NULL == (cp = malloc(end - start + 1)))
                   texiabort(p, NULL);
   
           memcpy(cp, &buf[start], end - start);
           cp[end - start] = '\0';
   
           p->indexs = realloc(p->indexs,
                   sizeof(char *) * (p->indexsz + 1));
   
           if (NULL == p->indexs)
                   texiabort(p, NULL);
           p->indexs[p->indexsz++] = cp;
   }
   
   static void
 dodefn(struct texi *p, enum texicmd cmd,  dodefn(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 385  dodefn(struct texi *p, enum texicmd cmd, 
Line 429  dodefn(struct texi *p, enum texicmd cmd, 
 }  }
   
 static void  static void
   domacro(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           size_t            start, end, endtoksz, len;
           struct teximacro  m;
           const char       *endtok, *blk;
   
           memset(&m, 0, sizeof(struct teximacro));
   
           while (*pos < sz && isws(buf[*pos]))
                   advance(p, buf, pos);
   
           for (start = end = *pos; end < sz; end++)
                   if (ismspace(buf[end]) || '{' == buf[end])
                           break;
   
           if (start == end)
                   texierr(p, "zero-length macro name");
   
           advanceto(p, buf, pos, end);
   
           m.key = malloc(end - start + 1);
           if (NULL == m.key)
                   texiabort(p, NULL);
           memcpy(m.key, &buf[start], end - start);
           m.key[end - start] = '\0';
   
           m.args = argparse(p, buf, sz, pos, &m.argsz, 0);
           advanceeoln(p, buf, sz, pos, 0);
   
           start = *pos;
           endtok = "\n@end macro\n";
           endtoksz = strlen(endtok);
           blk = memmem(&buf[start], sz, endtok, endtoksz);
           if (NULL == blk)
                   texierr(p, "unterminated macro body");
           while (&buf[*pos] != blk)
                   advance(p, buf, pos);
           assert('\n' == buf[*pos]);
           advance(p, buf, pos);
           len = blk - &buf[start];
           m.value = malloc(len + 1);
           if (NULL == m.value)
                   texiabort(p, NULL);
           memcpy(m.value, &buf[start], len);
           m.value[len] = '\0';
   
           p->macros = realloc
                   (p->macros,
                   (p->macrosz + 1) *
                   sizeof(struct teximacro));
           if (NULL == p->macros)
                   texiabort(p, NULL);
   
           p->macros[p->macrosz++] = m;
           advanceeoln(p, buf, sz, pos, 1);
   }
   
   static void
 doignblock(struct texi *p, enum texicmd cmd,  doignblock(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
           char             end[32];
         p->ign++;          const char      *term;
         parseto(p, buf, sz, pos, texitoks[cmd].tok);          size_t           endsz, endpos;
         p->ign--;  
           /*
            * We want to completely ignore everything in these blocks, so
            * simply jump to the @end block.
            */
           endsz = snprintf(end, sizeof(end),
                   "\n@end %s\n", texitoks[cmd].tok);
           assert(endsz < sizeof(end));
   
           /*
            * Look up where our end token occurs.
            * Set our end position based on the relative offset of that
            * from our current position, or the EOF if we don't have a
            * proper ending point.
            */
           term = memmem(&buf[*pos], sz, end, endsz);
           endpos = NULL == term ? sz :
                   *pos + term - &buf[*pos];
           assert(endpos <= sz);
           while (*pos < endpos)
                   advance(p, buf, pos);
   
           /* Only do this if we're not already at the end. */
           if (endpos < sz)
                   advanceto(p, buf, pos, endpos + endsz);
 }  }
   
 static void  static void
Line 464  doverb(struct texi *p, enum texicmd cmd, 
Line 591  doverb(struct texi *p, enum texicmd cmd, 
         const char      *end, *term;          const char      *end, *term;
         size_t           endsz, endpos;          size_t           endsz, endpos;
   
           advanceeoln(p, buf, sz, pos, 1);
   
         /* We end at exactly this token. */          /* We end at exactly this token. */
         end = "\n@end verbatim\n";          end = "\n@end verbatim\n";
         endsz = strlen(end);          endsz = strlen(end);
Line 479  doverb(struct texi *p, enum texicmd cmd, 
Line 608  doverb(struct texi *p, enum texicmd cmd, 
   
         teximacro(p, "Bd -literal -offset indent");          teximacro(p, "Bd -literal -offset indent");
         assert(endpos <= sz);          assert(endpos <= sz);
         /* Run to the point inclusive the endpoint newline. */          while (*pos < endpos) {
         while (*pos < endpos + 1) {                  if (buf[*pos] == '\n')
                           p->outcol = 0;
                   else
                           p->outcol++;
                 if (*pos > 0 && '.' == buf[*pos])                  if (*pos > 0 && '.' == buf[*pos])
                         if ('\n' == buf[*pos - 1])                          if ('\n' == buf[*pos - 1])
                                 fputs("\\&", stdout);                                  fputs("\\&", stdout);
Line 490  doverb(struct texi *p, enum texicmd cmd, 
Line 622  doverb(struct texi *p, enum texicmd cmd, 
                 advance(p, buf, pos);                  advance(p, buf, pos);
         }          }
         teximacro(p, "Ed");          teximacro(p, "Ed");
         advanceto(p, buf, pos, *pos + endpos + endsz);          advanceto(p, buf, pos, endpos + endsz);
 }  }
   
 static void  static void
Line 514  doverbinclude(struct texi *p, enum texicmd cmd, 
Line 646  doverbinclude(struct texi *p, enum texicmd cmd, 
                         advance(p, buf, pos);                          advance(p, buf, pos);
                         continue;                          continue;
                 }                  }
                 type = texicmd(p, buf, *pos, sz, &end);                  type = texicmd(p, buf, *pos, sz, &end, NULL);
                 advanceto(p, buf, pos, end);                  advanceto(p, buf, pos, end);
                 if (TEXICMD_VALUE != type)                  if (TEXICMD_VALUE != type)
                         texierr(p, "unknown verbatiminclude command");                          texierr(p, "unknown verbatiminclude command");
Line 573  doinclude(struct texi *p, enum texicmd cmd, 
Line 705  doinclude(struct texi *p, enum texicmd cmd, 
                         advance(p, buf, pos);                          advance(p, buf, pos);
                         continue;                          continue;
                 }                  }
                 type = texicmd(p, buf, *pos, sz, &end);                  type = texicmd(p, buf, *pos, sz, &end, NULL);
                 advanceto(p, buf, pos, end);                  advanceto(p, buf, pos, end);
                 if (TEXICMD_VALUE != type)                  if (TEXICMD_VALUE != type)
                         texierr(p, "unknown include command");                          texierr(p, "unknown include command");
Line 681  dotitle(struct texi *p, enum texicmd cmd, 
Line 813  dotitle(struct texi *p, enum texicmd cmd, 
         start = end = *pos;          start = end = *pos;
         while (end < sz && '\n' != buf[end])          while (end < sz && '\n' != buf[end])
                 end++;                  end++;
           advanceeoln(p, buf, sz, pos, 1);
         free(p->subtitle);          free(p->subtitle);
         p->subtitle = malloc(end - start + 1);          p->subtitle = malloc(end - start + 1);
           if (NULL == p->subtitle)
                   texiabort(p, NULL);
         memcpy(p->subtitle, &buf[start], end - start);          memcpy(p->subtitle, &buf[start], end - start);
         p->subtitle[end - start] = '\0';          p->subtitle[end - start] = '\0';
 }  }
Line 802  dosymbol(struct texi *p, enum texicmd cmd, 
Line 937  dosymbol(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_DOTS):          case (TEXICMD_DOTS):
                 texiputchars(p, "...");                  texiputchars(p, "...");
                 break;                  break;
           case (TEXICMD_EQUIV):
                   texiputchars(p, "\\(==");
                   break;
         case (TEXICMD_ERROR):          case (TEXICMD_ERROR):
                 texiputchars(p, "error\\(->");                  texiputchars(p, "error\\(->");
                 break;                  break;
Line 836  dosymbol(struct texi *p, enum texicmd cmd, 
Line 974  dosymbol(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_HYPHEN):          case (TEXICMD_HYPHEN):
                 break;                  break;
         default:          default:
                 texiwarn(p, "sym: %d", cmd);  
                 abort();                  abort();
         }          }
   
Line 893  static void
Line 1030  static void
 dovalue(struct texi *p, enum texicmd cmd,  dovalue(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         size_t           start, end;          size_t           start, end, i;
         int              clr;  
         char            *key, *val;          char            *key, *val;
         const char      *cp;          const char      *cp;
   
Line 910  dovalue(struct texi *p, enum texicmd cmd, 
Line 1046  dovalue(struct texi *p, enum texicmd cmd, 
                 advanceto(p, buf, pos, end);                  advanceto(p, buf, pos, end);
   
                 key = malloc(end - start + 1);                  key = malloc(end - start + 1);
                 if (NULL == key) {                  if (NULL == key)
                         perror(NULL);                          texiabort(p, NULL);
                         exit(EXIT_FAILURE);  
                 }  
                 memcpy(key, &buf[start], end - start);                  memcpy(key, &buf[start], end - start);
                 key[end - start] = '\0';                  key[end - start] = '\0';
   
Line 926  dovalue(struct texi *p, enum texicmd cmd, 
Line 1060  dovalue(struct texi *p, enum texicmd cmd, 
                 advanceeoln(p, buf, sz, pos, 1);                  advanceeoln(p, buf, sz, pos, 1);
   
                 val = malloc(end - start + 1);                  val = malloc(end - start + 1);
                 if (NULL == val) {                  if (NULL == val)
                         perror(NULL);                          texiabort(p, NULL);
                         exit(EXIT_FAILURE);  
                 }  
                 memcpy(val, &buf[start], end - start);                  memcpy(val, &buf[start], end - start);
                 val[end - start] = '\0';                  val[end - start] = '\0';
                 valueadd(p, key, val);                  valueadd(p, key, val);
Line 937  dovalue(struct texi *p, enum texicmd cmd, 
Line 1069  dovalue(struct texi *p, enum texicmd cmd, 
                 if (p->seenws)                  if (p->seenws)
                         texiputchar(p, ' ');                          texiputchar(p, ' ');
                 p->seenws = 0;                  p->seenws = 0;
                 if (NULL == (cp = valueblookup(p, buf, sz, pos)))                  if (NULL != (cp = valueblookup(p, buf, sz, pos))) {
                           for (i = 0; i < p->valstackpos; i++)
                                   if (cp == p->valstack[i])
                                           break;
                           if (i < p->valstackpos)
                                   texierr(p, "recursive value");
                           if (64 == p->valstackpos)
                                   texierr(p, "too many nested values");
                           p->valstack[p->valstackpos++] = cp;
                           parsemembuf(p, cp, strlen(cp));
                           p->valstackpos--;
                   } else
                         texiputchars(p, "{No value}");                          texiputchars(p, "{No value}");
                 else  
                         texiputchars(p, cp);  
         } else if (TEXICMD_IFCLEAR == cmd) {          } else if (TEXICMD_IFCLEAR == cmd) {
                 clr = NULL != valuellookup(p, buf, sz, pos);                  if (NULL != valuellookup(p, buf, sz, pos))
                 if (clr)                          doignblock(p, cmd, buf, sz, pos);
                         p->ign++;                  else
                 parseto(p, buf, sz, pos, texitoks[cmd].tok);                          parseto(p, buf, sz, pos, texitoks[cmd].tok);
                 if (clr)          } else if (TEXICMD_IFSET == cmd) {
                         p->ign--;                  if (NULL == valuellookup(p, buf, sz, pos))
                           doignblock(p, cmd, buf, sz, pos);
                   else
                           parseto(p, buf, sz, pos, texitoks[cmd].tok);
         } else if (TEXICMD_CLEAR == cmd)          } else if (TEXICMD_CLEAR == cmd)
                 valuelclear(p, buf, sz, pos);                  valuelclear(p, buf, sz, pos);
 }  }
Line 1121  dotop(struct texi *p, enum texicmd cmd, 
Line 1265  dotop(struct texi *p, enum texicmd cmd, 
         time_t           t;          time_t           t;
         char             date[32];          char             date[32];
   
           if (--p->ign)
                   texierr(p, "@top command while ignoring (%d)", p->ign);
   
         /*          /*
          * Here we print our standard mdoc(7) prologue.           * Here we print our standard mdoc(7) prologue.
          * We use the title set with @settitle for the `Nd' description           * We use the title set with @settitle for the `Nd' description
Line 1131  dotop(struct texi *p, enum texicmd cmd, 
Line 1278  dotop(struct texi *p, enum texicmd cmd, 
         t = time(NULL);          t = time(NULL);
         strftime(date, sizeof(date), "%F", localtime(&t));          strftime(date, sizeof(date), "%F", localtime(&t));
   
         p->ign--;  
         teximacroopen(p, "Dd");          teximacroopen(p, "Dd");
         texiputchars(p, date);          texiputchars(p, date);
         teximacroclose(p);          teximacroclose(p);
Line 1206  domultitable(struct texi *p, enum texicmd cmd, 
Line 1352  domultitable(struct texi *p, enum texicmd cmd, 
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         enum texilist   sv = p->list;          enum texilist   sv = p->list;
           int             svliteral = p->literal;
         enum texicmd    type;          enum texicmd    type;
         size_t          i, end, columns;          size_t          i, end, columns;
   
         p->list = TEXILIST_TABLE;          p->list = TEXILIST_TABLE;
           /*
            * TS/TE blocks aren't "in mdoc(7)", so we can disregard the
            * fact that we're in literal mode right now.
            */
           p->literal = 0;
         teximacro(p, "TS");          teximacro(p, "TS");
         columns = 0;          columns = 0;
   
Line 1226  domultitable(struct texi *p, enum texicmd cmd, 
Line 1378  domultitable(struct texi *p, enum texicmd cmd, 
                  * arguments to set the number of columns that we'll                   * arguments to set the number of columns that we'll
                  * have.                   * have.
                  */                   */
                 type = texicmd(p, buf, *pos, sz, &end);                  type = texicmd(p, buf, *pos, sz, &end, NULL);
                 advanceto(p, buf, pos, end);                  advanceto(p, buf, pos, end);
                 if (TEXICMD_COLUMNFRACTIONS != type)                  if (TEXICMD_COLUMNFRACTIONS != type)
                         texierr(p, "unknown multitable command");                          texierr(p, "unknown multitable command");
Line 1262  domultitable(struct texi *p, enum texicmd cmd, 
Line 1414  domultitable(struct texi *p, enum texicmd cmd, 
         parseto(p, buf, sz, pos, texitoks[cmd].tok);          parseto(p, buf, sz, pos, texitoks[cmd].tok);
         p->outmacro--;          p->outmacro--;
         teximacro(p, "TE");          teximacro(p, "TE");
           p->literal = svliteral;
         p->list = sv;          p->list = sv;
 }  }
   
Line 1339  doignline(struct texi *p, enum texicmd cmd, 
Line 1492  doignline(struct texi *p, enum texicmd cmd, 
  * This does NOT sanitise the directories!   * This does NOT sanitise the directories!
  */   */
 static char **  static char **
 parsedirs(const char *base, const char *cp, size_t *sz)  parsedirs(struct texi *p, const char *base, const char *cp, size_t *sz)
 {  {
         char             *tok, *str, *tofree;          char             *tok, *str, *tofree;
         const char       *cpp;          const char       *cpp;
Line 1351  parsedirs(const char *base, const char *cp, size_t *sz
Line 1504  parsedirs(const char *base, const char *cp, size_t *sz
                 for ( ; NULL != (cpp = strchr(cpp, ':')); (*sz)++)                  for ( ; NULL != (cpp = strchr(cpp, ':')); (*sz)++)
                         cpp++;                          cpp++;
   
         dirs = calloc(*sz, sizeof(char *));          if (NULL == (dirs = calloc(*sz, sizeof(char *))))
         if (NULL == dirs) {                  texiabort(p, NULL);
                 perror(NULL);          else if (NULL == (dirs[0] = strdup(base)))
                 exit(EXIT_FAILURE);                  texiabort(p, NULL);
         } else if (NULL == (dirs[0] = strdup(base))) {  
                 perror(NULL);  
                 exit(EXIT_FAILURE);  
         }  
   
         if (NULL == cp)          if (NULL == cp)
                 return(dirs);                  return(dirs);
   
         if (NULL == (tofree = tok = str = strdup(cp))) {          if (NULL == (tofree = tok = str = strdup(cp)))
                 perror(NULL);                  texiabort(p, NULL);
                 exit(EXIT_FAILURE);  
         }  
   
         for (i = 1; NULL != (tok = strsep(&str, ":")); i++)          for (i = 1; NULL != (tok = strsep(&str, ":")); i++)
                 if (NULL == (dirs[i] = strdup(tok))) {                  if (NULL == (dirs[i] = strdup(tok)))
                         perror(NULL);                          texiabort(p, NULL);
                         exit(EXIT_FAILURE);  
                 }  
   
         free(tofree);          free(tofree);
         return(dirs);          return(dirs);
Line 1408  main(int argc, char *argv[])
Line 1553  main(int argc, char *argv[])
         if (0 == (argc -= optind))          if (0 == (argc -= optind))
                 goto usage;                  goto usage;
   
         if (NULL == (path = strdup(argv[0]))) {          if (NULL == (path = strdup(argv[0])))
                 perror(NULL);                  texiabort(&texi, NULL);
                 exit(EXIT_FAILURE);          else if (NULL == (dir = dirname(path)))
         } else if (NULL == (dir = dirname(path))) {                  texiabort(&texi, NULL);
                 perror(argv[0]);  
                 free(path);  
                 exit(EXIT_FAILURE);  
         }  
         free(path);          free(path);
   
         if (NULL != (cp = strrchr(argv[0], '/')))          if (NULL != (cp = strrchr(argv[0], '/')))
Line 1423  main(int argc, char *argv[])
Line 1565  main(int argc, char *argv[])
         else          else
                 texi.title = strdup(argv[0]);                  texi.title = strdup(argv[0]);
   
         if (NULL == texi.title) {          if (NULL == texi.title)
                 perror(NULL);                  texiabort(&texi, NULL);
                 exit(EXIT_FAILURE);          else if (NULL != (path = strchr(texi.title, '.')))
         } else if (NULL != (path = strchr(texi.title, '.')))  
                 *path = '\0';                  *path = '\0';
   
         texi.ign = 1;          texi.ign = 1;
         texi.dirs = parsedirs(dir, Idir, &texi.dirsz);          texi.dirs = parsedirs(&texi, dir, Idir, &texi.dirsz);
         parsefile(&texi, argv[0], 1);          parsefile(&texi, argv[0], 1);
         /* We shouldn't get here. */          /* We shouldn't get here. */
         texiexit(&texi);          texiexit(&texi);

Legend:
Removed from v.1.25  
changed lines
  Added in v.1.32

CVSweb