Changeset 24893 in vbox for trunk/src/VBox/Runtime/common

Timestamp:

Nov 24, 2009 12:09:03 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

55167

Message:

IPRT: Improved RTStrVersionCompare() + testcase.

File:

• trunk/src/VBox/Runtime/common/string/strversion.cpp (modified) (2 diffs)

trunk/src/VBox/Runtime/common/string/strversion.cpp

@@ -37 +37 @@
 
 #include <iprt/assert.h>
-#include <iprt/ctype.h> /* needed for RT_C_IS_DIGIT */
 #include <iprt/err.h>
 #include <iprt/mem.h>
 
 
+/*******************************************************************************
+*   Defined Constants                                                          *
+*******************************************************************************/
+#define ISDIGIT(c) ((c) >= '0' && (c) <= '9')
+
+
+/*******************************************************************************
+*   Internal Functions                                                         *
+*******************************************************************************/
+static uint16_t RTStrVersionGetBlockCount(const char *pszVer)
+{
+    uint16_t l = 0;
+    const char *pszCur = pszVer;
+    while (pszCur = RTStrStr(pszCur, "."))
+    {
+        if (pszCur == NULL)
+            break;
+        l++;
+        pszCur++;
+    }
+    /* Adjust block count to also count in the very first block */
+    if (*pszVer != '\0')
+        l++;
+    return l;
+}
+
+
+static int RTStrVersionGetUInt32(const char *pszVer, uint16_t u16Block, uint32_t *pu32)
+{
+    /* First make a copy of the version string so that we can modify it */
+    char *pszString;
+    int rc = RTStrDupEx(&pszString, pszVer);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /* Go to the beginning of the block we want to parse */
+    char *pszCur = pszString;
+    for (uint16_t i = 0; i < u16Block; i++)
+    {
+        pszCur = RTStrStr(pszCur, ".");
+        if (pszCur == NULL)
+            break;
+        if (*pszCur != '\0')
+            pszCur++;
+    }
+
+    if (pszCur != NULL && *pszCur != '\0')
+    {
+        /* Skip trailing non-digits at the start of the block */
+        while (pszCur && *pszCur != '\0')
+        {
+            if (ISDIGIT(*pszCur))
+                break;
+            pszCur++;
+        }
+
+        /* Mark ending of the block */
+        char *pszEnd = RTStrStr(pszCur, ".");
+        if (NULL != pszEnd)
+            *pszEnd = '\0';
+
+        /* Convert to number */
+        rc = RTStrToUInt32Ex(pszCur, NULL /* ppszNext */, 10 /* Base */, pu32);
+        /* Skip trailing warnings */
+        if (   rc == VWRN_TRAILING_CHARS
+            || rc == VWRN_TRAILING_SPACES)
+            rc = VINF_SUCCESS;
+    }
+    else
+        rc = VERR_NOT_FOUND;
+
+    RTStrFree(pszString);
+    return rc;
+}
+
 
 /**
- * Converts a string representation of a version number to an unsigned number.
+ * Compares two version strings and returns the result. The version string has
+ * to be made of at least one number section, each section delimited by a ".",
+ * e.g. "123.45.67". Trailing zeros at the beginning and non-digits in a section
+ * will be skipped, so "12.foo006" becomes "12.6".
  *
  * @returns iprt status code.
@@ -55 +132 @@
  * @retval  VERR_NO_DIGITS
  *
- * @param   pszValue    Pointer to the string value.
- * @param   pu32        Where to store the converted number.
- *
- * @todo    r=bird: The returned value isn't really suitable for comparing two
- *          version strings.  Try see which result you get when converting
- *          "3.0.14" and "3.1.0" and comparing the values.  The way to fix this
- *          deficiency would be to convert the individual parts and dividing the
- *          return value into sections: bits 31:24 FirstNumber; 23:16 Second;
- *          15:8 Third; 7:0 Forth.  It would probably be a good idea to use a
- *          64-bit return value instead of a 32-bit one, so there is room for
- *          revision number when found.
- *
- *          Actually, because of the above, the kind of API I had in mind was
- *          int RTStrVersionCompare(const char *pszVer1, const char *pszVer2).
- *          It wouldn't try convert input to numbers, just do a parallel parse.
- *          This would allow easy handling beta/alpha/++ indicators and any
- *          number of dots and dashes.
+ * @todo    Deal with prefixes and suffixes!
+ * @param   pszVer1     First version string to compare.
+ * @param   pszVer2     First version string to compare.*
+ * @param   pui8Res     Pointer uint8_t value where to store the comparison result:
+ *                      0 if equal, 1 if pszVer1 is greater, 2 if pszVer2 is greater.
  */
