Changeset 85382 in vbox

Timestamp:

Jul 18, 2020 11:33:58 AM (4 years ago)

Author:

vboxsync

Message:

iprt/path.h: Adjustments and a bunch of todos for RTPathFindCommon[Ex].

Location:

trunk

Files:

• include/iprt/path.h (modified) (1 diff)
• src/VBox/GuestHost/DragAndDrop/DnDTransferList.cpp (modified) (1 diff)
• src/VBox/GuestHost/DragAndDrop/testcase/tstDnDPath.cpp (modified) (1 diff)
• src/VBox/GuestHost/DragAndDrop/testcase/tstDnDTransferObject.cpp (modified) (1 diff)
• src/VBox/Runtime/common/path/RTPathFindCommon.cpp (modified) (3 diffs)
• src/VBox/Runtime/testcase/tstRTPathFindCommon.cpp (modified) (1 diff)

trunk/include/iprt/path.h

@@ -521 +521 @@
 
 /**
+ * Finds the common path in a given set of paths.
+ *
+ * The paths are not made absolute or real, they are taken as given.
+ *
+ * @returns Length (in characters) of the common path, 0 if not found.
+ * @param   cPaths      Number of paths in \a papszPaths.
+ * @param   papszPaths  Array of paths to find common path for.
+ */
+RTDECL(size_t) RTPathFindCommon(size_t cPaths, const char * const *papszPaths);
+
+/**
  * Finds the common path in a given set of paths, extended version.
  *
- * Note: This does not check paths for existience or other things (e.g. symlinks).
+ * The paths are not made absolute or real, they are taken as given.
  *
  * @returns Length (in characters) of the common path, 0 if not found.
- * @param   papcszPaths         Array of paths to find common path for.
- * @param   cPaths              Number of paths in \a papcszPaths.
- * @param   szSeparator         Path separator to use for comparision.
- */
-RTDECL(size_t) RTPathFindCommonEx(const char * const *papcszPaths, size_t cPaths, char szSeparator);
-
-/**
- * Finds the common path in a given set of paths.
- *
- * Uses the system's native slash as separator.
- * Note: This does not check paths for existience or other things (e.g. symlinks).
- *
- * @returns Length (in characters) of the common path, 0 if not found.
- * @param   papcszPaths         Array of paths to find common path for.
- * @param   cPaths              Number of paths in \a papcszPaths.
- */
-RTDECL(size_t) RTPathFindCommon(const char * const *papcszPaths, size_t cPaths);
+ * @param   cPaths      Number of paths in \a papszPaths.
+ * @param   papszPaths  Array of paths to find common path for.
+ * @param   fFlags      RTPATH_STR_F_STYLE_XXX. Other RTPATH_STR_F_XXX flags
+ *                      will be ignored.
+ */
+RTDECL(size_t) RTPathFindCommonEx(size_t cPaths, const char * const *papszPaths, uint32_t fFlags);
 
 /**

trunk/src/VBox/GuestHost/DragAndDrop/DnDTransferList.cpp

@@ -582 +582 @@
     if (!pList->pszPathRootAbs)
     {
-        size_t cchRootPath = RTPathFindCommon(papcszPaths, cPaths);
+        size_t cchRootPath = RTPathFindCommon(cPaths, papcszPaths);
         if (cchRootPath)
         {

trunk/src/VBox/GuestHost/DragAndDrop/testcase/tstDnDPath.cpp

@@ -18 +18 @@
 #include <iprt/assert.h>
 #include <iprt/env.h>
-#include <iprt/err.h>
+#include <iprt/errcore.h>
 #include <iprt/path.h>
 #include <iprt/string.h>

trunk/src/VBox/GuestHost/DragAndDrop/testcase/tstDnDTransferObject.cpp

@@ -18 +18 @@
 #include <iprt/assert.h>
 #include <iprt/env.h>
-#include <iprt/err.h>
+#include <iprt/errcore.h>
 #include <iprt/mem.h>
 #include <iprt/string.h>

trunk/src/VBox/Runtime/common/path/RTPathFindCommon.cpp

@@ -35 +35 @@
 
 
-RTDECL(size_t) RTPathFindCommonEx(const char * const *papcszPaths, size_t cPaths, char szSeparator)
+RTDECL(size_t) RTPathFindCommonEx(size_t cPaths, const char * const *papszPaths, uint32_t fFlags)
 {
-    AssertPtrReturn(papcszPaths, 0);
-    AssertReturn(cPaths, 0);
-    AssertReturn(szSeparator != '\0', 0);
+    AssertReturn(cPaths > 0, 0);
+    AssertPtrReturn(papszPaths, 0);
+    AssertReturn(RTPATH_STR_F_IS_VALID(fFlags, 0), 0);
 
-    const char *pcszRef = papcszPaths[0]; /* The reference we're comparing with. */
+    /** @todo r=bird: Extremely naive code.
+     * - The original idea of taking either '/' or '\\' as separators is very out of
+     *   touch with the rest of path.h.  On DOS based systems we need to handle both
+     *   of those as well as ':'.
+     * - Why compare pszRef with itself?
+     * - Why derefernece pszRef[cch] for each other path.
+     * - Why perform NULL checks for each outer iteration.
+     * - Why perform '\0' check before comparing with pszRef[cch]?
+     *   It's sufficient to check if pszRef[cch] is '\0'.
+     * - Why backtrack to the last path separator?  It won't return the expected
+     *   result for cPaths=1, unless the path ends with a separator.
+     * - Multiple consequtive path separators must be treated as a single one (most
+     *   of the time anyways - UNC crap).
+     */
+    const char *pszRef = papszPaths[0]; /* The reference we're comparing with. */
+    const char chNaiveSep = (fFlags & RTPATH_STR_F_STYLE_MASK) == RTPATH_STR_F_STYLE_HOST
+                          ? RTPATH_SLASH
+                          : (fFlags & RTPATH_STR_F_STYLE_MASK) == RTPATH_STR_F_STYLE_DOS ? '\\' : '/';
 
     size_t cch = 0;
