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

Diff for /texi2mdoc/main.c between version 1.5 and 1.10

version 1.5, 2015/02/18 11:01:56 version 1.10, 2015/02/18 15:30:31
Line 27 
Line 27 
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   #include <time.h>
   #include <unistd.h>
   
 /*  /*
  * This defines each one of the Texinfo commands that we understand.   * This defines each one of the Texinfo commands that we understand.
Line 43  enum texicmd {
Line 45  enum texicmd {
         TEXICMD_AT,          TEXICMD_AT,
         TEXICMD_AUTHOR,          TEXICMD_AUTHOR,
         TEXICMD_BANG,          TEXICMD_BANG,
           TEXICMD_BULLET,
         TEXICMD_BYE,          TEXICMD_BYE,
         TEXICMD_CENTER,          TEXICMD_CENTER,
         TEXICMD_CHAPTER,          TEXICMD_CHAPTER,
Line 98  enum texicmd {
Line 101  enum texicmd {
         TEXICMD_NEWLINE,          TEXICMD_NEWLINE,
         TEXICMD_NODE,          TEXICMD_NODE,
         TEXICMD_NOINDENT,          TEXICMD_NOINDENT,
           TEXICMD_PXREF,
         TEXICMD_QUESTIONMARK,          TEXICMD_QUESTIONMARK,
         TEXICMD_QUOTATION,          TEXICMD_QUOTATION,
         TEXICMD_PAGE,          TEXICMD_PAGE,
Line 105  enum texicmd {
Line 109  enum texicmd {
         TEXICMD_PRINTINDEX,          TEXICMD_PRINTINDEX,
         TEXICMD_REF,          TEXICMD_REF,
         TEXICMD_SAMP,          TEXICMD_SAMP,
           TEXICMD_SC,
         TEXICMD_SECTION,          TEXICMD_SECTION,
         TEXICMD_SET,          TEXICMD_SET,
         TEXICMD_SETCHAPNEWPAGE,          TEXICMD_SETCHAPNEWPAGE,
Line 115  enum texicmd {
Line 120  enum texicmd {
         TEXICMD_SMALLEXAMPLE,          TEXICMD_SMALLEXAMPLE,
         TEXICMD_SQUIGGLE_LEFT,          TEXICMD_SQUIGGLE_LEFT,
         TEXICMD_SQUIGGLE_RIGHT,          TEXICMD_SQUIGGLE_RIGHT,
           TEXICMD_STRONG,
         TEXICMD_SUBSECTION,          TEXICMD_SUBSECTION,
         TEXICMD_SUBTITLE,          TEXICMD_SUBTITLE,
         TEXICMD_TAB,          TEXICMD_TAB,
Line 130  enum texicmd {
Line 136  enum texicmd {
         TEXICMD_UREF,          TEXICMD_UREF,
         TEXICMD_URL,          TEXICMD_URL,
         TEXICMD_VAR,          TEXICMD_VAR,
           TEXICMD_VSKIP,
         TEXICMD_W,          TEXICMD_W,
           TEXICMD_XREF,
         TEXICMD__MAX          TEXICMD__MAX
 };  };
   
Line 179  struct texi {
Line 187  struct texi {
         size_t            outcol; /* column in output line */          size_t            outcol; /* column in output line */
         char            **dirs; /* texi directories */          char            **dirs; /* texi directories */
         size_t            dirsz; /* number of texi directories */          size_t            dirsz; /* number of texi directories */
         enum texilist     list;          enum texilist     list; /* current list (set recursively) */
         int               outmacro; /* whether output is in line macro */          int               outmacro; /* if >0, output is in line macro */
         int               seenws; /* whitespace has been ignored */          int               seenws; /* ws has been seen (and ignored) */
         int               ign; /* don't print anything */          int               ign; /* if >0, don't print anything */
         int               literal;          int               literal; /* if >0, literal context */
           char             *title; /* title of document */
           char             *subtitle; /* subtitle of document */
 };  };
   
 /* FIXME: don't use this crap. */  /* FIXME: FIND A BETTER WAY. */
 #define ismpunct(_x) \  #define ismpunct(_x) \
         ('.' == (_x) || \          ('.' == (_x) || \
          ',' == (_x) || \           ',' == (_x) || \
          ';' == (_x))           ';' == (_x))
   /* Texi disregards spaces and tabs. */
 #define isws(_x) \  #define isws(_x) \
         (' ' == (_x) || '\t' == (_x))          (' ' == (_x) || '\t' == (_x))
   #define ismspace(_x) \
           (isws((_x)) || '\n' == (_x))
   
 static  void doarg1(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 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 *);
