Clean up path processing

lib/api.h

@@ -27,6 +27,7 @@
 #include <glib.h>
 
 #include "cfg.h"
+#include "cfg-funcs.h"
 #include "cmdline.h"
 #include "config.h"
 #include "session.h"

lib/cfg.c → lib/cfg-funcs.h

@@ -22,20 +22,25 @@
 * Hosted on http://github.com/sahib/rmlint
 **/
 
-#include <stdbool.h>
-#include <string.h>
-#include <unistd.h>
+#ifndef RM_CFG_FUNCS_H
+#define RM_CFG_FUNCS_H
 
-#include "cfg.h"
+#include <string.h>     // memset
+#include <stdbool.h>    // bool, true, false
+#include <limits.h>     // PATH_MAX (maybe)
+#include <glib.h>       // G_MAXUINT64, g_strdup, G_LOG_LEVEL_INFO, g_slist_free_full
 
-static void rm_path_free(RmPath *rmpath) {
-    free(rmpath->path);
-    g_slice_free(RmPath, rmpath);
-}
+#include "config.h"     // RM_DEFAULT_DIGEST, PATH_MAX (maybe), RmOff
+#include "cfg.h"        // RmCfg
+#include "pathtricia.h" // rm_trie_init
+#include "path-funcs.h" // rm_path_free, rm_path_is_valid, rm_path_is_json, rm_path_prepend
 
 /* Options not specified by commandline get a default option -
  * this is usually called before rm_cmd_parse_args */
