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

Diff for /mandoc/manpath.c between version 1.22 and 1.30

version 1.22, 2015/03/26 22:42:32 version 1.30, 2016/05/28 13:44:13
Line 21 
Line 21 
 #include <sys/stat.h>  #include <sys/stat.h>
   
 #include <ctype.h>  #include <ctype.h>
   #if HAVE_ERR
   #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 "manpath.h"  #include "manconf.h"
   
 #define MAN_CONF_FILE   "/etc/man.conf"  #if !HAVE_MANPATH
   static  void     manconf_file(struct manconf *, const char *);
   #endif
 static  void     manpath_add(struct manpaths *, const char *, int);  static  void     manpath_add(struct manpaths *, const char *, int);
 static  void     manpath_parseline(struct manpaths *, char *, int);  static  void     manpath_parseline(struct manpaths *, char *, int);
   
   
 void  void
 manpath_parse(struct manpaths *dirs, const char *file,  manconf_parse(struct manconf *conf, const char *file,
                 char *defp, char *auxp)                  char *defp, char *auxp)
 {  {
 #if HAVE_MANPATH  #if HAVE_MANPATH
Line 78  manpath_parse(struct manpaths *dirs, const char *file,
Line 83  manpath_parse(struct manpaths *dirs, const char *file,
         if ( ! ferror(stream) && feof(stream) &&          if ( ! ferror(stream) && feof(stream) &&
                         bsz && '\n' == buf[bsz - 1]) {                          bsz && '\n' == buf[bsz - 1]) {
                 buf[bsz - 1] = '\0';                  buf[bsz - 1] = '\0';
                 manpath_parseline(dirs, buf, 1);                  manpath_parseline(&conf->manpath, buf, 1);
         }          }
   
         free(buf);          free(buf);
         pclose(stream);          pclose(stream);
 #else  #else
         char             manpath_default[] = MANPATH_DEFAULT;  
         char            *insert;          char            *insert;
   
         /* Always prepend -m. */          /* Always prepend -m. */
         manpath_parseline(dirs, auxp, 1);          manpath_parseline(&conf->manpath, auxp, 1);
   
         /* If -M is given, it overrides everything else. */          /* If -M is given, it overrides everything else. */
         if (NULL != defp) {          if (NULL != defp) {
                 manpath_parseline(dirs, defp, 1);                  manpath_parseline(&conf->manpath, defp, 1);
                 return;                  return;
         }          }
   
Line 103  manpath_parse(struct manpaths *dirs, const char *file,
Line 107  manpath_parse(struct manpaths *dirs, const char *file,
   
         /* No MANPATH; use man.conf(5) only. */          /* No MANPATH; use man.conf(5) only. */
         if (NULL == defp || '\0' == defp[0]) {          if (NULL == defp || '\0' == defp[0]) {
                 manpath_manconf(dirs, file);                  manconf_file(conf, file);
                 if (dirs->sz == 0)  
                         manpath_parseline(dirs, manpath_default, 0);  
                 return;                  return;
         }          }
   
         /* Prepend man.conf(5) to MANPATH. */          /* Prepend man.conf(5) to MANPATH. */
         if (':' == defp[0]) {          if (':' == defp[0]) {
                 manpath_manconf(dirs, file);                  manconf_file(conf, file);
                 manpath_parseline(dirs, 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(dirs, defp, 0);                  manpath_parseline(&conf->manpath, defp, 0);
                 manpath_manconf(dirs, file);                  manconf_file(conf, file);
                 return;                  return;
         }          }
   
Line 127  manpath_parse(struct manpaths *dirs, const char *file,
Line 129  manpath_parse(struct manpaths *dirs, const char *file,
         insert = strstr(defp, "::");          insert = strstr(defp, "::");
         if (NULL != insert) {          if (NULL != insert) {
                 *insert++ = '\0';                  *insert++ = '\0';
                 manpath_parseline(dirs, defp, 0);                  manpath_parseline(&conf->manpath, defp, 0);
                 manpath_manconf(dirs, file);                  manconf_file(conf, file);
                 manpath_parseline(dirs, 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(dirs, defp, 0);          manpath_parseline(&conf->manpath, defp, 0);
 #endif  #endif
 }  }
   
Line 166  manpath_add(struct manpaths *dirs, const char *dir, in
Line 168  manpath_add(struct manpaths *dirs, const char *dir, in
         size_t           i;          size_t           i;
   
         if (NULL == (cp = realpath(dir, buf))) {          if (NULL == (cp = realpath(dir, buf))) {
                 if (complain) {                  if (complain)
                         fputs("manpath: ", stderr);                          warn("manpath: %s", dir);
                         perror(dir);  
                 }  
                 return;                  return;
         }          }
   
Line 178  manpath_add(struct manpaths *dirs, const char *dir, in
Line 178  manpath_add(struct manpaths *dirs, const char *dir, in
                         return;                          return;
   
         if (stat(cp, &sb) == -1) {          if (stat(cp, &sb) == -1) {
                 if (complain) {                  if (complain)
                         fputs("manpath: ", stderr);                          warn("manpath: %s", dir);
                         perror(dir);  
                 }  
                 return;                  return;
         }          }
   
Line 192  manpath_add(struct manpaths *dirs, const char *dir, in
Line 190  manpath_add(struct manpaths *dirs, const char *dir, in
 }  }
   
 void  void
 manpath_free(struct manpaths *p)  manconf_free(struct manconf *conf)
 {  {
         size_t           i;          size_t           i;
   
         for (i = 0; i < p->sz; i++)          for (i = 0; i < conf->manpath.sz; i++)
                 free(p->paths[i]);                  free(conf->manpath.paths[i]);
   
         free(p->paths);          free(conf->manpath.paths);
           free(conf->output.includes);
           free(conf->output.man);
           free(conf->output.paper);
           free(conf->output.style);
 }  }
   
 void  #if !HAVE_MANPATH
 manpath_manconf(struct manpaths *dirs, const char *file)  static void
   manconf_file(struct manconf *conf, const char *file)
 {  {
         const char *const toks[] = { "manpath", "_whatdb" };          const char *const toks[] = { "manpath", "output", "_whatdb" };
           char manpath_default[] = MANPATH_DEFAULT;
   
         FILE            *stream;          FILE            *stream;
         char            *cp, *ep;          char            *line, *cp, *ep;
         size_t           len, tok;          size_t           linesz, tok, toklen;
           ssize_t          linelen;
   
         if ((stream = fopen(file, "r")) == NULL)          if ((stream = fopen(file, "r")) == NULL)
                 return;                  goto out;
   
         while ((cp = fgetln(stream, &len)) != NULL) {          line = NULL;
                 ep = cp + len;          linesz = 0;
                 if (ep[-1] != '\n')  
                         break;          while ((linelen = getline(&line, &linesz, stream)) != -1) {
                 *--ep = '\0';                  cp = line;
                   ep = cp + linelen - 1;
                   while (ep > cp && isspace((unsigned char)*ep))
                           *ep-- = '\0';
                 while (isspace((unsigned char)*cp))                  while (isspace((unsigned char)*cp))
                         cp++;                          cp++;
                 if (*cp == '#')                  if (cp == ep || *cp == '#')
                         continue;                          continue;
   
                 for (tok = 0; tok < sizeof(toks)/sizeof(toks[0]); tok++) {                  for (tok = 0; tok < sizeof(toks)/sizeof(toks[0]); tok++) {
                         len = strlen(toks[tok]);                          toklen = strlen(toks[tok]);
                         if (cp + len < ep &&                          if (cp + toklen < ep &&
                             isspace((unsigned char)cp[len]) &&                              isspace((unsigned char)cp[toklen]) &&
                             !strncmp(cp, toks[tok], len)) {                              strncmp(cp, toks[tok], toklen) == 0) {
                                 cp += len;                                  cp += toklen;
                                 while (isspace((unsigned char)*cp))                                  while (isspace((unsigned char)*cp))
                                         cp++;                                          cp++;
                                 break;                                  break;
Line 237  manpath_manconf(struct manpaths *dirs, const char *fil
Line 245  manpath_manconf(struct manpaths *dirs, const char *fil
                 }                  }
   
                 switch (tok) {                  switch (tok) {
                 case 1:  /* _whatdb */                  case 2:  /* _whatdb */
                         while (ep > cp && ep[-1] != '/')                          while (ep > cp && ep[-1] != '/')
                                 ep--;                                  ep--;
                         if (ep == cp)                          if (ep == cp)
Line 245  manpath_manconf(struct manpaths *dirs, const char *fil
Line 253  manpath_manconf(struct manpaths *dirs, const char *fil
                         *ep = '\0';                          *ep = '\0';
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case 0:  /* manpath */                  case 0:  /* manpath */
                         manpath_add(dirs, cp, 0);                          manpath_add(&conf->manpath, cp, 0);
                           *manpath_default = '\0';
                         break;                          break;
                   case 1:  /* output */
                           manconf_output(&conf->output, cp);
                           break;
                 default:                  default:
                         break;                          break;
                 }                  }
         }          }
           free(line);
         fclose(stream);          fclose(stream);
   
   out:
           if (*manpath_default != '\0')
                   manpath_parseline(&conf->manpath, manpath_default, 0);
   }
   #endif
   
   void
   manconf_output(struct manoutput *conf, const char *cp)
   {
           const char *const toks[] = {
               "includes", "man", "paper", "style",
               "indent", "width", "fragment", "mdoc"
           };
   
           size_t   len, tok;
   
           for (tok = 0; tok < sizeof(toks)/sizeof(toks[0]); tok++) {
                   len = strlen(toks[tok]);
                   if ( ! strncmp(cp, toks[tok], len) &&
                       strchr(" =  ", cp[len]) != NULL) {
                           cp += len;
                           if (*cp == '=')
                                   cp++;
                           while (isspace((unsigned char)*cp))
                                   cp++;
                           break;
                   }
           }
   
           if (tok < 6 && *cp == '\0')
                   return;
   
           switch (tok) {
           case 0:
                   if (conf->includes == NULL)
                           conf->includes = mandoc_strdup(cp);
                   break;
           case 1:
                   if (conf->man == NULL)
                           conf->man = mandoc_strdup(cp);
                   break;
           case 2:
                   if (conf->paper == NULL)
                           conf->paper = mandoc_strdup(cp);
                   break;
           case 3:
                   if (conf->style == NULL)
                           conf->style = mandoc_strdup(cp);
                   break;
           case 4:
                   if (conf->indent == 0)
                           conf->indent = strtonum(cp, 0, 1000, NULL);
                   break;
           case 5:
                   if (conf->width == 0)
                           conf->width = strtonum(cp, 58, 1000, NULL);
                   break;
           case 6:
                   conf->fragment = 1;
                   break;
           case 7:
                   conf->mdoc = 1;
                   break;
           default:
                   break;
           }
 }  }

Legend:
Removed from v.1.22  
changed lines
  Added in v.1.30

CVSweb