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

Diff for /mandoc/mdoc_argv.c between version 1.28 and 1.42

version 1.28, 2009/10/15 01:33:12 version 1.42, 2010/05/07 15:49:36
Line 14 
Line 14 
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */   */
   #ifdef HAVE_CONFIG_H
   #include "config.h"
   #endif
   
 #include <sys/types.h>  #include <sys/types.h>
   
 #include <assert.h>  #include <assert.h>
Line 23 
Line 27 
 #include <string.h>  #include <string.h>
   
 #include "libmdoc.h"  #include "libmdoc.h"
   #include "libmandoc.h"
   
 /*  /*
  * Routines to parse arguments of macros.  Arguments follow the syntax   * Routines to parse arguments of macros.  Arguments follow the syntax
Line 39 
Line 44 
   
 #define MULTI_STEP       5  #define MULTI_STEP       5
   
 static  int              argv_a2arg(int, const char *);  static  int              argv_a2arg(enum mdoct, const char *);
 static  int              args(struct mdoc *, int, int *,  static  enum margserr    args(struct mdoc *, int, int *,
                                 char *, int, char **);                                  char *, int, char **);
 static  int              argv(struct mdoc *, int,  static  int              argv(struct mdoc *, int,
                                 struct mdoc_argv *, int *, char *);                                  struct mdoc_argv *, int *, char *);
Line 59  static int mdoc_argvflags[MDOC_ARG_MAX] = {
Line 64  static int mdoc_argvflags[MDOC_ARG_MAX] = {
         ARGV_NONE,      /* MDOC_Ragged */          ARGV_NONE,      /* MDOC_Ragged */
         ARGV_NONE,      /* MDOC_Unfilled */          ARGV_NONE,      /* MDOC_Unfilled */
         ARGV_NONE,      /* MDOC_Literal */          ARGV_NONE,      /* MDOC_Literal */
         ARGV_NONE,      /* MDOC_File */          ARGV_SINGLE,    /* MDOC_File */
         ARGV_OPT_SINGLE, /* MDOC_Offset */          ARGV_OPT_SINGLE, /* MDOC_Offset */
         ARGV_NONE,      /* MDOC_Bullet */          ARGV_NONE,      /* MDOC_Bullet */
         ARGV_NONE,      /* MDOC_Dash */          ARGV_NONE,      /* MDOC_Dash */
Line 203  static int mdoc_argflags[MDOC_MAX] = {
Line 208  static int mdoc_argflags[MDOC_MAX] = {
         0, /* %Q */          0, /* %Q */
         0, /* br */          0, /* br */
         0, /* sp */          0, /* sp */
           0, /* %U */
 };  };
   
   
