cleanup function signatures and definitions

src/branch.cpp

@@ -91,8 +91,8 @@ parse(const string &str_,
   else
     branch.mode = Branch::RW;
 
-  fs::glob(str,globbed);
-  fs::realpathize(globbed);
+  fs::glob(str,&globbed);
+  fs::realpathize(&globbed);
   for(size_t i = 0; i < globbed.size(); i++)
     {
       branch.path = globbed[i];
@@ -109,7 +109,7 @@ set(Branches          &branches_,
 
   branches_.clear();
 
-  str::split(paths,str_,':');
+  str::split(str_,':',&paths);
 
   for(size_t i = 0; i < paths.size(); i++)
     {
@@ -130,7 +130,7 @@ add_begin(Branches          &branches_,
 {
   vector<string> paths;
 
-  str::split(paths,str_,':');
+  str::split(str_,':',&paths);
 
   for(size_t i = 0; i < paths.size(); i++)
     {
@@ -151,7 +151,7 @@ add_end(Branches          &branches_,
 {
   vector<string> paths;
 
-  str::split(paths,str_,':');
+  str::split(str_,':',&paths);
 
   for(size_t i = 0; i < paths.size(); i++)
     {
@@ -186,7 +186,7 @@ erase_fnmatch(Branches          &branches_,
 {
   vector<string> patterns;
 
-  str::split(patterns,str_,':');
+  str::split(str_,':',&patterns);
 
   for(Branches::iterator i = branches_.begin();
       i != branches_.end();)

src/buildmap.hpp

@@ -23,16 +23,16 @@ template<typename K,typename V>
 class buildmap
 {
 public:
-  buildmap(const K &key,
-           const V &val)
+  buildmap(const K &key_,
+           const V &val_)
   {
-    _map.insert(std::make_pair(key,val));
+    _map.insert(std::make_pair(key_,val_));
   }
 
-  buildmap<K,V> &operator()(const K &key,
-                            const V &val)
+  buildmap<K,V> &operator()(const K &key_,
+                            const V &val_)
   {
-    _map.insert(std::make_pair(key,val));
+    _map.insert(std::make_pair(key_,val_));
     return *this;
   }
 

src/buildvector.hpp

@@ -23,14 +23,14 @@ template<typename V, bool SORT = false>
 class buildvector
 {
 public:
-  buildvector(const V &val)
+  buildvector(const V &val_)
   {
-    _vector.push_back(val);
+    _vector.push_back(val_);
   }
 
-  buildvector<V,SORT> &operator()(const V &val)
+  buildvector<V,SORT> &operator()(const V &val_)
   {
-    _vector.push_back(val);
+    _vector.push_back(val_);
     return *this;
   }
 

src/config_statfsignore.hpp

@@ -26,4 +26,5 @@ enum class StatFSIgnoreEnum
     RO,
     NC
   };
+
 typedef Enum<StatFSIgnoreEnum> StatFSIgnore;

src/fs.cpp

@@ -38,20 +38,20 @@ using std::vector;
 namespace fs
 {
   void
-  findallfiles(const vector<string> &basepaths,
-               const char           *fusepath,
-               vector<string>       &paths)
+  findallfiles(const vector<string> &basepaths_,
+               const char           *fusepath_,
+               vector<string>       *paths_)
   {
     string fullpath;
 
-    for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    for(size_t i = 0, ei = basepaths_.size(); i != ei; i++)
       {
-        fullpath = fs::path::make(basepaths[i],fusepath);
+        fullpath = fs::path::make(basepaths_[i],fusepath_);
 
         if(!fs::exists(fullpath))
           continue;
 
-        paths.push_back(fullpath);
+        paths_->push_back(fullpath);
       }
   }
 
@@ -91,17 +91,17 @@ namespace fs
   }
 
   void
-  realpathize(vector<string> &strs)
+  realpathize(vector<string> *strs_)
   {
     char *rv;
 
-    for(size_t i = 0; i < strs.size(); i++)
+    for(size_t i = 0; i < strs_->size(); i++)
       {
-        rv = fs::realpath(strs[i]);
+        rv = fs::realpath((*strs_)[i]);
         if(rv == NULL)
           continue;
 
-        strs[i] = rv;
+        (*strs_)[i] = rv;
 
         ::free(rv);
       }
@@ -119,38 +119,4 @@ namespace fs
   {
     return ::fcntl(fd,F_SETFL,mode);
   }
-
-  int
-  mfs(const vector<string> &basepaths,
-      const uint64_t        minfreespace,
-      string               &path)
-  {
-    int rv;
-    uint64_t mfs;
-    uint64_t spaceavail;
-    const string *mfsbasepath;
-
-    mfs = 0;
-    mfsbasepath = NULL;
-    for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
-      {
-        rv = fs::statvfs_cache_spaceavail(basepaths[i],&spaceavail);
-        if(rv == -1)
-          continue;
-        if(spaceavail < minfreespace)
-          continue;
-        if(spaceavail <= mfs)
-          continue;
-
-        mfs         = spaceavail;
-        mfsbasepath = &basepaths[i];
-      }
-
-    if(mfsbasepath == NULL)
-      return (errno=ENOENT,-1);
-
-    path = *mfsbasepath;
-
-    return 0;
-  }
 };

src/fs.hpp

@@ -24,20 +24,13 @@
 
 namespace fs
 {
-  using std::string;
-  using std::vector;
+  void findallfiles(const std::vector<std::string> &basepaths,
+                    const char                     *fusepath,
+                    std::vector<std::string>       *paths);
 
-  void findallfiles(const vector<string> &basepaths_,
-                    const char           *fusepath_,
-                    vector<string>       &paths_);
+  void realpathize(std::vector<std::string> *strs);
 
-  void realpathize(vector<string> &strs_);
-
-  int getfl(const int fd_);
-  int setfl(const int    fd_,
-            const mode_t mode_);
-
-  int mfs(const vector<string> &srcs_,
-          const uint64_t        minfreespace_,
-          string               &path_);
+  int getfl(const int fd);
+  int setfl(const int    fd,
+            const mode_t mode);
 }

src/fs_acl.hpp

@@ -25,6 +25,6 @@ namespace fs
   namespace acl
   {
     bool
-    dir_has_defaults(const std::string &fullpath_);
+    dir_has_defaults(const std::string &fullpath);
   }
 }

src/fs_attr.hpp

@@ -22,9 +22,9 @@ namespace fs
 {
   namespace attr
   {
-    int copy(const int fdin_,
-             const int fdout_);
-    int copy(const std::string &from_,
-             const std::string &to_);
+    int copy(const int fdin,
+             const int fdout);
+    int copy(const std::string &from,
+             const std::string &to);
   }
 }

src/fs_base_fadvise.hpp

@@ -19,17 +19,17 @@
 namespace fs
 {
   int
-  fadvise_dontneed(const int   fd_,
-                   const off_t offset_ = 0,
-                   const off_t len_    = 0);
+  fadvise_dontneed(const int   fd,
+                   const off_t offset = 0,
+                   const off_t len    = 0);
 
   int
-  fadvise_willneed(const int   fd_,
-                   const off_t offset_ = 0,
-                   const off_t len_    = 0);
+  fadvise_willneed(const int   fd,
+                   const off_t offset = 0,
+                   const off_t len    = 0);
 
   int
-  fadvise_sequential(const int   fd_,
-                     const off_t offset_ = 0,
-                     const off_t len_    = 0);
+  fadvise_sequential(const int   fd,
+                     const off_t offset = 0,
+                     const off_t len    = 0);
 }

src/fs_base_fallocate.hpp

@@ -21,8 +21,8 @@
 namespace fs
 {
   int
-  fallocate(const int   fd_,
-            const int   mode_,
-            const off_t offset_,
-            const off_t len_);
+  fallocate(const int   fd,
+            const int   mode,
+            const off_t offset,
+            const off_t len);
 }

src/fs_base_fstatat.hpp

@@ -28,27 +28,27 @@ namespace fs
   static
   inline
   int
-  fstatat(const int    dirfd,
-          const char  *pathname,
-          struct stat *statbuf,
-          const int    flags)
+  fstatat(const int    dirfd_,
+          const char  *pathname_,
+          struct stat *statbuf_,
+          const int    flags_)
   {
-    return ::fstatat(dirfd,
-                     pathname,
-                     statbuf,
-                     flags);
+    return ::fstatat(dirfd_,
+                     pathname_,
+                     statbuf_,
+                     flags_);
   }
 
   static
   inline
   int
-  fstatat_nofollow(const int    dirfd,
-                   const char  *pathname,
-                   struct stat *statbuf)
+  fstatat_nofollow(const int    dirfd_,
+                   const char  *pathname_,
+                   struct stat *statbuf_)
   {
-    return fs::fstatat(dirfd,
-                       pathname,
-                       statbuf,
+    return fs::fstatat(dirfd_,
+                       pathname_,
+                       statbuf_,
                        AT_SYMLINK_NOFOLLOW);
   }
 }

src/fs_base_futimesat.hpp

@@ -23,7 +23,7 @@
 namespace fs
 {
   int
-  futimesat(const int             dirfd_,
-            const char           *pathname_,
-            const struct timeval  times_[2]);
+  futimesat(const int             dirfd,
+            const char           *pathname,
+            const struct timeval  times[2]);
 }

src/fs_base_getdents.cpp

@@ -26,9 +26,9 @@
 namespace fs
 {
   int
-  getdents(unsigned int  fd_,
-           void         *dirp_,
-           unsigned int  count_)
+  getdents64(unsigned int  fd_,
+             void         *dirp_,
+             unsigned int  count_)
   {
 #if defined SYS_getdents64
     return ::syscall(SYS_getdents64,fd_,dirp_,count_);

src/fs_base_getdents.hpp

@@ -21,7 +21,7 @@
 namespace fs
 {
   int
-  getdents(unsigned int  fd,
-           void         *dirp,
-           unsigned int  count);
+  getdents64(unsigned int  fd,
+             void         *dirp,
+             unsigned int  count);
 }

src/fs_base_utime_utimensat.hpp

@@ -28,12 +28,12 @@ namespace fs
   static
   inline
   int
-  utime(const int              dirfd,
-        const std::string     &path,
-        const struct timespec  times[2],
-        const int              flags)
+  utime(const int              dirfd_,
+        const std::string     &path_,
+        const struct timespec  times_[2],
+        const int              flags_)
   {
-    return ::utimensat(dirfd,path.c_str(),times,flags);
+    return ::utimensat(dirfd_,path_.c_str(),times_,flags_);
   }
 
   static

src/fs_base_write.hpp

@@ -25,21 +25,21 @@ namespace fs
   static
   inline
   ssize_t
-  write(const int     fd,
-        const void   *buf,
-        const size_t  count)
+  write(const int     fd_,
+        const void   *buf_,
+        const size_t  count_)
   {
-    return ::write(fd,buf,count);
+    return ::write(fd_,buf_,count_);
   }
 
   static
   inline
   ssize_t
-  pwrite(const int     fd,
-         const void   *buf,
-         const size_t  count,
-         const off_t   offset)
+  pwrite(const int     fd_,
+         const void   *buf_,
+         const size_t  count_,
+         const off_t   offset_)
   {
-    return ::pwrite(fd,buf,count,offset);
+    return ::pwrite(fd_,buf_,count_,offset_);
   }
 }

src/fs_clonefile.hpp

@@ -19,6 +19,6 @@
 namespace fs
 {
   int
-  clonefile(const int src_fd_,
-            const int dst_fd_);
+  clonefile(const int src_fd,
+            const int dst_fd);
 }

src/fs_cow.cpp

@@ -115,7 +115,7 @@ namespace fs
 
       dst_fullpath = src_fullpath_;
 
-      dst_fd = fs::mktemp(dst_fullpath,O_WRONLY);
+      dst_fd = fs::mktemp(&dst_fullpath,O_WRONLY);
       if(dst_fd == -1)
         return cleanup_on_error(src_fd);
 

src/fs_cow.hpp

@@ -25,12 +25,12 @@ namespace fs
 {
   namespace cow
   {
-    bool is_eligible(const int flags_);
-    bool is_eligible(const struct stat &st_);
-    bool is_eligible(const int flags_, const struct stat &st_);
+    bool is_eligible(const int flags);
+    bool is_eligible(const struct stat &st);
+    bool is_eligible(const int flags, const struct stat &st);
 
-    bool is_eligible(const char *fullpath_, const int flags_);
+    bool is_eligible(const char *fullpath, const int flags);
 
-    int  break_link(const char *fullpath_);
+    int  break_link(const char *fullpath);
   }
 }

src/fs_exists.hpp

@@ -70,7 +70,7 @@ namespace fs
   {
     std::string fullpath;
 
-    fullpath = fs::path::make(&basepath_,relpath_);
+    fullpath = fs::path::make(basepath_,relpath_);
 
     return fs::exists(fullpath,st_);
   }

src/fs_ficlone.hpp

@@ -21,6 +21,6 @@
 namespace fs
 {
   int
-  ficlone(const int src_fd_,
-          const int dst_fd_);
+  ficlone(const int src_fd,
+          const int dst_fd);
 }

src/fs_glob.cpp

@@ -28,7 +28,7 @@ namespace fs
 {
   void
   glob(const string   &pattern_,
-       vector<string> &strs_)
+       vector<string> *strs_)
   {
     int flags;
     glob_t gbuf = {0};
@@ -37,7 +37,7 @@ namespace fs
     ::glob(pattern_.c_str(),flags,NULL,&gbuf);
 
     for(size_t i = 0; i < gbuf.gl_pathc; i++)
-      strs_.push_back(gbuf.gl_pathv[i]);
+      strs_->push_back(gbuf.gl_pathv[i]);
 
     ::globfree(&gbuf);
   }

src/fs_glob.hpp

@@ -22,6 +22,6 @@
 namespace fs
 {
   void
-  glob(const std::string        &pattern_,
-       std::vector<std::string> &strs_);
+  glob(const std::string        &pattern,
+       std::vector<std::string> *strs);
 }

src/fs_info.cpp

@@ -32,13 +32,13 @@ using std::string;
 namespace fs
 {
   int
-  info(const string *path_,
+  info(const string &path_,
        fs::info_t   *info_)
   {
     int rv;
     struct statvfs st;
 
-    rv = fs::statvfs_cache(path_->c_str(),&st);
+    rv = fs::statvfs_cache(path_.c_str(),&st);
     if(rv == 0)
       {
         info_->readonly   = StatVFS::readonly(st);

src/fs_info.hpp

@@ -25,6 +25,6 @@
 namespace fs
 {
   int
-  info(const std::string *path_,
-       fs::info_t        *info_);
+  info(const std::string &path,
+       fs::info_t        *info);
 }

src/fs_mktemp.cpp

@@ -48,7 +48,7 @@ generate_tmp_path(const string &base_)
 namespace fs
 {
   int
-  mktemp(string    &base_,
+  mktemp(string    *base_,
          const int  flags_)
   {
     int fd;
@@ -61,13 +61,13 @@ namespace fs
     flags = (flags_ | O_EXCL | O_CREAT);
     while(count-- > 0)
       {
-        tmppath = generate_tmp_path(base_);
+        tmppath = generate_tmp_path(*base_);
 
         fd = fs::open(tmppath,flags,S_IWUSR);
         if((fd == -1) && (errno == EEXIST))
           continue;
         else if(fd != -1)
-          base_ = tmppath;
+          *base_ = tmppath;
 
         return fd;
       }

src/fs_mktemp.hpp

@@ -23,6 +23,6 @@
 namespace fs
 {
   int
-  mktemp(std::string &base_,
-         const int    flags_);
+  mktemp(std::string *base,
+         const int    flags);
 }

src/fs_movefile.cpp

@@ -97,7 +97,7 @@ namespace l
 
     fs::path::append(fdout_path[0],fusepath_);
     fdout_temp = fdout_path[0];
-    fdout = fs::mktemp(fdout_temp,fdin_flags);
+    fdout = fs::mktemp(&fdout_temp,fdin_flags);
     if(fdout == -1)
       return -1;
 

src/fs_path.hpp

@@ -23,39 +23,37 @@ namespace fs
 {
   namespace path
   {
-    using std::string;
+    std::string dirname(const char *path);
+    std::string dirname(const std::string &path);
 
-    string dirname(const char *path);
-    string dirname(const string &path);
-
-    string basename(const string &path);
+    std::string basename(const std::string &path);
 
     static
     inline
     void
-    append(string     &base,
-           const char *suffix)
+    append(std::string &base_,
+           const char  *suffix_)
     {
-      base += suffix;
+      base_ += suffix_;
     }
 
     static
     inline
     void
-    append(string       &base,
-           const string &suffix)
+    append(std::string       &base_,
+           const std::string &suffix_)
     {
-      base += suffix;
+      base_ += suffix_;
     }
 
     static
     inline
-    string
+    std::string
     make(const char *base_,
          const char *suffix_)
     {
       char back;
-      string path(base_);
+      std::string path(base_);
 
       back = *path.rbegin();
       if((back != '/') && (suffix_[0] != '/'))
@@ -67,36 +65,18 @@ namespace fs
 
     static
     inline
-    string
-    make(const string &base_,
-         const char   *suffix_)
+    std::string
+    make(const std::string &base_,
+         const char        *suffix_)
     {
       return (base_ + suffix_);
     }
 
     static
     inline
-    string
-    make(const string *base_,
-         const char   *suffix_)
-    {
-      return (*base_ + suffix_);
-    }
-
-    static
-    inline
-    string
-    make(const string *base_,
-         const string *suffix_)
-    {
-      return (*base_ + *suffix_);
-    }
-
-    static
-    inline
-    string
-    make(const string &base_,
-         const string &suffix_)
+    std::string
+    make(const std::string &base_,
+         const std::string &suffix_)
     {
       return (base_ + suffix_);
     }

src/fs_statvfs_cache.hpp

@@ -26,21 +26,21 @@ namespace fs
   uint64_t
   statvfs_cache_timeout(void);
   void
-  statvfs_cache_timeout(const uint64_t timeout_);
+  statvfs_cache_timeout(const uint64_t timeout);
 
   int
-  statvfs_cache(const char     *path_,
-                struct statvfs *st_);
+  statvfs_cache(const char     *path,
+                struct statvfs *st);
 
   int
-  statvfs_cache_readonly(const std::string &path_,
-                         bool              *readonly_);
+  statvfs_cache_readonly(const std::string &path,
+                         bool              *readonly);
 
   int
-  statvfs_cache_spaceavail(const std::string &path_,
-                           uint64_t          *spaceavail_);
+  statvfs_cache_spaceavail(const std::string &path,
+                           uint64_t          *spaceavail);
 
   int
-  statvfs_cache_spaceused(const std::string &path_,
-                          uint64_t          *spaceused_);
+  statvfs_cache_spaceused(const std::string &path,
+                          uint64_t          *spaceused);
 }

src/fs_xattr.cpp

@@ -39,8 +39,8 @@ namespace fs
   namespace xattr
   {
     int
-    list(const int     fd,
-         vector<char> &attrs)
+    list(const int     fd_,
+         vector<char> *attrs_)
     {
       ssize_t rv;
 
@@ -48,21 +48,21 @@ namespace fs
       errno = ERANGE;
       while((rv == -1) && (errno == ERANGE))
         {
-          rv = fs::flistxattr(fd,NULL,0);
+          rv = fs::flistxattr(fd_,NULL,0);
           if(rv <= 0)
             return rv;
 
-          attrs.resize(rv);
+          attrs_->resize(rv);
 
-          rv = fs::flistxattr(fd,&attrs[0],rv);
+          rv = fs::flistxattr(fd_,&(*attrs_)[0],rv);
         }
 
       return rv;
     }
 
     int
-    list(const string &path,
-         vector<char> &attrs)
+    list(const string &path_,
+         vector<char> *attrs_)
     {
       ssize_t rv;
 
@@ -70,84 +70,84 @@ namespace fs
       errno = ERANGE;
       while((rv == -1) && (errno == ERANGE))
         {
-          rv = fs::llistxattr(path,NULL,0);
+          rv = fs::llistxattr(path_,NULL,0);
           if(rv <= 0)
             return rv;
 
-          attrs.resize(rv);
+          attrs_->resize(rv);
 
-          rv = fs::llistxattr(path,&attrs[0],rv);
+          rv = fs::llistxattr(path_,&(*attrs_)[0],rv);
         }
 
       return rv;
     }
 
     int
-    list(const int        fd,
-         vector<string> &attrvector)
+    list(const int       fd_,
+         vector<string> *attrvector_)
     {
       int rv;
       vector<char> attrs;
 
-      rv = list(fd,attrs);
+      rv = fs::xattr::list(fd_,&attrs);
       if(rv != -1)
         {
           string tmp(attrs.begin(),attrs.end());
-          str::split(attrvector,tmp,'\0');
+          str::split(tmp,'\0',attrvector_);
         }
 
       return rv;
     }
 
     int
-    list(const string   &path,
-         vector<string> &attrvector)
+    list(const string   &path_,
+         vector<string> *attrvector_)
     {
       int rv;
       vector<char> attrs;
 
-      rv = list(path,attrs);
+      rv = fs::xattr::list(path_,&attrs);
       if(rv != -1)
         {
           string tmp(attrs.begin(),attrs.end());
-          str::split(attrvector,tmp,'\0');
+          str::split(tmp,'\0',attrvector_);
         }
 
       return rv;
     }
 
     int
-    list(const int  fd,
-         string    &attrstr)
+    list(const int  fd_,
+         string    *attrstr_)
     {
       int rv;
       vector<char> attrs;
 
-      rv = list(fd,attrs);
+      rv = fs::xattr::list(fd_,&attrs);
       if(rv != -1)
-        attrstr = string(attrs.begin(),attrs.end());
+        *attrstr_ = string(attrs.begin(),attrs.end());
 
       return rv;
     }
 
     int
-    list(const string &path,
-         string       &attrstr)
+    list(const string &path_,
+         string       *attrstr_)
     {
       int rv;
       vector<char> attrs;
 
-      rv = list(path,attrs);
+      rv = fs::xattr::list(path_,&attrs);
       if(rv != -1)
-        attrstr = string(attrs.begin(),attrs.end());
+        *attrstr_ = string(attrs.begin(),attrs.end());
 
       return rv;
     }
 
     int
-    get(const int     fd,
-        const string &attr,
-        vector<char> &value)
+    get(const int     fd_,
+        const string &attr_,
+        vector<char> *value_)
     {
       ssize_t rv;
 
@@ -155,22 +155,22 @@ namespace fs
       errno = ERANGE;
       while((rv == -1) && (errno == ERANGE))
         {
-          rv = fs::fgetxattr(fd,attr,NULL,0);
+          rv = fs::fgetxattr(fd_,attr_,NULL,0);
           if(rv <= 0)
             return rv;
 
-          value.resize(rv);
+          value_->resize(rv);
 
-          rv = fs::fgetxattr(fd,attr,&value[0],rv);
+          rv = fs::fgetxattr(fd_,attr_,&(*value_)[0],rv);
         }
 
       return rv;
     }
 
     int
-    get(const string &path,
-        const string &attr,
-        vector<char> &value)
+    get(const string &path_,
+        const string &attr_,
+        vector<char> *value_)
     {
       ssize_t rv;
 
@@ -178,56 +178,56 @@ namespace fs
       errno = ERANGE;
       while((rv == -1) && (errno == ERANGE))
         {
-          rv = fs::lgetxattr(path,attr,NULL,0);
+          rv = fs::lgetxattr(path_,attr_,NULL,0);
           if(rv <= 0)
             return rv;
 
-          value.resize(rv);
+          value_->resize(rv);
 
-          rv = fs::lgetxattr(path,attr,&value[0],rv);
+          rv = fs::lgetxattr(path_,attr_,&(*value_)[0],rv);
         }
 
       return rv;
     }
 
     int
-    get(const int     fd,
-        const string &attr,
-        string       &value)
+    get(const int     fd_,
+        const string &attr_,
+        string       *value_)
     {
       int          rv;
       vector<char> tmpvalue;
 
-      rv = get(fd,attr,tmpvalue);
+      rv = get(fd_,attr_,&tmpvalue);
       if(rv != -1)
-        value = string(tmpvalue.begin(),tmpvalue.end());
+        *value_ = string(tmpvalue.begin(),tmpvalue.end());
 
       return rv;
     }
 
     int
-    get(const string &path,
-        const string &attr,
-        string       &value)
+    get(const string &path_,
+        const string &attr_,
+        string       *value_)
     {
       int          rv;
       vector<char> tmpvalue;
 
-      rv = get(path,attr,tmpvalue);
+      rv = fs::xattr::get(path_,attr_,&tmpvalue);
       if(rv != -1)
-        value = string(tmpvalue.begin(),tmpvalue.end());
+        *value_ = string(tmpvalue.begin(),tmpvalue.end());
 
       return rv;
     }
 
     int
-    get(const int           fd,
-        map<string,string> &attrs)
+    get(const int           fd_,
+        map<string,string> *attrs_)
     {
       int rv;
       string attrstr;
 
-      rv = list(fd,attrstr);
+      rv = fs::xattr::list(fd_,&attrstr);
       if(rv == -1)
         return -1;
 
@@ -239,9 +239,9 @@ namespace fs
           {
             string value;
 
-            rv = get(fd,key,value);
+            rv = fs::xattr::get(fd_,key,&value);
             if(rv != -1)
-              attrs[key] = value;
+              (*attrs_)[key] = value;
           }
       }
 
@@ -249,13 +249,13 @@ namespace fs
     }
 
     int
-    get(const string       &path,
-        map<string,string> &attrs)
+    get(const string       &path_,
+        map<string,string> *attrs_)
     {
       int rv;
       string attrstr;
 
-      rv = list(path,attrstr);
+      rv = fs::xattr::list(path_,&attrstr);
       if(rv == -1)
         return -1;
 
@@ -267,9 +267,9 @@ namespace fs
           {
             string value;
 
-            rv = get(path,key,value);
+            rv = fs::xattr::get(path_,key,&value);
             if(rv != -1)
-              attrs[key] = value;
+              (*attrs_)[key] = value;
           }
       }
 
@@ -277,41 +277,41 @@ namespace fs
     }
 
     int
-    set(const int     fd,
-        const string &key,
-        const string &value,
-        const int     flags)
+    set(const int     fd_,
+        const string &key_,
+        const string &value_,
+        const int     flags_)
     {
-      return fs::fsetxattr(fd,
-                           key.c_str(),
-                           value.data(),
-                           value.size(),
-                           flags);
+      return fs::fsetxattr(fd_,
+                           key_.c_str(),
+                           value_.data(),
+                           value_.size(),
+                           flags_);
     }
 
     int
-    set(const string &path,
-        const string &key,
-        const string &value,
-        const int     flags)
+    set(const string &path_,
+        const string &key_,
+        const string &value_,
+        const int     flags_)
     {
-      return fs::lsetxattr(path,
-                           key,
-                           value.data(),
-                           value.size(),
-                           flags);
+      return fs::lsetxattr(path_,
+                           key_,
+                           value_.data(),
+                           value_.size(),
+                           flags_);
     }
 
     int
-    set(const int                 fd,
-        const map<string,string> &attrs)
+    set(const int                 fd_,
+        const map<string,string> &attrs_)
     {
       int rv;
 
       for(map<string,string>::const_iterator
-            i = attrs.begin(), ei = attrs.end(); i != ei; ++i)
+            i = attrs_.begin(), ei = attrs_.end(); i != ei; ++i)
         {
-          rv = set(fd,i->first,i->second,0);
+          rv = fs::xattr::set(fd_,i->first,i->second,0);
           if(rv == -1)
             return -1;
         }
@@ -320,46 +320,46 @@ namespace fs
     }
 
     int
-    set(const string             &path,
-        const map<string,string> &attrs)
+    set(const string             &path_,
+        const map<string,string> &attrs_)
     {
       int fd;
 
-      fd = fs::open(path,O_RDONLY|O_NONBLOCK);
+      fd = fs::open(path_,O_RDONLY|O_NONBLOCK);
       if(fd == -1)
         return -1;
 
-      set(fd,attrs);
+      fs::xattr::set(fd,attrs_);
 
       return fs::close(fd);
     }
 
     int
-    copy(const int fdin,
-         const int fdout)
+    copy(const int fdin_,
+         const int fdout_)
     {
       int rv;
       map<string,string> attrs;
 
-      rv = get(fdin,attrs);
+      rv = fs::xattr::get(fdin_,&attrs);
       if(rv == -1)
         return -1;
 
-      return set(fdout,attrs);
+      return fs::xattr::set(fdout_,attrs);
     }
 
     int
-    copy(const string &from,
-         const string &to)
+    copy(const string &from_,
+         const string &to_)
     {
       int rv;
       map<string,string> attrs;
 
-      rv = get(from,attrs);
+      rv = fs::xattr::get(from_,&attrs);
       if(rv == -1)
         return -1;
 
-      return set(to,attrs);
+      return fs::xattr::set(to_,attrs);
     }
   }
 }

src/fs_xattr.hpp

@@ -30,21 +30,21 @@ namespace fs
 
 
     int list(const string   &path,
-             vector<char>   &attrs);
+             vector<char>   *attrs);
     int list(const string   &path,
-             string         &attrs);
+             string         *attrs);
     int list(const string   &path,
-             vector<string> &attrs);
+             vector<string> *attrs);
 
     int get(const string &path,
             const string &attr,
-            vector<char> &value);
+            vector<char> *value);
     int get(const string &path,
             const string &attr,
-            string       &value);
+            string       *value);
 
     int get(const string       &path,
-            map<string,string> &attrs);
+            map<string,string> *attrs);
 
     int set(const string &path,
             const string &key,

src/fuse_access.hpp

@@ -19,6 +19,6 @@
 namespace FUSE
 {
   int
-  access(const char *fusepath_,
-         int         mask_);
+  access(const char *fusepath,
+         int         mask);
 }

src/fuse_chmod.hpp

@@ -19,6 +19,6 @@
 namespace FUSE
 {
   int
-  chmod(const char *fusepath_,
-        mode_t      mode_);
+  chmod(const char *fusepath,
+        mode_t      mode);
 }

src/fuse_chown.hpp

@@ -19,7 +19,7 @@
 namespace FUSE
 {
   int
-  chown(const char *fusepath_,
-        uid_t       uid_,
-        gid_t       gid_);
+  chown(const char *fusepath,
+        uid_t       uid,
+        gid_t       gid);
 }

src/fuse_create.hpp

@@ -23,7 +23,7 @@
 namespace FUSE
 {
   int
-  create(const char     *fusepath_,
-         mode_t          mode_,
-         fuse_file_info *ffi_);
+  create(const char     *fusepath,
+         mode_t          mode,
+         fuse_file_info *ffi);
 }

src/fuse_fallocate.hpp

@@ -16,11 +16,13 @@
 
 #pragma once
 
+#include "fuse.h"
+
 namespace FUSE
 {
   int
-  fallocate(int             mode_,
-            off_t           offset_,
-            off_t           len_,
-            fuse_file_info *ffi_);
+  fallocate(int             mode,
+            off_t           offset,
+            off_t           len,
+            fuse_file_info *ffi);
 }

src/fuse_fchmod.hpp

@@ -23,6 +23,6 @@
 namespace FUSE
 {
   int
-  fchmod(const struct fuse_file_info *ffi_,
-         const mode_t                 mode_);
+  fchmod(const fuse_file_info *ffi,
+         const mode_t          mode);
 }

src/fuse_fchown.hpp

@@ -21,7 +21,7 @@
 namespace FUSE
 {
   int
-  fchown(const struct fuse_file_info *ffi_,
-         uid_t                        uid_,
-         gid_t                        gid_);
+  fchown(const fuse_file_info *ffi,
+         uid_t                 uid,
+         gid_t                 gid);
 }

src/fuse_flock.hpp

@@ -21,7 +21,7 @@
 namespace FUSE
 {
   int
-  flock(const char     *fusepath_,
-        fuse_file_info *ffi_,
-        int             op_);
+  flock(const char     *fusepath,
+        fuse_file_info *ffi,
+        int             op);
 }

src/fuse_flush.hpp

@@ -21,5 +21,5 @@
 namespace FUSE
 {
   int
-  flush(fuse_file_info *ffi_);
+  flush(fuse_file_info *ffi);
 }

src/fuse_free_hide.hpp

@@ -23,5 +23,5 @@
 namespace FUSE
 {
   int
-  free_hide(const uint64_t fh_);
+  free_hide(const uint64_t fh);
 }

src/fuse_fsync.hpp

@@ -21,6 +21,6 @@
 namespace FUSE
 {
   int
-  fsync(int             isdatasync_,
-        fuse_file_info *ffi_);
+  fsync(int             isdatasync,
+        fuse_file_info *ffi);
 }

src/fuse_fsyncdir.hpp

@@ -21,6 +21,6 @@
 namespace FUSE
 {
   int
-  fsyncdir(int             isdatasync_,
-           fuse_file_info *ffi_);
+  fsyncdir(int             isdatasync,
+           fuse_file_info *ffi);
 }

src/fuse_ftruncate.hpp

@@ -24,6 +24,6 @@
 namespace FUSE
 {
   int
-  ftruncate(off_t           size_,
-            fuse_file_info *ffi_);
+  ftruncate(off_t           size,
+            fuse_file_info *ffi);
 }

src/fuse_futimens.hpp

@@ -23,6 +23,6 @@
 namespace FUSE
 {
   int
-  futimens(const struct fuse_file_info *ffi_,
-           const timespec               ts_[2]);
+  futimens(const fuse_file_info *ffi,
+           const timespec        ts[2]);
 }

src/fuse_getxattr.cpp

@@ -63,10 +63,10 @@ namespace l
 
   static
   int
-  getxattr_controlfile(const Config &config,
-                       const char   *attrname,
-                       char         *buf,
-                       const size_t  count)
+  getxattr_controlfile(const Config &config_,
+                       const char   *attrname_,
+                       char         *buf_,
+                       const size_t  count_)
   {
     int rv;
     size_t len;
@@ -74,42 +74,42 @@ namespace l
     string val;
     vector<string> attr;
 
-    if(!str::startswith(attrname,"user.mergerfs."))
+    if(!str::startswith(attrname_,"user.mergerfs."))
       return -ENOATTR;
 
-    key = &attrname[14];
-    rv = config.get(key,&val);
+    key = &attrname_[14];
+    rv = config_.get(key,&val);
     if(rv < 0)
       return rv;
 
     len = val.size();
 
-    if(count == 0)
+    if(count_ == 0)
       return len;
 
-    if(count < len)
+    if(count_ < len)
       return -ERANGE;
 
-    memcpy(buf,val.c_str(),len);
+    memcpy(buf_,val.c_str(),len);
 
     return (int)len;
   }
 
   static
   int
-  getxattr_from_string(char         *destbuf,
-                       const size_t  destbufsize,
-                       const string &src)
+  getxattr_from_string(char         *destbuf_,
+                       const size_t  destbufsize_,
+                       const string &src_)
   {
-    const size_t srcbufsize = src.size();
+    const size_t srcbufsize = src_.size();
 
-    if(destbufsize == 0)
+    if(destbufsize_ == 0)
       return srcbufsize;
 
-    if(srcbufsize > destbufsize)
+    if(srcbufsize > destbufsize_)
       return -ERANGE;
 
-    memcpy(destbuf,src.data(),srcbufsize);
+    memcpy(destbuf_,src_.data(),srcbufsize);
 
     return srcbufsize;
   }
@@ -117,9 +117,9 @@ namespace l
   static
   int
   getxattr_user_mergerfs_allpaths(const Branches &branches_,
-                                  const char     *fusepath,
-                                  char           *buf,
-                                  const size_t    count)
+                                  const char     *fusepath_,
+                                  char           *buf_,
+                                  const size_t    count_)
   {
     string concated;
     vector<string> paths;
@@ -127,90 +127,90 @@ namespace l
 
     branches_.to_paths(branches);
 
-    fs::findallfiles(branches,fusepath,paths);
+    fs::findallfiles(branches,fusepath_,&paths);
 
     concated = str::join(paths,'\0');
 
-    return l::getxattr_from_string(buf,count,concated);
+    return l::getxattr_from_string(buf_,count_,concated);
   }
 
   static
   int
-  getxattr_user_mergerfs(const string         &basepath,
-                         const char           *fusepath,
-                         const string         &fullpath,
+  getxattr_user_mergerfs(const string         &basepath_,
+                         const char           *fusepath_,
+                         const string         &fullpath_,
                          const Branches       &branches_,
-                         const char           *attrname,
-                         char                 *buf,
-                         const size_t          count)
+                         const char           *attrname_,
+                         char                 *buf_,
+                         const size_t          count_)
   {
     vector<string> attr;
 
-    str::split(attr,attrname,'.');
+    str::split(attrname_,'.',&attr);
 
     if(attr[2] == "basepath")
-      return l::getxattr_from_string(buf,count,basepath);
+      return l::getxattr_from_string(buf_,count_,basepath_);
     else if(attr[2] ==  "relpath")
-      return l::getxattr_from_string(buf,count,fusepath);
+      return l::getxattr_from_string(buf_,count_,fusepath_);
     else if(attr[2] == "fullpath")
-      return l::getxattr_from_string(buf,count,fullpath);
+      return l::getxattr_from_string(buf_,count_,fullpath_);
     else if(attr[2] == "allpaths")
-      return l::getxattr_user_mergerfs_allpaths(branches_,fusepath,buf,count);
+      return l::getxattr_user_mergerfs_allpaths(branches_,fusepath_,buf_,count_);
 
     return -ENOATTR;
   }
 
   static
   int
-  getxattr(Policy::Func::Search  searchFunc,
+  getxattr(Policy::Func::Search  searchFunc_,
            const Branches       &branches_,
-           const size_t          minfreespace,
-           const char           *fusepath,
-           const char           *attrname,
-           char                 *buf,
-           const size_t          count)
+           const size_t          minfreespace_,
+           const char           *fusepath_,
+           const char           *attrname_,
+           char                 *buf_,
+           const size_t          count_)
   {
     int rv;
     string fullpath;
     vector<string> basepaths;
 
-    rv = searchFunc(branches_,fusepath,minfreespace,&basepaths);
+    rv = searchFunc_(branches_,fusepath_,minfreespace_,&basepaths);
     if(rv == -1)
       return -errno;
 
-    fullpath = fs::path::make(basepaths[0],fusepath);
+    fullpath = fs::path::make(basepaths[0],fusepath_);
 
-    if(str::startswith(attrname,"user.mergerfs."))
+    if(str::startswith(attrname_,"user.mergerfs."))
       return l::getxattr_user_mergerfs(basepaths[0],
-                                       fusepath,
+                                       fusepath_,
                                        fullpath,
                                        branches_,
-                                       attrname,
-                                       buf,
-                                       count);
+                                       attrname_,
+                                       buf_,
+                                       count_);
 
-    return l::lgetxattr(fullpath,attrname,buf,count);
+    return l::lgetxattr(fullpath,attrname_,buf_,count_);
   }
 }
 
 namespace FUSE
 {
   int
-  getxattr(const char *fusepath,
-           const char *attrname,
-           char       *buf,
-           size_t      count)
+  getxattr(const char *fusepath_,
+           const char *attrname_,
+           char       *buf_,
+           size_t      count_)
   {
     const Config &config = Config::ro();
 
-    if(fusepath == config.controlfile)
+    if(fusepath_ == config.controlfile)
       return l::getxattr_controlfile(config,
-                                     attrname,
-                                     buf,
-                                     count);
+                                     attrname_,
+                                     buf_,
+                                     count_);
 
     if((config.security_capability == false) &&
-       l::is_attrname_security_capability(attrname))
+       l::is_attrname_security_capability(attrname_))
       return -ENOATTR;
 
     if(config.xattr.to_int())
@@ -222,9 +222,9 @@ namespace FUSE
     return l::getxattr(config.func.getxattr.policy,
                        config.branches,
                        config.minfreespace,
-                       fusepath,
-                       attrname,
-                       buf,
-                       count);
+                       fusepath_,
+                       attrname_,
+                       buf_,
+                       count_);
   }
 }

src/fuse_getxattr.hpp

@@ -19,8 +19,8 @@
 namespace FUSE
 {
   int
-  getxattr(const char *fusepath_,
-           const char *attrname_,
-           char       *buf_,
-           size_t      count_);
+  getxattr(const char *fusepath,
+           const char *attrname,
+           char       *buf,
+           size_t      count);
 }

src/fuse_init.hpp

@@ -21,5 +21,5 @@
 namespace FUSE
 {
   void *
-  init(fuse_conn_info *conn_);
+  init(fuse_conn_info *conn);
 }

src/fuse_ioctl.cpp

@@ -344,7 +344,7 @@ namespace l
 
     config.branches.to_paths(branches);
 
-    fs::findallfiles(branches,fusepath.c_str(),paths);
+    fs::findallfiles(branches,fusepath.c_str(),&paths);
 
     concated = str::join(paths,'\0');
 

src/fuse_ioctl.hpp

@@ -21,10 +21,10 @@
 namespace FUSE
 {
   int
-  ioctl(unsigned long   cmd_,
-        void           *arg_,
-        fuse_file_info *ffi_,
-        unsigned int    flags_,
-        void           *data_,
-        uint32_t       *out_bufsz_);
+  ioctl(unsigned long   cmd,
+        void           *arg,
+        fuse_file_info *ffi,
+        unsigned int    flags,
+        void           *data,
+        uint32_t       *out_bufsz);
 }

src/fuse_link.cpp

@@ -44,8 +44,8 @@ namespace l
     string oldfullpath;
     string newfullpath;
 
-    oldfullpath = fs::path::make(&oldbasepath_,oldfusepath_);
-    newfullpath = fs::path::make(&oldbasepath_,newfusepath_);
+    oldfullpath = fs::path::make(oldbasepath_,oldfusepath_);
+    newfullpath = fs::path::make(oldbasepath_,newfusepath_);
 
     rv = fs::link(oldfullpath,newfullpath);
 
@@ -152,8 +152,8 @@ namespace l
     string oldfullpath;
     string newfullpath;
 
-    oldfullpath = fs::path::make(&oldbasepath_,oldfusepath_);
-    newfullpath = fs::path::make(&oldbasepath_,newfusepath_);
+    oldfullpath = fs::path::make(oldbasepath_,oldfusepath_);
+    newfullpath = fs::path::make(oldbasepath_,newfusepath_);
 
     rv = fs::link(oldfullpath,newfullpath);
     if((rv == -1) && (errno == ENOENT))

src/fuse_link.hpp

@@ -19,6 +19,6 @@
 namespace FUSE
 {
   int
-  link(const char *from_,
-       const char *to_);
+  link(const char *from,
+       const char *to);
 }

src/fuse_listxattr.hpp

@@ -19,7 +19,7 @@
 namespace FUSE
 {
   int
-  listxattr(const char *fusepath_,
-            char       *buf_,
-            size_t      count_);
+  listxattr(const char *fusepath,
+            char       *buf,
+            size_t      count);
 }

src/fuse_mkdir.hpp

@@ -19,6 +19,6 @@
 namespace FUSE
 {
   int
-  mkdir(const char *fusepath_,
-        mode_t      mode_);
+  mkdir(const char *fusepath,
+        mode_t      mode);
 }

src/fuse_mknod.cpp

@@ -59,7 +59,7 @@ namespace l
     int rv;
     string fullpath;
 
-    fullpath = fs::path::make(&createpath_,fusepath_);
+    fullpath = fs::path::make(createpath_,fusepath_);
 
     rv = l::mknod_core(fullpath,mode_,umask_,dev_);
 

src/fuse_mknod.hpp

@@ -20,7 +20,7 @@
 namespace FUSE
 {
   int
-  mknod(const char *fusepath_,
-        mode_t      mode_,
-        dev_t       rdev_);
+  mknod(const char *fusepath,
+        mode_t      mode,
+        dev_t       rdev);
 }

src/fuse_open.hpp

@@ -21,6 +21,6 @@
 namespace FUSE
 {
   int
-  open(const char     *fusepath_,
-       fuse_file_info *ffi_);
+  open(const char     *fusepath,
+       fuse_file_info *ffi);
 }

src/fuse_opendir.hpp

@@ -21,6 +21,6 @@
 namespace FUSE
 {
   int
-  opendir(const char     *fusepath_,
-          fuse_file_info *ffi_);
+  opendir(const char     *fusepath,
+          fuse_file_info *ffi);
 }

src/fuse_prepare_hide.hpp

@@ -23,6 +23,6 @@
 namespace FUSE
 {
   int
-  prepare_hide(const char *name_,
-               uint64_t   *fh_);
+  prepare_hide(const char *name,
+               uint64_t   *fh);
 }

src/fuse_read.hpp

@@ -21,14 +21,14 @@
 namespace FUSE
 {
   int
-  read(char           *buf_,
-       size_t          count_,
-       off_t           offset_,
-       fuse_file_info *ffi_);
+  read(char           *buf,
+       size_t          count,
+       off_t           offset,
+       fuse_file_info *ffi);
 
   int
-  read_null(char           *buf_,
-            size_t          count_,
-            off_t           offset_,
-            fuse_file_info *ffi_);
+  read_null(char           *buf,
+            size_t          count,
+            off_t           offset,
+            fuse_file_info *ffi);
 }

src/fuse_read_buf.hpp

@@ -23,8 +23,8 @@
 namespace FUSE
 {
   int
-  read_buf(struct fuse_bufvec **buf_,
-           size_t               size_,
-           off_t                offset_,
-           fuse_file_info      *ffi_);
+  read_buf(struct fuse_bufvec **buf,
+           size_t               size,
+           off_t                offset,
+           fuse_file_info      *ffi);
 }

src/fuse_readdir.hpp

@@ -21,6 +21,6 @@
 namespace FUSE
 {
   int
-  readdir(fuse_file_info *ffi_,
-          fuse_dirents_t *buf_);
+  readdir(fuse_file_info *ffi,
+          fuse_dirents_t *buf);
 }

src/fuse_readdir_linux.cpp

@@ -74,7 +74,7 @@ namespace l
         int dirfd;
         int64_t nread;
 
-        basepath = fs::path::make(&branches_[i].path,dirname_);
+        basepath = fs::path::make(branches_[i].path,dirname_);
 
         dirfd = fs::open_dir_ro(basepath);
         if(dirfd == -1)
@@ -86,7 +86,7 @@ namespace l
 
         for(;;)
           {
-            nread = fs::getdents(dirfd,buf,g_DENTS_BUF_POOL.size());
+            nread = fs::getdents64(dirfd,buf,g_DENTS_BUF_POOL.size());
             if(nread == -1)
               break;
             if(nread == 0)

src/fuse_readdir_plus.hpp

@@ -21,6 +21,6 @@
 namespace FUSE
 {
   int
-  readdir_plus(fuse_file_info *ffi_,
-               fuse_dirents_t *buf_);
+  readdir_plus(fuse_file_info *ffi,
+               fuse_dirents_t *buf);
 }

src/fuse_readdir_plus_linux.cpp

@@ -83,7 +83,7 @@ namespace l
         int dirfd;
         int64_t nread;
 
-        basepath = fs::path::make(&branches_[i].path,dirname_);
+        basepath = fs::path::make(branches_[i].path,dirname_);
 
         dirfd = fs::open_dir_ro(basepath);
         if(dirfd == -1)
@@ -95,7 +95,7 @@ namespace l
 
         for(;;)
           {
-            nread = fs::getdents(dirfd,buf,g_DENTS_BUF_POOL.size());
+            nread = fs::getdents64(dirfd,buf,g_DENTS_BUF_POOL.size());
             if(nread == -1)
               break;
             if(nread == 0)

src/fuse_readdir_plus_linux.hpp

@@ -27,9 +27,9 @@
 namespace FUSE
 {
   int
-  readdir_plus_linux(const Branches &branches_,
-                     const char     *dirname_,
-                     const uint64_t  entry_timeout_,
-                     const uint64_t  attr_timeout_,
-                     fuse_dirents_t *buf_);
+  readdir_plus_linux(const Branches &branches,
+                     const char     *dirname,
+                     const uint64_t  entry_timeout,
+                     const uint64_t  attr_timeout,
+                     fuse_dirents_t *buf);
 }

src/fuse_readdir_plus_posix.cpp

@@ -83,7 +83,7 @@ namespace l
         int dirfd;
         DIR *dh;
 
-        basepath = fs::path::make(&branches_[i].path,dirname_);
+        basepath = fs::path::make(branches_[i].path,dirname_);
 
         dh = fs::opendir(basepath);
         if(!dh)

src/fuse_readdir_plus_posix.hpp

@@ -27,9 +27,9 @@
 namespace FUSE
 {
   int
-  readdir_plus_posix(const Branches &branches_,
-                     const char     *dirname_,
-                     const uint64_t  entry_timeout_,
-                     const uint64_t  attr_timeout_,
-                     fuse_dirents_t *buf_);
+  readdir_plus_posix(const Branches &branches,
+                     const char     *dirname,
+                     const uint64_t  entry_timeout,
+                     const uint64_t  attr_timeout,
+                     fuse_dirents_t *buf);
 }

src/fuse_readdir_posix.cpp

@@ -72,7 +72,7 @@ namespace l
         int dirfd;
         DIR *dh;
 
-        basepath = fs::path::make(&branches_[i].path,dirname_);
+        basepath = fs::path::make(branches_[i].path,dirname_);
 
         dh = fs::opendir(basepath);
         if(!dh)

src/fuse_readlink.hpp

@@ -19,7 +19,7 @@
 namespace FUSE
 {
   int
-  readlink(const char *fusepath_,
-           char       *buf_,
-           size_t      size_);
+  readlink(const char *fusepath,
+           char       *buf,
+           size_t      size);
 }

src/fuse_release.hpp

@@ -21,5 +21,5 @@
 namespace FUSE
 {
   int
-  release(fuse_file_info *ffi_);
+  release(fuse_file_info *ffi);
 }

src/fuse_releasedir.hpp

@@ -21,5 +21,5 @@
 namespace FUSE
 {
   int
-  releasedir(fuse_file_info *ffi_);
+  releasedir(fuse_file_info *ffi);
 }

src/fuse_removexattr.hpp

@@ -19,6 +19,6 @@
 namespace FUSE
 {
   int
-  removexattr(const char *fusepath_,
-              const char *attrname_);
+  removexattr(const char *fusepath,
+              const char *attrname);
 }

src/fuse_rename.hpp

@@ -19,6 +19,6 @@
 namespace FUSE
 {
   int
-  rename(const char *from_,
-         const char *to_);
+  rename(const char *from,
+         const char *to);
 }

src/fuse_rmdir.hpp

@@ -19,5 +19,5 @@
 namespace FUSE
 {
   int
-  rmdir(const char *fusepath_);
+  rmdir(const char *fusepath);
 }

src/fuse_setxattr.hpp

@@ -19,9 +19,9 @@
 namespace FUSE
 {
   int
-  setxattr(const char *fusepath_,
-           const char *attrname_,
-           const char *attrval_,
-           size_t      attrvalsize_,
-           int         flags_);
+  setxattr(const char *fusepath,
+           const char *attrname,
+           const char *attrval,
+           size_t      attrvalize,
+           int         flags);
 }

src/fuse_statfs.cpp

@@ -99,7 +99,7 @@ namespace l
     for(size_t i = 0, ei = branches_.size(); i < ei; i++)
       {
         fullpath = ((mode_ == StatFS::ENUM::FULL) ?
-                    fs::path::make(&branches_[i].path,fusepath_) :
+                    fs::path::make(branches_[i].path,fusepath_) :
                     branches_[i].path);
 
         rv = fs::lstat(fullpath,&st);

src/fuse_statfs.hpp

@@ -21,6 +21,6 @@
 namespace FUSE
 {
   int
-  statfs(const char     *fusepath_,
-         struct statvfs *fsstat_);
+  statfs(const char     *fusepath,
+         struct statvfs *fsstat);
 }

src/fuse_symlink.cpp

@@ -44,7 +44,7 @@ namespace l
     int rv;
     string fullnewpath;
 
-    fullnewpath = fs::path::make(&newbasepath_,newpath_);
+    fullnewpath = fs::path::make(newbasepath_,newpath_);
 
     rv = fs::symlink(oldpath_,fullnewpath);
 

src/fuse_symlink.hpp

@@ -19,6 +19,6 @@
 namespace FUSE
 {
   int
-  symlink(const char *oldpath_,
-          const char *newpath_);
+  symlink(const char *oldpath,
+          const char *newpath);
 }

src/fuse_truncate.hpp

@@ -21,6 +21,6 @@
 namespace FUSE
 {
   int
-  truncate(const char *fusepath_,
-           off_t       size_);
+  truncate(const char *fusepath,
+           off_t       size);
 }

src/fuse_unlink.hpp

@@ -19,5 +19,5 @@
 namespace FUSE
 {
   int
-  unlink(const char *fusepath_);
+  unlink(const char *fusepath);
 }

src/fuse_utimens.hpp

@@ -21,6 +21,6 @@
 namespace FUSE
 {
   int
-  utimens(const char     *fusepath_,
-          const timespec  ts_[2]);
+  utimens(const char     *fusepath,
+          const timespec  ts[2]);
 }

src/fuse_write.hpp

@@ -21,14 +21,14 @@
 namespace FUSE
 {
   int
-  write(const char     *buf_,
-        size_t          count_,
-        off_t           offset_,
-        fuse_file_info *ffi_);
+  write(const char     *buf,
+        size_t          count,
+        off_t           offset,
+        fuse_file_info *ffi);
 
   int
-  write_null(const char     *buf_,
-             size_t          count_,
-             off_t           offset_,
-             fuse_file_info *ffi_);
+  write_null(const char     *buf,
+             size_t          count,
+             off_t           offset,
+             fuse_file_info *ffi);
 }

src/fuse_write_buf.hpp

@@ -23,12 +23,12 @@
 namespace FUSE
 {
   int
-  write_buf(struct fuse_bufvec *buf_,
-            off_t               offset_,
-            fuse_file_info     *ffi_);
+  write_buf(struct fuse_bufvec *buf,
+            off_t               offset,
+            fuse_file_info     *ffi);
 
   int
-  write_buf_null(struct fuse_bufvec *buf_,
-                 off_t               offset_,
-                 fuse_file_info     *ffi_);
+  write_buf_null(struct fuse_bufvec *buf,
+                 off_t               offset,
+                 fuse_file_info     *ffi);
 }

src/mergerfs.cpp

@@ -77,59 +77,59 @@ namespace l
 {
   static
   void
-  get_fuse_operations(struct fuse_operations &ops,
-                      const bool              nullrw)
+  get_fuse_operations(struct fuse_operations &ops_,
+                      const bool              nullrw_)
   {
-    ops.access          = FUSE::access;
-    ops.bmap            = NULL;
-    ops.chmod           = FUSE::chmod;
-    ops.chown           = FUSE::chown;
-    ops.copy_file_range = FUSE::copy_file_range;
-    ops.create          = FUSE::create;
-    ops.destroy         = FUSE::destroy;
-    ops.fallocate       = FUSE::fallocate;
-    ops.fchmod          = FUSE::fchmod;
-    ops.fchown          = FUSE::fchown;
-    ops.fgetattr        = FUSE::fgetattr;
-    ops.flock           = NULL; // FUSE::flock;
-    ops.flush           = FUSE::flush;
-    ops.free_hide       = FUSE::free_hide;
-    ops.fsync           = FUSE::fsync;
-    ops.fsyncdir        = FUSE::fsyncdir;
-    ops.ftruncate       = FUSE::ftruncate;
-    ops.futimens        = FUSE::futimens;
-    ops.getattr         = FUSE::getattr;
-    ops.getxattr        = FUSE::getxattr;
-    ops.init            = FUSE::init;
-    ops.ioctl           = FUSE::ioctl;
-    ops.link            = FUSE::link;
-    ops.listxattr       = FUSE::listxattr;
-    ops.lock            = NULL;
-    ops.mkdir           = FUSE::mkdir;
-    ops.mknod           = FUSE::mknod;
-    ops.open            = FUSE::open;
-    ops.opendir         = FUSE::opendir;
-    ops.poll            = NULL;
-    ops.prepare_hide    = FUSE::prepare_hide;
-    ops.read            = (nullrw ? FUSE::read_null : FUSE::read);
-    ops.read_buf        = (nullrw ? NULL : FUSE::read_buf);
-    ops.readdir         = FUSE::readdir;
-    ops.readdir_plus    = FUSE::readdir_plus;
-    ops.readlink        = FUSE::readlink;
-    ops.release         = FUSE::release;
-    ops.releasedir      = FUSE::releasedir;
-    ops.removexattr     = FUSE::removexattr;
-    ops.rename          = FUSE::rename;
-    ops.rmdir           = FUSE::rmdir;
-    ops.setxattr        = FUSE::setxattr;
-    ops.statfs          = FUSE::statfs;
-    ops.symlink         = FUSE::symlink;
-    ops.truncate        = FUSE::truncate;
-    ops.unlink          = FUSE::unlink;
-    ops.utime           = NULL; /* deprecated; use utimens() */
-    ops.utimens         = FUSE::utimens;
-    ops.write           = (nullrw ? FUSE::write_null : FUSE::write);
-    ops.write_buf       = (nullrw ? FUSE::write_buf_null : FUSE::write_buf);
+    ops_.access          = FUSE::access;
+    ops_.bmap            = NULL;
+    ops_.chmod           = FUSE::chmod;
+    ops_.chown           = FUSE::chown;
+    ops_.copy_file_range = FUSE::copy_file_range;
+    ops_.create          = FUSE::create;
+    ops_.destroy         = FUSE::destroy;
+    ops_.fallocate       = FUSE::fallocate;
+    ops_.fchmod          = FUSE::fchmod;
+    ops_.fchown          = FUSE::fchown;
+    ops_.fgetattr        = FUSE::fgetattr;
+    ops_.flock           = NULL; // FUSE::flock;
+    ops_.flush           = FUSE::flush;
+    ops_.free_hide       = FUSE::free_hide;
+    ops_.fsync           = FUSE::fsync;
+    ops_.fsyncdir        = FUSE::fsyncdir;
+    ops_.ftruncate       = FUSE::ftruncate;
+    ops_.futimens        = FUSE::futimens;
+    ops_.getattr         = FUSE::getattr;
+    ops_.getxattr        = FUSE::getxattr;
+    ops_.init            = FUSE::init;
+    ops_.ioctl           = FUSE::ioctl;
+    ops_.link            = FUSE::link;
+    ops_.listxattr       = FUSE::listxattr;
+    ops_.lock            = NULL;
+    ops_.mkdir           = FUSE::mkdir;
+    ops_.mknod           = FUSE::mknod;
+    ops_.open            = FUSE::open;
+    ops_.opendir         = FUSE::opendir;
+    ops_.poll            = NULL;
+    ops_.prepare_hide    = FUSE::prepare_hide;
+    ops_.read            = (nullrw_ ? FUSE::read_null : FUSE::read);
+    ops_.read_buf        = (nullrw_ ? NULL : FUSE::read_buf);
+    ops_.readdir         = FUSE::readdir;
+    ops_.readdir_plus    = FUSE::readdir_plus;
+    ops_.readlink        = FUSE::readlink;
+    ops_.release         = FUSE::release;
+    ops_.releasedir      = FUSE::releasedir;
+    ops_.removexattr     = FUSE::removexattr;
+    ops_.rename          = FUSE::rename;
+    ops_.rmdir           = FUSE::rmdir;
+    ops_.setxattr        = FUSE::setxattr;
+    ops_.statfs          = FUSE::statfs;
+    ops_.symlink         = FUSE::symlink;
+    ops_.truncate        = FUSE::truncate;
+    ops_.unlink          = FUSE::unlink;
+    ops_.utime           = NULL; /* deprecated; use utimens() */
+    ops_.utimens         = FUSE::utimens;
+    ops_.write           = (nullrw_ ? FUSE::write_null : FUSE::write);
+    ops_.write_buf       = (nullrw_ ? FUSE::write_buf_null : FUSE::write_buf);
 
     return;
   }
@@ -182,8 +182,8 @@ namespace l
 }
 
 int
-main(int    argc,
-     char **argv)
+main(int    argc_,
+     char **argv_)
 {
-  return l::main(argc,argv);
+  return l::main(argc_,argv_);
 }

src/num.hpp

@@ -22,7 +22,7 @@
 
 namespace num
 {
-  int to_uint64_t(const std::string &str_, uint64_t &value_);
-  int to_double(const std::string &str_, double *value_);
-  int to_time_t(const std::string &str_, time_t &value_);
+  int to_uint64_t(const std::string &str, uint64_t *value);
+  int to_double(const std::string &str, double *value);
+  int to_time_t(const std::string &str, time_t *value);
 }

src/policy_all.cpp

@@ -50,7 +50,7 @@ namespace all
 
         if(branch->ro_or_nc())
           error_and_continue(error,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(error,ENOENT);
         if(info.readonly)

src/policy_cache.hpp

@@ -41,16 +41,16 @@ public:
   PolicyCache(void);
 
 public:
-  void erase(const char *fusepath_);
-  void cleanup(const int prob_ = 1);
+  void erase(const char *fusepath);
+  void cleanup(const int prob = 1);
   void clear(void);
 
 public:
-  int operator()(Policy::Func::Search &func_,
-                 const Branches       &branches_,
-                 const char           *fusepath_,
-                 const uint64_t        minfreespace_,
-                 std::string          *branch_);
+  int operator()(Policy::Func::Search &func,
+                 const Branches       &branches,
+                 const char           *fusepath,
+                 const uint64_t        minfreespace,
+                 std::string          *branch);
 
 public:
   uint64_t timeout;

src/policy_epall.cpp

@@ -35,9 +35,9 @@ namespace epall
   static
   int
   create(const Branches &branches_,
-         const char     *fusepath,
-         const uint64_t  minfreespace,
-         vector<string> *paths)
+         const char     *fusepath_,
+         const uint64_t  minfreespace_,
+         vector<string> *paths_)
   {
     rwlock::ReadGuard guard(&branches_.lock);
 
@@ -51,22 +51,22 @@ namespace epall
       {
         branch = &branches_[i];
 
-        if(!fs::exists(branch->path,fusepath))
+        if(!fs::exists(branch->path,fusepath_))
           error_and_continue(error,ENOENT);
         if(branch->ro_or_nc())
           error_and_continue(error,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(error,ENOENT);
         if(info.readonly)
           error_and_continue(error,EROFS);
-        if(info.spaceavail < minfreespace)
+        if(info.spaceavail < minfreespace_)
           error_and_continue(error,ENOSPC);
 
-        paths->push_back(branch->path);
+        paths_->push_back(branch->path);
       }
 
-    if(paths->empty())
+    if(paths_->empty())
       return (errno=error,-1);
 
     return 0;
@@ -75,8 +75,8 @@ namespace epall
   static
   int
   action(const Branches &branches_,
-         const char     *fusepath,
-         vector<string> *paths)
+         const char     *fusepath_,
+         vector<string> *paths_)
   {
     rwlock::ReadGuard guard(&branches_.lock);
 
@@ -90,7 +90,7 @@ namespace epall
       {
         branch = &branches_[i];
 
-        if(!fs::exists(branch->path,fusepath))
+        if(!fs::exists(branch->path,fusepath_))
           error_and_continue(error,ENOENT);
         if(branch->ro())
           error_and_continue(error,EROFS);
@@ -100,10 +100,10 @@ namespace epall
         if(readonly)
           error_and_continue(error,EROFS);
 
-        paths->push_back(branch->path);
+        paths_->push_back(branch->path);
       }
 
-    if(paths->empty())
+    if(paths_->empty())
       return (errno=error,-1);
 
     return 0;
@@ -112,8 +112,8 @@ namespace epall
   static
   int
   search(const Branches &branches_,
-         const char     *fusepath,
-         vector<string> *paths)
+         const char     *fusepath_,
+         vector<string> *paths_)
   {
     rwlock::ReadGuard guard(&branches_.lock);
 
@@ -123,13 +123,13 @@ namespace epall
       {
         branch = &branches_[i];
 
-        if(!fs::exists(branch->path,fusepath))
+        if(!fs::exists(branch->path,fusepath_))
           continue;
 
-        paths->push_back(branch->path);
+        paths_->push_back(branch->path);
       }
 
-    if(paths->empty())
+    if(paths_->empty())
       return (errno=ENOENT,-1);
 
     return 0;
@@ -137,20 +137,20 @@ namespace epall
 }
 
 int
-Policy::Func::epall(const Category  type,
+Policy::Func::epall(const Category  type_,
                     const Branches &branches_,
-                    const char     *fusepath,
-                    const uint64_t  minfreespace,
-                    vector<string> *paths)
+                    const char     *fusepath_,
+                    const uint64_t  minfreespace_,
+                    vector<string> *paths_)
 {
-  switch(type)
+  switch(type_)
     {
     case Category::CREATE:
-      return epall::create(branches_,fusepath,minfreespace,paths);
+      return epall::create(branches_,fusepath_,minfreespace_,paths_);
     case Category::ACTION:
-      return epall::action(branches_,fusepath,paths);
+      return epall::action(branches_,fusepath_,paths_);
     case Category::SEARCH:
     default:
-      return epall::search(branches_,fusepath,paths);
+      return epall::search(branches_,fusepath_,paths_);
     }
 }

src/policy_epff.cpp

@@ -55,7 +55,7 @@ namespace epff
           error_and_continue(error,ENOENT);
         if(branch->ro_or_nc())
           error_and_continue(error,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(error,ENOENT);
         if(info.readonly)

src/policy_eplfs.cpp

@@ -36,9 +36,9 @@ namespace eplfs
   static
   int
   create(const Branches &branches_,
-         const char     *fusepath,
-         const uint64_t  minfreespace,
-         vector<string> *paths)
+         const char     *fusepath_,
+         const uint64_t  minfreespace_,
+         vector<string> *paths_)
   {
     rwlock::ReadGuard guard(&branches_.lock);
 
@@ -56,16 +56,16 @@ namespace eplfs
       {
         branch = &branches_[i];
 
-        if(!fs::exists(branch->path,fusepath))
+        if(!fs::exists(branch->path,fusepath_))
           error_and_continue(error,ENOENT);
         if(branch->ro_or_nc())
           error_and_continue(error,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(error,ENOENT);
         if(info.readonly)
           error_and_continue(error,EROFS);
-        if(info.spaceavail < minfreespace)
+        if(info.spaceavail < minfreespace_)
           error_and_continue(error,ENOSPC);
         if(info.spaceavail > eplfs)
           continue;
@@ -77,7 +77,7 @@ namespace eplfs
     if(eplfsbasepath == NULL)
       return (errno=error,-1);
 
-    paths->push_back(*eplfsbasepath);
+    paths_->push_back(*eplfsbasepath);
 
     return 0;
   }
@@ -85,8 +85,8 @@ namespace eplfs
   static
   int
   action(const Branches &branches_,
-         const char     *fusepath,
-         vector<string> *paths)
+         const char     *fusepath_,
+         vector<string> *paths_)
   {
     rwlock::ReadGuard guard(&branches_.lock);
 
@@ -104,11 +104,11 @@ namespace eplfs
       {
         branch = &branches_[i];
 
-        if(!fs::exists(branch->path,fusepath))
+        if(!fs::exists(branch->path,fusepath_))
           error_and_continue(error,ENOENT);
         if(branch->ro())
           error_and_continue(error,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(error,ENOENT);
         if(info.readonly)
@@ -123,7 +123,7 @@ namespace eplfs
     if(eplfsbasepath == NULL)
       return (errno=error,-1);
 
-    paths->push_back(*eplfsbasepath);
+    paths_->push_back(*eplfsbasepath);
 
     return 0;
   }
@@ -131,8 +131,8 @@ namespace eplfs
   static
   int
   search(const Branches        &branches_,
-         const char            *fusepath,
-         vector<string>        *paths)
+         const char            *fusepath_,
+         vector<string>        *paths_)
   {
     rwlock::ReadGuard guard(&branches_.lock);
 
@@ -148,7 +148,7 @@ namespace eplfs
       {
         branch = &branches_[i];
 
-        if(!fs::exists(branch->path,fusepath))
+        if(!fs::exists(branch->path,fusepath_))
           continue;
         rv = fs::statvfs_cache_spaceavail(branch->path,&spaceavail);
         if(rv == -1)
@@ -163,27 +163,27 @@ namespace eplfs
     if(eplfsbasepath == NULL)
       return (errno=ENOENT,-1);
 
-    paths->push_back(*eplfsbasepath);
+    paths_->push_back(*eplfsbasepath);
 
     return 0;
   }
 }
 
 int
-Policy::Func::eplfs(const Category  type,
+Policy::Func::eplfs(const Category  type_,
                     const Branches &branches_,
-                    const char     *fusepath,
-                    const uint64_t  minfreespace,
-                    vector<string> *paths)
+                    const char     *fusepath_,
+                    const uint64_t  minfreespace_,
+                    vector<string> *paths_)
 {
-  switch(type)
+  switch(type_)
     {
     case Category::CREATE:
-      return eplfs::create(branches_,fusepath,minfreespace,paths);
+      return eplfs::create(branches_,fusepath_,minfreespace_,paths_);
     case Category::ACTION:
-      return eplfs::action(branches_,fusepath,paths);
+      return eplfs::action(branches_,fusepath_,paths_);
     case Category::SEARCH:
     default:
-      return eplfs::search(branches_,fusepath,paths);
+      return eplfs::search(branches_,fusepath_,paths_);
     }
 }

src/policy_eplus.cpp

@@ -36,9 +36,9 @@ namespace eplus
   static
   int
   create(const Branches &branches_,
-         const char     *fusepath,
-         const uint64_t  minfreespace,
-         vector<string> *paths)
+         const char     *fusepath_,
+         const uint64_t  minfreespace_,
+         vector<string> *paths_)
   {
     rwlock::ReadGuard guard(&branches_.lock);
 
@@ -56,16 +56,16 @@ namespace eplus
       {
         branch = &branches_[i];
 
-        if(!fs::exists(branch->path,fusepath))
+        if(!fs::exists(branch->path,fusepath_))
           error_and_continue(error,ENOENT);
         if(branch->ro_or_nc())
           error_and_continue(error,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(error,ENOENT);
         if(info.readonly)
           error_and_continue(error,EROFS);
-        if(info.spaceavail < minfreespace)
+        if(info.spaceavail < minfreespace_)
           error_and_continue(error,ENOSPC);
         if(info.spaceused >= eplus)
           continue;
@@ -77,7 +77,7 @@ namespace eplus
     if(eplusbasepath == NULL)
       return (errno=error,-1);
 
-    paths->push_back(*eplusbasepath);
+    paths_->push_back(*eplusbasepath);
 
     return 0;
   }
@@ -85,8 +85,8 @@ namespace eplus
   static
   int
   action(const Branches &branches_,
-         const char     *fusepath,
-         vector<string> *paths)
+         const char     *fusepath_,
+         vector<string> *paths_)
   {
     rwlock::ReadGuard guard(&branches_.lock);
 
@@ -104,11 +104,11 @@ namespace eplus
       {
         branch = &branches_[i];
 
-        if(!fs::exists(branch->path,fusepath))
+        if(!fs::exists(branch->path,fusepath_))
           error_and_continue(error,ENOENT);
         if(branch->ro())
           error_and_continue(error,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(error,ENOENT);
         if(info.readonly)
@@ -123,7 +123,7 @@ namespace eplus
     if(eplusbasepath == NULL)
       return (errno=error,-1);
 
-    paths->push_back(*eplusbasepath);
+    paths_->push_back(*eplusbasepath);
 
     return 0;
   }
@@ -131,8 +131,8 @@ namespace eplus
   static
   int
   search(const Branches &branches_,
-         const char     *fusepath,
-         vector<string> *paths)
+         const char     *fusepath_,
+         vector<string> *paths_)
   {
     rwlock::ReadGuard guard(&branches_.lock);
 
@@ -148,7 +148,7 @@ namespace eplus
       {
         branch = &branches_[i];
 
-        if(!fs::exists(branch->path,fusepath))
+        if(!fs::exists(branch->path,fusepath_))
           continue;
         rv = fs::statvfs_cache_spaceused(branch->path,&spaceused);
         if(rv == -1)
@@ -163,27 +163,27 @@ namespace eplus
     if(eplusbasepath == NULL)
       return (errno=ENOENT,-1);
 
-    paths->push_back(*eplusbasepath);
+    paths_->push_back(*eplusbasepath);
 
     return 0;
   }
 }
 
 int
-Policy::Func::eplus(const Category  type,
+Policy::Func::eplus(const Category  type_,
                     const Branches &branches_,
-                    const char     *fusepath,
-                    const uint64_t  minfreespace,
-                    vector<string> *paths)
+                    const char     *fusepath_,
+                    const uint64_t  minfreespace_,
+                    vector<string> *paths_)
 {
-  switch(type)
+  switch(type_)
     {
     case Category::CREATE:
-      return eplus::create(branches_,fusepath,minfreespace,paths);
+      return eplus::create(branches_,fusepath_,minfreespace_,paths_);
     case Category::ACTION:
-      return eplus::action(branches_,fusepath,paths);
+      return eplus::action(branches_,fusepath_,paths_);
     case Category::SEARCH:
     default:
-      return eplus::search(branches_,fusepath,paths);
+      return eplus::search(branches_,fusepath_,paths_);
     }
 }

src/policy_epmfs.cpp

@@ -60,7 +60,7 @@ namespace epmfs
           error_and_continue(error,ENOENT);
         if(branch->ro_or_nc())
           error_and_continue(error,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(error,ENOENT);
         if(info.readonly)
@@ -108,7 +108,7 @@ namespace epmfs
           error_and_continue(error,ENOENT);
         if(branch->ro())
           error_and_continue(error,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(error,ENOENT);
         if(info.readonly)

src/policy_ff.cpp

@@ -34,8 +34,8 @@ namespace ff
   static
   int
   create(const Branches &branches_,
-         const uint64_t  minfreespace,
-         vector<string> *paths)
+         const uint64_t  minfreespace_,
+         vector<string> *paths_)
   {
     rwlock::ReadGuard guard(&branches_.lock);
 
@@ -51,15 +51,15 @@ namespace ff
 
         if(branch->ro_or_nc())
           error_and_continue(error,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(error,ENOENT);
         if(info.readonly)
           error_and_continue(error,EROFS);
-        if(info.spaceavail < minfreespace)
+        if(info.spaceavail < minfreespace_)
           error_and_continue(error,ENOSPC);
 
-        paths->push_back(branch->path);
+        paths_->push_back(branch->path);
 
         return 0;
       }
@@ -69,14 +69,14 @@ namespace ff
 }
 
 int
-Policy::Func::ff(const Category  type,
+Policy::Func::ff(const Category  type_,
                  const Branches &branches_,
-                 const char     *fusepath,
-                 const uint64_t  minfreespace,
-                 vector<string> *paths)
+                 const char     *fusepath_,
+                 const uint64_t  minfreespace_,
+                 vector<string> *paths_)
 {
-  if(type == Category::CREATE)
-    return ff::create(branches_,minfreespace,paths);
+  if(type_ == Category::CREATE)
+    return ff::create(branches_,minfreespace_,paths_);
 
-  return Policy::Func::epff(type,branches_,fusepath,minfreespace,paths);
+  return Policy::Func::epff(type_,branches_,fusepath_,minfreespace_,paths_);
 }

src/policy_lfs.cpp

@@ -56,7 +56,7 @@ namespace lfs
 
         if(branch->ro_or_nc())
           error_and_continue(error,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(error,ENOENT);
         if(info.readonly)
@@ -80,14 +80,14 @@ namespace lfs
 }
 
 int
-Policy::Func::lfs(const Category  type,
+Policy::Func::lfs(const Category  type_,
                   const Branches &branches_,
-                  const char     *fusepath,
-                  const uint64_t  minfreespace,
-                  vector<string> *paths)
+                  const char     *fusepath_,
+                  const uint64_t  minfreespace_,
+                  vector<string> *paths_)
 {
-  if(type == Category::CREATE)
-    return lfs::create(branches_,minfreespace,paths);
+  if(type_ == Category::CREATE)
+    return lfs::create(branches_,minfreespace_,paths_);
 
-  return Policy::Func::eplfs(type,branches_,fusepath,minfreespace,paths);
+  return Policy::Func::eplfs(type_,branches_,fusepath_,minfreespace_,paths_);
 }

src/policy_lus.cpp

@@ -35,8 +35,8 @@ namespace lus
   static
   int
   create(const Branches &branches_,
-         const uint64_t  minfreespace,
-         vector<string> *paths)
+         const uint64_t  minfreespace_,
+         vector<string> *paths_)
   {
     rwlock::ReadGuard guard(&branches_.lock);
 
@@ -56,12 +56,12 @@ namespace lus
 
         if(branch->ro_or_nc())
           error_and_continue(error,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(error,ENOENT);
         if(info.readonly)
           error_and_continue(error,EROFS);
-        if(info.spaceavail < minfreespace)
+        if(info.spaceavail < minfreespace_)
           error_and_continue(error,ENOSPC);
         if(info.spaceused >= lus)
           continue;
@@ -73,21 +73,21 @@ namespace lus
     if(lusbasepath == NULL)
       return (errno=error,-1);
 
-    paths->push_back(*lusbasepath);
+    paths_->push_back(*lusbasepath);
 
     return 0;
   }
 }
 
 int
-Policy::Func::lus(const Category  type,
+Policy::Func::lus(const Category  type_,
                   const Branches &branches_,
-                  const char     *fusepath,
-                  const uint64_t  minfreespace,
-                  vector<string> *paths)
+                  const char     *fusepath_,
+                  const uint64_t  minfreespace_,
+                  vector<string> *paths_)
 {
-  if(type == Category::CREATE)
-    return lus::create(branches_,minfreespace,paths);
+  if(type_ == Category::CREATE)
+    return lus::create(branches_,minfreespace_,paths_);
 
-  return Policy::Func::eplus(type,branches_,fusepath,minfreespace,paths);
+  return Policy::Func::eplus(type_,branches_,fusepath_,minfreespace_,paths_);
 }

src/policy_mfs.cpp

@@ -55,7 +55,7 @@ namespace mfs
 
         if(branch->ro_or_nc())
           error_and_continue(error,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(error,ENOENT);
         if(info.readonly)
@@ -79,14 +79,14 @@ namespace mfs
 }
 
 int
-Policy::Func::mfs(const Category  type,
+Policy::Func::mfs(const Category  type_,
                   const Branches &branches_,
-                  const char     *fusepath,
-                  const uint64_t  minfreespace,
-                  vector<string> *paths)
+                  const char     *fusepath_,
+                  const uint64_t  minfreespace_,
+                  vector<string> *paths_)
 {
-  if(type == Category::CREATE)
-    return mfs::create(branches_,minfreespace,paths);
+  if(type_ == Category::CREATE)
+    return mfs::create(branches_,minfreespace_,paths_);
 
-  return Policy::Func::epmfs(type,branches_,fusepath,minfreespace,paths);
+  return Policy::Func::epmfs(type_,branches_,fusepath_,minfreespace_,paths_);
 }

src/policy_msplfs.cpp

@@ -59,7 +59,7 @@ namespace msplfs
           error_and_continue(*err_,ENOENT);
         if(branch->ro_or_nc())
           error_and_continue(*err_,EROFS);
-        rv = fs::info(&branch->path,&info);
+        rv = fs::info(branch->path,&info);
         if(rv == -1)
           error_and_continue(*err_,ENOENT);
         if(info.readonly)