rework API

3 files changed, 287 insertions, 1200 deletions

diff --git a/sal/rtl/source/string.c b/sal/rtl/source/string.c
index cac1ba899130..263579e8bdc4 100644
--- a/sal/rtl/source/string.c
+++ b/sal/rtl/source/string.c
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: string.c,v $
  *
- *  $Revision: 1.6 $
+ *  $Revision: 1.7 $
  *
- *  last change: $Author: obr $ $Date: 2001-03-30 14:36:27 $
+ *  last change: $Author: th $ $Date: 2001-05-09 12:54:32 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -98,303 +98,6 @@ static rtl_String aImplEmpty_rtl_String =
 
 /* ======================================================================= */
 
-/*************************************************************************
- *  rtl_str_compareIgnoreCase_WithLength
- */
-sal_Int32 SAL_CALL
-rtl_str_compareIgnoreCase_WithLength( const sal_Char *first,
-                                      const sal_Char *second,
-                                      sal_Int32 len )
-{
-    sal_Char  a;
-    sal_Char  b;
-
-    while ( len )
-    {
-        a = *first;
-        b = *second;
-        if ( (a >= 97) && (a <= 122) )
-            a -= 32;
-
-        if ( (b >= 97) && (b <= 122) )
-            b -= 32;
-
-        /* Naechstes Zeichen */
-        first++;
-        second++;
-        len--;
-
-        /* If characters don't match but case may be ignored,
-           try converting both characters to uppercase.
-           If the results match, then the comparison scan should
-           continue. */
-
-        if ( a == b )
-            continue;
-
-        return (sal_Int32)a - (sal_Int32)b;
-    }
-
-    return 0; /* strings are equal */
-}
-
-/*************************************************************************
- *  rtl_str_compareIgnoreCase
- */
-sal_Int32 SAL_CALL
-rtl_str_compareIgnoreCase( const sal_Char * first, const sal_Char * second )
-{
-    sal_Int32 firstLen    = rtl_str_getLength(first);
-    sal_Int32 secondLen   = rtl_str_getLength(second);
-    sal_Int32 shortestLen = 1 + (firstLen < secondLen ? firstLen : secondLen);
-
-    return rtl_str_compareIgnoreCase_WithLength( first, second, shortestLen );
-}
-
-/*************************************************************************
- *  rtl_str_equalsIgnoreCase_WithLength
- */
-sal_Bool SAL_CALL
-rtl_str_equalsIgnoreCase_WithLength( const sal_Char * first,
-                                     sal_Int32 firstLen,
-                                     const sal_Char * second,
-                                     sal_Int32 secondLen )
-{
-    if (firstLen != secondLen)
-        return sal_False;
-
-    return rtl_str_compareIgnoreCase_WithLength(first, second, firstLen) == 0;
-}
-
-
-/*************************************************************************
- *  rtl_str_equalsIgnoreCase
- */
-sal_Bool SAL_CALL
-rtl_str_equalsIgnoreCase( const sal_Char * first, const sal_Char * second )
-{
-    return rtl_str_equalsIgnoreCase_WithLength(
-                                        first,  rtl_str_getLength(first),
-                                        second, rtl_str_getLength(second));
-}
-
-/*************************************************************************
- *  rtl_str_toAsciiLowerCase_WithLength
- */
-void SAL_CALL rtl_str_toAsciiLowerCase_WithLength( sal_Char * str, sal_Int32 len )
-{
-    while ( *str )
-    {
-        if ( (*str >= 65) && (*str <= 90) )
-            *str += 32;
-
-        str++;
-    }
-}
-
-/*************************************************************************
- *  rtl_str_toAsciiLowerCase
- */
-void SAL_CALL rtl_str_toAsciiLowerCase( sal_Char * str )
-{
-    while ( *str )
-    {
-        if ( (*str >= 65) && (*str <= 90) )
-            *str += 32;
-
-        str++;
-    }
-}
-
-/*************************************************************************
- *  rtl_str_toAsciiUpperCase_WithLength
- */
-void SAL_CALL rtl_str_toAsciiUpperCase_WithLength( sal_Char * str, sal_Int32 len )
-{
-    while ( *str )
-    {
-        if ( (*str >= 97) && (*str <= 122) )
-            *str -= 32;
-
-        str++;
-    }
-}
-
-/*************************************************************************
- *  rtl_str_toAsciiUpperCase
- */
-void SAL_CALL rtl_str_toAsciiUpperCase( sal_Char * str )
-{
-    while ( *str )
-    {
-        if ( (*str >= 97) && (*str <= 122) )
-            *str -= 32;
-
-        str++;
-    }
-}
-
-/*************************************************************************
- *  rtl_str_trim_WithLength
- */
-sal_Int32 SAL_CALL rtl_str_trim_WithLength( sal_Char * str, sal_Int32 len )
-{
-    sal_Int32 preSpaces = 0;
-    sal_Int32 postSpaces = 0;
-    sal_Int32 newLen = 0;
-    sal_Int32 index = len - 1;
-
-    while ( (preSpaces < len) && (*(str+preSpaces) == ' ') )
-        preSpaces++;
-
-    while ( (index > preSpaces) && (*(str+index) == ' ') )
-    {
-        postSpaces++;
-        index--;
-    }
-
-    newLen = len - preSpaces - postSpaces;
-
-    if ( newLen != len )
-    {
-        sal_Char *newStr = str + preSpaces;
-        index = 0;
-
-        while ( index != newLen )
-        {
-            *(str + index) = *(newStr + index);
-            index++;
-        }
-        *(str + index) = '\0';
-    }
-
-    return newLen;
-}
-
-/*************************************************************************
- *  rtl_str_trim
- */
-sal_Int32 SAL_CALL rtl_str_trim( sal_Char * str )
-{
-    return rtl_str_trim_WithLength(str, rtl_str_getLength(str));
-}
-
-/*************************************************************************
- *
- *  rtl_string_XXX Functions
- *
- ************************************************************************/
-
-
-/*************************************************************************
- *  rtl_string_newReplace
- */
-void SAL_CALL rtl_string_newReplace( rtl_String ** newStr,
-                                     rtl_String * str,
-                                     sal_Char oldChar,
-                                     sal_Char newChar)
-{
-    rtl_string_newFromString(newStr, str);
-
-    if (!(*newStr)) return;
-
-    rtl_str_replaceChar_WithLength( (*newStr)->buffer, (*newStr)->length, oldChar, newChar );
-}
-
-/*************************************************************************
- *  rtl_String_newToLowerCase
- */
-void SAL_CALL rtl_string_newToLowerCase( rtl_String ** newStr, rtl_String * str)
-{
-    rtl_string_newFromString(newStr, str);
-
-    if (!(*newStr)) return;
-
-    rtl_str_toAsciiLowerCase_WithLength((*newStr)->buffer, (*newStr)->length);
-}
-
-/*************************************************************************
- *  rtl_String_newToUpperCase
- */
-void SAL_CALL rtl_string_newToUpperCase( rtl_String ** newStr, rtl_String * str)
-{
-    rtl_string_newFromString(newStr, str);
-
-    if (!(*newStr)) return;
-
-    rtl_str_toAsciiUpperCase_WithLength((*newStr)->buffer, (*newStr)->length);
-}
-
-/*************************************************************************
- *  rtl_string_newTrim
- */
-void SAL_CALL rtl_string_newTrim( rtl_String ** newStr, rtl_String * str )
-{
-    rtl_string_newFromString(newStr, str);
-
-    if (!(*newStr)) return;
-
-    (*newStr)->length = rtl_str_trim_WithLength((*newStr)->buffer, (*newStr)->length);
-}
-
-/*************************************************************************
- *  rtl_string_getTokenCount
- */
-sal_Int32 SAL_CALL rtl_string_getTokenCount( rtl_String * str , sal_Char cTok)
-{
-    sal_Int32 count = 0;
-    sal_Int32 index1 = 0;
-    sal_Int32 index2 = 0;
-    sal_Char *buffer = str->buffer;
-
-    while ((index2 = rtl_str_indexOfChar_WithLength(buffer + index1, str->length - index1, cTok)) >= 0)
-    {
-        if (index2 <= (str->length - index1) && index2 >= 0)
-            count++;
-
-        index1 += index2 + 1;
-    }
-
-    if (index2 < 0 && index1 <= str->length)
-        count++;
-
-    return count;
-}
-
-/*************************************************************************
- *  rtl_string_getToken
- */
-void SAL_CALL rtl_string_getToken( rtl_String ** newStr , rtl_String * str, sal_Int32 nToken, sal_Char cTok)
-{
-    sal_Int32 count = 0;
-    sal_Int32 index1 = 0;
-    sal_Int32 index2 = 0;
-    sal_Char *buffer = str->buffer;
-
-    while ((index2 = rtl_str_indexOfChar_WithLength(buffer + index1, str->length - index1, cTok)) >= 0)
-    {
-        if (count == nToken)
-        {
-            rtl_string_newFromStr_WithLength( newStr, buffer + index1, index2 );
-            return;
-        }
-
-        if (index2 <= (str->length - index1) && index2 >= 0)
-            count++;
-
-        index1 += index2 + 1;
-    }
-
-    if (nToken == 0 || nToken == count)
-        rtl_string_newFromStr_WithLength( newStr, buffer + index1, str->length - index1 );
-    else
-        rtl_string_new(newStr);
-
-    return;
-}
-
-/* ======================================================================= */
-
 #define IMPL_RTL_STRCODE            sal_Char
 #define IMPL_RTL_USTRCODE( c )      ((unsigned char)c)
 #define IMPL_RTL_STRNAME( n )       rtl_str_ ## n