Line 211  static int mdoc_argflags[MDOC_MAX] = {
Line 217  static int mdoc_argflags[MDOC_MAX] = {
  * [value0...], which may either have a single mandatory value, at least   * [value0...], which may either have a single mandatory value, at least
  * one mandatory value, an optional single value, or no value.   * one mandatory value, an optional single value, or no value.
  */   */
 int  enum margverr
 mdoc_argv(struct mdoc *m, int line, int tok,  mdoc_argv(struct mdoc *m, int line, enum mdoct tok,
                 struct mdoc_arg **v, int *pos, char *buf)                  struct mdoc_arg **v, int *pos, char *buf)
 {  {
         char             *p, sv;          char             *p, sv;
Line 265  mdoc_argv(struct mdoc *m, int line, int tok,
Line 271  mdoc_argv(struct mdoc *m, int line, int tok,
         if ( ! argv(m, line, &tmp, pos, buf))          if ( ! argv(m, line, &tmp, pos, buf))
                 return(ARGV_ERROR);                  return(ARGV_ERROR);
   
         if (NULL == (arg = *v)) {          if (NULL == (arg = *v))
                 *v = calloc(1, sizeof(struct mdoc_arg));                  arg = *v = mandoc_calloc(1, sizeof(struct mdoc_arg));
                 if (NULL == *v) {  
                         (void)mdoc_nerr(m, m->last, EMALLOC);  
                         return(ARGV_ERROR);  
                 }  
                 arg = *v;  
         }  
   
         arg->argc++;          arg->argc++;
         arg->argv = realloc(arg->argv, arg->argc *          arg->argv = mandoc_realloc
                         sizeof(struct mdoc_argv));                  (arg->argv, arg->argc * sizeof(struct mdoc_argv));
   
         if (NULL == arg->argv) {  
                 (void)mdoc_nerr(m, m->last, EMALLOC);  
                 return(ARGV_ERROR);  
         }  
   
         (void)memcpy(&arg->argv[(int)arg->argc - 1],          (void)memcpy(&arg->argv[(int)arg->argc - 1],
                         &tmp, sizeof(struct mdoc_argv));                          &tmp, sizeof(struct mdoc_argv));
   
Line 293  mdoc_argv(struct mdoc *m, int line, int tok,
Line 288  mdoc_argv(struct mdoc *m, int line, int tok,
 void  void
 mdoc_argv_free(struct mdoc_arg *p)  mdoc_argv_free(struct mdoc_arg *p)
 {  {
         int              i, j;          int              i;
   
         if (NULL == p)          if (NULL == p)
                 return;                  return;
Line 305  mdoc_argv_free(struct mdoc_arg *p)
Line 300  mdoc_argv_free(struct mdoc_arg *p)
         }          }
         assert(p->argc);          assert(p->argc);
   
         /* LINTED */          for (i = (int)p->argc - 1; i >= 0; i--)
         for (i = 0; i < (int)p->argc; i++) {                  mdoc_argn_free(p, i);
                 if (0 == p->argv[i].sz)  
                         continue;  
                 if (NULL == p->argv[i].value)  
                         continue;  
   
                 /* LINTED */          free(p->argv);
                 for (j = 0; j < (int)p->argv[i].sz; j++)          free(p);
                         if (p->argv[i].value[j])  }
                                 free(p->argv[i].value[j]);  
   
                 free(p->argv[i].value);  
   void
   mdoc_argn_free(struct mdoc_arg *p, int iarg)
   {
           struct mdoc_argv *arg = &p->argv[iarg];
           int               j;
   
           if (arg->sz && arg->value) {
                   for (j = (int)arg->sz - 1; j >= 0; j--)
                           free(arg->value[j]);
                   free(arg->value);
         }          }
   
         free(p->argv);          for (--p->argc; iarg < (int)p->argc; iarg++)
         free(p);                  p->argv[iarg] = p->argv[iarg+1];
 }  }
   
   
 int  enum margserr
 mdoc_zargs(struct mdoc *m, int line, int *pos,  mdoc_zargs(struct mdoc *m, int line, int *pos,
                 char *buf, int flags, char **v)                  char *buf, int flags, char **v)
 {  {
Line 334  mdoc_zargs(struct mdoc *m, int line, int *pos, 
Line 334  mdoc_zargs(struct mdoc *m, int line, int *pos, 
 }  }
   
   
 int  enum margserr
 mdoc_args(struct mdoc *m, int line,  mdoc_args(struct mdoc *m, int line, int *pos,
                 int *pos, char *buf, int tok, char **v)                  char *buf, enum mdoct tok, char **v)
 {  {
         int               fl, c, i;          int               fl, c, i;
         struct mdoc_node *n;          struct mdoc_node *n;
   
         fl = (0 == tok) ? 0 : mdoc_argflags[tok];          fl = mdoc_argflags[tok];
   
         if (MDOC_It != tok)          if (MDOC_It != tok)
                 return(args(m, line, pos, buf, fl, v));                  return(args(m, line, pos, buf, fl, v));
Line 372  mdoc_args(struct mdoc *m, int line, 
Line 372  mdoc_args(struct mdoc *m, int line, 
 }  }
   
   
 static int  static enum margserr
 args(struct mdoc *m, int line, int *pos,  args(struct mdoc *m, int line, int *pos,
                 char *buf, int fl, char **v)                  char *buf, int fl, char **v)
 {  {
         int               i;          int               i;
         char             *p, *pp;          char             *p, *pp;
           enum margserr     rc;
   
         /*          /*
          * Parse out the terms (like `val' in `.Xx -arg val' or simply           * Parse out the terms (like `val' in `.Xx -arg val' or simply
Line 397  args(struct mdoc *m, int line, int *pos, 
Line 398  args(struct mdoc *m, int line, int *pos, 
         assert(*pos);          assert(*pos);
         assert(' ' != buf[*pos]);          assert(' ' != buf[*pos]);
   
         if (0 == buf[*pos])          if ('\0' == buf[*pos])
                 return(ARGS_EOLN);                  return(ARGS_EOLN);
   
         /*          /*
Line 406  args(struct mdoc *m, int line, int *pos, 
Line 407  args(struct mdoc *m, int line, int *pos, 
          * follows the pattern of [[::delim::][ ]+]+.           * follows the pattern of [[::delim::][ ]+]+.
          */           */
   
         if ((fl & ARGS_DELIM) && mdoc_iscdelim(buf[*pos])) {          if ((fl & ARGS_DELIM) && mdoc_iscdelim(buf[*pos]) > 1) {
                 for (i = *pos; buf[i]; ) {                  for (i = *pos; buf[i]; ) {
                         if ( ! mdoc_iscdelim(buf[i]))                          if ( mdoc_iscdelim(buf[i]) < 2)
                                 break;                                  break;
                         i++;                          i++;
                         if (0 == buf[i] || ' ' != buf[i])                          if (0 == buf[i] || ' ' != buf[i])
Line 453  args(struct mdoc *m, int line, int *pos, 
Line 454  args(struct mdoc *m, int line, int *pos, 
                                 break;                                  break;
                 }                  }
   
                   /* By default, assume a phrase. */
                   rc = ARGS_PHRASE;
   
                 /*                  /*
                  * Adjust new-buffer position to be beyond delimiter                   * Adjust new-buffer position to be beyond delimiter
                  * mark (e.g., Ta -> end + 2).                   * mark (e.g., Ta -> end + 2).
                  */                   */
                 if (p && pp) {                  if (p && pp) {
                         *pos += pp < p ? 2 : 1;                          *pos += pp < p ? 2 : 1;
                           rc = pp < p ? ARGS_PHRASE : ARGS_PPHRASE;
                         p = pp < p ? pp : p;                          p = pp < p ? pp : p;
                 } else if (p && ! pp) {                  } else if (p && ! pp) {
                           rc = ARGS_PPHRASE;
                         *pos += 1;                          *pos += 1;
                 } else if (pp && ! p) {                  } else if (pp && ! p) {
                         p = pp;                          p = pp;
Line 488  args(struct mdoc *m, int line, int *pos, 
Line 494  args(struct mdoc *m, int line, int *pos, 
                 for (pp = &buf[*pos]; ' ' == *pp; pp++, (*pos)++)                  for (pp = &buf[*pos]; ' ' == *pp; pp++, (*pos)++)
                         /* Skip ahead. */ ;                          /* Skip ahead. */ ;
   
                 return(ARGS_PHRASE);                  return(rc);
         }          }
   
         /*          /*
Line 557  args(struct mdoc *m, int line, int *pos, 
Line 563  args(struct mdoc *m, int line, int *pos, 
   
   
 static int  static int
 argv_a2arg(int tok, const char *p)  argv_a2arg(enum mdoct tok, const char *p)
 {  {
   
         /*          /*
Line 672  argv_multi(struct mdoc *m, int line, 
Line 678  argv_multi(struct mdoc *m, int line, 
                 else if (ARGS_EOLN == c)                  else if (ARGS_EOLN == c)
                         break;                          break;
   
                 if (0 == v->sz % MULTI_STEP) {                  if (0 == v->sz % MULTI_STEP)
                         v->value = realloc(v->value,                          v->value = mandoc_realloc(v->value,
                                 (v->sz + MULTI_STEP) * sizeof(char *));                                  (v->sz + MULTI_STEP) * sizeof(char *));
                         if (NULL == v->value) {  
                                 (void)mdoc_nerr(m, m->last, EMALLOC);                  v->value[(int)v->sz] = mandoc_strdup(p);
                                 return(ARGV_ERROR);  
                         }  
                 }  
                 if (NULL == (v->value[(int)v->sz] = strdup(p)))  
                         return(mdoc_nerr(m, m->last, EMALLOC));  
         }          }
   
         return(1);          return(1);
Line 705  argv_opt_single(struct mdoc *m, int line, 
Line 706  argv_opt_single(struct mdoc *m, int line, 
                 return(1);                  return(1);
   
         v->sz = 1;          v->sz = 1;
         if (NULL == (v->value = calloc(1, sizeof(char *))))          v->value = mandoc_malloc(sizeof(char *));
                 return(mdoc_nerr(m, m->last, EMALLOC));          v->value[0] = mandoc_strdup(p);
         if (NULL == (v->value[0] = strdup(p)))  
                 return(mdoc_nerr(m, m->last, EMALLOC));  
   
         return(1);          return(1);
 }  }
Line 733  argv_single(struct mdoc *m, int line, 
Line 732  argv_single(struct mdoc *m, int line, 
                 return(mdoc_perr(m, line, ppos, EARGVAL));                  return(mdoc_perr(m, line, ppos, EARGVAL));
   
         v->sz = 1;          v->sz = 1;
         if (NULL == (v->value = calloc(1, sizeof(char *))))          v->value = mandoc_malloc(sizeof(char *));
                 return(mdoc_nerr(m, m->last, EMALLOC));          v->value[0] = mandoc_strdup(p);
         if (NULL == (v->value[0] = strdup(p)))  
                 return(mdoc_nerr(m, m->last, EMALLOC));  
   
         return(1);          return(1);
 }  }
Legend:
Removed from v.1.28  
changed lines
  Added in v.1.42
CVSweb