-RTDECL(int) RTStrVersionToUInt32(const char *pszVer, uint32_t *pu32)
+int RTStrVersionCompare(const char *pszVer1, const char *pszVer2, uint8_t *pui8Res)
 {
-    const char *psz = pszVer;
-    AssertPtr(pu32);
-    AssertPtr(psz);
-
-    char *pszNew = (char*)RTMemAllocZ((strlen(pszVer) + 1) * sizeof(char));
-    if (pszNew == NULL)
-        return VERR_NO_MEMORY;
-
-    unsigned    i            = 0;
-    bool        fLastInvalid = false;
-    while (    psz
-           && *psz != '\0')
-    {
-        if (fLastInvalid)
-        {
-            if (   *psz == '-'
-                || *psz == '_')
-                fLastInvalid = false;
-        }
-        else
-        {
-            if (RT_C_IS_DIGIT(*psz))
-                pszNew[i++] = *psz;
-            else if (   *psz != '.'
-                     && i == 0)
-                fLastInvalid = true;
-        }
-        psz++;
-    }
-    pszNew[i] = '\0';
-
-    /* Convert final number string to number */
-    int rc;
-    if (fLastInvalid)
-    {
-        *pu32 = 0;
+    AssertPtr(pszVer1);
+    AssertPtr(pszVer2);
+
+    uint16_t len1 = RTStrVersionGetBlockCount(pszVer1);
+    uint16_t len2 = RTStrVersionGetBlockCount(pszVer2);
+
+    int rc = 0;
+    if (len1 > 0 && len2 > 0)
+    {
+        /* Figure out which version string is longer and set the corresponding
+         * pointers */
+        uint16_t range;
+        uint16_t padding;
+        const char *pszShorter, *pszLonger;
+        if (len1 >= len2)
+        {
+            range = len1;
+            padding = len1 - len2;
+            pszLonger = pszVer1;
+            pszShorter = pszVer2;
+        }
+        else if (len2 > len1)
+        {
+            range = len2;
+            padding = len2 - len1;
+            pszLonger = pszVer2;
+            pszShorter = pszVer1;
+        }
+
+        /* Now process each section (delimited by a ".") */
+        AssertPtr(pszShorter);
+        AssertPtr(pszLonger);
+        AssertPtr(pui8Res);
+        *pui8Res = 0;
+        uint32_t val1, val2;
+        for (uint16_t i = 0;    i < range
+                             && *pui8Res == 0
+                             && RT_SUCCESS(rc)
+                           ; i++)
+        {
+            rc = RTStrVersionGetUInt32(pszLonger, i, &val1);
+            if (RT_SUCCESS(rc))
+            {
+                if (i >= range - padding)
+                {
+                    /* If we're in the padding range, there are no numbers left
+                     * to compare with anymore, so just assume "0" then */
+                    val2 = 0;
+                }
+                else
+                {
+                    rc = RTStrVersionGetUInt32(pszShorter, i, &val2);
+                }
+            }
+
+            if (RT_SUCCESS(rc))
+            {
+                if (val1 > val2)
+                {
+                    *pui8Res = (pszLonger == pszVer1) ? 1 : 2;
+                    break;
+                }
+                else if (val2 > val1)
+                {
+                    *pui8Res = (pszShorter == pszVer1) ? 1 : 2;
+                    break;
+                }
+            }
+        }
+    }
+    else
+    {
         rc = VERR_NO_DIGITS;
     }
-    else
-    {
-        rc = RTStrToUInt32Ex(pszNew, NULL /*pszNext*/, 10 /*uBase*/, pu32);
-        if (rc != VINF_SUCCESS)
-            *pu32 = 0;
-    }
-    RTStrFree(pszNew);
+
+    if (RT_FAILURE(rc))
+        *pui8Res = 0; /* Zero out value */
     return rc;
 }
-
+RT_EXPORT_SYMBOL(RTStrVersionCompare);