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

Diff for /mandoc/mdoc.c between version 1.148 and 1.170

version 1.148, 2010/06/26 16:07:08 version 1.170, 2010/12/16 17:14:48
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2008, 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv>
    * Copyright (c) 2010 Ingo Schwarze <schwarze@openbsd.org>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
Line 21 
Line 22 
 #include <sys/types.h>  #include <sys/types.h>
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  
 #include <stdarg.h>  #include <stdarg.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
Line 29 
Line 29 
 #include <time.h>  #include <time.h>
   
 #include "mandoc.h"  #include "mandoc.h"
 #include "regs.h"  
 #include "libmdoc.h"  #include "libmdoc.h"
 #include "libmandoc.h"  #include "libmandoc.h"
   
Line 97  static struct mdoc_node *node_alloc(struct mdoc *, int
Line 96  static struct mdoc_node *node_alloc(struct mdoc *, int
                                 enum mdoct, enum mdoc_type);                                  enum mdoct, enum mdoc_type);
 static  int               node_append(struct mdoc *,  static  int               node_append(struct mdoc *,
                                 struct mdoc_node *);                                  struct mdoc_node *);
 static  int               mdoc_ptext(struct mdoc *,  static  int               mdoc_ptext(struct mdoc *, int, char *, int);
                                 const struct regset *,  static  int               mdoc_pmacro(struct mdoc *, int, char *, int);
                                 int, char *, int);  
 static  int               mdoc_pmacro(struct mdoc *,  
                                 const struct regset *,  
                                 int, char *, int);  
 static  int               macrowarn(struct mdoc *, int,  
                                 const char *, int);  
   
   
 const struct mdoc_node *  const struct mdoc_node *
Line 196  mdoc_free(struct mdoc *mdoc)
Line 189  mdoc_free(struct mdoc *mdoc)
  * Allocate volatile and non-volatile parse resources.   * Allocate volatile and non-volatile parse resources.
  */   */
 struct mdoc *  struct mdoc *
 mdoc_alloc(void *data, int pflags, mandocmsg msg)  mdoc_alloc(struct regset *regs, void *data, mandocmsg msg)
 {  {
         struct mdoc     *p;          struct mdoc     *p;
   
Line 204  mdoc_alloc(void *data, int pflags, mandocmsg msg)
Line 197  mdoc_alloc(void *data, int pflags, mandocmsg msg)
   
         p->msg = msg;          p->msg = msg;
         p->data = data;          p->data = data;
         p->pflags = pflags;          p->regs = regs;
   
         mdoc_hash_init();          mdoc_hash_init();
         mdoc_alloc1(p);          mdoc_alloc1(p);
Line 234  mdoc_endparse(struct mdoc *m)
Line 227  mdoc_endparse(struct mdoc *m)
  * the macro (mdoc_pmacro()) or text parser (mdoc_ptext()).   * the macro (mdoc_pmacro()) or text parser (mdoc_ptext()).
  */   */
 int  int
 mdoc_parseln(struct mdoc *m, const struct regset *regs,  mdoc_parseln(struct mdoc *m, int ln, char *buf, int offs)
                 int ln, char *buf, int offs)  
 {  {
   
         if (MDOC_HALT & m->flags)          if (MDOC_HALT & m->flags)
                 return(0);                  return(0);
   
         m->flags |= MDOC_NEWLINE;          m->flags |= MDOC_NEWLINE;
   
           /*
            * Let the roff nS register switch SYNOPSIS mode early,
            * such that the parser knows at all times
            * whether this mode is on or off.
            * Note that this mode is also switched by the Sh macro.
            */
           if (m->regs->regs[(int)REG_nS].set) {
                   if (m->regs->regs[(int)REG_nS].v.u)
                           m->flags |= MDOC_SYNOPSIS;
                   else
                           m->flags &= ~MDOC_SYNOPSIS;
           }
   
         return(('.' == buf[offs] || '\'' == buf[offs]) ?          return(('.' == buf[offs] || '\'' == buf[offs]) ?
                         mdoc_pmacro(m, regs, ln, buf, offs) :                          mdoc_pmacro(m, ln, buf, offs) :
                         mdoc_ptext(m, regs, ln, buf, offs));                          mdoc_ptext(m, ln, buf, offs));
 }  }
   
   
Line 280  mdoc_macro(MACRO_PROT_ARGS)
Line 286  mdoc_macro(MACRO_PROT_ARGS)
                         ! (MDOC_PBODY & m->flags)) {                          ! (MDOC_PBODY & m->flags)) {
                 if ( ! mdoc_pmsg(m, line, ppos, MANDOCERR_BADPROLOG))                  if ( ! mdoc_pmsg(m, line, ppos, MANDOCERR_BADPROLOG))
                         return(0);                          return(0);
                   if (NULL == m->meta.msec)
                           m->meta.msec = mandoc_strdup("1");
                 if (NULL == m->meta.title)                  if (NULL == m->meta.title)
                         m->meta.title = mandoc_strdup("UNKNOWN");                          m->meta.title = mandoc_strdup("UNKNOWN");
                 if (NULL == m->meta.vol)                  if (NULL == m->meta.vol)
Line 291  mdoc_macro(MACRO_PROT_ARGS)
Line 299  mdoc_macro(MACRO_PROT_ARGS)
                 m->flags |= MDOC_PBODY;                  m->flags |= MDOC_PBODY;
         }          }
   
         return((*mdoc_macros[tok].fp)          return((*mdoc_macros[tok].fp)(m, tok, line, ppos, pos, buf));
                         (m, regs, tok, line, ppos, pos, buf));  
 }  }
   
   
