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

Diff for /mandoc/mansearch.c between version 1.51 and 1.54

version 1.51, 2014/11/27 01:58:21 version 1.54, 2015/02/27 16:02:10
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2012 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2012 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2013, 2014 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2013, 2014, 2015 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 21 
 #include <sys/types.h>  #include <sys/types.h>
   
 #include <assert.h>  #include <assert.h>
   #include <errno.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <getopt.h>  #include <getopt.h>
   #include <glob.h>
 #include <limits.h>  #include <limits.h>
 #include <regex.h>  #include <regex.h>
 #include <stdio.h>  #include <stdio.h>
Line 84  struct match {
Line 86  struct match {
         int              form; /* bit field: formatted, zipped? */          int              form; /* bit field: formatted, zipped? */
 };  };
   
 static  void             buildnames(struct manpage *, sqlite3 *,  static  void             buildnames(const struct mansearch *,
                                   struct manpage *, sqlite3 *,
                                 sqlite3_stmt *, uint64_t,                                  sqlite3_stmt *, uint64_t,
                                 const char *, int form);                                  const char *, int form);
 static  char            *buildoutput(sqlite3 *, sqlite3_stmt *,  static  char            *buildoutput(sqlite3 *, sqlite3_stmt *,
Line 95  static void  *hash_calloc(size_t, size_t, void *);
Line 98  static void  *hash_calloc(size_t, size_t, void *);
 static  struct expr     *exprcomp(const struct mansearch *,  static  struct expr     *exprcomp(const struct mansearch *,
                                 int, char *[]);                                  int, char *[]);
 static  void             exprfree(struct expr *);  static  void             exprfree(struct expr *);
 static  struct expr     *exprspec(struct expr *, uint64_t,  
                                  const char *, const char *);  
 static  struct expr     *exprterm(const struct mansearch *, char *, int);  static  struct expr     *exprterm(const struct mansearch *, char *, int);
 static  int              manpage_compare(const void *, const void *);  static  int              manpage_compare(const void *, const void *);
 static  void             sql_append(char **sql, size_t *sz,  static  void             sql_append(char **sql, size_t *sz,
Line 246  mansearch(const struct mansearch *search,
Line 247  mansearch(const struct mansearch *search,
                     SQLITE_OPEN_READONLY, NULL);                      SQLITE_OPEN_READONLY, NULL);
   
                 if (SQLITE_OK != c) {                  if (SQLITE_OK != c) {
                         perror(MANDOC_DB);                          fprintf(stderr, "%s/%s: %s\n",
                               paths->paths[i], MANDOC_DB, strerror(errno));
                         sqlite3_close(db);                          sqlite3_close(db);
                         continue;                          continue;
                 }                  }
Line 341  mansearch(const struct mansearch *search,
Line 343  mansearch(const struct mansearch *search,
                         mpage->bits = mp->bits;                          mpage->bits = mp->bits;
                         mpage->sec = 10;                          mpage->sec = 10;
                         mpage->form = mp->form;                          mpage->form = mp->form;
                         buildnames(mpage, db, s, mp->pageid,                          buildnames(search, mpage, db, s, mp->pageid,
                             paths->paths[i], mp->form);                              paths->paths[i], mp->form);
                         mpage->output = TYPE_Nd & outbit ?                          if (mpage->names != NULL) {
                             mp->desc : outbit ?                                  mpage->output = TYPE_Nd & outbit ?
                             buildoutput(db, s2, mp->pageid, outbit) : NULL;                                      mp->desc : outbit ?
                                       buildoutput(db, s2, mp->pageid, outbit) :
                                       NULL;
                                   cur++;
                           }
                         free(mp);                          free(mp);
                         cur++;  
                 }                  }
   
                 sqlite3_finalize(s);                  sqlite3_finalize(s);
Line 405  manpage_compare(const void *vp1, const void *vp2)
Line 409  manpage_compare(const void *vp1, const void *vp2)
 }  }
   
 static void  static void
 buildnames(struct manpage *mpage, sqlite3 *db, sqlite3_stmt *s,  buildnames(const struct mansearch *search, struct manpage *mpage,
                   sqlite3 *db, sqlite3_stmt *s,
                 uint64_t pageid, const char *path, int form)                  uint64_t pageid, const char *path, int form)
 {  {
         char            *newnames, *prevsec, *prevarch;          glob_t           globinfo;
           char            *firstname, *newnames, *prevsec, *prevarch;
         const char      *oldnames, *sep1, *name, *sec, *sep2, *arch, *fsec;          const char      *oldnames, *sep1, *name, *sec, *sep2, *arch, *fsec;
         size_t           i;          size_t           i;
         int              c;          int              c, globres;
   
         mpage->file = NULL;          mpage->file = NULL;
         mpage->names = NULL;          mpage->names = NULL;
         prevsec = prevarch = NULL;          firstname = prevsec = prevarch = NULL;
         i = 1;          i = 1;
         SQL_BIND_INT64(db, s, i, pageid);          SQL_BIND_INT64(db, s, i, pageid);
         while (SQLITE_ROW == (c = sqlite3_step(s))) {          while (SQLITE_ROW == (c = sqlite3_step(s))) {
Line 430  buildnames(struct manpage *mpage, sqlite3 *db, sqlite3
Line 436  buildnames(struct manpage *mpage, sqlite3 *db, sqlite3
                         sep1 = ", ";                          sep1 = ", ";
                 }                  }
   
                 /* Fetch the next name. */                  /* Fetch the next name, rejecting sec/arch mismatches. */
   
                 sec = (const char *)sqlite3_column_text(s, 0);                  sec = (const char *)sqlite3_column_text(s, 0);
                   if (search->sec != NULL && strcasecmp(sec, search->sec))
                           continue;
                 arch = (const char *)sqlite3_column_text(s, 1);                  arch = (const char *)sqlite3_column_text(s, 1);
                   if (search->arch != NULL && *arch != '\0' &&
                       strcasecmp(arch, search->arch))
                           continue;
                 name = (const char *)sqlite3_column_text(s, 2);                  name = (const char *)sqlite3_column_text(s, 2);
   
                 /* Remember the first section found. */                  /* Remember the first section found. */
Line 485  buildnames(struct manpage *mpage, sqlite3 *db, sqlite3
Line 496  buildnames(struct manpage *mpage, sqlite3 *db, sqlite3
                 sep2 = *arch == '\0' ? "" : "/";                  sep2 = *arch == '\0' ? "" : "/";
                 mandoc_asprintf(&mpage->file, "%s/%s%s%s%s/%s.%s",                  mandoc_asprintf(&mpage->file, "%s/%s%s%s%s/%s.%s",
                     path, sep1, sec, sep2, arch, name, fsec);                      path, sep1, sec, sep2, arch, name, fsec);
                   if (access(mpage->file, R_OK) != -1)
                           continue;
   
                   /* Handle unusual file name extensions. */
   
                   if (firstname == NULL)
                           firstname = mpage->file;
                   else
                           free(mpage->file);
                   mandoc_asprintf(&mpage->file, "%s/%s%s%s%s/%s.*",
                       path, sep1, sec, sep2, arch, name);
                   globres = glob(mpage->file, 0, NULL, &globinfo);
                   free(mpage->file);
                   mpage->file = globres ? NULL :
                       mandoc_strdup(*globinfo.gl_pathv);
                   globfree(&globinfo);
         }          }
         if (c != SQLITE_DONE)          if (c != SQLITE_DONE)
                 fprintf(stderr, "%s\n", sqlite3_errmsg(db));                  fprintf(stderr, "%s\n", sqlite3_errmsg(db));
         sqlite3_reset(s);          sqlite3_reset(s);
   
           /* If none of the files is usable, use the first name. */
   
           if (mpage->file == NULL)
                   mpage->file = firstname;
           else if (mpage->file != firstname)
                   free(firstname);
   
         /* Append one final section to the names. */          /* Append one final section to the names. */
   
         if (prevsec != NULL) {          if (prevsec != NULL) {
Line 643  exprcomp(const struct mansearch *search, int argc, cha
Line 677  exprcomp(const struct mansearch *search, int argc, cha
         struct expr     *first, *prev, *cur, *next;          struct expr     *first, *prev, *cur, *next;
   
         first = cur = NULL;          first = cur = NULL;
         logic = igncase = toclose = 0;          logic = igncase = toopen = toclose = 0;
         toopen = NULL != search->sec || NULL != search->arch;  
   
         for (i = 0; i < argc; i++) {          for (i = 0; i < argc; i++) {
                 if (0 == strcmp("(", argv[i])) {                  if (0 == strcmp("(", argv[i])) {
Line 710  exprcomp(const struct mansearch *search, int argc, cha
Line 743  exprcomp(const struct mansearch *search, int argc, cha
   
                 toopen = logic = igncase = 0;                  toopen = logic = igncase = 0;
         }          }
         if (toopen || logic || igncase || toclose)          if ( ! (toopen || logic || igncase || toclose))
                 goto fail;                  return(first);
   
         if (NULL != search->sec || NULL != search->arch)  
                 cur->close++;  
         if (NULL != search->arch)  
                 cur = exprspec(cur, TYPE_arch, search->arch, "^(%s|any)$");  
         if (NULL != search->sec)  
                 exprspec(cur, TYPE_sec, search->sec, "^%s$");  
   
         return(first);  
   
 fail:  fail:
         if (NULL != first)          if (NULL != first)
                 exprfree(first);                  exprfree(first);
         return(NULL);          return(NULL);
 }  
   
 static struct expr *  
 exprspec(struct expr *cur, uint64_t key, const char *value,  
                 const char *format)  
 {  
         char     errbuf[BUFSIZ];  
         char    *cp;  
         int      irc;  
   
         mandoc_asprintf(&cp, format, value);  
         cur->next = mandoc_calloc(1, sizeof(struct expr));  
         cur = cur->next;  
         cur->and = 1;  
         cur->bits = key;  
         if (0 != (irc = regcomp(&cur->regexp, cp,  
             REG_EXTENDED | REG_NOSUB | REG_ICASE))) {  
                 regerror(irc, &cur->regexp, errbuf, sizeof(errbuf));  
                 fprintf(stderr, "regcomp: %s\n", errbuf);  
                 cur->substr = value;  
         }  
         free(cp);  
         return(cur);  
 }  }
   
 static struct expr *  static struct expr *
Legend:
Removed from v.1.51  
changed lines
  Added in v.1.54
CVSweb