Changeset 26481 in vbox for trunk

Timestamp:

Feb 14, 2010 1:00:49 AM (15 years ago)

Author:

vboxsync

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

57648

Message:

IPRT: Added RTStrAAppend, RTStrAAppendN, RTStrAAppendExN[V]{,1}, RTStrAlloc, RTStrAllocEx and RTStrRealloc. Fixed bug in RTStrDupN.

Location:

trunk

Files:

• include/iprt/string.h (modified) (1 diff)
• src/VBox/Runtime/common/string/stringalloc.cpp (modified) (6 diffs)
• src/VBox/Runtime/testcase/Makefile.kmk (modified) (2 diffs)
• src/VBox/Runtime/testcase/tstRTStrAlloc.cpp (added)

trunk/include/iprt/string.h

@@ -181 +181 @@
 
 /**
+ * Appends a string onto an existing IPRT allocated string.
+ *
+ * @retval  VINF_SUCCESS
+ * @retval  VERR_NO_STR_MEMORY if we failed to reallocate the string, @a *ppsz
+ *          remains unchanged.
+ *
+ * @param   ppsz                Pointer to the string pointer.  The string
+ *                              pointer must either be NULL or point to a string
+ *                              returned by an IPRT string API.  (In/Out)
+ * @param   pszAppend           The string to append.  NULL and empty strings
+ *                              are quietly ignored.
+ */
+RTDECL(int) RTStrAAppend(char **ppsz, const char *pszAppend);
+
+/**
+ * Appends N bytes from a strings onto an existing IPRT allocated string.
+ *
+ * @retval  VINF_SUCCESS
+ * @retval  VERR_NO_STR_MEMORY if we failed to reallocate the string, @a *ppsz
+ *          remains unchanged.
+ *
+ * @param   ppsz                Pointer to the string pointer.  The string
+ *                              pointer must either be NULL or point to a string
+ *                              returned by an IPRT string API.  (In/Out)
+ * @param   pszAppend           The string to append.  Can be NULL if cchAppend
+ *                              is NULL.
+ * @param   cchAppend           The number of chars (not code points) to append
+ *                              from pszAppend.   Must not be more than
+ *                              @a pszAppend contains, except for the special
+ *                              value RTSTR_MAX that can be used to indicate all
+ *                              of @a pszAppend without having to strlen it.
+ */
+RTDECL(int) RTStrAAppendN(char **ppsz, const char *pszAppend, size_t cchAppend);
+
+/**
+ * Appends one or more strings onto an existing IPRT allocated string.
+ *
+ * This is a very flexible and efficient alternative to using RTStrAPrintf to
+ * combine several strings together.
+ *
+ * @retval  VINF_SUCCESS
+ * @retval  VERR_NO_STR_MEMORY if we failed to reallocate the string, @a *ppsz
+ *          remains unchanged.
+ *
+ * @param   ppsz                Pointer to the string pointer.  The string
+ *                              pointer must either be NULL or point to a string
+ *                              returned by an IPRT string API.  (In/Out)
+ * @param   cPairs              The number of string / length pairs in the
+ *                              @a va.
+ * @param   va                  List of string (const char *) and length
+ *                              (size_t) pairs.  The strings will be appended to
+ *                              the string in the first argument.
+ */
+RTDECL(int) RTStrAAppendExNV(char **ppsz, size_t cPairs, va_list va);
+
+/**
+ * Appends one or more strings onto an existing IPRT allocated string.
+ *
+ * This is a very flexible and efficient alternative to using RTStrAPrintf to
+ * combine several strings together.
+ *
+ * @retval  VINF_SUCCESS
+ * @retval  VERR_NO_STR_MEMORY if we failed to reallocate the string, @a *ppsz
+ *          remains unchanged.
+ *
+ * @param   ppsz                Pointer to the string pointer.  The string
+ *                              pointer must either be NULL or point to a string
+ *                              returned by an IPRT string API.  (In/Out)
+ * @param   cPairs              The number of string / length pairs in the
+ *                              ellipsis.
+ * @param   ...                 List of string (const char *) and length
+ *                              (size_t) pairs.  The strings will be appended to
+ *                              the string in the first argument.
+ */
+RTDECL(int) RTStrAAppendExN(char **ppsz, size_t cPairs, ...);
+
+/**
+ * Allocates memory for string storage.
+ *
+ * You should normally not use this function, except if there is some very
+ * custom string handling you need doing that isn't covered by any of the other
+ * APIs.
+ *
+ * @returns Pointer to the allocated string.  The first byte is always set
+ *          to the string terminator char, the contents of the remainder of the
+ *          memory is undefined.  The string must be freed by calling RTStrFree.
+ *
+ *          NULL is returned if the allocation failed.  Please translate this to
+ *          VERR_NO_STR_MEMORY and not VERR_NO_MEMORY.  Also consider
+ *          RTStrAllocEx if an IPRT status code is required.
+ *
+ * @param   cb                  How many bytes to allocate.  If this is zero, we
+ *                              will allocate a terminator byte anyway.
+ */
+RTDECL(char *) RTStrAlloc(size_t cb);
+
+/**
+ * Allocates memory for string storage, with status code.
+ *
+ * You should normally not use this function, except if there is some very
+ * custom string handling you need doing that isn't covered by any of the other
+ * APIs.
+ *
+ * @retval  VINF_SUCCESS
+ * @retval  VERR_NO_STR_MEMORY
+ *
+ * @param   ppsz                Where to return the allocated string.  This will
+ *                              be set to NULL on failure.  On success, the
+ *                              returned memory will always start with a
+ *                              terminator char so that it is considered a valid
+ *                              C string, the contents of rest of the memory is
+ *                              undefined.
+ * @param   cb                  How many bytes to allocate.  If this is zero, we
+ *                              will allocate a terminator byte anyway.
+ */
+RTDECL(int) RTStrAllocEx(char **ppsz, size_t cb);
+
+/**
+ * Reallocates the specifed string.
+ *
+ * You should normally not have use this function, except perhaps to truncate a
+ * really long string you've got from some IPRT string API.
+ *
+ * @returns VINF_SUCCESS.
+ * @retval  VERR_NO_STR_MEMORY if we failed to reallocate the string, @a *ppsz
+ *          remains unchanged.
+ *
+ * @param   ppsz                Pointer to the string variable containing the
+ *                              input and output string.
+ *
+ *                              When not freeing the string, the result will
+ *                              always have the last byte set to the terminator
+ *                              character so that when used for string
+ *                              truncation the result will be a valid C string
+ *                              (your job to keep it a valid UTF-8 string).
+ *
+ *                              When the input string is NULL and we're supposed
+ *                              to reallocate, the returned string will also
+ *                              have the first byte set to the terminator char
+ *                              so it will be a valid C string.
+ *
+ * @param   cbNew               When @a cbNew is zero, we'll behave like
+ *                              RTStrFree and @a *ppsz will be set to NULL.
+ *
+ *                              When not zero, this will be the new size of the
+ *                              memory backing the string, i.e. it includes the
+ *                              terminator char.
+ */
+RTDECL(int) RTStrRealloc(char **ppsz, size_t cbNew);
+
+/**
  * Validates the UTF-8 encoding of the string.
  *

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

@@ -36 +36 @@
 #include "internal/iprt.h"
 
-#include <iprt/alloc.h>
+#include <iprt/alloca.h>
 #include <iprt/assert.h>
+#include <iprt/mem.h>
 #include <iprt/err.h>
 #include "internal/string.h"
 
 
-/**
- * Free string allocated by any of the non-UCS-2 string functions.
- *
- * @returns iprt status code.
- * @param   pszString      Pointer to buffer with string to free.
- *                         NULL is accepted.
- */
+
+RTDECL(char *) RTStrAlloc(size_t cb)
+{
+    char *psz = (char *)RTMemAlloc(RT_MAX(cb, 1));
+    if (psz)
+        *psz = '\0';
+    return psz;
+}
+RT_EXPORT_SYMBOL(RTStrAlloc);
+
+
+RTDECL(int) RTStrAllocEx(char **ppsz, size_t cb)
+{
+    char *psz = *ppsz = (char *)RTMemAlloc(RT_MAX(cb, 1));
+    if (psz)
+    {
+        *psz = '\0';
+        return VINF_SUCCESS;
+    }
+    return VERR_NO_STR_MEMORY;
+}
+RT_EXPORT_SYMBOL(RTStrAlloc);
+
+
+RTDECL(int) RTStrRealloc(char **ppsz, size_t cbNew)
+{
+    char *pszOld = *ppsz;
+    if (!cbNew)
+    {
+        RTMemFree(pszOld);
+        *ppsz = NULL;
+    }
+    else if (pszOld)
+    {
+        char *pszNew = (char *)RTMemRealloc(pszOld, cbNew);
+        if (!pszNew)
+            return VERR_NO_STR_MEMORY;
+        pszNew[cbNew - 1] = '\0';
+        *ppsz = pszNew;
+    }
+    else
+    {
+        char *pszNew = (char *)RTMemAlloc(cbNew);
+        if (!pszNew)
+            return VERR_NO_STR_MEMORY;
+        pszNew[0] = '\0';
+        pszNew[cbNew - 1] = '\0';
+        *ppsz = pszNew;
+    }
+    return VINF_SUCCESS;
+}
+
 RTDECL(void)  RTStrFree(char *pszString)
 {
@@ -57 +103 @@
 
 
-/**
- * Allocates a new copy of the given UTF-8 string.
- *
- * @returns Pointer to the allocated UTF-8 string.
- * @param   pszString       UTF-8 string to duplicate.
- */
 RTDECL(char *) RTStrDup(const char *pszString)
 {
@@ -75 +115 @@
 
 
-/**
- * Allocates a new copy of the given UTF-8 string.
- *
- * @returns iprt status code.
- * @param   ppszString      Receives pointer of the allocated UTF-8 string.
- *                          The returned pointer must be freed using RTStrFree().
- * @param   pszString       UTF-8 string to duplicate.
- */
 RTDECL(int)  RTStrDupEx(char **ppszString, const char *pszString)
 {
@@ -101 +133 @@
 
 
-/**
- * Allocates a new copy of the given UTF-8 substring.
- *
- * @returns Pointer to the allocated UTF-8 substring.
- * @param   pszString       UTF-8 string to duplicate.
- * @param   cchMax          The max number of chars to duplicate, not counting
- *                          the terminator.
- */
 RTDECL(char *) RTStrDupN(const char *pszString, size_t cchMax)
 {
@@ -114 +138 @@
     char  *pszEnd = (char *)memchr(pszString, '\0', cchMax);
     size_t cch    = pszEnd ? (uintptr_t)pszEnd - (uintptr_t)pszString : cchMax;
-    char  *pszDst = (char *)RTMemAlloc(cch);
+    char  *pszDst = (char *)RTMemAlloc(cch + 1);
     if (pszDst)
     {
@@ -124 +148 @@
 RT_EXPORT_SYMBOL(RTStrDupN);
 
+
+RTDECL(int) RTStrAAppend(char **ppsz, const char *pszAppend)
+{
+    if (!pszAppend)
+        return VINF_SUCCESS;
+    return RTStrAAppendN(ppsz, pszAppend, RTSTR_MAX);
+}
+
+
+RTDECL(int) RTStrAAppendN(char **ppsz, const char *pszAppend, size_t cchAppend)
+{
+    if (!cchAppend)
+        return VINF_SUCCESS;
+    if (cchAppend == RTSTR_MAX)
+        cchAppend = strlen(pszAppend);
+    else
+        Assert(cchAppend == RTStrNLen(pszAppend, cchAppend));
+
+    size_t const cchOrg = *ppsz ? strlen(*ppsz) : 0;
+    char *pszNew = (char *)RTMemRealloc(*ppsz, cchOrg + cchAppend + 1);
+    if (!pszNew)
+        return VERR_NO_STR_MEMORY;
+
+    memcpy(&pszNew[cchOrg], pszAppend, cchAppend);
+    pszNew[cchOrg + cchAppend] = '\0';
+
+    *ppsz = pszNew;
+    return VINF_SUCCESS;
+}
+
+
+RTDECL(int) RTStrAAppendExNV(char **ppsz, size_t cPairs, va_list va)
+{
+    AssertPtr(ppsz);
+    if (!cPairs)
+        return VINF_SUCCESS;
+
+    /*
+     * Determin the length of each string and calc the new total.
+     */
+    struct RTStrAAppendExNVStruct
+    {
+        const char *psz;
+        size_t      cch;
+    } *paPairs = (struct RTStrAAppendExNVStruct *)alloca(cPairs * sizeof(*paPairs));
+    AssertReturn(paPairs, VERR_NO_STR_MEMORY);
+
+    size_t  cchOrg      = *ppsz ? strlen(*ppsz) : 0;
+    size_t  cchNewTotal = cchOrg;
+    for (size_t i = 0; i < cPairs; i++)
+    {
+        const char *psz = va_arg(va, const char *);
+        size_t      cch = va_arg(va, size_t);
+        AssertPtrNull(psz);
+        Assert(cch == RTSTR_MAX || cch == RTStrNLen(psz, cch));
+
+        if (cch == RTSTR_MAX)
+            cch = psz ? strlen(psz) : 0;
+        cchNewTotal += cch;
+
+        paPairs[i].cch = cch;
+        paPairs[i].psz = psz;
+    }
+    cchNewTotal++;                      /* '\0' */
+
+    /*
+     * Try reallocate the string.
+     */
+    char *pszNew = (char *)RTMemRealloc(*ppsz, cchNewTotal);
+    if (!pszNew)
+        return VERR_NO_STR_MEMORY;
+
+    /*
+     * Do the appending.
+     */
+    size_t off = cchOrg;
+    for (size_t i = 0; i < cPairs; i++)
+    {
+        memcpy(&pszNew[off], paPairs[i].psz, paPairs[i].cch);
+        off += paPairs[i].cch;
+    }
+    Assert(off + 1 == cchNewTotal);
+    pszNew[off] = '\0';
+
+    /* done */
+    *ppsz = pszNew;
+    return VINF_SUCCESS;
+}
+RT_EXPORT_SYMBOL(RTStrAAppendExNV);
+
+
+RTDECL(int) RTStrAAppendExN(char **ppsz, size_t cPairs, ...)
+{
+    va_list va;
+    va_start(va, cPairs);
+    int rc = RTStrAAppendExNV(ppsz, cPairs, va);
+    va_end(va);
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTStrAAppendExN);
+

trunk/src/VBox/Runtime/testcase/Makefile.kmk

@@ -98 +98 @@
         tstSems \
         tstRTSemXRoads \
+        tstRTStrAlloc \
         tstRTStrCache \
         tstRTStrFormat \
@@ -393 +394 @@
 tstRTSemXRoads_SOURCES = tstRTSemXRoads.cpp
 
+tstRTStrAlloc_TEMPLATE = VBOXR3TSTEXE
+tstRTStrAlloc_SOURCES = tstRTStrAlloc.cpp
+
 tstRTStrCache_TEMPLATE = VBOXR3TSTEXE
 tstRTStrCache_SOURCES = tstRTStrCache.cpp