diff --git a/sal/rtl/source/strtmpl.c b/sal/rtl/source/strtmpl.c
index 0fbc465c4627..6e0f41792584 100644
--- a/sal/rtl/source/strtmpl.c
+++ b/sal/rtl/source/strtmpl.c
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: strtmpl.c,v $
  *
- *  $Revision: 1.5 $
+ *  $Revision: 1.6 $
  *
- *  last change: $Author: th $ $Date: 2001-03-20 14:36:00 $
+ *  last change: $Author: th $ $Date: 2001-05-09 12:55:34 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -148,6 +148,96 @@ sal_Int32 SAL_CALL IMPL_RTL_STRNAME( compare_WithLength )( const IMPL_RTL_STRCOD
 
 /* ----------------------------------------------------------------------- */
 
+sal_Int32 SAL_CALL IMPL_RTL_STRNAME( shortenedCompare_WithLength )( const IMPL_RTL_STRCODE* pStr1,
+                                                                    sal_Int32 nStr1Len,
+                                                                    const IMPL_RTL_STRCODE* pStr2,
+                                                                    sal_Int32 nStr2Len,
+                                                                    sal_Int32 nShortenedLength )
+{
+    const IMPL_RTL_STRCODE* pStr1End = pStr1 + nStr1Len;
+    const IMPL_RTL_STRCODE* pStr2End = pStr2 + nStr2Len;
+    sal_Int32 nRet = 0;
+    while( nShortenedLength &&
+           (pStr1 < pStr1End) &&
+           (pStr2 < pStr2End) &&
+            ((nRet = ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr1 )))-
+                     ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr2 )))) == 0) )
+    {
+        nShortenedLength--;
+        pStr1++;
+        pStr2++;
+    }
+
+    if ( nRet || (nShortenedLength == 0) )
+        return nRet;
+    return nStr1Len - nStr2Len;
+}
+
+/* ----------------------------------------------------------------------- */
+
+sal_Int32 SAL_CALL IMPL_RTL_STRNAME( compareIgnoreAsciiCase )( const IMPL_RTL_STRCODE* pStr1,
+                                                               const IMPL_RTL_STRCODE* pStr2 )
+{
+    sal_Int32   nRet;
+    sal_Int32   c1;
+    sal_Int32   c2;
+    do
+    {
+        /* If character between 'A' and 'Z', than convert it to lowercase */
+        c1 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr1 );
+        c2 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr2 );
+        if ( (c1 >= 65) && (c1 <= 90) )
+            c1 += 32;
+        if ( (c2 >= 65) && (c2 <= 90) )
+            c2 += 32;
+        nRet = c1-c2;
+        if ( nRet != 0 )
+            break;
+
+        pStr1++;
+        pStr2++;
+    }
+    while ( c2 );
+
+    return nRet;
+}
+
+/* ----------------------------------------------------------------------- */
+
+sal_Int32 SAL_CALL IMPL_RTL_STRNAME( compareIgnoreAsciiCase_WithLength )( const IMPL_RTL_STRCODE* pStr1,
+                                                                          sal_Int32 nStr1Len,
+                                                                          const IMPL_RTL_STRCODE* pStr2,
+                                                                          sal_Int32 nStr2Len )
+{
+    const IMPL_RTL_STRCODE* pStr1End = pStr1 + nStr1Len;
+    const IMPL_RTL_STRCODE* pStr2End = pStr2 + nStr2Len;
+    sal_Int32   nRet = 0;
+    sal_Int32   c1;
+    sal_Int32   c2;
+    while ( (pStr1 < pStr1End) && (pStr2 < pStr2End) )
+    {
+        /* If character between 'A' and 'Z', than convert it to lowercase */
+        c1 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr1 );
+        c2 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr2 );
+        if ( (c1 >= 65) && (c1 <= 90) )
+            c1 += 32;
+        if ( (c2 >= 65) && (c2 <= 90) )
+            c2 += 32;
+        nRet = c1-c2;
+        if ( nRet != 0 )
+            break;
+
+        pStr1++;
+        pStr2++;
+    }
+
+    if ( nRet )
+        return nRet;
+    return nStr1Len - nStr2Len;
+}
+
+/* ----------------------------------------------------------------------- */
+
 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( hashCode )( const IMPL_RTL_STRCODE* pStr )
 {
     return IMPL_RTL_STRNAME( hashCode_WithLength )( pStr, IMPL_RTL_STRNAME( getLength )( pStr ) );
@@ -443,11 +533,121 @@ void SAL_CALL IMPL_RTL_STRNAME( replaceChar_WithLength )( IMPL_RTL_STRCODE* pStr
 
 /* ----------------------------------------------------------------------- */
 
+void SAL_CALL IMPL_RTL_STRNAME( toAsciiLowerCase )( IMPL_RTL_STRCODE* pStr )
+{
+    while ( *pStr )
+    {
+        /* Between A-Z (65-90), than to lowercase (+32) */
+        if ( (*pStr >= 65) && (*pStr <= 90) )
+            *pStr += 32;
+
+        pStr++;
+    }
+}
+
+/* ----------------------------------------------------------------------- */
+
+void SAL_CALL IMPL_RTL_STRNAME( toAsciiLowerCase_WithLength )( IMPL_RTL_STRCODE* pStr,
+                                                               sal_Int32 nLen )
+{
+    while ( nLen > 0 )
+    {
+        /* Between A-Z (65-90), than to lowercase (+32) */
+        if ( (*pStr >= 65) && (*pStr <= 90) )
+            *pStr += 32;
+
+        pStr++;
+        nLen--;
+    }
+}
+
+/* ----------------------------------------------------------------------- */
+
+void SAL_CALL IMPL_RTL_STRNAME( toAsciiUpperCase )( IMPL_RTL_STRCODE* pStr )
+{
+    while ( *pStr )
+    {
+        /* Between a-z (97-122), than to uppercase (-32) */
+        if ( (*pStr >= 97) && (*pStr <= 122) )
+            *pStr -= 32;
+
+        pStr++;
+    }
+}
+
+/* ----------------------------------------------------------------------- */
+
+void SAL_CALL IMPL_RTL_STRNAME( toAsciiUpperCase_WithLength )( IMPL_RTL_STRCODE* pStr,
+                                                               sal_Int32 nLen )
+{
+    while ( nLen > 0 )
+    {
+        /* Between a-z (97-122), than to uppercase (-32) */
+        if ( (*pStr >= 97) && (*pStr <= 122) )
+            *pStr -= 32;
+
+        pStr++;
+        nLen--;
+    }
+}
+
+/* ----------------------------------------------------------------------- */
+
+sal_Int32 SAL_CALL IMPL_RTL_STRNAME( trim )( IMPL_RTL_STRCODE* pStr )
+{
+    return IMPL_RTL_STRNAME( trim_WithLength )( pStr, IMPL_RTL_STRNAME( getLength )( pStr ) );
+}
+
+/* ----------------------------------------------------------------------- */
+
+sal_Int32 SAL_CALL IMPL_RTL_STRNAME( trim_WithLength )( IMPL_RTL_STRCODE* pStr, sal_Int32 nLen )
+{
+    sal_Int32 nPreSpaces    = 0;
+    sal_Int32 nPostSpaces   = 0;
+    sal_Int32 nIndex        = nLen-1;
+
+    while ( (nPreSpaces < nLen) && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE(*(pStr+nPreSpaces)) ) )
+        nPreSpaces++;
+
+    while ( (nIndex > nPreSpaces) && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE(*(pStr+nIndex)) ) )
+    {
+        nPostSpaces++;
+        nIndex--;
+    }
+
+    if ( nPostSpaces )
+    {
+        nLen -= nPostSpaces;
+        *(pStr+nLen) = 0;
+    }
+
+    if ( nPreSpaces )
+    {
+        IMPL_RTL_STRCODE* pNewStr = pStr+nPreSpaces;
+
+        nLen -= nPreSpaces;
+        nIndex = nLen;
+
+        while ( nIndex )
+        {
+            *pStr = *pNewStr;
+            pStr++;
+            pNewStr++;
+            nIndex--;
+        }
+        *pStr = 0;
+    }
+
+    return nLen;
+}
+
+/* ----------------------------------------------------------------------- */
+
 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( valueOfBoolean )( IMPL_RTL_STRCODE* pStr, sal_Bool b )
 {
     if ( b )
     {
-        *pStr = 'T';
+        *pStr = 't';
         pStr++;
         *pStr = 'r';
         pStr++;
@@ -460,7 +660,7 @@ sal_Int32 SAL_CALL IMPL_RTL_STRNAME( valueOfBoolean )( IMPL_RTL_STRCODE* pStr, s
     }
     else
     {
-        *pStr = 'F';
+        *pStr = 'f';
         pStr++;
         *pStr = 'a';
         pStr++;
@@ -1222,351 +1422,6 @@ void SAL_CALL IMPL_RTL_STRINGNAME( newReplaceStrAt )( IMPL_RTL_STRINGDATA** ppTh
     }
 }
 
-/* ======================================================================= */
-/* ======================================================================= */
-
-#if 0
-
-/* This file is included from string.c and ustring.c and shares the
-   template code between both implementations */
-
-/* ======================================================================= */
-/* C-String functions which could be used without the String-Class         */
-/* ======================================================================= */
-
-sal_Int32 SAL_CALL IMPL_RTL_STRNAME( getLengthMax )( const IMPL_RTL_STRCODE* pStr,
-                                                     sal_Int32 nMaxCount )
-{
-    sal_Int32 nMaxLen = 0;
-    while ( (nMaxLen < nMaxCount) && *pStr )
-    {
-        pStr++;
-        nMaxLen++;
-    }
-    return nMaxLen;
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Int32 SAL_CALL IMPL_RTL_STRNAME( compareMax )( const IMPL_RTL_STRCODE* pStr1,
-                                                   const IMPL_RTL_STRCODE* pStr2,
-                                                   sal_Int32 nCount )
-{
-    sal_Int32 nRet = 0;
-    while ( nCount &&
-            ((nRet = ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr1 )))-
-                     ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr2 )))) == 0) &&
-            *pStr2 )
-    {
-        pStr1++;
-        pStr2++;
-        nCount--;
-    }
-
-    return nRet;
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Int32 SAL_CALL IMPL_RTL_STRNAME( compareIgnoreAsciiCase )( const IMPL_RTL_STRCODE* pStr1,
-                                                               const IMPL_RTL_STRCODE* pStr2 )
-{
-    sal_Int32   nRet;
-    sal_Int32   c1;
-    sal_Int32   c2;
-    do
-    {
-        /* If character between 'A' and 'Z', than convert it to lowercase */
-        c1 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr1 );
-        c2 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr2 );
-        if ( (c1 >= 65) && (c1 <= 90) )
-            c1 += 32;
-        if ( (c2 >= 65) && (c2 <= 90) )
-            c2 += 32;
-        nRet = c1-c2;
-        if ( nRet != 0 )
-            break;
-
-        pStr1++;
-        pStr2++;
-    }
-    while ( c2 );
-
-    return nRet;
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Int32 SAL_CALL IMPL_RTL_STRNAME( compareIgnoreAsciiCaseMax )( const IMPL_RTL_STRCODE* pStr1,
-                                                                  const IMPL_RTL_STRCODE* pStr2,
-                                                                  sal_Int32 nCount )
-{
-    sal_Int32   nRet = 0;
-    sal_Int32   c1;
-    sal_Int32   c2;
-    do
-    {
-        if ( !nCount )
-            break;
-
-        /* If character between 'A' and 'Z', than convert it to lowercase */
-        c1 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr1 );
-        c2 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr2 );
-        if ( (c1 >= 65) && (c1 <= 90) )
-            c1 += 32;
-        if ( (c2 >= 65) && (c2 <= 90) )
-            c2 += 32;
-        nRet = c1-c2;
-        if ( nRet != 0 )
-            break;
-
-        pStr1++;
-        pStr2++;
-        nCount--;
-    }
-    while ( c2 );
-
-    return nRet;
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Int32 SAL_CALL IMPL_RTL_STRNAME( compareIgnoreAsciiCase_WithLength )( const IMPL_RTL_STRCODE* pStr1,
-                                                                          sal_Int32 nStr1Len,
-                                                                          const IMPL_RTL_STRCODE* pStr2,
-                                                                          sal_Int32 nStr2Len )
-{
-    const IMPL_RTL_STRCODE* pStr1End = pStr1 + nStr1Len;
-    const IMPL_RTL_STRCODE* pStr2End = pStr2 + nStr2Len;
-    sal_Int32   nRet = 0;
-    sal_Int32   c1;
-    sal_Int32   c2;
-    while ( (pStr1 < pStr1End) && (pStr2 < pStr2End) )
-    {
-        /* If character between 'A' and 'Z', than convert it to lowercase */
-        c1 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr1 );
-        c2 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr2 );
-        if ( (c1 >= 65) && (c1 <= 90) )
-            c1 += 32;
-        if ( (c2 >= 65) && (c2 <= 90) )
-            c2 += 32;
-        nRet = c1-c2;
-        if ( nRet != 0 )
-            break;
-
-        pStr1++;
-        pStr2++;
-    }
-
-    if ( nRet )
-        return nRet;
-    return nStr1Len - nStr2Len;
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Bool SAL_CALL IMPL_RTL_STRNAME( equals )( const IMPL_RTL_STRCODE* pStr1,
-                                              const IMPL_RTL_STRCODE* pStr2 )
-{
-    return IMPL_RTL_STRNAME( compare )( pStr1, pStr2 ) == 0;
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Bool SAL_CALL IMPL_RTL_STRNAME( equals_WithLength )( const IMPL_RTL_STRCODE* pStr1,
-                                                         sal_Int32 nStr1Len,
-                                                         const IMPL_RTL_STRCODE* pStr2,
-                                                         sal_Int32 nStr2Len )
-{
-    if ( nStr1Len != nStr2Len )
-        return sal_False;
-
-    return IMPL_RTL_STRNAME( compare_WithLength )( pStr1, nStr1Len, pStr2, nStr2Len ) == 0;
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Bool SAL_CALL IMPL_RTL_STRNAME( equalsIgnoreAsciiCase )( const IMPL_RTL_STRCODE* pStr1,
-                                                             const IMPL_RTL_STRCODE* pStr2 )
-{
-    return IMPL_RTL_STRNAME( compareIgnoreAsciiCase )( pStr1, pStr2 ) == 0;
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Bool SAL_CALL IMPL_RTL_STRNAME( equalsIgnoreAsciiCase_WithLength )( const IMPL_RTL_STRCODE* pStr1,
-                                                                        sal_Int32 nStr1Len,
-                                                                        const IMPL_RTL_STRCODE* pStr2,
-                                                                        sal_Int32 nStr2Len )
-{
-    if ( nStr1Len != nStr2Len )
-        return sal_False;
-
-    return IMPL_RTL_STRNAME( compareIgnoreAsciiCase_WithLength )( pStr1, nStr1Len, pStr2, nStr2Len ) == 0;
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Int32 SAL_CALL IMPL_RTL_STRNAME( indexOfCharMax )( const IMPL_RTL_STRCODE* pStr,
-                                                       IMPL_RTL_STRCODE c,
-                                                       sal_Int32 nCount )
-{
-    const IMPL_RTL_STRCODE* pTempStr = pStr;
-    while ( nCount && *pTempStr )
-    {
-        if ( *pTempStr == c )
-            return pTempStr-pStr;
-
-        pTempStr++;
-        nCount--;
-    }
-
-    return -1;
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Int32 SAL_CALL IMPL_RTL_STRNAME( lastIndexOfCharMax )( const IMPL_RTL_STRCODE* pStr,
-                                                           IMPL_RTL_STRCODE c,
-                                                           sal_Int32 nCount )
-{
-    return IMPL_RTL_STRNAME( lastIndexOfChar_WithLength )( pStr, IMPL_RTL_STRNAME( getLengthMax )( pStr, nCount ), c );
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Int32 SAL_CALL IMPL_RTL_STRNAME( indexOfStrMax )( const IMPL_RTL_STRCODE* pStr,
-                                                      const IMPL_RTL_STRCODE* pSubStr,
-                                                      sal_Int32 nMaxLen )
-{
-    return IMPL_RTL_STRNAME( indexOfStr_WithLength )( pStr, IMPL_RTL_STRNAME( getLengthMax )( pStr, nMaxLen ),
-                                                      pSubStr, IMPL_RTL_STRNAME( getLengthMax )( pSubStr, nMaxLen ) );
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Int32 SAL_CALL IMPL_RTL_STRNAME( lastIndexOfStrMax )( const IMPL_RTL_STRCODE* pStr,
-                                                          const IMPL_RTL_STRCODE* pSubStr,
-                                                          sal_Int32 nMaxLen )
-{
-    return IMPL_RTL_STRNAME( lastIndexOfStr_WithLength )( pStr, IMPL_RTL_STRNAME( getLengthMax )( pStr, nMaxLen ),
-                                                          pSubStr, IMPL_RTL_STRNAME( getLengthMax )( pSubStr, nMaxLen ) );
-}
-
-/* ----------------------------------------------------------------------- */
-
-void SAL_CALL IMPL_RTL_STRNAME( toAsciiLowerCase )( IMPL_RTL_STRCODE* pStr )
-{
-    while ( *pStr )
-    {
-        /* Between A-Z (65-90), than to lowercase (+32) */
-        if ( (*pStr >= 65) && (*pStr <= 90) )
-            *pStr += 32;
-
-        pStr++;
-    }
-}
-
-/* ----------------------------------------------------------------------- */
-
-void SAL_CALL IMPL_RTL_STRNAME( toAsciiLowerCase_WithLength )( IMPL_RTL_STRCODE* pStr,
-                                                               sal_Int32 nLen )
-{
-    while ( nLen > 0 )
-    {
-        /* Between A-Z (65-90), than to lowercase (+32) */
-        if ( (*pStr >= 65) && (*pStr <= 90) )
-            *pStr += 32;
-
-        pStr++;
-        nLen--;
-    }
-}
-
-/* ----------------------------------------------------------------------- */
-
-void SAL_CALL IMPL_RTL_STRNAME( toAsciiUpperCase )( IMPL_RTL_STRCODE* pStr )
-{
-    while ( *pStr )
-    {
-        /* Between a-z (97-122), than to uppercase (-32) */
-        if ( (*pStr >= 97) && (*pStr <= 122) )
-            *pStr -= 32;
-
-        pStr++;
-    }
-}
-
-/* ----------------------------------------------------------------------- */
-
-void SAL_CALL IMPL_RTL_STRNAME( toAsciiUpperCase_WithLength )( IMPL_RTL_STRCODE* pStr,
-                                                               sal_Int32 nLen )
-{
-    while ( nLen > 0 )
-    {
-        /* Between a-z (97-122), than to uppercase (-32) */
-        if ( (*pStr >= 97) && (*pStr <= 122) )
-            *pStr -= 32;
-
-        pStr++;
-        nLen--;
-    }
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Int32 SAL_CALL IMPL_RTL_STRNAME( trim )( IMPL_RTL_STRCODE* pStr )
-{
-    return IMPL_RTL_STRNAME( trim_WithLength )( pStr, IMPL_RTL_STRNAME( getLength )( pStr ) );
-}
-
-/* ----------------------------------------------------------------------- */
-
-sal_Int32 SAL_CALL IMPL_RTL_STRNAME( trim_WithLength )( IMPL_RTL_STRCODE* pStr, sal_Int32 nLen )
-{
-    sal_Int32 nPreSpaces    = 0;
-    sal_Int32 nPostSpaces   = 0;
-    sal_Int32 nIndex        = nLen-1;
-
-    while ( (nPreSpaces < nLen) && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE(*(pStr+nPreSpaces)) ) )
-        nPreSpaces++;
-
-    while ( (nIndex > nPreSpaces) && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE(*(pStr+nIndex)) ) )
-    {
-        nPostSpaces++;
-        nIndex--;
-    }
-
-    if ( nPostSpaces )
-    {
-        nLen -= nPostSpaces;
-        *(pStr+nLen) = 0;
-    }
-
-    if ( nPreSpaces )
-    {
-        IMPL_RTL_STRCODE* pNewStr = pStr+nPreSpaces;
-
-        nLen -= nPreSpaces;
-        nIndex = nLen;
-
-        while ( nIndex )
-        {
-            *pStr = *pNewStr;
-            pStr++;
-            pNewStr++;
-            nIndex--;
-        }
-        *pStr = 0;
-    }
-
-    return nLen;
-}
-
-/* ======================================================================= */
-/* String-Class functions                                                  */
-/* ======================================================================= */
-
 /* ----------------------------------------------------------------------- */
 
 void SAL_CALL IMPL_RTL_STRINGNAME( newReplace )( IMPL_RTL_STRINGDATA** ppThis,
@@ -1787,37 +1642,22 @@ void SAL_CALL IMPL_RTL_STRINGNAME( newTrim )( IMPL_RTL_STRINGDATA** ppThis,
 
 /* ----------------------------------------------------------------------- */
 
-sal_Int32 SAL_CALL IMPL_RTL_STRINGNAME( getTokenCount )( const IMPL_RTL_STRINGDATA* pThis,
-                                                         IMPL_RTL_STRCODE cTok )
-{
-    sal_Int32               nTokCount   = 1;
-    sal_Int32               nLen        = pThis->length;
-    const IMPL_RTL_STRCODE* pCharStr    = pThis->buffer;
-    while ( nLen > 0 )
-    {
-        if ( *pCharStr == cTok )
-            nTokCount++;
-        pCharStr++;
-        nLen--;
-    }
-
-    return nTokCount;
-}
-
-/* ----------------------------------------------------------------------- */
-
-void SAL_CALL IMPL_RTL_STRINGNAME( getToken )( IMPL_RTL_STRINGDATA** ppThis,
-                                               IMPL_RTL_STRINGDATA* pStr,
-                                               sal_Int32 nToken,
-                                               IMPL_RTL_STRCODE cTok )
+sal_Int32 SAL_CALL IMPL_RTL_STRINGNAME( getToken )( IMPL_RTL_STRINGDATA** ppThis,
+                                                    IMPL_RTL_STRINGDATA* pStr,
+                                                    sal_Int32 nToken,
+                                                    IMPL_RTL_STRCODE cTok,
+                                                    sal_Int32 nIndex )
 {
     IMPL_RTL_STRINGDATA*    pOrg            = *ppThis;
     const IMPL_RTL_STRCODE* pCharStr        = pStr->buffer;
-    const IMPL_RTL_STRCODE* pCharStrStart   = pCharStr;
+    const IMPL_RTL_STRCODE* pCharStrStart;
+    const IMPL_RTL_STRCODE* pOrgCharStr;
+    sal_Int32               nLen            = pStr->length-nIndex;
     sal_Int32               nTokCount       = 0;
-    sal_Int32               nFirstChar      = 0;
-    sal_Int32               nLen            = pStr->length;
 
+    pCharStr += nIndex;
+    pOrgCharStr = pCharStr;
+    pCharStrStart = pCharStr;
     while ( nLen > 0 )
     {
         if ( *pCharStr == cTok )
@@ -1838,9 +1678,16 @@ void SAL_CALL IMPL_RTL_STRINGNAME( getToken )( IMPL_RTL_STRINGDATA** ppThis,
     }
 
     if ( (nToken < 0) || (nTokCount < nToken) || (pCharStr == pCharStrStart) )
+    {
         IMPL_RTL_STRINGNAME( new )( ppThis );
+        return -1;
+    }
     else
+    {
         IMPL_RTL_STRINGNAME( newFromStr_WithLength )( ppThis, pCharStrStart, pCharStr-pCharStrStart );
+        if ( nLen )
+            return nIndex+(pCharStr-pOrgCharStr)+1;
+        else
+            return -1;
+    }
 }
-
-#endif
diff --git a/sal/rtl/source/ustring.c b/sal/rtl/source/ustring.c
index 678b90022dbc..ccdfe1121638 100644
--- a/sal/rtl/source/ustring.c
+++ b/sal/rtl/source/ustring.c
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: ustring.c,v $
  *
- *  $Revision: 1.8 $
+ *  $Revision: 1.9 $
  *
- *  last change: $Author: obr $ $Date: 2001-03-30 14:36:27 $
+ *  last change: $Author: th $ $Date: 2001-05-09 12:54:47 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -59,12 +59,6 @@
  *
  ************************************************************************/
 
-#ifndef _RTL_CHAR_H_
-#include <rtl/char.h>
-#endif
-#ifndef _RTL_LOCALE_H_
-#include <rtl/locale.h>
-#endif
 #ifndef _RTL_MEMORY_H_
 #include <rtl/memory.h>
 #endif
@@ -105,105 +99,6 @@ static rtl_uString aImplEmpty_rtl_uString =
 /* ======================================================================= */
 
 /*************************************************************************
- *  rtl_ustr_equalsIgnoreCase_WithLength
- */
-sal_Bool SAL_CALL rtl_ustr_equalsIgnoreCase_WithLength( const sal_Unicode * first,
-                                                        sal_Int32 firstLen,
-                                                        const sal_Unicode * second,
-                                                        sal_Int32 secondLen )
-{
-    sal_Unicode a;
-    sal_Unicode b;
-
-    if (firstLen != secondLen)
-        return sal_False;
-
-    while ( firstLen )
-    {
-        a = rtl_char_toUpperCase(*first);
-        b = rtl_char_toUpperCase(*second);
-
-        /* Naechstes Zeichen */
-        first++;
-        second++;
-        firstLen--;
-
-        /* If characters don't match but case may be ignored,
-           try converting both characters to uppercase.
-           If the results match, then the comparison scan should
-           continue. */
-        if ( a == b )
-            continue;
-
-        /* Unfortunately, conversion to uppercase does not work properly
-           for the Georgian alphabet, which has strange rules about case
-           conversion.  So we need to make one last check before
-           exiting. */
-        if ( rtl_char_toLowerCase(a) == rtl_char_toLowerCase(b) )
-            continue;
-
-        return sal_False;
-    }
-
-    return sal_True;      /* Strings sind gleich */
-}
-
-/*************************************************************************
- *  rtl_ustr_equalsIgnoreCase
- */
-sal_Bool SAL_CALL rtl_ustr_equalsIgnoreCase( const sal_Unicode * first, const sal_Unicode * second )
-{
-    return rtl_ustr_equalsIgnoreCase_WithLength( first, rtl_ustr_getLength(first),
-                                                 second, rtl_ustr_getLength(second) );
-}
-
-/*************************************************************************
- *  rtl_ustr_compare_WithLength
- */
-sal_Int32 SAL_CALL rtl_ustr_shortenedCompare_WithLength( const sal_Unicode * first,
-                                                        sal_Int32 firstLen,
-                                                        const sal_Unicode * second,
-                                                        sal_Int32 secondLen,
-                                                        sal_Int32 shortenedLength )
-{
-    const sal_Unicode * firstEnd = first + firstLen;
-    const sal_Unicode * secondEnd = second + secondLen;
-    sal_Int32 nResult = 0;
-    while( shortenedLength-- && first < firstEnd && second < secondEnd
-        && (0 == (nResult = (sal_Int32)*first++ - (sal_Int32)*second++ ) ) )
-        ;
-    if( nResult || !(shortenedLength != -1) )
-        return nResult;
-    return firstLen - secondLen;
-}
-
-/*************************************************************************
- *  rtl_ustr_ascii_compare_WithLength
- */
-sal_Int32 SAL_CALL rtl_ustr_ascii_compare_WithLength( const sal_Unicode * first,
-                                                      sal_Int32 firstLen,
-                                                      const sal_Char * second )
-{
-    return rtl_ustr_ascii_shortenedCompare_WithLength( first, firstLen, second, 0x7FFFFFF );
-}
-
-/*************************************************************************
- *  rtl_ustr_ascii_compare
- */
-sal_Int32 SAL_CALL rtl_ustr_ascii_compare( const sal_Unicode * first, const sal_Char * second )
-{
-    sal_Int32 nRet;
-    while ( ((nRet = ((sal_Int32)*first)-((sal_Int32)*second)) == 0) &&
-            *second )
-    {
-        first++;
-        second++;
-    }
-
-    return nRet;
-}
-
-/*************************************************************************
  *  rtl_ustr_ascii_shortenedCompare_WithLength
  */
 sal_Int32 SAL_CALL rtl_ustr_ascii_shortenedCompare_WithLength( const sal_Unicode * first,
@@ -254,459 +149,103 @@ sal_Int32 SAL_CALL rtl_ustr_asciil_reverseCompare_WithLength( const sal_Unicode
     return firstLen - secondLen;
 }
 
+/* ======================================================================= */
 
-/*************************************************************************
- *  rtl_ustr_toAsciiLowerCase_WithLength
- */
-void SAL_CALL rtl_ustr_toAsciiLowerCase_WithLength( sal_Unicode * str, sal_Int32 len )
-{
-    sal_Unicode ch;
-
-    while ( *str )
-    {
-        ch = *str;
-        *str = rtl_char_toLowerCase(ch);
-        str++;
-    }
-}
-
-/*************************************************************************
- *  rtl_ustr_toAsciiLowerCase
- */
-void SAL_CALL rtl_ustr_toAsciiLowerCase( sal_Unicode * str )
-{
-    sal_Unicode ch;
+#define IMPL_RTL_STRCODE            sal_Unicode
+#define IMPL_RTL_USTRCODE( c )      (c)
+#define IMPL_RTL_STRNAME( n )       rtl_ustr_ ## n
 
-    while ( *str )
-    {
-        ch = *str;
-        *str = rtl_char_toLowerCase(ch);
-        str++;
-    }
-}
+#define IMPL_RTL_STRINGNAME( n )    rtl_uString_ ## n
+#define IMPL_RTL_STRINGDATA         rtl_uString
+#define IMPL_RTL_EMPTYSTRING        aImplEmpty_rtl_uString
 
-/*************************************************************************
- *  rtl_ustr_toAsciiUpperCase_WithLength
- */
-void SAL_CALL rtl_ustr_toAsciiUpperCase_WithLength(sal_Unicode * str, sal_Int32 len)
-{
-    sal_Unicode ch;
+/* ======================================================================= */
 
-    while ( *str )
-    {
-        ch = *str;
-        *str = rtl_char_toUpperCase(ch);
-        str++;
-    }
-}
+/* Include String/UString template code */
 
-/*************************************************************************
- *  rtl_ustr_toAsciiUpperCase
- */
-void SAL_CALL rtl_ustr_toAsciiUpperCase(sal_Unicode * str)
-{
-    sal_Unicode ch;
+#include "strtmpl.c"
 
-    while ( *str )
-    {
-        ch = *str;
-        *str = rtl_char_toUpperCase(ch);
-        str++;
-    }
-}
+/* ======================================================================= */
 
-/*************************************************************************
- *  rtl_ustr_trim_WithLength
- */
-sal_Int32 SAL_CALL rtl_ustr_trim_WithLength( sal_Unicode * str, sal_Int32 len )
+sal_Int32 SAL_CALL rtl_ustr_ascii_compare( const sal_Unicode* pStr1,
+                                           const sal_Char* pStr2 )
 {
-    sal_Int32 preSpaces = 0;
-    sal_Int32 postSpaces = 0;
-    sal_Int32 newLen = 0;
-    sal_Int32 index = len - 1;
-
-    while ( (preSpaces < len) && rtl_char_isWhitespace(*(str+preSpaces)) )
-        preSpaces++;
-
-    while ( (index > preSpaces) && rtl_char_isWhitespace(*(str+index)) )
-    {
-        postSpaces++;
-        index--;
-    }
-
-    newLen = len - preSpaces - postSpaces;
-
-    if ( newLen != len )
+    sal_Int32 nRet;
+    while ( ((nRet = ((sal_Int32)(*pStr1))-
+                     ((sal_Int32)((unsigned char)(pStr2)))) == 0) &&
+            *pStr2 )
     {
-        sal_Unicode *newStr = str + preSpaces;
-        index = 0;
-
-        while ( index != newLen )
-        {
-            *(str + index) = *(newStr + index);
-            index++;
-        }
-        *(str + index) = 0;
+        pStr1++;
+        pStr2++;
     }
 
-    return newLen;
-}
-
-/*************************************************************************
- *  rtl_ustr_trim
- */
-sal_Int32 SAL_CALL rtl_ustr_trim( sal_Unicode * str )
-{
-    return rtl_ustr_trim_WithLength(str, rtl_ustr_getLength(str));
+    return nRet;
 }
 
-/*************************************************************************
- *
- *  rtl_uString_XXX Functions
- *
- ************************************************************************/
-
-/*************************************************************************
- *  rtl_wstr_getLength
- */
-static sal_Int32 SAL_CALL rtl_wstr_getLength( const wchar_t* str )
-{
-    const wchar_t * pTempStr = str;
-    while( *pTempStr ) pTempStr++;
-    return pTempStr - str;
-}
+/* ----------------------------------------------------------------------- */
 
-/*************************************************************************
- *  rtl_uString_newFromWStr
- */
-void SAL_CALL rtl_uString_newFromWStr( rtl_uString ** newStr, const wchar_t * value )
+sal_Int32 SAL_CALL rtl_ustr_ascii_compare_WithLength( const sal_Unicode* pStr1,
+                                                      sal_Int32 nStr1Len,
+                                                      const sal_Char* pStr2 )
 {
-    sal_Int32 length;
-    sal_Unicode* p;
-
-    if (!value)
+    sal_Int32 nRet = 0;
+    while( nStr1Len &&
+           ((nRet = ((sal_Int32)(*pStr1))-
+                    ((sal_Int32)((unsigned char)(*pStr2)))) == 0) &&
+           *pStr2 )
     {
-        rtl_uString_new(newStr);
-        return;
+        pStr1++;
+        pStr2++;
+        nStr1Len--;
     }
 
-    length = rtl_wstr_getLength(value);
-
-    if (*newStr)
-        rtl_uString_release(*newStr);
-
-    *newStr = (rtl_uString*)rtl_allocateMemory( sizeof(rtl_uString) + (length * sizeof(sal_Unicode)) );
-    if ( *newStr )
-    {
-        (*newStr)->refCount = 1;
-        (*newStr)->length = length;
-
-        p = (*newStr)->buffer;
-        while ( length )
-        {
-            *p = (sal_Unicode)(*value);
-            p++;
-            value++;
-            length--;
-        }
-        *p = 0;
-    }
+    return nRet;
 }
 
-/*************************************************************************
- *  rtl_uString_newFromWStr_WithLength
- */
-void SAL_CALL rtl_uString_newFromWStr_WithLength( rtl_uString ** newStr,
-                                                  const wchar_t * value,
-                                                  sal_Int32 len)
+/* ----------------------------------------------------------------------- */
+
+void SAL_CALL rtl_uString_newFromAscii( rtl_uString** ppThis,
+                                        const sal_Char* pCharStr )
 {
-    sal_Unicode* p;
+    sal_Int32 nLen;
 
-    if (!value || len < 0)
+    if ( pCharStr )
     {
-        rtl_uString_new(newStr);
-        return;
+        const sal_Char* pTempStr = pCharStr;
+        while( *pTempStr )
+            pTempStr++;
+        nLen = pTempStr-pCharStr;
     }
+    else
+        nLen = 0;
 
-    if (*newStr)
-        rtl_uString_release(*newStr);
-
-    *newStr = (rtl_uString*)rtl_allocateMemory( sizeof(rtl_uString) + (len * sizeof(sal_Unicode)) );
-    if ( *newStr )
-    {
-        (*newStr)->refCount = 1;
-        (*newStr)->length = len;
-
-        p = (*newStr)->buffer;
-        while ( len )
-        {
-            *p = (sal_Unicode)(*value);
-            p++;
-            value++;
-            len--;
-        }
-        *p = 0;
-    }
-}
-
-/*************************************************************************
- *  rtl_uString_newFromASCII
- */
-void SAL_CALL rtl_uString_newFromAscii( rtl_uString ** newStr, const sal_Char * value )
-{
-    sal_Int32 length;
-    sal_Unicode* p;
-
-    if (!value)
+    if ( !nLen )
     {
-        rtl_uString_new(newStr);
+        IMPL_RTL_STRINGNAME( new )( ppThis );
         return;
     }
 
-    length = rtl_str_getLength( value );
-
-    if (*newStr)
-        rtl_uString_release(*newStr);
+    if ( *ppThis )
+        IMPL_RTL_STRINGNAME( release )( *ppThis );
 
-    *newStr = (rtl_uString*)rtl_allocateMemory( sizeof(rtl_uString) + (length * sizeof(sal_Unicode)) );
-    if ( *newStr )
+    *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nLen );
+    if ( (*ppThis) )
     {
-        (*newStr)->refCount = 1;
-        (*newStr)->length = length;
-
-        p = (*newStr)->buffer;
-        while ( length )
+        IMPL_RTL_STRCODE* pBuffer = (*ppThis)->buffer;
+        do
         {
             /* Check ASCII range */
-            OSL_ENSURE( (*value & 0x80) == 0, "Found ASCII char > 127");
-
-            *p = (sal_Unicode)(*value);
-            p++;
-            value++;
-            length--;
-        }
-        *p = 0;
-    }
-}
-
-/*************************************************************************
- *  rtl_uString_newReplace
- */
-void SAL_CALL rtl_uString_newReplace( rtl_uString ** newStr,
-                                      rtl_uString * str,
-                                      sal_Unicode oldChar,
-                                      sal_Unicode newChar)
-{
-    rtl_uString_newFromString(newStr, str);
-
-    if (!(*newStr)) return;
-
-    rtl_ustr_replaceChar_WithLength((*newStr)->buffer, (*newStr)->length, oldChar, newChar);
-}
-
-/*************************************************************************
- *  rtl_uString_newToLowerCase
- */
-void SAL_CALL rtl_uString_newToLowerCase( rtl_uString ** newStr,
-                                          rtl_uString * str,
-                                          struct _rtl_Locale * locale )
-{
-    if (locale && locale->Language->length == 2
-      && locale->Language->buffer[0] == 't'
-      && locale->Language->buffer[0] == 'r' )
-    {
-        sal_Int32 i;
-        sal_Int32 len = str->length;
-
-        rtl_uString_new_WithLength(newStr, str->length);
-
-        if (!(*newStr)) return;
-
-        (*newStr)->length = str->length;
-
-        /* special loop for Turkey */
-        for (i = 0; i < len; i++)
-        {
-            sal_Unicode ch = str->buffer[i];
-            if (ch == L'I')
-            {
-                (*newStr)->buffer[i] = (sal_Unicode)0x0131; /* dotless small i */
-                continue;
-            }
-            if ((sal_uInt16)ch == 0x0130)               /* dotted I */
-            {
-                (*newStr)->buffer[i] = L'i';    /* dotted i */
-                continue;
-            }
-            (*newStr)->buffer[i] = rtl_char_toLowerCase(ch);
-        }
-    } else
-    {
-        rtl_uString_newFromString(newStr, str);
-
-        if (!(*newStr)) return;
-
-        rtl_ustr_toAsciiLowerCase_WithLength((*newStr)->buffer, (*newStr)->length);
-    }
-}
-
-/*************************************************************************
- *  rtl_uString_newToUpperCase
- */
-void SAL_CALL rtl_uString_newToUpperCase( rtl_uString ** newStr,
-                                          rtl_uString * str,
-                                          struct _rtl_Locale * locale )
-{
-    sal_Int32 i;
-    sal_Int32 len = str->length;
-    sal_Int32 resultOffset = 0;
-    sal_Unicode *result = (sal_Unicode*)rtl_allocateMemory((len + 1)* sizeof(sal_Unicode));
-
-    if (locale && locale->Language->length == 2
-      && locale->Language->buffer[0] == 't'
-      && locale->Language->buffer[0] == 'r' )
-    {
-        /* special loop for Turkey */
-        for (i = 0; i < len; i++)
-        {
-            sal_Unicode ch = str->buffer[i];
-            if ((sal_uInt16)ch == 0x0131)            /* dotless i */
-            {
-                result[i+resultOffset] = L'I';          /* cap I */
-                continue;
-            }
-            if (ch == L'i')
-            {
-                result[i+resultOffset] = (sal_Unicode)0x0130;       /* dotted cap i */
-                continue;
-            }
-            if ((sal_uInt16)ch == 0x00DF)               /* sharp s */
-            {
-                /* Grow result. */
-                sal_Unicode *result2 = (sal_Unicode*)rtl_allocateMemory((len + 1 + resultOffset + 1) * sizeof(sal_Unicode));
-                rtl_copyMemory(result2, result, (i + resultOffset) * sizeof(sal_Unicode));
-                result2[i+resultOffset] = L'S';
-                resultOffset++;
-                result2[i+resultOffset] = L'S';
-                rtl_freeMemory(result);
-                result = result2;
-                continue;
-            }
-            result[i+resultOffset] = rtl_char_toUpperCase(ch);
-        }
-    } else
-    {
-        for (i = 0; i < len; i++)
-        {
-            sal_Unicode ch = str->buffer[i];
-
-            if ((sal_uInt16)ch == 0x00DF)               /* sharp s */
-            {
-                /* Grow result. */
-                sal_Unicode *result2 = (sal_Unicode*)rtl_allocateMemory((len + 1 + resultOffset + 1) * sizeof(sal_Unicode));
-                rtl_copyMemory(result2, result, (i + resultOffset) * sizeof(sal_Unicode));
-                result2[i+resultOffset] = L'S';
-                resultOffset++;
-                result2[i+resultOffset] = L'S';
-                rtl_freeMemory(result);
-                result = result2;
-                continue;
-            }
-            result[i+resultOffset] = rtl_char_toUpperCase(ch);
-        }
-
-    }
-
-    result[len + resultOffset] = L'\0';
-    rtl_uString_newFromStr_WithLength(newStr, result, len + resultOffset);
-    rtl_freeMemory(result);
-}
-
-/*************************************************************************
- *  rtl_uString_newTrim
- */
-void SAL_CALL rtl_uString_newTrim( rtl_uString ** newStr, rtl_uString * str )
-{
-    rtl_uString_newFromString(newStr, str);
-
-    if (!(*newStr)) return;
-
-    (*newStr)->length = rtl_ustr_trim_WithLength((*newStr)->buffer, (*newStr)->length);
-}
-
-/*************************************************************************
- *  rtl_uString_getTokenCount
- */
-sal_Int32 SAL_CALL rtl_uString_getTokenCount( rtl_uString * str , sal_Unicode cTok)
-{
-    sal_Int32 count = 0;
-    sal_Int32 index1 = 0;
-    sal_Int32 index2 = 0;
-    sal_Unicode * buffer = str->buffer;
-
-    while ((index2 = rtl_ustr_indexOfChar_WithLength(buffer + index1, str->length - index1, cTok)) >= 0)
-    {
-        if (index2 <= (str->length - index1) && index2 >= 0)
-            count++;
-
-        index1 += index2 + 1;
-    }
-
-    if (index2 < 0 && index1 <= str->length)
-        count++;
+            OSL_ENSURE( ((unsigned char)*pCharStr) <= 127,
+                        "rtl_uString_newFromAscii() - Found ASCII char > 127" );
 
-    return count;
-}
-
-/*************************************************************************
- *  rtl_uString_getToken
- */
-void SAL_CALL rtl_uString_getToken( rtl_uString ** newStr , rtl_uString * str, sal_Int32 nToken, sal_Unicode cTok)
-{
-    sal_Int32 count = 0;
-    sal_Int32 index1 = 0;
-    sal_Int32 index2 = 0;
-    sal_Unicode * buffer = str->buffer;
-
-    while ((index2 = rtl_ustr_indexOfChar_WithLength(buffer + index1, str->length - index1, cTok)) >= 0)
-    {
-        if (count == nToken)
-        {
-            rtl_uString_newFromStr_WithLength( newStr, buffer + index1, index2 );
-            return;
+            *pBuffer = *pCharStr;
+            pBuffer++;
+            pCharStr++;
         }
-
-        if (index2 <= (str->length - index1) && index2 >= 0)
-            count++;
-
-        index1 += index2 + 1;
+        while ( *pCharStr );
     }
-
-    if (nToken == 0 || nToken == count)
-        rtl_uString_newFromStr_WithLength( newStr, buffer + index1, str->length - index1 );
-    else
-        rtl_uString_new(newStr);
-
-    return;
 }
 
-
-/* ======================================================================= */
-
-#define IMPL_RTL_STRCODE            sal_Unicode
-#define IMPL_RTL_USTRCODE( c )      (c)
-#define IMPL_RTL_STRNAME( n )       rtl_ustr_ ## n
-
-#define IMPL_RTL_STRINGNAME( n )    rtl_uString_ ## n
-#define IMPL_RTL_STRINGDATA         rtl_uString
-#define IMPL_RTL_EMPTYSTRING        aImplEmpty_rtl_uString
-
-/* ======================================================================= */
-
-/* Include String/UString template code */
-
-#include "strtmpl.c"
-
 /* ======================================================================= */
 
 static int rtl_ImplGetFastUTF8UnicodeLen( const sal_Char* pStr, sal_Int32 nLen )
@@ -807,10 +346,8 @@ void SAL_CALL rtl_string2UString( rtl_uString** ppThis,
                     do
                     {
                         /* Check ASCII range */
-/* SBLLINK!
                         OSL_ENSURE( ((unsigned char)*pStr) <= 127,
                                     "rtl_string2UString() - UTF8 test encoding is wrong" );
-*/
 
                         *pBuffer = *pStr;
                         pBuffer++;