Line 323  node_append(struct mdoc *mdoc, struct mdoc_node *p)
Line 330  node_append(struct mdoc *mdoc, struct mdoc_node *p)
   
         if ( ! mdoc_valid_pre(mdoc, p))          if ( ! mdoc_valid_pre(mdoc, p))
                 return(0);                  return(0);
         if ( ! mdoc_action_pre(mdoc, p))  
                 return(0);  
   
         switch (p->type) {          switch (p->type) {
         case (MDOC_HEAD):          case (MDOC_HEAD):
Line 336  node_append(struct mdoc *mdoc, struct mdoc_node *p)
Line 341  node_append(struct mdoc *mdoc, struct mdoc_node *p)
                 p->parent->tail = p;                  p->parent->tail = p;
                 break;                  break;
         case (MDOC_BODY):          case (MDOC_BODY):
                   if (p->end)
                           break;
                 assert(MDOC_BLOCK == p->parent->type);                  assert(MDOC_BLOCK == p->parent->type);
                 p->parent->body = p;                  p->parent->body = p;
                 break;                  break;
Line 349  node_append(struct mdoc *mdoc, struct mdoc_node *p)
Line 356  node_append(struct mdoc *mdoc, struct mdoc_node *p)
         case (MDOC_TEXT):          case (MDOC_TEXT):
                 if ( ! mdoc_valid_post(mdoc))                  if ( ! mdoc_valid_post(mdoc))
                         return(0);                          return(0);
                 if ( ! mdoc_action_post(mdoc))  
                         return(0);  
                 break;                  break;
         default:          default:
                 break;                  break;
Line 372  node_alloc(struct mdoc *m, int line, int pos, 
Line 377  node_alloc(struct mdoc *m, int line, int pos, 
         p->pos = pos;          p->pos = pos;
         p->tok = tok;          p->tok = tok;
         p->type = type;          p->type = type;
   
           /* Flag analysis. */
   
           if (MDOC_SYNOPSIS & m->flags)
                   p->flags |= MDOC_SYNPRETTY;
           else
                   p->flags &= ~MDOC_SYNPRETTY;
         if (MDOC_NEWLINE & m->flags)          if (MDOC_NEWLINE & m->flags)
                 p->flags |= MDOC_LINE;                  p->flags |= MDOC_LINE;
         m->flags &= ~MDOC_NEWLINE;          m->flags &= ~MDOC_NEWLINE;
   
         return(p);          return(p);
 }  }
   
Line 422  mdoc_body_alloc(struct mdoc *m, int line, int pos, enu
Line 435  mdoc_body_alloc(struct mdoc *m, int line, int pos, enu
   
   
 int  int
   mdoc_endbody_alloc(struct mdoc *m, int line, int pos, enum mdoct tok,
                   struct mdoc_node *body, enum mdoc_endbody end)
   {
           struct mdoc_node *p;
   
           p = node_alloc(m, line, pos, tok, MDOC_BODY);
           p->pending = body;
           p->end = end;
           if ( ! node_append(m, p))
                   return(0);
           m->next = MDOC_NEXT_SIBLING;
           return(1);
   }
   
   
   int
 mdoc_block_alloc(struct mdoc *m, int line, int pos,  mdoc_block_alloc(struct mdoc *m, int line, int pos,
                 enum mdoct tok, struct mdoc_arg *args)                  enum mdoct tok, struct mdoc_arg *args)
 {  {
Line 478  mdoc_word_alloc(struct mdoc *m, int line, int pos, con
Line 507  mdoc_word_alloc(struct mdoc *m, int line, int pos, con
 }  }
   
   
 void  static void
 mdoc_node_free(struct mdoc_node *p)  mdoc_node_free(struct mdoc_node *p)
 {  {
   
           /*
            * XXX: if these end up being problematic in terms of memory
            * management and dereferencing freed blocks, then make them
            * into reference-counted double-pointers.
            */
   
           if (MDOC_Bd == p->tok && MDOC_BLOCK == p->type)
                   if (p->data.Bd)
                           free(p->data.Bd);
           if (MDOC_Bl == p->tok && MDOC_BLOCK == p->type)
                   if (p->data.Bl)
                           free(p->data.Bl);
           if (MDOC_Bf == p->tok && MDOC_HEAD == p->type)
                   if (p->data.Bf)
                           free(p->data.Bf);
           if (MDOC_An == p->tok)
                   if (p->data.An)
                           free(p->data.An);
   
         if (p->string)          if (p->string)
                 free(p->string);                  free(p->string);
         if (p->args)          if (p->args)
Line 507  mdoc_node_unlink(struct mdoc *m, struct mdoc_node *n)
Line 555  mdoc_node_unlink(struct mdoc *m, struct mdoc_node *n)
                 n->parent->nchild--;                  n->parent->nchild--;
                 if (n->parent->child == n)                  if (n->parent->child == n)
                         n->parent->child = n->prev ? n->prev : n->next;                          n->parent->child = n->prev ? n->prev : n->next;
                   if (n->parent->last == n)
                           n->parent->last = n->prev ? n->prev : NULL;
         }          }
   
         /* Adjust parse point, if applicable. */          /* Adjust parse point, if applicable. */
Line 546  mdoc_node_delete(struct mdoc *m, struct mdoc_node *p)
Line 596  mdoc_node_delete(struct mdoc *m, struct mdoc_node *p)
  * control character.   * control character.
  */   */
 static int  static int
 mdoc_ptext(struct mdoc *m, const struct regset *regs,  mdoc_ptext(struct mdoc *m, int line, char *buf, int offs)
                 int line, char *buf, int offs)  
 {  {
         char             *c, *ws, *end;          char             *c, *ws, *end;
         struct mdoc_node *n;          struct mdoc_node *n;
Line 575  mdoc_ptext(struct mdoc *m, const struct regset *regs,
Line 624  mdoc_ptext(struct mdoc *m, const struct regset *regs,
          */           */
   
         if (MDOC_Bl == n->tok && MDOC_BODY == n->type &&          if (MDOC_Bl == n->tok && MDOC_BODY == n->type &&
                         LIST_column == n->data.Bl.type) {                          LIST_column == n->data.Bl->type) {
                 /* `Bl' is open without any children. */                  /* `Bl' is open without any children. */
                 m->flags |= MDOC_FREECOL;                  m->flags |= MDOC_FREECOL;
                 return(mdoc_macro(m, regs, MDOC_It,                  return(mdoc_macro(m, MDOC_It, line, offs, &offs, buf));
                                         line, offs, &offs, buf));  
         }          }
   
         if (MDOC_It == n->tok && MDOC_BLOCK == n->type &&          if (MDOC_It == n->tok && MDOC_BLOCK == n->type &&
                         NULL != n->parent &&                          NULL != n->parent &&
                         MDOC_Bl == n->parent->tok &&                          MDOC_Bl == n->parent->tok &&
                         LIST_column == n->parent->data.Bl.type) {                          LIST_column == n->parent->data.Bl->type) {
                 /* `Bl' has block-level `It' children. */                  /* `Bl' has block-level `It' children. */
                 m->flags |= MDOC_FREECOL;                  m->flags |= MDOC_FREECOL;
                 return(mdoc_macro(m, regs, MDOC_It,                  return(mdoc_macro(m, MDOC_It, line, offs, &offs, buf));
                                         line, offs, &offs, buf));  
         }          }
   
         /*          /*
Line 647  mdoc_ptext(struct mdoc *m, const struct regset *regs,
Line 694  mdoc_ptext(struct mdoc *m, const struct regset *regs,
                         return(0);                          return(0);
   
                 /*                  /*
                  * Insert a `Pp' in the case of a blank line.  Technically,                   * Insert a `sp' in the case of a blank line.  Technically,
                  * blank lines aren't allowed, but enough manuals assume this                   * blank lines aren't allowed, but enough manuals assume this
                  * behaviour that we want to work around it.                   * behaviour that we want to work around it.
                  */                   */
                 if ( ! mdoc_elem_alloc(m, line, offs, MDOC_Pp, NULL))                  if ( ! mdoc_elem_alloc(m, line, offs, MDOC_sp, NULL))
                         return(0);                          return(0);
   
                 m->next = MDOC_NEXT_SIBLING;                  m->next = MDOC_NEXT_SIBLING;
Line 672  mdoc_ptext(struct mdoc *m, const struct regset *regs,
Line 719  mdoc_ptext(struct mdoc *m, const struct regset *regs,
   
         assert(buf < end);          assert(buf < end);
   
         if (mandoc_eos(buf+offs, (size_t)(end-buf-offs)))          if (mandoc_eos(buf+offs, (size_t)(end-buf-offs), 0))
                 m->last->flags |= MDOC_EOS;                  m->last->flags |= MDOC_EOS;
   
         return(1);          return(1);
 }  }
   
   
 static int  
 macrowarn(struct mdoc *m, int ln, const char *buf, int offs)  
 {  
         int              rc;  
   
         rc = mdoc_vmsg(m, MANDOCERR_MACRO, ln, offs,  
                         "unknown macro: %s%s",  
                         buf, strlen(buf) > 3 ? "..." : "");  
   
         /* FIXME: logic should be in driver. */  
         /* FIXME: broken, will error out and not omit a message. */  
         return(MDOC_IGN_MACRO & m->pflags ? rc : 0);  
 }  
   
   
 /*  /*
  * Parse a macro line, that is, a line beginning with the control   * Parse a macro line, that is, a line beginning with the control
  * character.   * character.
  */   */
 int  static int
 mdoc_pmacro(struct mdoc *m, const struct regset *regs,  mdoc_pmacro(struct mdoc *m, int ln, char *buf, int offs)
                 int ln, char *buf, int offs)  
 {  {
         enum mdoct        tok;          enum mdoct        tok;
         int               i, j, sv;          int               i, j, sv;
Line 716  mdoc_pmacro(struct mdoc *m, const struct regset *regs,
Line 747  mdoc_pmacro(struct mdoc *m, const struct regset *regs,
   
         i = offs;          i = offs;
   
         /* Accept whitespace after the initial control char. */          /* Accept tabs/whitespace after the initial control char. */
   
         if (' ' == buf[i]) {          if (' ' == buf[i] || '\t' == buf[i]) {
                 i++;                  i++;
                 while (buf[i] && ' ' == buf[i])                  while (buf[i] && (' ' == buf[i] || '\t' == buf[i]))
                         i++;                          i++;
                 if ('\0' == buf[i])                  if ('\0' == buf[i])
                         return(1);                          return(1);
Line 728  mdoc_pmacro(struct mdoc *m, const struct regset *regs,
Line 759  mdoc_pmacro(struct mdoc *m, const struct regset *regs,
   
         sv = i;          sv = i;
   
         /* Copy the first word into a nil-terminated buffer. */          /*
            * Copy the first word into a nil-terminated buffer.
            * Stop copying when a tab, space, or eoln is encountered.
            */
   
         for (j = 0; j < 4; j++, i++) {          j = 0;
                 if ('\0' == (mac[j] = buf[i]))          while (j < 4 && '\0' != buf[i] && ' ' != buf[i] && '\t' != buf[i])
                         break;                  mac[j++] = buf[i++];
                 else if (' ' == buf[i])  
                         break;  
   
                 /* Check for invalid characters. */  
   
                 if (isgraph((u_char)buf[i]))  
                         continue;  
                 if ( ! mdoc_pmsg(m, ln, i, MANDOCERR_BADCHAR))  
                         return(0);  
                 i--;  
         }  
   
         mac[j] = '\0';          mac[j] = '\0';
   
         if (j == 4 || j < 2) {          tok = (j > 1 || j < 4) ? mdoc_hash_find(mac) : MDOC_MAX;
                 if ( ! macrowarn(m, ln, mac, sv))          if (MDOC_MAX == tok) {
                         goto err;                  mdoc_vmsg(m, MANDOCERR_MACRO, ln, sv, "%s", buf + sv - 1);
                 return(1);                  return(1);
         }  
   
         if (MDOC_MAX == (tok = mdoc_hash_find(mac))) {  
                 if ( ! macrowarn(m, ln, mac, sv))  
                         goto err;  
                 return(1);  
         }          }
   
         /* The macro is sane.  Jump to the next word. */          /* Disregard the first trailing tab, if applicable. */
   
           if ('\t' == buf[i])
                   i++;
   
           /* Jump to the next non-whitespace word. */
   
         while (buf[i] && ' ' == buf[i])          while (buf[i] && ' ' == buf[i])
                 i++;                  i++;
   
Line 779  mdoc_pmacro(struct mdoc *m, const struct regset *regs,
Line 800  mdoc_pmacro(struct mdoc *m, const struct regset *regs,
          */           */
   
         if (NULL == m->last || MDOC_It == tok || MDOC_El == tok) {          if (NULL == m->last || MDOC_It == tok || MDOC_El == tok) {
                 if ( ! mdoc_macro(m, regs, tok, ln, sv, &i, buf))                  if ( ! mdoc_macro(m, tok, ln, sv, &i, buf))
                         goto err;                          goto err;
                 return(1);                  return(1);
         }          }
Line 793  mdoc_pmacro(struct mdoc *m, const struct regset *regs,
Line 814  mdoc_pmacro(struct mdoc *m, const struct regset *regs,
          */           */
   
         if (MDOC_Bl == n->tok && MDOC_BODY == n->type &&          if (MDOC_Bl == n->tok && MDOC_BODY == n->type &&
                         LIST_column == n->data.Bl.type) {                          LIST_column == n->data.Bl->type) {
                 m->flags |= MDOC_FREECOL;                  m->flags |= MDOC_FREECOL;
                 if ( ! mdoc_macro(m, regs, MDOC_It, ln, sv, &sv, buf))                  if ( ! mdoc_macro(m, MDOC_It, ln, sv, &sv, buf))
                         goto err;                          goto err;
                 return(1);                  return(1);
         }          }
Line 809  mdoc_pmacro(struct mdoc *m, const struct regset *regs,
Line 830  mdoc_pmacro(struct mdoc *m, const struct regset *regs,
         if (MDOC_It == n->tok && MDOC_BLOCK == n->type &&          if (MDOC_It == n->tok && MDOC_BLOCK == n->type &&
                         NULL != n->parent &&                          NULL != n->parent &&
                         MDOC_Bl == n->parent->tok &&                          MDOC_Bl == n->parent->tok &&
                         LIST_column == n->parent->data.Bl.type) {                          LIST_column == n->parent->data.Bl->type) {
                 m->flags |= MDOC_FREECOL;                  m->flags |= MDOC_FREECOL;
                 if ( ! mdoc_macro(m, regs, MDOC_It, ln, sv, &sv, buf))                  if ( ! mdoc_macro(m, MDOC_It, ln, sv, &sv, buf))
                         goto err;                          goto err;
                 return(1);                  return(1);
         }          }
   
         /* Normal processing of a macro. */          /* Normal processing of a macro. */
   
         if ( ! mdoc_macro(m, regs, tok, ln, sv, &i, buf))          if ( ! mdoc_macro(m, tok, ln, sv, &i, buf))
                 goto err;                  goto err;
   
         return(1);          return(1);
Legend:
Removed from v.1.148  
changed lines
  Added in v.1.170
CVSweb