Line 208  static void doenumerate(struct texi *, enum texicmd, c
Line 220  static void doenumerate(struct texi *, enum texicmd, c
 static  void doenv(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doenv(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doexample(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doexample(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dofile(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dofile(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void doignargn(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doignblock(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doignblock(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doignbracket(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doignbracket(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doignline(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doignline(struct texi *, enum texicmd, const char *, size_t, size_t *);
Line 215  static void doinclude(struct texi *, enum texicmd, con
Line 228  static void doinclude(struct texi *, enum texicmd, con
 static  void doitalic(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doitalic(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 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 doliteral(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doliteral(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 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 224  static void dosection(struct texi *, enum texicmd, con
Line 238  static void dosection(struct texi *, enum texicmd, con
 static  void dosp(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosp(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dosubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dosymbol(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosymbol(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void dotitle(struct texi *, enum texicmd, const char *, size_t, size_t *);
   
 static  const struct texitok texitoks[TEXICMD__MAX] = {  static  const struct texitok texitoks[TEXICMD__MAX] = {
         { doarg1, "acronym", 7 }, /* TEXICMD_ACRONYM */          { doignargn, "acronym", 7 }, /* TEXICMD_ACRONYM */
         { doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */          { doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */
         { doignbracket, "anchor", 6 }, /* TEXICMD_ANCHOR */          { doignbracket, "anchor", 6 }, /* TEXICMD_ANCHOR */
         { dochapter, "appendix", 8 }, /* TEXICMD_APPENDIX */          { dochapter, "appendix", 8 }, /* TEXICMD_APPENDIX */
Line 235  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 250  static const struct texitok texitoks[TEXICMD__MAX] = {
         { dosymbol, "@", 1 }, /* TEXICMD_AT */          { dosymbol, "@", 1 }, /* TEXICMD_AT */
         { doignline, "author", 6 }, /* TEXICMD_AUTHOR */          { doignline, "author", 6 }, /* TEXICMD_AUTHOR */
         { dosymbol, "!", 1 }, /* TEXICMD_BANG */          { dosymbol, "!", 1 }, /* TEXICMD_BANG */
           { dosymbol, "bullet", 6 }, /* TEXICMD_BULLET */
         { dobye, "bye", 3 }, /* TEXICMD_BYE */          { dobye, "bye", 3 }, /* TEXICMD_BYE */
         { doignline, "center", 5 }, /* TEXICMD_CENTER */          { doignline, "center", 5 }, /* TEXICMD_CENTER */
         { dochapter, "chapter", 7 }, /* TEXICMD_CHAPTER */          { dochapter, "chapter", 7 }, /* TEXICMD_CHAPTER */
Line 260  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 276  static const struct texitok texitoks[TEXICMD__MAX] = {
         { doignblock, "direntry", 8 }, /* TEXICMD_DIRENTRY */          { doignblock, "direntry", 8 }, /* TEXICMD_DIRENTRY */
         { dodisplay, "display", 7 }, /* TEXICMD_DISPLAY */          { dodisplay, "display", 7 }, /* TEXICMD_DISPLAY */
         { dosymbol, "dots", 4 }, /* TEXICMD_DOTS */          { dosymbol, "dots", 4 }, /* TEXICMD_DOTS */
         { doarg1, "email", 5 }, /* TEXICMD_EMAIL */          { dolink, "email", 5 }, /* TEXICMD_EMAIL */
         { doemph, "emph", 4 }, /* TEXICMD_EMPH */          { doemph, "emph", 4 }, /* TEXICMD_EMPH */
         { NULL, "end", 3 }, /* TEXICMD_END */          { NULL, "end", 3 }, /* TEXICMD_END */
         { doenumerate, "enumerate", 9 }, /* TEXICMD_ENUMERATE */          { doenumerate, "enumerate", 9 }, /* TEXICMD_ENUMERATE */
Line 290  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 306  static const struct texitok texitoks[TEXICMD__MAX] = {
         { dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */          { dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */
         { doignline, "node", 4 }, /* TEXICMD_NODE */          { doignline, "node", 4 }, /* TEXICMD_NODE */
         { doignline, "noindent", 8 }, /* TEXICMD_NOINDENT */          { doignline, "noindent", 8 }, /* TEXICMD_NOINDENT */
           { dolink, "pxref", 5 }, /* TEXICMD_PXREF */
         { dosymbol, "?", 1 }, /* TEXICMD_QUESTIONMARK */          { dosymbol, "?", 1 }, /* TEXICMD_QUESTIONMARK */
         { doquotation, "quotation", 9 }, /* TEXICMD_QUOTATION */          { doquotation, "quotation", 9 }, /* TEXICMD_QUOTATION */
         { doignline, "page", 4 }, /* TEXICMD_PAGE */          { doignline, "page", 4 }, /* TEXICMD_PAGE */
Line 297  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 314  static const struct texitok texitoks[TEXICMD__MAX] = {
         { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */          { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */
         { dobracket, "ref", 3 }, /* TEXICMD_REF */          { dobracket, "ref", 3 }, /* TEXICMD_REF */
         { doliteral, "samp", 4 }, /* TEXICMD_SAMP */          { doliteral, "samp", 4 }, /* TEXICMD_SAMP */
           { dobracket, "sc", 2 }, /* TEXICMD_SC */
         { dosection, "section", 7 }, /* TEXICMD_SECTION */          { dosection, "section", 7 }, /* TEXICMD_SECTION */
         { doignline, "set", 3 }, /* TEXICMD_SET */          { doignline, "set", 3 }, /* TEXICMD_SET */
         { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */          { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */
         { doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */          { doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */
         { doignline, "settitle", 8 }, /* TEXICMD_SETTITLE */          { dotitle, "settitle", 8 }, /* TEXICMD_SETTITLE */
         { dosp, "sp", 2 }, /* TEXICMD_SP */          { dosp, "sp", 2 }, /* TEXICMD_SP */
         { dosymbol, " ", 1 }, /* TEXICMD_SPACE */          { dosymbol, " ", 1 }, /* TEXICMD_SPACE */
         { doexample, "smallexample", 12 }, /* TEXICMD_SMALLEXAMPLE */          { doexample, "smallexample", 12 }, /* TEXICMD_SMALLEXAMPLE */
         { dosymbol, "{", 1 }, /* TEXICMD_SQUIGGLE_LEFT */          { dosymbol, "{", 1 }, /* TEXICMD_SQUIGGLE_LEFT */
         { dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */          { dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */
           { doemph, "strong", 6 }, /* TEXICMD_STRONG */
         { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */          { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */
         { doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */          { doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */
         { dosymbol, "\t", 1 }, /* TEXICMD_TAB */          { dosymbol, "\t", 1 }, /* TEXICMD_TAB */
Line 319  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 338  static const struct texitok texitoks[TEXICMD__MAX] = {
         { dotop, "top", 3 }, /* TEXICMD_TOP */          { dotop, "top", 3 }, /* TEXICMD_TOP */
         { dochapter, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */          { dochapter, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */
         { dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */          { dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */
         { doarg1, "uref", 4 }, /* TEXICMD_UREF */          { dolink, "uref", 4 }, /* TEXICMD_UREF */
         { doarg1, "url", 3 }, /* TEXICMD_URL */          { dolink, "url", 3 }, /* TEXICMD_URL */
         { doliteral, "var", 3 }, /* TEXICMD_VAR */          { doliteral, "var", 3 }, /* TEXICMD_VAR */
           { dosp, "vskip", 5 }, /* TEXICMD_VSKIP */
         { dobracket, "w", 1 }, /* TEXICMD_W */          { dobracket, "w", 1 }, /* TEXICMD_W */
           { dolink, "xref", 4 }, /* TEXICMD_XREF */
 };  };
   
 /*  /*
Line 339  texifilepop(struct texi *p)
Line 360  texifilepop(struct texi *p)
 }  }
   
 /*  /*
  * Unmap all files that we're currently using.   * Unmap all files that we're currently using and free all resources
    * that we've allocated during the parse.
  * The utility should exit(...) after this is called.   * The utility should exit(...) after this is called.
  */   */
 static void  static void
Line 355  texiexit(struct texi *p)
Line 377  texiexit(struct texi *p)
   
         for (i = 0; i < p->dirsz; i++)          for (i = 0; i < p->dirsz; i++)
                 free(p->dirs[i]);                  free(p->dirs[i]);
   
         free(p->dirs);          free(p->dirs);
           free(p->subtitle);
           free(p->title);
 }  }
   
 /*  /*
Line 390  texiwarn(const struct texi *p, const char *fmt, ...)
Line 415  texiwarn(const struct texi *p, const char *fmt, ...)
         fputc('\n', stderr);          fputc('\n', stderr);
 }  }
   
   /*
    * Print an error message (to stderr) tied to our current location in
    * the parse sequence, invoke texiexit(), then die.
    */
 static void  static void
 texierr(struct texi *p, const char *fmt, ...)  texierr(struct texi *p, const char *fmt, ...)
 {  {
Line 408  texierr(struct texi *p, const char *fmt, ...)
Line 437  texierr(struct texi *p, const char *fmt, ...)
 }  }
   
 /*  /*
  * Put a single data character.   * Put a single data character to the output if we're not ignoring.
  * This MUST NOT be a mdoc(7) command: it should be free text that's   * Adjusts our output status.
  * outputted to the screen.  
  */   */
 static void  static void
 texiputchar(struct texi *p, char c)  texiputchar(struct texi *p, char c)
Line 438  texiputchars(struct texi *p, const char *s)
Line 466  texiputchars(struct texi *p, const char *s)
 }  }
   
 /*  /*
  * Put an mdoc(7) command without the trailing newline.   * Close an mdoc(7) macro opened with teximacroopen().
  * This should ONLY be used for mdoc(7) commands!   * If there are no more macros on the line, prints a newline.
  */   */
 static void  static void
 teximacroclose(struct texi *p)  teximacroclose(struct texi *p)
 {  {
   
           /* FIXME: punctuation. */
         if (0 == --p->outmacro)          if (0 == --p->outmacro)
                 texiputchar(p, '\n');                  texiputchar(p, '\n');
 }  }
   
 /*  /*
  * Put an mdoc(7) command without the trailing newline.   * Open a mdoc(7) macro.
  * This should ONLY be used for mdoc(7) commands!   * This is used for line macros, e.g., Qq [foo bar baz].
    * It can be invoked for nested macros, e.g., Qq Li foo .
  */   */
 static void  static void
 teximacroopen(struct texi *p, const char *s)  teximacroopen(struct texi *p, const char *s)
Line 470  teximacroopen(struct texi *p, const char *s)
Line 500  teximacroopen(struct texi *p, const char *s)
 }  }
   
 /*  /*
  * Put an mdoc(7) command with the trailing newline.   * Put a stadnalone mdoc(7) command with the trailing newline.
  * This should ONLY be used for mdoc(7) commands!  
  */   */
 static void  static void
 teximacro(struct texi *p, const char *s)  teximacro(struct texi *p, const char *s)
Line 516  advancenext(struct texi *p, const char *buf, size_t sz
Line 545  advancenext(struct texi *p, const char *buf, size_t sz
 {  {
   
         if (p->literal) {          if (p->literal) {
                 while (*pos < sz && isspace(buf[*pos])) {                  while (*pos < sz && ismspace(buf[*pos])) {
                         if (*pos && '\n' == buf[*pos] &&                          if (*pos && '\n' == buf[*pos] &&
                                 '\\' == buf[*pos - 1])                                  '\\' == buf[*pos - 1])
                                 texiputchar(p, 'e');                                  texiputchar(p, 'e');
Line 526  advancenext(struct texi *p, const char *buf, size_t sz
Line 555  advancenext(struct texi *p, const char *buf, size_t sz
                 return(*pos);                  return(*pos);
         }          }
   
         while (*pos < sz && isspace(buf[*pos])) {          while (*pos < sz && ismspace(buf[*pos])) {
                 p->seenws = 1;                  p->seenws = 1;
                 /*                  /*
                  * If it looks like we've printed a double-line, then                   * If it looks like we've printed a double-line, then
Line 549  advanceeoln(struct texi *p, const char *buf, 
Line 578  advanceeoln(struct texi *p, const char *buf, 
         size_t sz, size_t *pos, int consumenl)          size_t sz, size_t *pos, int consumenl)
 {  {
   
           /* FIXME: disregards @NEWLINE. */
         while (*pos < sz && '\n' != buf[*pos])          while (*pos < sz && '\n' != buf[*pos])
                 advance(p, buf, pos);                  advance(p, buf, pos);
         if (*pos < sz && consumenl)          if (*pos < sz && consumenl)
Line 575  advanceto(struct texi *p, const char *buf, size_t *pos
Line 605  advanceto(struct texi *p, const char *buf, size_t *pos
  * This also will advance the input stream.   * This also will advance the input stream.
  */   */
 static void  static void
 texiword(struct texi *p, const char *buf, size_t sz, size_t *pos)  texiword(struct texi *p, const char *buf,
           size_t sz, size_t *pos, char extra)
 {  {
   
         /*  
          * XXX: if we're in literal mode, then we shouldn't do any  
          * reflowing of text here.  
          */  
         if (0 == p->outmacro && p->outcol > 72 && 0 == p->literal)          if (0 == p->outmacro && p->outcol > 72 && 0 == p->literal)
                 texiputchar(p, '\n');                  texiputchar(p, '\n');
           /* FIXME: abstract this: we use it elsewhere. */
         if (p->seenws && p->outcol && 0 == p->literal)          if (p->seenws && p->outcol && 0 == p->literal)
                 texiputchar(p, ' ');                  texiputchar(p, ' ');
   
         p->seenws = 0;          p->seenws = 0;
   
         while (*pos < sz && ! isspace(buf[*pos])) {          while (*pos < sz && ! ismspace(buf[*pos])) {
                 switch (buf[*pos]) {                  switch (buf[*pos]) {
                 case ('@'):                  case ('@'):
                 case ('}'):                  case ('}'):
                 case ('{'):                  case ('{'):
                         return;                          return;
                 }                  }
                   if ('\0' != extra && buf[*pos] == extra)
                           return;
                 if (*pos < sz - 1 &&                  if (*pos < sz - 1 &&
                          '`' == buf[*pos] &&                           '`' == buf[*pos] &&
                          '`' == buf[*pos + 1]) {                           '`' == buf[*pos + 1]) {
Line 613  texiword(struct texi *p, const char *buf, size_t sz, s
Line 642  texiword(struct texi *p, const char *buf, size_t sz, s
         }          }
 }  }
   
   /*
    * Look up the command at position "pos" in the buffer, returning it (or
    * TEXICMD__MAX if none found) and setting "end" to be the absolute
    * index after the command name.
    */
 static enum texicmd  static enum texicmd
 texicmd(struct texi *p, const char *buf,  texicmd(struct texi *p, const char *buf,
         size_t pos, size_t sz, size_t *end)          size_t pos, size_t sz, size_t *end)
Line 621  texicmd(struct texi *p, const char *buf, 
Line 655  texicmd(struct texi *p, const char *buf, 
   
         assert('@' == buf[pos]);          assert('@' == buf[pos]);
   
         if (++pos >= sz)          if ((*end = pos) == sz)
                 return(TEXICMD__MAX);                  return(TEXICMD__MAX);
           else if ((*end = ++pos) == sz)
                   return(TEXICMD__MAX);
   
         /* Alphabetic commands are special. */          /* Alphabetic commands are special. */
         if ( ! isalpha(buf[pos])) {          if ( ! isalpha(buf[pos])) {
                 *end = pos + 1;                  if ((*end = pos + 1) == sz)
                           return(TEXICMD__MAX);
                 for (i = 0; i < TEXICMD__MAX; i++) {                  for (i = 0; i < TEXICMD__MAX; i++) {
                         if (1 != texitoks[i].len)                          if (1 != texitoks[i].len)
                                 continue;                                  continue;
Line 637  texicmd(struct texi *p, const char *buf, 
Line 674  texicmd(struct texi *p, const char *buf, 
                 return(TEXICMD__MAX);                  return(TEXICMD__MAX);
         }          }
   
         for (*end = pos; *end < sz && ! isspace(buf[*end]); (*end)++)          for (*end = pos; *end < sz && ! ismspace(buf[*end]); (*end)++)
                 if ((*end > pos && ('@' == buf[*end] ||                  if ((*end > pos && ('@' == buf[*end] ||
                           '{' == buf[*end] || '}' == buf[*end])))                            '{' == buf[*end] || '}' == buf[*end])))
                         break;                          break;
Line 654  texicmd(struct texi *p, const char *buf, 
Line 691  texicmd(struct texi *p, const char *buf, 
         return(TEXICMD__MAX);          return(TEXICMD__MAX);
 }  }
   
 static void  /*
 parseeof(struct texi *p, const char *buf, size_t sz)   * Parse an argument from a bracketed command, e.g., @url{foo, baz}.
    * Num should be set to the argument we're currently parsing, although
    * it suffixes for it to be zero or non-zero.
    * This will return 1 if there are more arguments, 0 otherwise.
    * This will stop (returning 0) in the event of EOF or if we're not at a
    * bracket for the zeroth parse.
    */
   static int
   parsearg(struct texi *p, const char *buf,
           size_t sz, size_t *pos, size_t num)
 {  {
         size_t           pos = 0;          size_t           end;
         enum texicmd     cmd;          enum texicmd     cmd;
         size_t           end;  
   
         while ((pos = advancenext(p, buf, sz, &pos)) < sz) {          while (*pos < sz && ismspace(buf[*pos]))
                 switch (buf[pos]) {                  advance(p, buf, pos);
           if (*pos == sz || (0 == num && '{' != buf[*pos]))
                   return(0);
           if (0 == num)
                   advance(p, buf, pos);
   
           while ((*pos = advancenext(p, buf, sz, pos)) < sz) {
                   switch (buf[*pos]) {
                   case (','):
                           advance(p, buf, pos);
                           return(1);
                 case ('}'):                  case ('}'):
                         if (0 == p->ign)                          advance(p, buf, pos);
                                 texiwarn(p, "unexpected \"}\"");                          return(0);
                         advance(p, buf, &pos);  
                         continue;  
                 case ('{'):                  case ('{'):
                         if (0 == p->ign)                          if (0 == p->ign)
                                 texiwarn(p, "unexpected \"{\"");                                  texiwarn(p, "unexpected \"{\"");
                         advance(p, buf, &pos);                          advance(p, buf, pos);
                         continue;                          continue;
                 case ('@'):                  case ('@'):
                         break;                          break;
                 default:                  default:
                         texiword(p, buf, sz, &pos);                          texiword(p, buf, sz, pos, ',');
                         continue;                          continue;
                 }                  }
   
                 cmd = texicmd(p, buf, pos, sz, &end);                  cmd = texicmd(p, buf, *pos, sz, &end);
                 advanceto(p, buf, &pos, end);                  advanceto(p, buf, pos, end);
                 if (TEXICMD__MAX == cmd)                  if (TEXICMD__MAX == cmd)
                         continue;                          continue;
                 if (NULL != texitoks[cmd].fp)                  if (NULL != texitoks[cmd].fp)
                         (*texitoks[cmd].fp)(p, cmd, buf, sz, &pos);                          (*texitoks[cmd].fp)(p, cmd, buf, sz, pos);
         }          }
           return(0);
 }  }
   
   /*
    * Parse until the end of a bracketed statement, e.g., @foo{bar baz}.
    * This will stop in the event of EOF or if we're not at a bracket.
    */
 static void  static void
 parsebracket(struct texi *p, const char *buf, size_t sz, size_t *pos)  parsebracket(struct texi *p, const char *buf, size_t sz, size_t *pos)
 {  {
         size_t           end;          size_t           end;
         enum texicmd     cmd;          enum texicmd     cmd;
   
         while (*pos < sz && isspace(buf[*pos]))          while (*pos < sz && ismspace(buf[*pos]))
                 advance(p, buf, pos);                  advance(p, buf, pos);
   
         if (*pos == sz || '{' != buf[*pos])          if (*pos == sz || '{' != buf[*pos])
Line 715  parsebracket(struct texi *p, const char *buf, size_t s
Line 773  parsebracket(struct texi *p, const char *buf, size_t s
                 case ('@'):                  case ('@'):
                         break;                          break;
                 default:                  default:
                         texiword(p, buf, sz, pos);                          texiword(p, buf, sz, pos, '\0');
                         continue;                          continue;
                 }                  }
   
Line 760  parseeoln(struct texi *p, const char *buf, size_t sz, 
Line 818  parseeoln(struct texi *p, const char *buf, size_t sz, 
                 case ('@'):                  case ('@'):
                         break;                          break;
                 default:                  default:
                         texiword(p, buf, sz, pos);                          texiword(p, buf, sz, pos, '\0');
                         continue;                          continue;
                 }                  }
   
Line 773  parseeoln(struct texi *p, const char *buf, size_t sz, 
Line 831  parseeoln(struct texi *p, const char *buf, size_t sz, 
         }          }
 }  }
   
   /*
    * Parse a single word or command.
    * This will return immediately at the EOF.
    */
 static void  static void
 parsesingle(struct texi *p, const char *buf, size_t sz, size_t *pos)  parsesingle(struct texi *p, const char *buf, size_t sz, size_t *pos)
 {  {
Line 796  parsesingle(struct texi *p, const char *buf, size_t sz
Line 858  parsesingle(struct texi *p, const char *buf, size_t sz
         case ('@'):          case ('@'):
                 break;                  break;
         default:          default:
                 texiword(p, buf, sz, pos);                  texiword(p, buf, sz, pos, '\0');
                 return;                  return;
         }          }
   
Line 808  parsesingle(struct texi *p, const char *buf, size_t sz
Line 870  parsesingle(struct texi *p, const char *buf, size_t sz
                 (*texitoks[cmd].fp)(p, cmd, buf, sz, pos);                  (*texitoks[cmd].fp)(p, cmd, buf, sz, pos);
 }  }
   
   /*
    * Parse til the end of the buffer.
    */
 static void  static void
   parseeof(struct texi *p, const char *buf, size_t sz)
   {
           size_t   pos;
   
           for (pos = 0; pos < sz; )
                   parsesingle(p, buf, sz, &pos);
   }
   
   /*
    * Parse a block sequence until we have the "@end endtoken" command
    * invocation.
    * This will return immediately at EOF.
    */
   static void
 parseto(struct texi *p, const char *buf,  parseto(struct texi *p, const char *buf,
         size_t sz, size_t *pos, const char *endtoken)          size_t sz, size_t *pos, const char *endtoken)
 {  {
Line 834  parseto(struct texi *p, const char *buf, 
Line 913  parseto(struct texi *p, const char *buf, 
                 case ('@'):                  case ('@'):
                         break;                          break;
                 default:                  default:
                         texiword(p, buf, sz, pos);                          texiword(p, buf, sz, pos, '\0');
                         continue;                          continue;
                 }                  }
   
Line 844  parseto(struct texi *p, const char *buf, 
Line 923  parseto(struct texi *p, const char *buf, 
                         while (*pos < sz && isws(buf[*pos]))                          while (*pos < sz && isws(buf[*pos]))
                                 advance(p, buf, pos);                                  advance(p, buf, pos);
                         /*                          /*
                          * FIXME: skip tabs and also check the full                           * FIXME: check the full word, not just its
                          * word, not just its initial substring!                           * initial substring!
                          */                           */
                         if (sz - *pos >= endtoksz && 0 == strncmp                          if (sz - *pos >= endtoksz && 0 == strncmp
                                  (&buf[*pos], endtoken, endtoksz)) {                                   (&buf[*pos], endtoken, endtoksz)) {
Line 862  parseto(struct texi *p, const char *buf, 
Line 941  parseto(struct texi *p, const char *buf, 
         }          }
 }  }
   
   /*
    * Memory-map the file "fname" and begin parsing it.
    * This can be called in a nested context.
    */
 static void  static void
 parsefile(struct texi *p, const char *fname)  parsefile(struct texi *p, const char *fname)
 {  {
Line 997  doinline(struct texi *p, const char *buf, 
Line 1080  doinline(struct texi *p, const char *buf, 
         parsebracket(p, buf, sz, pos);          parsebracket(p, buf, sz, pos);
         if (*pos < sz - 1 &&          if (*pos < sz - 1 &&
                  ismpunct(buf[*pos]) &&                   ismpunct(buf[*pos]) &&
                  isspace(buf[*pos + 1])) {                   ismspace(buf[*pos + 1])) {
                 texiputchar(p, ' ');                  texiputchar(p, ' ');
                 texiputchar(p, buf[*pos]);                  texiputchar(p, buf[*pos]);
                 advance(p, buf, pos);                  advance(p, buf, pos);
Line 1038  doinclude(struct texi *p, enum texicmd cmd, 
Line 1121  doinclude(struct texi *p, enum texicmd cmd, 
         for (i = 0; i < p->dirsz; i++) {          for (i = 0; i < p->dirsz; i++) {
                 rc = snprintf(path, sizeof(path),                  rc = snprintf(path, sizeof(path),
                         "%s/%s", p->dirs[i], fname);                          "%s/%s", p->dirs[i], fname);
                 texiwarn(p, "trying: %s", path);  
                 if (rc < 0)                  if (rc < 0)
                         texierr(p, "couldn't format path");                          texierr(p, "couldn't format path");
                 else if ((size_t)rc >= sizeof(path))                  else if ((size_t)rc >= sizeof(path))
Line 1160  dobye(struct texi *p, enum texicmd cmd, 
Line 1242  dobye(struct texi *p, enum texicmd cmd, 
 }  }
   
 static void  static void
   dotitle(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           size_t   start, end;
   
           while (*pos < sz && isws(buf[*pos]))
                   advance(p, buf, pos);
           start = end = *pos;
           while (end < sz && '\n' != buf[end])
                   end++;
           free(p->subtitle);
           p->subtitle = malloc(end - start + 1);
           memcpy(p->subtitle, &buf[start], end - start);
           p->subtitle[end - start] = '\0';
   }
   
   static void
 dosymbol(struct texi *p, enum texicmd cmd,  dosymbol(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
Line 1182  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1281  dosymbol(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_BANG):          case (TEXICMD_BANG):
                 texiputchar(p, '!');                  texiputchar(p, '!');
                 break;                  break;
           case (TEXICMD_BULLET):
                   texiputchars(p, "\\(bu");
                   break;
         case (TEXICMD_COPYRIGHT):          case (TEXICMD_COPYRIGHT):
                 texiputchars(p, "\\(co");                  texiputchars(p, "\\(co");
                 break;                  break;
Line 1225  doquotation(struct texi *p, enum texicmd cmd, 
Line 1327  doquotation(struct texi *p, enum texicmd cmd, 
         teximacro(p, "Qc");          teximacro(p, "Qc");
 }  }
   
 /* FIXME */  
 static void  static void
 domath(struct texi *p, enum texicmd cmd,  domath(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 1261  domath(struct texi *p, enum texicmd cmd, 
Line 1362  domath(struct texi *p, enum texicmd cmd, 
         advance(p, buf, pos);          advance(p, buf, pos);
 }  }
   
 /* FIXME */  
 static void  static void
 doarg1(struct texi *p, enum texicmd cmd,  dolink(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
           int      c;
   
         if (*pos == sz || '{' != buf[*pos])  
                 return;  
         advance(p, buf, pos);  
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_EMAIL):          case (TEXICMD_EMAIL):
                 teximacroopen(p, "Mt");                  teximacroopen(p, "Mt");
Line 1278  doarg1(struct texi *p, enum texicmd cmd, 
Line 1376  doarg1(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_URL):          case (TEXICMD_URL):
                 teximacroopen(p, "Lk");                  teximacroopen(p, "Lk");
                 break;                  break;
         default:          case (TEXICMD_XREF):
                   texiputchars(p, "See Section");
                   teximacroopen(p, "Qq");
                 break;                  break;
           case (TEXICMD_PXREF):
                   texiputchars(p, "see Section");
                   teximacroopen(p, "Qq");
                   break;
           default:
                   abort();
         }          }
         /* FIXME: this is ugly */  
         while (*pos < sz && '}' != buf[*pos] && ',' != buf[*pos]) {          c = parsearg(p, buf, sz, pos, 0);
                 texiputchar(p, buf[*pos]);          p->ign++;
                 advance(p, buf, pos);          while (c > 0)
         }                  c = parsearg(p, buf, sz, pos, 1);
         while (*pos < sz && '}' != buf[*pos])          p->ign--;
                 advance(p, buf, pos);  
         if (*pos < sz)  
                 advance(p, buf, pos);  
         if (*pos < sz - 1 &&          if (*pos < sz - 1 &&
                  ismpunct(buf[*pos]) &&                   ismpunct(buf[*pos]) &&
                  isspace(buf[*pos + 1])) {                   ismspace(buf[*pos + 1])) {
                 texiputchar(p, ' ');                  texiputchar(p, ' ');
                 texiputchar(p, buf[*pos]);                  texiputchar(p, buf[*pos]);
                 advance(p, buf, pos);                  advance(p, buf, pos);
         }          }
         switch (cmd) {  
         case (TEXICMD_EMAIL):          teximacroclose(p);
         case (TEXICMD_UREF):  
         case (TEXICMD_URL):  
                 teximacroclose(p);  
                 break;  
         default:  
                 break;  
         }  
 }  }
   
 static void  static void
   doignargn(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           int      c;
   
           c = parsearg(p, buf, sz, pos, 0);
           p->ign++;
           while (c > 0)
                   c = parsearg(p, buf, sz, pos, 1);
           p->ign--;
   }
   
   static void
 dosubsection(struct texi *p, enum texicmd cmd,  dosubsection(struct texi *p, enum texicmd cmd,
                 const char *buf, size_t sz, size_t *pos)                  const char *buf, size_t sz, size_t *pos)
 {  {
Line 1363  static void
Line 1473  static void
 dotop(struct texi *p, enum texicmd cmd,  dotop(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
           const char      *cp;
           time_t           t;
           char             date[32];
   
           t = time(NULL);
           strftime(date, sizeof(date), "%F", localtime(&t));
   
         p->ign--;          p->ign--;
         advanceeoln(p, buf, sz, pos, 1);          advanceeoln(p, buf, sz, pos, 1);
         teximacro(p, "Dd $Mdocdate$");          teximacroopen(p, "Dd");
         teximacro(p, "Dt SOMETHING 7");          texiputchars(p, date);
           teximacroclose(p);
           teximacroopen(p, "Dt");
           for (cp = p->title; '\0' != *cp; cp++)
                   texiputchar(p, toupper(*cp));
           teximacroclose(p);
         teximacro(p, "Os");          teximacro(p, "Os");
         teximacro(p, "Sh NAME");          teximacro(p, "Sh NAME");
         teximacro(p, "Nm Something");          teximacroopen(p, "Nm");
         teximacro(p, "Nd Something");          texiputchars(p, p->title);
           teximacroclose(p);
           teximacroopen(p, "Nd");
           texiputchars(p, NULL != p->subtitle ?
                   p->subtitle : "Unknown description");
           teximacroclose(p);
 }  }
   
 static void  static void
Line 1400  doitem(struct texi *p, enum texicmd cmd, 
Line 1526  doitem(struct texi *p, enum texicmd cmd, 
   
         if (TEXILIST_ITEM == p->list)          if (TEXILIST_ITEM == p->list)
                 teximacroclose(p);                  teximacroclose(p);
         else          else if (p->outcol > 0)
                 texiputchar(p, '\n');                  texiputchar(p, '\n');
 }  }
   
Line 1461  doignline(struct texi *p, enum texicmd cmd, 
Line 1587  doignline(struct texi *p, enum texicmd cmd, 
         advanceeoln(p, buf, sz, pos, 1);          advanceeoln(p, buf, sz, pos, 1);
 }  }
   
   /*
    * Parse colon-separated directories from "cp" (if not NULL) and returns
    * the array of pointers.
    * Prepends "base" to the array.
    * This does NOT sanitise the directories!
    */
 static char **  static char **
 parsedirs(const char *base, const char *cp, size_t *sz)  parsedirs(const char *base, const char *cp, size_t *sz)
 {  {
Line 1507  main(int argc, char *argv[])
Line 1639  main(int argc, char *argv[])
         struct texi      texi;          struct texi      texi;
         int              c;          int              c;
         char            *path, *dir;          char            *path, *dir;
         const char      *progname, *Idir;          const char      *progname, *Idir, *cp;
   
         progname = strrchr(argv[0], '/');          progname = strrchr(argv[0], '/');
         if (progname == NULL)          if (progname == NULL)
Line 1515  main(int argc, char *argv[])
Line 1647  main(int argc, char *argv[])
         else          else
                 ++progname;                  ++progname;
   
           memset(&texi, 0, sizeof(struct texi));
         Idir = NULL;          Idir = NULL;
   
         while (-1 != (c = getopt(argc, argv, "I:")))          while (-1 != (c = getopt(argc, argv, "I:")))
                 switch (c) {                  switch (c) {
                 case ('I'):                  case ('I'):
Line 1539  main(int argc, char *argv[])
Line 1673  main(int argc, char *argv[])
         }          }
         free(path);          free(path);
   
         memset(&texi, 0, sizeof(struct texi));          if (NULL != (cp = strrchr(argv[0], '/')))
                   texi.title = strdup(cp + 1);
           else
                   texi.title = strdup(argv[0]);
   
           if (NULL == texi.title) {
                   perror(NULL);
                   exit(EXIT_FAILURE);
           } else if (NULL != (path = strchr(texi.title, '.')))
                   *path = '\0';
   
         texi.ign = 1;          texi.ign = 1;
         texi.dirs = parsedirs(dir, Idir, &texi.dirsz);          texi.dirs = parsedirs(dir, Idir, &texi.dirsz);
         parsefile(&texi, argv[0]);          parsefile(&texi, argv[0]);
Line 1547  main(int argc, char *argv[])
Line 1691  main(int argc, char *argv[])
         texiexit(&texi);          texiexit(&texi);
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
 usage:  usage:
         fprintf(stderr, "usage: %s file\n", progname);          fprintf(stderr, "usage: %s [-Idirs] file\n", progname);
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
 }  }
Legend:
Removed from v.1.5  
changed lines
  Added in v.1.10
CVSweb