@@ -48 +65 @@
         for (size_t i = 0; i < cPaths; ++i)
         {
-            const char *pcszPath = papcszPaths[i];
+            const char *pcszPath = papszPaths[i];
             if (   pcszPath
                 && pcszPath[cch]
-                && pcszPath[cch] == pcszRef[cch])
+                && pcszPath[cch] == pszRef[cch])
                 continue;
 
             while (   cch
-                   && pcszRef[--cch] != szSeparator) { }
+                   && pszRef[--cch] != chNaiveSep) { }
 
             return cch ? cch + 1 : 0;
         }
-    }
-    while (++cch);
+    } while (++cch);
 
     return 0;
@@ -67 +83 @@
 
 
-RTDECL(size_t) RTPathFindCommon(const char * const *papcszPaths, size_t cPaths)
+RTDECL(size_t) RTPathFindCommon(size_t cPaths, const char * const *papszPaths)
 {
-    return RTPathFindCommonEx(papcszPaths, cPaths, RTPATH_SLASH);
+    return RTPathFindCommonEx(cPaths, papszPaths, RTPATH_STR_F_STYLE_HOST);
 }
 RT_EXPORT_SYMBOL(RTPathFindCommon);

trunk/src/VBox/Runtime/testcase/tstRTPathFindCommon.cpp

@@ -46 +46 @@
     struct
     {
-        char const *papszPath1;
-        char const *papszPath2;
-        char const *papszPath3;
-        char const *papszPatCommon;
+        char const *apszPaths[3];
+        char const *pszCommon;
+        uint32_t    fFlags;
     } aTests[] =
     {
         /* Simple stuff first. */
-        { "", "", "", "" },
-        { "none", "none", "", "" },
+        { { "",                     "",                 "" },                       "",          RTPATH_STR_F_STYLE_UNIX },
+        { { "none",                 "none",             "" },                       "",          RTPATH_STR_F_STYLE_UNIX },
         /* Missing start slash. */
-        { "/path/to/stuff1", "path/to/stuff2", "", "" },
+        { { "/path/to/stuff1",      "path/to/stuff2",   "" },                       "",          RTPATH_STR_F_STYLE_UNIX },
         /* Working stuff. */
-        { "/path/to/stuff1", "/path/to/stuff2", "/path/to/stuff3", "/path/to/" },
-        { "/path/to/stuff1", "/path/to/", "/path/", "/path/" },
-        { "/path/to/stuff1", "/", "/path/", "" },
-        { "/path/to/../stuff1", "./../", "/path/to/stuff2/..", "" }
+        { { "/path/to/stuff1",      "/path/to/stuff2",  "/path/to/stuff3" },        "/path/to/", RTPATH_STR_F_STYLE_UNIX },
+        { { "/path/to/stuff1",      "/path/to/",        "/path/" },                 "/path/",    RTPATH_STR_F_STYLE_UNIX },
+        { { "/path/to/stuff1",      "/",                "/path/" },                 "",          RTPATH_STR_F_STYLE_UNIX },
+        { { "/path/to/../stuff1",   "./../",            "/path/to/stuff2/.." },     "",          RTPATH_STR_F_STYLE_UNIX },
     };
 
-    const size_t cNumPaths = 3; /* Number of paths to compare. */
+    for (size_t i = 0; i < RT_ELEMENTS(aTests); i++)
+    {
+        size_t cPaths = RT_ELEMENTS(aTests[i].apszPaths);
+        while (cPaths > 0 && aTests[i].apszPaths[cPaths - 1] == NULL)
+            cPaths--;
 
-    size_t cchRes;
-    for (size_t i = 0; i < RT_ELEMENTS(aTests); i++)
-        RTTEST_CHECK_MSG(hTest, (cchRes = RTPathFindCommonEx((const char * const *)&aTests[i], cNumPaths, '/')) == strlen(aTests[i].papszPatCommon),
-                         (hTest, "Test %zu failed: Got %zu, expected %zu\n", i, cchRes, strlen(aTests[i].papszPatCommon)));
+        size_t const cchCommon = RTPathFindCommonEx(cPaths, aTests[i].apszPaths, aTests[i].fFlags);
+        size_t const cchExpect = strlen(aTests[i].pszCommon);
+        if (cchCommon != cchExpect)
+            RTTestFailed(hTest,
+                         "Test %zu failed: got %zu, expected %zu (cPaths=%zu: %s %s %s)", i, cchCommon, cchExpect, cPaths,
+                         aTests[i].apszPaths[0], aTests[i].apszPaths[1], aTests[i].apszPaths[2]);
+    }
 
     /*