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

Diff for /mandoc/mdoc.c between version 1.89 and 1.96

version 1.89, 2009/07/07 09:29:15 version 1.96, 2009/07/27 19:43:02
Line 25 
Line 25 
   
 const   char *const __mdoc_merrnames[MERRMAX] = {  const   char *const __mdoc_merrnames[MERRMAX] = {
         "trailing whitespace", /* ETAILWS */          "trailing whitespace", /* ETAILWS */
         "empty last list column", /* ECOLEMPTY */  
         "argument-like parameter", /* EARGVPARM */  
         "unexpected quoted parameter", /* EQUOTPARM */          "unexpected quoted parameter", /* EQUOTPARM */
         "unterminated quoted parameter", /* EQUOTTERM */          "unterminated quoted parameter", /* EQUOTTERM */
         "system: malloc error", /* EMALLOC */          "system: malloc error", /* EMALLOC */
Line 79  const char *const __mdoc_merrnames[MERRMAX] = {   
Line 77  const char *const __mdoc_merrnames[MERRMAX] = {   
         "unterminated quoted phrase", /* EQUOTPHR */          "unterminated quoted phrase", /* EQUOTPHR */
         "closure macro without prior context", /* ENOCTX */          "closure macro without prior context", /* ENOCTX */
         "invalid whitespace after control character", /* ESPACE */          "invalid whitespace after control character", /* ESPACE */
           "no description found for library" /* ELIB */
 };  };
   
 const   char *const __mdoc_macronames[MDOC_MAX] = {  const   char *const __mdoc_macronames[MDOC_MAX] = {
Line 116  const char *const __mdoc_macronames[MDOC_MAX] = {   
Line 115  const char *const __mdoc_macronames[MDOC_MAX] = {   
         /* LINTED */          /* LINTED */
         "Brc",          "\%C",          "Es",           "En",          "Brc",          "\%C",          "Es",           "En",
         /* LINTED */          /* LINTED */
         "Dx",           "\%Q"          "Dx",           "\%Q",          "br",           "sp"
         };          };
   
 const   char *const __mdoc_argnames[MDOC_ARG_MAX] = {  const   char *const __mdoc_argnames[MDOC_ARG_MAX] = {
Line 143  static int    node_append(struct mdoc *, 
Line 142  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               pstring(struct mdoc *, int, int,
                                   const char *, size_t);
   
   #ifdef __linux__
   extern  size_t            strlcpy(char *, const char *, size_t);
   #endif
   
   
 const struct mdoc_node *  const struct mdoc_node *
 mdoc_node(const struct mdoc *m)  mdoc_node(const struct mdoc *m)
 {  {
Line 428  node_append(struct mdoc *mdoc, struct mdoc_node *p)
Line 433  node_append(struct mdoc *mdoc, struct mdoc_node *p)
   
   
 static struct mdoc_node *  static struct mdoc_node *
 node_alloc(struct mdoc *mdoc, int line,  node_alloc(struct mdoc *m, int line,
                 int pos, int tok, enum mdoc_type type)                  int pos, int tok, enum mdoc_type type)
 {  {
         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)mdoc_nerr(mdoc, mdoc->last, EMALLOC);                  (void)mdoc_nerr(m, m->last, EMALLOC);
                 return(NULL);                  return(NULL);
         }          }
   
         p->sec = mdoc->lastsec;          p->sec = m->lastsec;
         p->line = line;          p->line = line;
         p->pos = pos;          p->pos = pos;
         p->tok = tok;          p->tok = tok;
Line 450  node_alloc(struct mdoc *mdoc, int line, 
Line 455  node_alloc(struct mdoc *mdoc, int line, 
   
   
 int  int
 mdoc_tail_alloc(struct mdoc *mdoc, int line, int pos, int tok)  mdoc_tail_alloc(struct mdoc *m, int line, int pos, int tok)
 {  {
         struct mdoc_node *p;          struct mdoc_node *p;
   
         p = node_alloc(mdoc, line, pos, tok, MDOC_TAIL);          p = node_alloc(m, line, pos, tok, MDOC_TAIL);
         if (NULL == p)          if (NULL == p)
                 return(0);                  return(0);
         return(node_append(mdoc, p));          return(node_append(m, p));
 }  }
   
   
 int  int
 mdoc_head_alloc(struct mdoc *mdoc, int line, int pos, int tok)  mdoc_head_alloc(struct mdoc *m, int line, int pos, int tok)
 {  {
         struct mdoc_node *p;          struct mdoc_node *p;
   
         assert(mdoc->first);          assert(m->first);
         assert(mdoc->last);          assert(m->last);
   
         p = node_alloc(mdoc, line, pos, tok, MDOC_HEAD);          p = node_alloc(m, line, pos, tok, MDOC_HEAD);
         if (NULL == p)          if (NULL == p)
                 return(0);                  return(0);
         return(node_append(mdoc, p));          return(node_append(m, p));
 }  }
   
   
 int  int
 mdoc_body_alloc(struct mdoc *mdoc, int line, int pos, int tok)  mdoc_body_alloc(struct mdoc *m, int line, int pos, int tok)
 {  {
         struct mdoc_node *p;          struct mdoc_node *p;
   
         p = node_alloc(mdoc, line, pos, tok, MDOC_BODY);          p = node_alloc(m, line, pos, tok, MDOC_BODY);
         if (NULL == p)          if (NULL == p)
                 return(0);                  return(0);
         return(node_append(mdoc, p));          return(node_append(m, p));
 }  }
   
   
 int  int
 mdoc_block_alloc(struct mdoc *mdoc, int line, int pos,  mdoc_block_alloc(struct mdoc *m, int line, int pos,
                 int tok, struct mdoc_arg *args)                  int tok, struct mdoc_arg *args)
 {  {
         struct mdoc_node *p;          struct mdoc_node *p;
   
         p = node_alloc(mdoc, line, pos, tok, MDOC_BLOCK);          p = node_alloc(m, line, pos, tok, MDOC_BLOCK);
         if (NULL == p)          if (NULL == p)
                 return(0);                  return(0);
         p->args = args;          p->args = args;
         if (p->args)          if (p->args)
                 (args->refcnt)++;                  (args->refcnt)++;
         return(node_append(mdoc, p));          return(node_append(m, p));
 }  }
   
   
 int  int
 mdoc_elem_alloc(struct mdoc *mdoc, int line, int pos,  mdoc_elem_alloc(struct mdoc *m, int line, int pos,
                 int tok, struct mdoc_arg *args)                  int tok, struct mdoc_arg *args)
 {  {
         struct mdoc_node *p;          struct mdoc_node *p;
   
         p = node_alloc(mdoc, line, pos, tok, MDOC_ELEM);          p = node_alloc(m, line, pos, tok, MDOC_ELEM);
         if (NULL == p)          if (NULL == p)
                 return(0);                  return(0);
         p->args = args;          p->args = args;
         if (p->args)          if (p->args)
                 (args->refcnt)++;                  (args->refcnt)++;
         return(node_append(mdoc, p));          return(node_append(m, p));
 }  }
   
   
 int  static int
 mdoc_word_alloc(struct mdoc *mdoc,  pstring(struct mdoc *m, int line, int pos, const char *p, size_t len)
                 int line, int pos, const char *word)  
 {  {
         struct mdoc_node *p;          struct mdoc_node *n;
           size_t            sv;
   
         p = node_alloc(mdoc, line, pos, -1, MDOC_TEXT);          n = node_alloc(m, line, pos, -1, MDOC_TEXT);
         if (NULL == p)          if (NULL == n)
                 return(0);                  return(mdoc_nerr(m, m->last, EMALLOC));
         if (NULL == (p->string = strdup(word))) {  
                 (void)mdoc_nerr(mdoc, mdoc->last, EMALLOC);          n->string = malloc(len + 1);
                 return(0);          if (NULL == n->string) {
                   free(n);
                   return(mdoc_nerr(m, m->last, EMALLOC));
         }          }
   
         return(node_append(mdoc, p));          sv = strlcpy(n->string, p, len + 1);
   
           /* Prohibit truncation. */
           assert(sv < len + 1);
   
           return(node_append(m, n));
 }  }
   
   
   int
   mdoc_word_alloc(struct mdoc *m, int line, int pos, const char *p)
   {
   
           return(pstring(m, line, pos, p, strlen(p)));
   }
   
   
 void  void
 mdoc_node_free(struct mdoc_node *p)  mdoc_node_free(struct mdoc_node *p)
 {  {
Line 573  mdoc_node_freelist(struct mdoc_node *p)
Line 593  mdoc_node_freelist(struct mdoc_node *p)
 static int  static int
 parsetext(struct mdoc *m, int line, char *buf)  parsetext(struct mdoc *m, int line, char *buf)
 {  {
           int              i, j;
   
         if (SEC_NONE == m->lastnamed)          if (SEC_NONE == m->lastnamed)
                 return(mdoc_perr(m, line, 0, ETEXTPROL));                  return(mdoc_perr(m, line, 0, ETEXTPROL));
   
           /*
            * If in literal mode, then pass the buffer directly to the
            * back-end, as it should be preserved as a single term.
            */
   
         if (0 == buf[0] && ! (MDOC_LITERAL & m->flags))          if (MDOC_LITERAL & m->flags) {
                   if ( ! mdoc_word_alloc(m, line, 0, buf))
                           return(0);
                   m->next = MDOC_NEXT_SIBLING;
                   return(1);
           }
   
           /* Disallow blank/white-space lines in non-literal mode. */
   
           for (i = 0; ' ' == buf[i]; i++)
                   /* Skip leading whitespace. */ ;
           if (0 == buf[i])
                 return(mdoc_perr(m, line, 0, ENOBLANK));                  return(mdoc_perr(m, line, 0, ENOBLANK));
   
         if ( ! mdoc_word_alloc(m, line, 0, buf))          /*
            * Break apart a free-form line into tokens.  Spaces are
            * stripped out of the input.
            */
   
           for (j = i; buf[i]; i++) {
                   if (' ' != buf[i])
                           continue;
   
                   /* Escaped whitespace. */
                   if (i && ' ' == buf[i] && '\\' == buf[i - 1])
                           continue;
   
                   buf[i++] = 0;
                   if ( ! pstring(m, line, j, &buf[j], (size_t)(i - j)))
                           return(0);
                   m->next = MDOC_NEXT_SIBLING;
   
                   for ( ; ' ' == buf[i]; i++)
                           /* Skip trailing whitespace. */ ;
   
                   j = i;
                   if (0 == buf[i])
                           break;
           }
   
           if (j != i && ! pstring(m, line, j, &buf[j], (size_t)(i - j)))
                 return(0);                  return(0);
   
         m->next = MDOC_NEXT_SIBLING;          m->next = MDOC_NEXT_SIBLING;
Line 588  parsetext(struct mdoc *m, int line, char *buf)
Line 651  parsetext(struct mdoc *m, int line, char *buf)
 }  }
   
   
   
   
 static int  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_verr(m, ln, 1,                  return(mdoc_verr(m, ln, 0,
                                 "unknown macro: %s%s",                                  "unknown macro: %s%s",
                                 buf, strlen(buf) > 3 ? "..." : ""));                                  buf, strlen(buf) > 3 ? "..." : ""));
         return(mdoc_vwarn(m, ln, 1, "unknown macro: %s%s",          return(mdoc_vwarn(m, ln, 0, "unknown macro: %s%s",
                                 buf, strlen(buf) > 3 ? "..." : ""));                                  buf, strlen(buf) > 3 ? "..." : ""));
 }  }
   

Legend:
Removed from v.1.89  
changed lines
  Added in v.1.96

CVSweb