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

Diff for /mandoc/mdoc.c between version 1.87 and 1.88

version 1.87, 2009/07/06 09:21:24 version 1.88, 2009/07/06 13:04:52
Line 23 
Line 23 
   
 #include "libmdoc.h"  #include "libmdoc.h"
   
 enum    merr {  
         ENOCALL,  
         EBODYPROL,  
         EPROLBODY,  
         ESPACE,  
         ETEXTPROL,  
         ENOBLANK,  
         EMALLOC  
 };  
   
 const   char *const __mdoc_macronames[MDOC_MAX] = {  const   char *const __mdoc_macronames[MDOC_MAX] = {
         "Ap",           "Dd",           "Dt",           "Os",          "Ap",           "Dd",           "Dt",           "Os",
         "Sh",           "Ss",           "Pp",           "D1",          "Sh",           "Ss",           "Pp",           "D1",
Line 95  static int    node_append(struct mdoc *, 
Line 85  static int    node_append(struct mdoc *, 
 static  int               parsetext(struct mdoc *, int, char *);  static  int               parsetext(struct mdoc *, int, char *);
 static  int               parsemacro(struct mdoc *, int, char *);  static  int               parsemacro(struct mdoc *, int, char *);
 static  int               macrowarn(struct mdoc *, int, const char *);  static  int               macrowarn(struct mdoc *, int, const char *);
 static  int               perr(struct mdoc *, int, int, enum merr);  
   
   
 const struct mdoc_node *  const struct mdoc_node *
 mdoc_node(const struct mdoc *m)  mdoc_node(const struct mdoc *m)
 {  {
Line 259  mdoc_verr(struct mdoc *mdoc, int ln, int pos, 
Line 249  mdoc_verr(struct mdoc *mdoc, int ln, int pos, 
         va_start(ap, fmt);          va_start(ap, fmt);
         (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);          (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
         va_end(ap);          va_end(ap);
   
         return((*mdoc->cb.mdoc_err)(mdoc->data, ln, pos, buf));          return((*mdoc->cb.mdoc_err)(mdoc->data, ln, pos, buf));
 }  }
   
Line 275  mdoc_vwarn(struct mdoc *mdoc, int ln, int pos, const c
Line 266  mdoc_vwarn(struct mdoc *mdoc, int ln, int pos, const c
         va_start(ap, fmt);          va_start(ap, fmt);
         (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);          (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
         va_end(ap);          va_end(ap);
   
         return((*mdoc->cb.mdoc_warn)(mdoc->data, ln, pos, buf));          return((*mdoc->cb.mdoc_warn)(mdoc->data, ln, pos, buf));
 }  }
   
   
 int  int
 mdoc_nerr(struct mdoc *mdoc, const struct mdoc_node *node,  mdoc_err(struct mdoc *m, int line, int pos, int iserr, enum merr type)
                 const char *fmt, ...)  
 {  {
         char             buf[256];          char             *p;
         va_list          ap;  
   
         if (NULL == mdoc->cb.mdoc_err)  
                 return(0);  
   
         va_start(ap, fmt);  
         (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);  
         va_end(ap);  
         return((*mdoc->cb.mdoc_err)(mdoc->data,  
                                 node->line, node->pos, buf));  
 }  
   
   
 int  
 mdoc_warn(struct mdoc *mdoc, const char *fmt, ...)  
 {  
         char             buf[256];  
         va_list          ap;  
   
         if (NULL == mdoc->cb.mdoc_warn)  
                 return(0);  
   
         va_start(ap, fmt);  
         (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);  
         va_end(ap);  
         return((*mdoc->cb.mdoc_warn)(mdoc->data, mdoc->last->line,  
                                 mdoc->last->pos, buf));  
 }  
   
   
 int  
 mdoc_err(struct mdoc *mdoc, const char *fmt, ...)  
 {  
         char             buf[256];  
         va_list          ap;  
   
         if (NULL == mdoc->cb.mdoc_err)  
                 return(0);  
   
         va_start(ap, fmt);  
         (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);  
         va_end(ap);  
         return((*mdoc->cb.mdoc_err)(mdoc->data, mdoc->last->line,  
                                 mdoc->last->pos, buf));  
 }  
   
   
 int  
 mdoc_pwarn(struct mdoc *mdoc, int line, int pos, const char *fmt, ...)  
 {  
         char             buf[256];  
         va_list          ap;  
   
         if (NULL == mdoc->cb.mdoc_warn)  
                 return(0);  
   
         va_start(ap, fmt);  
         (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);  
         va_end(ap);  
         return((*mdoc->cb.mdoc_warn)(mdoc->data, line, pos, buf));  
 }  
   
 int  
 mdoc_perr(struct mdoc *mdoc, int line, int pos, const char *fmt, ...)  
 {  
         char             buf[256];  
         va_list          ap;  
   
         if (NULL == mdoc->cb.mdoc_err)  
                 return(0);  
   
         va_start(ap, fmt);  
         (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);  
         va_end(ap);  
         return((*mdoc->cb.mdoc_err)(mdoc->data, line, pos, buf));  
 }  
   
   
 int  
 mdoc_macro(struct mdoc *m, int tok,  
                 int ln, int pp, int *pos, char *buf)  
 {  
   
         if (MDOC_PROLOGUE & mdoc_macros[tok].flags &&  
                         MDOC_PBODY & m->flags)  
                 return(perr(m, ln, pp, EPROLBODY));  
         if ( ! (MDOC_PROLOGUE & mdoc_macros[tok].flags) &&  
                         ! (MDOC_PBODY & m->flags))  
                 return(perr(m, ln, pp, EBODYPROL));  
   
         if (1 != pp && ! (MDOC_CALLABLE & mdoc_macros[tok].flags))  
                 return(perr(m, ln, pp, ENOCALL));  
   
         return((*mdoc_macros[tok].fp)(m, tok, ln, pp, pos, buf));  
 }  
   
   
 static int  
 perr(struct mdoc *m, int line, int pos, enum merr type)  
 {  
         char            *p;  
   
         p = NULL;          p = NULL;
   
         switch (type) {          switch (type) {
         case (ENOCALL):          case (ENOCALL):
                 p = "not callable";                  p = "not callable";
Line 409  perr(struct mdoc *m, int line, int pos, enum merr type
Line 300  perr(struct mdoc *m, int line, int pos, enum merr type
         case (ESPACE):          case (ESPACE):
                 p = "whitespace disallowed after delimiter";                  p = "whitespace disallowed after delimiter";
                 break;                  break;
           case (ETOOLONG):
                   p = "text argument too long";
                   break;
           case (EESCAPE):
                   p = "invalid escape sequence";
                   break;
           case (EPRINT):
                   p = "invalid character";
                   break;
           case (ENESTDISP):
                   p = "displays may not be nested";
                   break;
           case (EBOOL):
                   p = "expected boolean value";
                   break;
           case (EARGREP):
                   p = "argument repeated";
                   break;
           case (EMULTIDISP):
                   p = "multiple display types specified";
                   break;
           case (EMULTILIST):
                   p = "multiple list types specified";
                   break;
           case (ELISTTYPE):
                   p = "missing list type";
                   break;
           case (EDISPTYPE):
                   p = "missing display type";
                   break;
           case (ESECNAME):
                   p = "the NAME section must come first";
                   break;
           case (ELINE):
                   p = "expected line arguments";
                   break;
           case (ENOPROLOGUE):
                   p = "document has no prologue";
                   break;
           case (ENODAT):
                   p = "document has no data";
                   break;
           case (ECOLMIS):
                   p = "column syntax style mismatch";
                   break;
           case (EATT):
                   p = "expected valid AT&T symbol";
                   break;
           case (ENAME):
                   p = "default name not yet set";
                   break;
           case (ENOWIDTH):
                   p = "superfluous width argument";
                   break;
           case (EMISSWIDTH):
                   p = "missing width argument";
                   break;
           case (EWRONGMSEC):
                   p = "document section in wrong manual section";
                   break;
           case (ESECOOO):
                   p = "document section out of conventional order";
                   break;
           case (ESECREP):
                   p = "document section repeated";
                   break;
           case (EBADSTAND):
                   p = "unknown standard";
                   break;
           case (ENAMESECINC):
                   p = "NAME section contents incomplete/badly-ordered";
                   break;
           case (ENOMULTILINE):
                   p = "suggested no multi-line arguments";
                   break;
           case (EMULTILINE):
                   p = "suggested multi-line arguments";
                   break;
           case (ENOLINE):
                   p = "suggested no line arguments";
                   break;
           case (EPROLOOO):
                   p = "prologue macros out-of-order";
                   break;
           case (EPROLREP):
                   p = "prologue macros repeated";
                   break;
           case (EARGVAL):
                   p = "argument value suggested";
                   break;
           case (EFONT):
                   p = "invalid font mode";
                   break;
           case (EBADMSEC):
                   p = "inappropriate manual section";
                   break;
           case (EBADSEC):
                   p = "inappropriate document section";
                   break;
           case (EQUOTTERM):
                   p = "unterminated quoted parameter";
                   break;
           case (EQUOTPARM):
                   p = "unexpected quoted parameter";
                   break;
           case (EARGVPARM):
                   p = "argument-like parameter";
                   break;
           case (ECOLEMPTY):
                   p = "last list column is empty";
                   break;
           case (ETAILWS):
                   p = "trailing whitespace";
                   break;
           case (ENUMFMT):
                   p = "bad number format";
                   break;
           case (EUTSNAME):
                   p = "utsname";
                   break;
           case (EBADDATE):
                   p = "malformed date syntax";
                   break;
           case (EOPEN):
                   p = "explicit scope still open on exit";
                   break;
           case (EQUOT):
                   p = "unterminated quotation";
                   break;
           case (ENOCTX):
                   p = "closure has no prior context";
                   break;
           case (ENOPARMS):
                   p = "unexpect line arguments";
                   break;
           case (EIGNE):
                   p = "ignoring empty element";
                   break;
           case (EIMPBRK):
                   p = "crufty end-of-line scope violation";
                   break;
           case (EMACPARM):
                   p = "macro-like parameter";
                   break;
           case (EOBS):
                   p = "macro marked obsolete";
                   break;
         }          }
   
         assert(p);          assert(p);
         return(mdoc_perr(m, line, pos, p));  
           if (iserr)
                   return(mdoc_verr(m, line, pos, p));
   
           return(mdoc_vwarn(m, line, pos, p));
 }  }
   
   
   int
   mdoc_macro(struct mdoc *m, int tok,
                   int ln, int pp, int *pos, char *buf)
   {
   
           if (MDOC_PROLOGUE & mdoc_macros[tok].flags &&
                           MDOC_PBODY & m->flags)
                   return(mdoc_perr(m, ln, pp, EPROLBODY));
           if ( ! (MDOC_PROLOGUE & mdoc_macros[tok].flags) &&
                           ! (MDOC_PBODY & m->flags))
                   return(mdoc_perr(m, ln, pp, EBODYPROL));
   
           if (1 != pp && ! (MDOC_CALLABLE & mdoc_macros[tok].flags))
                   return(mdoc_perr(m, ln, pp, ENOCALL));
   
           return((*mdoc_macros[tok].fp)(m, tok, ln, pp, pos, buf));
   }
   
   
 static int  static int
 node_append(struct mdoc *mdoc, struct mdoc_node *p)  node_append(struct mdoc *mdoc, struct mdoc_node *p)
 {  {
Line 486  node_alloc(struct mdoc *mdoc, int line, 
Line 548  node_alloc(struct mdoc *mdoc, int line, 
         struct mdoc_node *p;          struct mdoc_node *p;
   
         if (NULL == (p = calloc(1, sizeof(struct mdoc_node)))) {          if (NULL == (p = calloc(1, sizeof(struct mdoc_node)))) {
                 (void)perr(mdoc, (mdoc)->last->line,                  (void)mdoc_nerr(mdoc, mdoc->last, EMALLOC);
                                 (mdoc)->last->pos, EMALLOC);  
                 return(NULL);                  return(NULL);
         }          }
   
Line 583  mdoc_word_alloc(struct mdoc *mdoc, 
Line 644  mdoc_word_alloc(struct mdoc *mdoc, 
         if (NULL == p)          if (NULL == p)
                 return(0);                  return(0);
         if (NULL == (p->string = strdup(word))) {          if (NULL == (p->string = strdup(word))) {
                 (void)perr(mdoc, (mdoc)->last->line,                  (void)mdoc_nerr(mdoc, mdoc->last, EMALLOC);
                                 (mdoc)->last->pos, EMALLOC);  
                 return(0);                  return(0);
         }          }
   
         return(node_append(mdoc, p));          return(node_append(mdoc, p));
 }  }
   
Line 628  parsetext(struct mdoc *m, int line, char *buf)
Line 689  parsetext(struct mdoc *m, int line, char *buf)
 {  {
   
         if (SEC_NONE == m->lastnamed)          if (SEC_NONE == m->lastnamed)
                 return(perr(m, line, 0, ETEXTPROL));                  return(mdoc_perr(m, line, 0, ETEXTPROL));
   
         if (0 == buf[0] && ! (MDOC_LITERAL & m->flags))          if (0 == buf[0] && ! (MDOC_LITERAL & m->flags))
                 return(perr(m, line, 0, ENOBLANK));                  return(mdoc_perr(m, line, 0, ENOBLANK));
   
         if ( ! mdoc_word_alloc(m, line, 0, buf))          if ( ! mdoc_word_alloc(m, line, 0, buf))
                 return(0);                  return(0);
Line 645  static int
Line 706  static int
 macrowarn(struct mdoc *m, int ln, const char *buf)  macrowarn(struct mdoc *m, int ln, const char *buf)
 {  {
         if ( ! (MDOC_IGN_MACRO & m->pflags))          if ( ! (MDOC_IGN_MACRO & m->pflags))
                 return(mdoc_perr(m, ln, 1,                  return(mdoc_verr(m, ln, 1,
                                 "unknown macro: %s%s",                                  "unknown macro: %s%s",
                                 buf, strlen(buf) > 3 ? "..." : ""));                                  buf, strlen(buf) > 3 ? "..." : ""));
         return(mdoc_pwarn(m, ln, 1, "unknown macro: %s%s",          return(mdoc_vwarn(m, ln, 1, "unknown macro: %s%s",
                                 buf, strlen(buf) > 3 ? "..." : ""));                                  buf, strlen(buf) > 3 ? "..." : ""));
 }  }
   
Line 674  parsemacro(struct mdoc *m, int ln, char *buf)
Line 735  parsemacro(struct mdoc *m, int ln, char *buf)
                         i++;                          i++;
                 if (0 == buf[i])                  if (0 == buf[i])
                         return(1);                          return(1);
                 return(perr(m, ln, 1, ESPACE));                  return(mdoc_perr(m, ln, 1, ESPACE));
         }          }
   
         /* Copy the first word into a nil-terminated buffer. */          /* Copy the first word into a nil-terminated buffer. */

Legend:
Removed from v.1.87  
changed lines
  Added in v.1.88

CVSweb