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

Diff for /mandoc/manpath.c between version 1.36 and 1.42

version 1.36, 2018/10/02 14:56:47 version 1.42, 2020/07/21 15:10:01
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2011,2014,2015,2017,2018 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2011,2014,2015,2017-2019 Ingo Schwarze <schwarze@openbsd.org>
  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
Line 21 
Line 21 
 #include <sys/stat.h>  #include <sys/stat.h>
   
 #include <ctype.h>  #include <ctype.h>
 #if HAVE_ERR  #include <errno.h>
 #include <err.h>  
 #endif  
 #include <limits.h>  #include <limits.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   
 #include "mandoc_aux.h"  #include "mandoc_aux.h"
   #include "mandoc.h"
 #include "manconf.h"  #include "manconf.h"
   
 static  void     manconf_file(struct manconf *, const char *);  static  void     manconf_file(struct manconf *, const char *);
 static  void     manpath_add(struct manpaths *, const char *, int);  static  void     manpath_add(struct manpaths *, const char *, char);
 static  void     manpath_parseline(struct manpaths *, char *, int);  static  void     manpath_parseline(struct manpaths *, char *, char);
   
   
 void  void
Line 44  manconf_parse(struct manconf *conf, const char *file,
Line 43  manconf_parse(struct manconf *conf, const char *file,
         char            *insert;          char            *insert;
   
         /* Always prepend -m. */          /* Always prepend -m. */
         manpath_parseline(&conf->manpath, auxp, 1);          manpath_parseline(&conf->manpath, auxp, 'm');
   
         /* If -M is given, it overrides everything else. */          /* If -M is given, it overrides everything else. */
         if (NULL != defp) {          if (NULL != defp) {
                 manpath_parseline(&conf->manpath, defp, 1);                  manpath_parseline(&conf->manpath, defp, 'M');
                 return;                  return;
         }          }
   
Line 66  manconf_parse(struct manconf *conf, const char *file,
Line 65  manconf_parse(struct manconf *conf, const char *file,
         /* Prepend man.conf(5) to MANPATH. */          /* Prepend man.conf(5) to MANPATH. */
         if (':' == defp[0]) {          if (':' == defp[0]) {
                 manconf_file(conf, file);                  manconf_file(conf, file);
                 manpath_parseline(&conf->manpath, defp, 0);                  manpath_parseline(&conf->manpath, defp, '\0');
                 return;                  return;
         }          }
   
         /* Append man.conf(5) to MANPATH. */          /* Append man.conf(5) to MANPATH. */
         if (':' == defp[strlen(defp) - 1]) {          if (':' == defp[strlen(defp) - 1]) {
                 manpath_parseline(&conf->manpath, defp, 0);                  manpath_parseline(&conf->manpath, defp, '\0');
                 manconf_file(conf, file);                  manconf_file(conf, file);
                 return;                  return;
         }          }
Line 81  manconf_parse(struct manconf *conf, const char *file,
Line 80  manconf_parse(struct manconf *conf, const char *file,
         insert = strstr(defp, "::");          insert = strstr(defp, "::");
         if (NULL != insert) {          if (NULL != insert) {
                 *insert++ = '\0';                  *insert++ = '\0';
                 manpath_parseline(&conf->manpath, defp, 0);                  manpath_parseline(&conf->manpath, defp, '\0');
                 manconf_file(conf, file);                  manconf_file(conf, file);
                 manpath_parseline(&conf->manpath, insert + 1, 0);                  manpath_parseline(&conf->manpath, insert + 1, '\0');
                 return;                  return;
         }          }
   
         /* MANPATH overrides man.conf(5) completely. */          /* MANPATH overrides man.conf(5) completely. */
         manpath_parseline(&conf->manpath, defp, 0);          manpath_parseline(&conf->manpath, defp, '\0');
 }  }
   
 void  void
 manpath_base(struct manpaths *dirs)  manpath_base(struct manpaths *dirs)
 {  {
         char path_base[] = MANPATH_BASE;          char path_base[] = MANPATH_BASE;
         manpath_parseline(dirs, path_base, 0);          manpath_parseline(dirs, path_base, '\0');
 }  }
   
 /*  /*
  * Parse a FULL pathname from a colon-separated list of arrays.   * Parse a FULL pathname from a colon-separated list of arrays.
  */   */
 static void  static void
 manpath_parseline(struct manpaths *dirs, char *path, int complain)  manpath_parseline(struct manpaths *dirs, char *path, char option)
 {  {
         char    *dir;          char    *dir;
   
Line 110  manpath_parseline(struct manpaths *dirs, char *path, i
Line 109  manpath_parseline(struct manpaths *dirs, char *path, i
                 return;                  return;
   
         for (dir = strtok(path, ":"); dir; dir = strtok(NULL, ":"))          for (dir = strtok(path, ":"); dir; dir = strtok(NULL, ":"))
                 manpath_add(dirs, dir, complain);                  manpath_add(dirs, dir, option);
 }  }
   
 /*  /*
Line 118  manpath_parseline(struct manpaths *dirs, char *path, i
Line 117  manpath_parseline(struct manpaths *dirs, char *path, i
  * Grow the array one-by-one for simplicity's sake.   * Grow the array one-by-one for simplicity's sake.
  */   */
 static void  static void
 manpath_add(struct manpaths *dirs, const char *dir, int complain)  manpath_add(struct manpaths *dirs, const char *dir, char option)
 {  {
         char             buf[PATH_MAX];          char             buf[PATH_MAX];
         struct stat      sb;          struct stat      sb;
         char            *cp;          char            *cp;
         size_t           i;          size_t           i;
   
         if (NULL == (cp = realpath(dir, buf))) {          if ((cp = realpath(dir, buf)) == NULL)
                 if (complain)                  goto fail;
                         warn("manpath: %s", dir);  
                 return;  
         }  
   
         for (i = 0; i < dirs->sz; i++)          for (i = 0; i < dirs->sz; i++)
                 if (0 == strcmp(dirs->paths[i], dir))                  if (strcmp(dirs->paths[i], dir) == 0)
                         return;                          return;
   
         if (stat(cp, &sb) == -1) {          if (stat(cp, &sb) == -1)
                 if (complain)                  goto fail;
                         warn("manpath: %s", dir);  
                 return;  
         }  
   
         dirs->paths = mandoc_reallocarray(dirs->paths,          dirs->paths = mandoc_reallocarray(dirs->paths,
             dirs->sz + 1, sizeof(char *));              dirs->sz + 1, sizeof(*dirs->paths));
   
         dirs->paths[dirs->sz++] = mandoc_strdup(cp);          dirs->paths[dirs->sz++] = mandoc_strdup(cp);
           return;
   
   fail:
           if (option != '\0')
                   mandoc_msg(MANDOCERR_BADARG_BAD, 0, 0,
                       "-%c %s: %s", option, dir, strerror(errno));
 }  }
   
 void  void
Line 165  manconf_free(struct manconf *conf)
Line 163  manconf_free(struct manconf *conf)
 static void  static void
 manconf_file(struct manconf *conf, const char *file)  manconf_file(struct manconf *conf, const char *file)
 {  {
         const char *const toks[] = { "manpath", "output", "_whatdb" };          const char *const toks[] = { "manpath", "output" };
         char manpath_default[] = MANPATH_DEFAULT;          char manpath_default[] = MANPATH_DEFAULT;
   
         FILE            *stream;          FILE            *stream;
Line 202  manconf_file(struct manconf *conf, const char *file)
Line 200  manconf_file(struct manconf *conf, const char *file)
                 }                  }
   
                 switch (tok) {                  switch (tok) {
                 case 2:  /* _whatdb */  
                         while (ep > cp && ep[-1] != '/')  
                                 ep--;  
                         if (ep == cp)  
                                 continue;  
                         *ep = '\0';  
                         /* FALLTHROUGH */  
                 case 0:  /* manpath */                  case 0:  /* manpath */
                         manpath_add(&conf->manpath, cp, 0);                          manpath_add(&conf->manpath, cp, '\0');
                         *manpath_default = '\0';                          *manpath_default = '\0';
                         break;                          break;
                 case 1:  /* output */                  case 1:  /* output */
Line 225  manconf_file(struct manconf *conf, const char *file)
Line 216  manconf_file(struct manconf *conf, const char *file)
   
 out:  out:
         if (*manpath_default != '\0')          if (*manpath_default != '\0')
                 manpath_parseline(&conf->manpath, manpath_default, 0);                  manpath_parseline(&conf->manpath, manpath_default, '\0');
 }  }
   
 int  int
 manconf_output(struct manoutput *conf, const char *cp, int fromfile)  manconf_output(struct manoutput *conf, const char *cp, int fromfile)
 {  {
         const char *const toks[] = {          const char *const toks[] = {
             "includes", "man", "paper", "style",              "includes", "man", "paper", "style", "indent", "width",
             "indent", "width", "fragment", "mdoc", "noval", "toc"              "tag", "outfilename", "tagfilename",
               "fragment", "mdoc", "noval", "toc"
         };          };
           const size_t ntoks = sizeof(toks) / sizeof(toks[0]);
   
         const char      *errstr;          const char      *errstr;
         char            *oldval;          char            *oldval;
         size_t           len, tok;          size_t           len, tok;
   
         for (tok = 0; tok < sizeof(toks)/sizeof(toks[0]); tok++) {          for (tok = 0; tok < ntoks; tok++) {
                 len = strlen(toks[tok]);                  len = strlen(toks[tok]);
                 if ( ! strncmp(cp, toks[tok], len) &&                  if (strncmp(cp, toks[tok], len) == 0 &&
                     strchr(" =  ", cp[len]) != NULL) {                      strchr(" =  ", cp[len]) != NULL) {
                         cp += len;                          cp += len;
                         if (*cp == '=')                          if (*cp == '=')
Line 253  manconf_output(struct manoutput *conf, const char *cp,
Line 246  manconf_output(struct manoutput *conf, const char *cp,
                 }                  }
         }          }
   
         if (tok < 6 && *cp == '\0') {          if (tok < 8 && *cp == '\0') {
                 warnx("-O %s=?: Missing argument value", toks[tok]);                  mandoc_msg(MANDOCERR_BADVAL_MISS, 0, 0, "-O %s=?", toks[tok]);
                 return -1;                  return -1;
         }          }
         if ((tok == 6 || tok == 7) && *cp != '\0') {          if (tok > 8 && tok < ntoks && *cp != '\0') {
                 warnx("-O %s: Does not take a value: %s", toks[tok], cp);                  mandoc_msg(MANDOCERR_BADVAL, 0, 0, "-O %s=%s", toks[tok], cp);
                 return -1;                  return -1;
         }          }
   
Line 299  manconf_output(struct manoutput *conf, const char *cp,
Line 292  manconf_output(struct manoutput *conf, const char *cp,
                 conf->indent = strtonum(cp, 0, 1000, &errstr);                  conf->indent = strtonum(cp, 0, 1000, &errstr);
                 if (errstr == NULL)                  if (errstr == NULL)
                         return 0;                          return 0;
                 warnx("-O indent=%s is %s", cp, errstr);                  mandoc_msg(MANDOCERR_BADVAL_BAD, 0, 0,
                       "-O indent=%s is %s", cp, errstr);
                 return -1;                  return -1;
         case 5:          case 5:
                 if (conf->width) {                  if (conf->width) {
Line 309  manconf_output(struct manoutput *conf, const char *cp,
Line 303  manconf_output(struct manoutput *conf, const char *cp,
                 conf->width = strtonum(cp, 1, 1000, &errstr);                  conf->width = strtonum(cp, 1, 1000, &errstr);
                 if (errstr == NULL)                  if (errstr == NULL)
                         return 0;                          return 0;
                 warnx("-O width=%s is %s", cp, errstr);                  mandoc_msg(MANDOCERR_BADVAL_BAD, 0, 0,
                       "-O width=%s is %s", cp, errstr);
                 return -1;                  return -1;
         case 6:          case 6:
                 conf->fragment = 1;                  if (conf->tag != NULL) {
                           oldval = mandoc_strdup(conf->tag);
                           break;
                   }
                   conf->tag = mandoc_strdup(cp);
                 return 0;                  return 0;
         case 7:          case 7:
                 conf->mdoc = 1;                  if (conf->outfilename != NULL) {
                           oldval = mandoc_strdup(conf->outfilename);
                           break;
                   }
                   conf->outfilename = mandoc_strdup(cp);
                 return 0;                  return 0;
         case 8:          case 8:
                 conf->noval = 1;                  if (conf->tagfilename != NULL) {
                           oldval = mandoc_strdup(conf->tagfilename);
                           break;
                   }
                   conf->tagfilename = mandoc_strdup(cp);
                 return 0;                  return 0;
         case 9:          case 9:
                   conf->fragment = 1;
                   return 0;
           case 10:
                   conf->mdoc = 1;
                   return 0;
           case 11:
                   conf->noval = 1;
                   return 0;
           case 12:
                 conf->toc = 1;                  conf->toc = 1;
                 return 0;                  return 0;
         default:          default:
                 if (fromfile)                  mandoc_msg(MANDOCERR_BADARG_BAD, 0, 0, "-O %s", cp);
                         warnx("-O %s: Bad argument", cp);  
                 return -1;                  return -1;
         }          }
         if (fromfile == 0)          if (fromfile) {
                 warnx("-O %s=%s: Option already set to %s",                  free(oldval);
                     toks[tok], cp, oldval);                  return 0;
         free(oldval);          } else {
         return -1;                  mandoc_msg(MANDOCERR_BADVAL_DUPE, 0, 0,
                       "-O %s=%s: already set to %s", toks[tok], cp, oldval);
                   free(oldval);
                   return -1;
           }
 }  }

Legend:
Removed from v.1.36  
changed lines
  Added in v.1.42

CVSweb