+static INLINE
 void rm_cfg_set_default(RmCfg *cfg) {
+    g_assert(cfg);
+
     /* Set everything to 0 at first,
      * only non-null options are listed below.
      */
@@ -87,8 +92,8 @@ void rm_cfg_set_default(RmCfg *cfg) {
      * 32k => 15.8 seconds */
     cfg->read_buf_len = 16 * 1024;
 
-    cfg->total_mem = (RmOff)1024 * 1024 * 1024;
-    cfg->sweep_size = 1024 * 1024 * 1024;
+    cfg->total_mem = 1024L * 1024 * 1024;
+    cfg->sweep_size = 1024L * 1024 * 1024;
     cfg->sweep_count = 1024 * 16;
 
     cfg->skip_start_factor = 0.0;
@@ -103,46 +108,64 @@ void rm_cfg_set_default(RmCfg *cfg) {
     rm_trie_init(&cfg->file_trie);
 }
 
-guint rm_cfg_add_path(RmCfg *cfg, bool is_prefd, const char *path) {
-    int rc = 0;
-
-#if HAVE_FACCESSAT
-    rc = faccessat(AT_FDCWD, path, R_OK, AT_EACCESS);
-#else
-    rc = access(path, R_OK);
-#endif
-
-    if(rc != 0) {
-        rm_log_warning_line(_("Can't open directory or file \"%s\": %s"), path,
-                            strerror(errno));
-        return 0;
-    }
-
-    char *real_path = realpath(path, NULL);
-    if(real_path == NULL) {
-        rm_log_warning_line(_("Can't get real path for directory or file \"%s\": %s"),
-                            path, strerror(errno));
-        return 0;
+static INLINE
+bool rm_cfg_prepend_json(
+    RmCfg *const cfg,
+    const char *const path
+) {
+    g_assert(cfg);
+    char *real_path;
+    if(rm_path_is_valid(path, &real_path) && rm_path_is_json(real_path)) {
+        rm_path_prepend(
+            &cfg->json_paths,
+            real_path,
+            cfg->path_count++,
+            false /* not preferred */
+        );
+        return true;
     }
+    return false;
+}
 
-    RmPath *rmpath = g_slice_new(RmPath);
-    rmpath->path = real_path;
-    rmpath->is_prefd = is_prefd;
-    rmpath->idx = cfg->path_count++;
-    rmpath->treat_as_single_vol = strncmp(path, "//", 2) == 0;
-
-    if(cfg->replay && g_str_has_suffix(rmpath->path, ".json")) {
-        cfg->json_paths = g_slist_prepend(cfg->json_paths, rmpath);
-        return 1;
+#define PREPEND_TO(list)    \
+    rm_path_prepend(        \
+        &(list),            \
+        real_path,          \
+        index,              \
+        preferred           \
+    )
+
+static INLINE
+bool rm_cfg_prepend_path(
+    RmCfg *const cfg,
+    const char *const path,
+    const unsigned int index,
+    const bool replay,
+    const bool preferred
+) {
+    g_assert(cfg);
+    char *real_path;
+    if(rm_path_is_valid(path, &real_path)) {
+        if(replay && rm_path_is_json(path)) {
+            PREPEND_TO(cfg->json_paths);
+        } else {
+            PREPEND_TO(cfg->paths);
+            ++(cfg->path_count);
+        }
+        return true;
     }
-
-    cfg->paths = g_slist_prepend(cfg->paths, rmpath);
-    return 1;
+    return false;
 }
 
-void rm_cfg_free_paths(RmCfg *cfg) {
+#undef PREPEND_TO
+
+static INLINE
+void rm_cfg_free_paths(RmCfg *const cfg) {
+    g_assert(cfg);
     g_slist_free_full(cfg->paths, (GDestroyNotify)rm_path_free);
     cfg->paths = NULL;
     g_slist_free_full(cfg->json_paths, (GDestroyNotify)rm_path_free);
     cfg->json_paths = NULL;
 }
+
+#endif /* end of include guard */

lib/cfg.h

@@ -22,29 +22,15 @@
 * Hosted on http://github.com/sahib/rmlint
 **/
 
-#ifndef RM_SETTINGS_H
-#define RM_SETTINGS_H
+#ifndef RM_CFG_H
+#define RM_CFG_H
 
-#include <stdio.h>
+#include <stdbool.h>    // bool
+#include <glib.h>       // gboolean, gdouble, gint, GSList, guint
 
-#include "checksum.h"
-#include "pathtricia.h"
-#include "utilities.h"
-
-/* Struct for paths passed to rmlint from command line (or stdin) */
-typedef struct RmPath {
-    /* the RealPath of the passed string */
-    char *path;
-
-    /* index number (command line order) */
-    guint idx;
-
-    /* whether path was tagged as preferred path */
-    bool is_prefd;
-
-    /* whether to treat all files under path as one filesystem */
-    bool treat_as_single_vol;
-} RmPath;
+#include "config.h"     // RmOff
+#include "pathtricia.h" // RmTrie
+#include "checksum.h"   // RmDigestType
 
 /* Storage struct for all options settable in cmdline. */
 typedef struct RmCfg {
@@ -87,7 +73,6 @@ typedef struct RmCfg {
     gboolean progress_enabled;
     gboolean list_mounts;
     gboolean replay;
-    gboolean read_stdin;
     gboolean read_stdin0;
     gboolean no_backup;
 
@@ -115,16 +100,13 @@ typedef struct RmCfg {
      *
      *   + To record  a  unique  index for each path supplied by the
      *     user; a path's index represents  the number of paths that
-     *     were already processed. This is always the case.
+     *     were  already  processed. This  is  the  case DURING  the
+     *     processing of user-input options (such as '--replay').
      *
-     *   + To provide  quick  access to the length of its associated
-     *     RmCfg::paths list. This is only the case when NOT running
-     *     in "--replay"  mode; when running in  "--replay" mode, it
-     *     just represents the total number  of paths that have been
-     *     supplied by  the user, i.e.,  the sums of the  lengths of
-     *     the associated lists  RmCfg::{paths,json_paths}, which is
-     *     not meant to be a useful  number to know, and is simply a
-     *     byproduct of calculating path indicies.
+     *   + To provide  quick access  to the length of its associated
+     *     RmCfg::paths list.  This is the case AFTER the processing
+     *     of user-input options (including during the processing of
+     *     non-option paths from the command line or stdin).
      */
     guint path_count;
 
@@ -186,19 +168,4 @@ typedef struct RmCfg {
 
 } RmCfg;
 
-/**
- * @brief Reset RmCfg to default cfg and all other vars to 0.
- */
-void rm_cfg_set_default(RmCfg *cfg);
-
-/**
- * @brief check and add a path to cfg->paths.
- */
-guint rm_cfg_add_path(RmCfg *cfg, bool is_prefd, const char *path);
-
-/**
- * @brief free all data associated with cfg->paths.
- */
-void rm_cfg_free_paths(RmCfg *cfg);
-
 #endif /* end of include guard */