sal: add some argument checking assertions for strings and buffers

Also remove some now redundant asserts from headers.

Some of these actually trigger on unit tests so are commented out.

Change-Id: I07c6b2b2bd175361691a141f22eec584e3ab8f0b

include/rtl/strbuf.hxx

@@ -473,8 +473,6 @@ public:
      */
     OStringBuffer & append( const sal_Char * str, sal_Int32 len)
     {
-        assert( len >= 0 );
-        assert( len == 0 || str != 0 );
         rtl_stringbuffer_insert( &pData, &nCapacity, getLength(), str, len );
         return *this;
     }
@@ -645,7 +643,6 @@ public:
        @since LibreOffice 4.4
     */
     char * appendUninitialized(sal_Int32 length) {
-        assert(length >= 0);
         sal_Int32 n = getLength();
         rtl_stringbuffer_insert(&pData, &nCapacity, n, 0, length);
         return pData->buffer + n;
@@ -734,9 +731,6 @@ public:
      */
     OStringBuffer & insert( sal_Int32 offset, const sal_Char * str, sal_Int32 len)
     {
-        assert( offset >= 0 && offset <= pData->length );
-        assert( len >= 0 );
-        assert( len == 0 || str != 0 );
         rtl_stringbuffer_insert( &pData, &nCapacity, offset, str, len );
         return *this;
     }
@@ -918,8 +912,6 @@ public:
      */
     OStringBuffer & remove( sal_Int32 start, sal_Int32 len )
     {
-        assert( start >= 0 && start <= pData->length );
-        assert( len >= 0 );
         rtl_stringbuffer_remove( &pData, start, len );
         return *this;
     }

include/rtl/ustrbuf.hxx

@@ -457,8 +457,6 @@ public:
      */
     OUStringBuffer & append( const sal_Unicode * str, sal_Int32 len)
     {
-        assert( len >= 0 );
-        assert( len == 0 || str != 0 );
         rtl_uStringbuffer_insert( &pData, &nCapacity, getLength(), str, len );
         return *this;
     }
@@ -537,7 +535,6 @@ public:
      */
     OUStringBuffer & appendAscii( const sal_Char * str, sal_Int32 len)
     {
-        assert( len >= 0 );
         rtl_uStringbuffer_insert_ascii( &pData, &nCapacity, getLength(), str, len );
         return *this;
     }
@@ -734,7 +731,6 @@ public:
        @since LibreOffice 4.4
     */
     sal_Unicode * appendUninitialized(sal_Int32 length) {
-        assert(length >= 0);
         sal_Int32 n = getLength();
         rtl_uStringbuffer_insert(&pData, &nCapacity, n, 0, length);
         return pData->buffer + n;
@@ -802,9 +798,6 @@ public:
      */
     OUStringBuffer & insert( sal_Int32 offset, const sal_Unicode * str, sal_Int32 len)
     {
-        assert( offset >= 0 && offset <= pData->length );
-        assert( len >= 0 );
-        assert( len == 0 || str != 0 );
         rtl_uStringbuffer_insert( &pData, &nCapacity, offset, str, len );
         return *this;
     }
@@ -1048,8 +1041,6 @@ public:
      */
     OUStringBuffer & remove( sal_Int32 start, sal_Int32 len )
     {
-        assert( start >= 0 && start <= pData->length );
-        assert( len >= 0 );
         rtl_uStringbuffer_remove( &pData, start, len );
         return *this;
     }
@@ -1066,7 +1057,6 @@ public:
      */
     OUStringBuffer & truncate( sal_Int32 start = 0 )
     {
-        assert( start >= 0 && start <= pData->length );
         rtl_uStringbuffer_remove( &pData, start, getLength() - start );
         return *this;
     }
@@ -1353,7 +1343,6 @@ public:
     */
     OUStringBuffer copy( sal_Int32 beginIndex ) const
     {
-        assert(beginIndex >= 0 && beginIndex <= getLength());
         return copy( beginIndex, getLength() - beginIndex );
     }
 

sal/rtl/strbuf.cxx

@@ -29,6 +29,8 @@ void SAL_CALL rtl_stringbuffer_newFromStr_WithLength( rtl_String ** newStr,
                                                       const sal_Char * value,
                                                       sal_Int32 count )
 {
+    assert(newStr);
+    assert(count >= 0);
     if (!value)
     {
         rtl_string_new_WithLength( newStr, 16 );
@@ -48,6 +50,9 @@ sal_Int32 SAL_CALL rtl_stringbuffer_newFromStringBuffer( rtl_String ** newStr,
                                                          sal_Int32 capacity,
                                                          rtl_String * oldStr )
 {
+    assert(newStr);
+    assert(oldStr);
+    assert(capacity >= 0);
     sal_Int32 newCapacity = capacity;
 
     if (newCapacity < oldStr->length)
@@ -67,6 +72,9 @@ sal_Int32 SAL_CALL rtl_stringbuffer_newFromStringBuffer( rtl_String ** newStr,
 void SAL_CALL rtl_stringbuffer_ensureCapacity
     (rtl_String ** This, sal_Int32* capacity, sal_Int32 minimumCapacity)
 {
+    assert(This);
+//    assert(capacity && *capacity >= 0);
+//    assert(minimumCapacity >= 0);
     if (minimumCapacity > *capacity)
     {
         rtl_String * pTmp = *This;
@@ -94,6 +102,11 @@ void SAL_CALL rtl_stringbuffer_insert( rtl_String ** This,
                                        const sal_Char * str,
                                        sal_Int32 len )
 {
+    assert(This);
+    assert(capacity && *capacity >= 0);
+    assert(offset >= 0 && offset <= (**This).length);
+    assert(len == 0 || str != nullptr);
+    assert(len >= 0);
     sal_Int32 nOldLen;
     sal_Char * pBuf;
     sal_Int32 n;
@@ -134,6 +147,9 @@ void SAL_CALL rtl_stringbuffer_remove( rtl_String ** This,
                                        sal_Int32 start,
                                        sal_Int32 len )
 {
+    assert(This);
+    assert(start >= 0 && start <= (**This).length);
+    assert(len >= 0);
     sal_Int32 nTailLen;
     sal_Char * pBuf;
 

sal/rtl/string.cxx

@@ -88,6 +88,7 @@ static rtl_String const aImplEmpty_rtl_String =
 sal_Int32 SAL_CALL rtl_str_valueOfFloat(sal_Char * pStr, float f)
     SAL_THROW_EXTERN_C()
 {
+    assert(pStr);
     rtl_String * pResult = NULL;
     sal_Int32 nLen;
     rtl_math_doubleToString(
@@ -104,6 +105,7 @@ sal_Int32 SAL_CALL rtl_str_valueOfFloat(sal_Char * pStr, float f)
 sal_Int32 SAL_CALL rtl_str_valueOfDouble(sal_Char * pStr, double d)
     SAL_THROW_EXTERN_C()
 {
+    assert(pStr);
     rtl_String * pResult = NULL;
     sal_Int32 nLen;
     rtl_math_doubleToString(
@@ -119,12 +121,14 @@ sal_Int32 SAL_CALL rtl_str_valueOfDouble(sal_Char * pStr, double d)
 
 float SAL_CALL rtl_str_toFloat(sal_Char const * pStr) SAL_THROW_EXTERN_C()
 {
+    assert(pStr);
     return (float) rtl_math_stringToDouble(pStr, pStr + rtl_str_getLength(pStr),
                                            '.', 0, 0, 0);
 }
 
 double SAL_CALL rtl_str_toDouble(sal_Char const * pStr) SAL_THROW_EXTERN_C()
 {
+    assert(pStr);
     return rtl_math_stringToDouble(pStr, pStr + rtl_str_getLength(pStr), '.', 0,
                                    0, 0);
 }
@@ -192,10 +196,10 @@ bool SAL_CALL rtl_impl_convertUStringToString(rtl_String ** pTarget,
                                                   sal_uInt32 nFlags,
                                                   bool bCheckErrors)
 {
-    OSL_ASSERT(pTarget != NULL
-               && (pSource != NULL || nLength == 0)
-               && nLength >= 0
-               && (nLength == 0 || rtl_isOctetTextEncoding(nEncoding)));
+    assert(pTarget != nullptr);
+    assert(pSource != nullptr || nLength == 0);
+    assert(nLength >= 0);
+    OSL_ASSERT(nLength == 0 || rtl_isOctetTextEncoding(nEncoding));
 
     if ( !nLength )
         rtl_string_new( pTarget );

sal/rtl/ustrbuf.cxx

@@ -33,6 +33,8 @@ void SAL_CALL rtl_uStringbuffer_newFromStr_WithLength( rtl_uString ** newStr,
                                                        const sal_Unicode * value,
                                                        sal_Int32 count)
 {
+    assert(newStr);
+    assert(count >= 0);
     if (!value)
     {
         rtl_uString_new_WithLength( newStr, 16 );
@@ -56,6 +58,8 @@ rtl_uString * SAL_CALL rtl_uStringBuffer_refReturn( rtl_uString * pThis )
 rtl_uString * SAL_CALL rtl_uStringBuffer_makeStringAndClear( rtl_uString ** ppThis,
                                                              sal_Int32 *nCapacity )
 {
+    assert(ppThis);
+    assert(nCapacity);
     // avoid an un-necessary atomic ref/unref pair
     rtl_uString *pStr = *ppThis;
     *ppThis = NULL;
@@ -72,6 +76,9 @@ sal_Int32 SAL_CALL rtl_uStringbuffer_newFromStringBuffer( rtl_uString ** newStr,
                                                           sal_Int32 capacity,
                                                           rtl_uString * oldStr )
 {
+    assert(newStr);
+    assert(capacity >= 0);
+    assert(oldStr);
     sal_Int32 newCapacity = capacity;
 
     if (newCapacity < oldStr->length)
@@ -90,6 +97,9 @@ sal_Int32 SAL_CALL rtl_uStringbuffer_newFromStringBuffer( rtl_uString ** newStr,
 void SAL_CALL rtl_uStringbuffer_ensureCapacity
     (rtl_uString ** This, sal_Int32* capacity, sal_Int32 minimumCapacity)
 {
+    assert(This);
+    assert(capacity && *capacity >= 0);
+    assert(minimumCapacity >= 0);
     if (minimumCapacity > *capacity)
     {
         rtl_uString * pTmp = *This;
@@ -116,6 +126,11 @@ void SAL_CALL rtl_uStringbuffer_insert( rtl_uString ** This,
                                         const sal_Unicode * str,
                                         sal_Int32 len)
 {
+    assert(This);
+    assert(capacity && *capacity >= 0);
+    assert(offset >= 0 && offset <= (**This).length);
+    assert(len == 0 || str != nullptr);
+    assert(len >= 0);
     sal_Int32 nOldLen;
     sal_Unicode * pBuf;
     sal_Int32 n;
@@ -174,6 +189,11 @@ void SAL_CALL rtl_uStringbuffer_insert_ascii(   /*inout*/rtl_uString ** This,
                                                 const sal_Char * str,
                                                 sal_Int32 len)
 {
+    assert(This);
+    assert(capacity && *capacity >= 0);
+    assert(offset >= 0 && offset <= (**This).length);
+    assert(len == 0 || str != nullptr);
+    assert(len >= 0);
     sal_Int32 nOldLen;
     sal_Unicode * pBuf;
     sal_Int32 n;
@@ -214,6 +234,9 @@ void SAL_CALL rtl_uStringbuffer_remove( rtl_uString ** This,
                                        sal_Int32 start,
                                        sal_Int32 len )
 {
+    assert(This);
+    assert(start >= 0 && start <= (**This).length);
+    assert(len >= 0);
     sal_Int32 nTailLen;
     sal_Unicode * pBuf;
 

sal/rtl/ustring.cxx

@@ -97,6 +97,8 @@ sal_Int32 rtl_ustr_indexOfAscii_WithLength(
     sal_Unicode const * str, sal_Int32 len,
     char const * subStr, sal_Int32 subLen) SAL_THROW_EXTERN_C()
 {
+    assert(len >= 0);
+    assert(subLen >= 0);
     if (subLen > 0 && subLen <= len) {
         sal_Int32 i;
         for (i = 0; i <= len - subLen; ++i) {
@@ -114,6 +116,8 @@ sal_Int32 rtl_ustr_lastIndexOfAscii_WithLength(
     sal_Unicode const * str, sal_Int32 len,
     char const * subStr, sal_Int32 subLen) SAL_THROW_EXTERN_C()
 {
+    assert(len >= 0);
+    assert(subLen >= 0);
     if (subLen > 0 && subLen <= len) {
         sal_Int32 i;
         for (i = len - subLen; i >= 0; --i) {
@@ -130,6 +134,7 @@ sal_Int32 rtl_ustr_lastIndexOfAscii_WithLength(
 sal_Int32 SAL_CALL rtl_ustr_valueOfFloat(sal_Unicode * pStr, float f)
     SAL_THROW_EXTERN_C()
 {
+    assert(pStr);
     rtl_uString * pResult = NULL;
     sal_Int32 nLen;
     rtl_math_doubleToUString(
@@ -146,6 +151,7 @@ sal_Int32 SAL_CALL rtl_ustr_valueOfFloat(sal_Unicode * pStr, float f)
 sal_Int32 SAL_CALL rtl_ustr_valueOfDouble(sal_Unicode * pStr, double d)
     SAL_THROW_EXTERN_C()
 {
+    assert(pStr);
     rtl_uString * pResult = NULL;
     sal_Int32 nLen;
     rtl_math_doubleToUString(
@@ -176,6 +182,7 @@ float doubleToFloat(double x) {
 
 float SAL_CALL rtl_ustr_toFloat(sal_Unicode const * pStr) SAL_THROW_EXTERN_C()
 {
+    assert(pStr);
     return doubleToFloat(rtl_math_uStringToDouble(pStr,
                                             pStr + rtl_ustr_getLength(pStr),
                                             '.', 0, 0, 0));
@@ -183,6 +190,7 @@ float SAL_CALL rtl_ustr_toFloat(sal_Unicode const * pStr) SAL_THROW_EXTERN_C()
 
 double SAL_CALL rtl_ustr_toDouble(sal_Unicode const * pStr) SAL_THROW_EXTERN_C()
 {
+    assert(pStr);
     return rtl_math_uStringToDouble(pStr, pStr + rtl_ustr_getLength(pStr), '.',
                                     0, 0, 0);
 }
@@ -193,6 +201,8 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_compare( const sal_Unicode* pStr1,
                                            const sal_Char* pStr2 )
     SAL_THROW_EXTERN_C()
 {
+    assert(pStr1);
+    assert(pStr2);
     sal_Int32 nRet;
     while ( ((nRet = ((sal_Int32)(*pStr1))-
                      ((sal_Int32)((unsigned char)(*pStr2)))) == 0) &&
@@ -215,6 +225,9 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_compare_WithLength( const sal_Unicode* pStr1,
                                                       const sal_Char* pStr2 )
     SAL_THROW_EXTERN_C()
 {
+    assert(pStr1);
+    assert(nStr1Len >= 0);
+    assert(pStr2);
     sal_Int32 nRet = 0;
     while( ((nRet = (nStr1Len ? (sal_Int32)(*pStr1) : 0)-
                     ((sal_Int32)((unsigned char)(*pStr2)))) == 0) &&
@@ -239,6 +252,8 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_shortenedCompare_WithLength( const sal_Unicode
                                                                sal_Int32 nShortenedLength )
     SAL_THROW_EXTERN_C()
 {
+    assert(nStr1Len >= 0);
+    assert(nShortenedLength >= 0);
     const sal_Unicode*  pStr1End = pStr1 + nStr1Len;
     sal_Int32           nRet;
     while ( (nShortenedLength > 0) &&
@@ -284,6 +299,7 @@ sal_Int32 SAL_CALL rtl_ustr_asciil_reverseCompare_WithLength( const sal_Unicode*
                                                               sal_Int32 nStr2Len )
     SAL_THROW_EXTERN_C()
 {
+    assert(nStr1Len >= 0 && nStr2Len >= 0);
     const sal_Unicode*  pStr1Run = pStr1+nStr1Len;
     const sal_Char*     pStr2Run = pStr2+nStr2Len;
     sal_Int32           nRet;
@@ -309,6 +325,7 @@ sal_Bool SAL_CALL rtl_ustr_asciil_reverseEquals_WithLength( const sal_Unicode* p
                                                               sal_Int32 nStrLen )
     SAL_THROW_EXTERN_C()
 {
+    assert(nStrLen >= 0);
     const sal_Unicode*  pStr1Run = pStr1+nStrLen;
     const sal_Char*     pStr2Run = pStr2+nStrLen;
     while ( pStr1 < pStr1Run )
@@ -331,6 +348,8 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_compareIgnoreAsciiCase( const sal_Unicode* pSt
                                                           const sal_Char* pStr2 )
     SAL_THROW_EXTERN_C()
 {
+    assert(pStr1);
+    assert(pStr2);
     sal_Int32   nRet;
     sal_Int32   c1;
     sal_Int32   c2;
@@ -365,6 +384,8 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( const sal_U
                                                                      const sal_Char* pStr2 )
     SAL_THROW_EXTERN_C()
 {
+    assert(nStr1Len >= 0);
+    assert(pStr2);
     sal_Int32   nRet;
     sal_Int32   c1;
     sal_Int32   c2;
@@ -400,6 +421,7 @@ sal_Int32 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
     sal_Unicode const * first, sal_Int32 firstLen,
     char const * second, sal_Int32 secondLen) SAL_THROW_EXTERN_C()
 {
+    assert(firstLen >= 0 && secondLen >= 0);
     sal_Int32 i;
     sal_Int32 len = firstLen < secondLen ? firstLen : secondLen;
     for (i = 0; i < len; ++i) {
@@ -431,6 +453,8 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( co
                                                                               sal_Int32 nShortenedLength )
     SAL_THROW_EXTERN_C()
 {
+    assert(nStr1Len >= 0);
+    assert(nShortenedLength >= 0);
     const sal_Unicode*  pStr1End = pStr1 + nStr1Len;
     sal_Int32           nRet;
     sal_Int32           c1;
@@ -482,6 +506,7 @@ void SAL_CALL rtl_uString_newFromAscii( rtl_uString** ppThis,
                                         const sal_Char* pCharStr )
     SAL_THROW_EXTERN_C()
 {
+    assert(ppThis);
     sal_Int32 nLen;
 
     if ( pCharStr )
@@ -528,10 +553,8 @@ void SAL_CALL rtl_uString_newFromCodePoints(
     sal_Int32 n;
     sal_Int32 i;
     sal_Unicode * p;
-    OSL_ASSERT(
-        newString != NULL &&
-        (codePoints != NULL || codePointCount == 0) &&
-        codePointCount >= 0);
+    assert(newString != nullptr);
+    assert((codePoints != nullptr || codePointCount == 0) && codePointCount >= 0);
     if (codePointCount == 0) {
         rtl_uString_new(newString);
         return;
@@ -801,6 +824,8 @@ void SAL_CALL rtl_string2UString( rtl_uString** ppThis,
                                   rtl_TextEncoding eTextEncoding,
                                   sal_uInt32 nCvtFlags ) SAL_THROW_EXTERN_C()
 {
+    assert(ppThis);
+    assert(nLen >= 0);
     rtl_string2UString_status( ppThis, pStr, nLen, eTextEncoding,
                                nCvtFlags, NULL );
 }
@@ -863,6 +888,8 @@ static void rtl_ustring_intern_internal( rtl_uString ** newStr,
 void SAL_CALL rtl_uString_intern( rtl_uString ** newStr,
                                   rtl_uString  * str) SAL_THROW_EXTERN_C()
 {
+    assert(newStr);
+    assert(str);
     if (SAL_STRING_IS_INTERN(str))
     {
         IMPL_RTL_AQUIRE( str );
@@ -909,6 +936,8 @@ void SAL_CALL rtl_uString_internConvert( rtl_uString   ** newStr,
                                          sal_uInt32     * pInfo )
     SAL_THROW_EXTERN_C()
 {
+    assert(newStr);
+    assert(len >= 0);
     rtl_uString *scratch;
 
     if (*newStr)
@@ -1056,6 +1085,8 @@ sal_Bool rtl_convertStringToUString(
     rtl_uString ** target, char const * source, sal_Int32 length,
     rtl_TextEncoding encoding, sal_uInt32 flags) SAL_THROW_EXTERN_C()
 {
+    assert(target);
+    assert(length >= 0);
     sal_uInt32 info;
     rtl_string2UString_status(target, source, length, encoding, flags, &info);
     return (info & RTL_TEXTTOUNICODE_INFO_ERROR) == 0;