1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_tools.hxx" 26 27 #include <string.h> 28 29 #include "boost/static_assert.hpp" 30 31 #include "osl/diagnose.h" 32 #ifndef _OSL_INTERLCK_H 33 #include <osl/interlck.h> 34 #endif 35 #ifndef _RTL_ALLOC_H 36 #include <rtl/alloc.h> 37 #endif 38 #ifndef _RTL_MEMORY_H 39 #include <rtl/memory.h> 40 #endif 41 #include <rtl/tencinfo.h> 42 #include <rtl/instance.hxx> 43 44 #include <tools/string.hxx> 45 #include <impstrg.hxx> 46 47 // For shared byte convert tables 48 #ifndef _TOOLS_TOOLSIN_HXX 49 #include <toolsin.hxx> 50 #endif 51 52 #include <tools/debug.hxx> 53 54 // ======================================================================= 55 56 DBG_NAME( ByteString ) 57 DBG_NAMEEX( UniString ) 58 59 // ----------------------------------------------------------------------- 60 61 #define STRCODE sal_Char 62 #define STRCODEU unsigned char 63 #define STRING ByteString 64 #define STRINGDATA ByteStringData 65 #define DBGCHECKSTRING DbgCheckByteString 66 #define STRING_TYPE rtl_String 67 #define STRING_ACQUIRE rtl_string_acquire 68 #define STRING_RELEASE rtl_string_release 69 #define STRING_NEW rtl_string_new 70 71 72 // ----------------------------------------------------------------------- 73 74 xub_StrLen ImplStringLen( const sal_Char* pStr ) 75 { 76 const sal_Char* pTempStr = pStr; 77 while( *pTempStr ) 78 ++pTempStr; 79 return (xub_StrLen)(pTempStr-pStr); 80 } 81 82 // ----------------------------------------------------------------------- 83 84 xub_StrLen ImplStringLen( const sal_Unicode* pStr ) 85 { 86 const sal_Unicode* pTempStr = pStr; 87 while( *pTempStr ) 88 ++pTempStr; 89 return (xub_StrLen)(pTempStr-pStr); 90 } 91 92 // ----------------------------------------------------------------------- 93 94 #include <strimp.cxx> 95 #include <strcvt.cxx> 96 97 // ----------------------------------------------------------------------- 98 99 ByteString ByteString::CreateFromInt32( sal_Int32 n, sal_Int16 nRadix ) 100 { 101 sal_Char aBuf[RTL_STR_MAX_VALUEOFINT32]; 102 BOOST_STATIC_ASSERT(RTL_STR_MAX_VALUEOFINT32 <= STRING_MAXLEN); 103 return ByteString( 104 aBuf, 105 static_cast< xub_StrLen >(rtl_str_valueOfInt32( aBuf, n, nRadix )) ); 106 } 107 108 // ----------------------------------------------------------------------- 109 110 ByteString ByteString::CreateFromInt64( sal_Int64 n, sal_Int16 nRadix ) 111 { 112 sal_Char aBuf[RTL_STR_MAX_VALUEOFINT64]; 113 BOOST_STATIC_ASSERT(RTL_STR_MAX_VALUEOFINT64 <= STRING_MAXLEN); 114 return ByteString( 115 aBuf, 116 static_cast< xub_StrLen >(rtl_str_valueOfInt64( aBuf, n, nRadix )) ); 117 } 118 119 // ----------------------------------------------------------------------- 120 121 ByteString ByteString::CreateFromFloat( float f ) 122 { 123 sal_Char aBuf[RTL_STR_MAX_VALUEOFFLOAT]; 124 BOOST_STATIC_ASSERT(RTL_STR_MAX_VALUEOFFLOAT <= STRING_MAXLEN); 125 return ByteString( 126 aBuf, static_cast< xub_StrLen >(rtl_str_valueOfFloat( aBuf, f )) ); 127 } 128 129 // ----------------------------------------------------------------------- 130 131 ByteString ByteString::CreateFromDouble( double d ) 132 { 133 sal_Char aBuf[RTL_STR_MAX_VALUEOFDOUBLE]; 134 BOOST_STATIC_ASSERT(RTL_STR_MAX_VALUEOFDOUBLE <= STRING_MAXLEN); 135 return ByteString( 136 aBuf, static_cast< xub_StrLen >(rtl_str_valueOfDouble( aBuf, d )) ); 137 } 138 139 // ----------------------------------------------------------------------- 140 141 namespace { struct Empty : public rtl::Static< const ByteString, Empty> {}; } 142 const ByteString& ByteString::EmptyString() 143 { 144 return Empty::get(); 145 } 146 147 // ----------------------------------------------------------------------- 148 149 sal_Int32 ByteString::ToInt32() const 150 { 151 DBG_CHKTHIS( ByteString, DbgCheckByteString ); 152 153 return atoi( mpData->maStr ); 154 } 155 156 // ----------------------------------------------------------------------- 157 158 sal_Int64 ByteString::ToInt64() const 159 { 160 DBG_CHKTHIS( ByteString, DbgCheckByteString ); 161 162 return atoi( mpData->maStr ); 163 } 164 165 // ----------------------------------------------------------------------- 166 167 float ByteString::ToFloat() const 168 { 169 DBG_CHKTHIS( ByteString, DbgCheckByteString ); 170 171 OSL_ENSURE(false, "ByteString::ToFloat unusable"); 172 return 0; 173 } 174 175 // ----------------------------------------------------------------------- 176 177 double ByteString::ToDouble() const 178 { 179 DBG_CHKTHIS( ByteString, DbgCheckByteString ); 180 181 OSL_ENSURE(false, "ByteString::ToDouble unusable"); 182 return 0; 183 } 184 185 // ----------------------------------------------------------------------- 186 187 sal_Bool ByteString::IsLowerAscii() const 188 { 189 DBG_CHKTHIS( ByteString, DbgCheckByteString ); 190 191 sal_Int32 nIndex = 0; 192 sal_Int32 nLen = mpData->mnLen; 193 const sal_Char* pStr = mpData->maStr; 194 while ( nIndex < nLen ) 195 { 196 if ( (*pStr >= 65) && (*pStr <= 90) ) 197 return sal_False; 198 199 ++pStr, 200 ++nIndex; 201 } 202 203 return sal_True; 204 } 205 206 // ----------------------------------------------------------------------- 207 208 sal_Bool ByteString::IsUpperAscii() const 209 { 210 DBG_CHKTHIS( ByteString, DbgCheckByteString ); 211 212 sal_Int32 nIndex = 0; 213 sal_Int32 nLen = mpData->mnLen; 214 const sal_Char* pStr = mpData->maStr; 215 while ( nIndex < nLen ) 216 { 217 if ( (*pStr >= 97) && (*pStr <= 122) ) 218 return sal_False; 219 220 ++pStr, 221 ++nIndex; 222 } 223 224 return sal_True; 225 } 226 227 // ----------------------------------------------------------------------- 228 229 sal_Bool ByteString::IsAlphaAscii() const 230 { 231 DBG_CHKTHIS( ByteString, DbgCheckByteString ); 232 233 sal_Int32 nIndex = 0; 234 sal_Int32 nLen = mpData->mnLen; 235 const sal_Char* pStr = mpData->maStr; 236 while ( nIndex < nLen ) 237 { 238 if ( !(((*pStr >= 97) && (*pStr <= 122)) || 239 ((*pStr >= 65) && (*pStr <= 90))) ) 240 return sal_False; 241 242 ++pStr, 243 ++nIndex; 244 } 245 246 return sal_True; 247 } 248 249 // ----------------------------------------------------------------------- 250 251 sal_Bool ByteString::IsNumericAscii() const 252 { 253 DBG_CHKTHIS( ByteString, DbgCheckByteString ); 254 255 sal_Int32 nIndex = 0; 256 sal_Int32 nLen = mpData->mnLen; 257 const sal_Char* pStr = mpData->maStr; 258 while ( nIndex < nLen ) 259 { 260 if ( !((*pStr >= 48) && (*pStr <= 57)) ) 261 return sal_False; 262 263 ++pStr, 264 ++nIndex; 265 } 266 267 return sal_True; 268 } 269 270 // ----------------------------------------------------------------------- 271 272 sal_Bool ByteString::IsAlphaNumericAscii() const 273 { 274 DBG_CHKTHIS( ByteString, DbgCheckByteString ); 275 276 sal_Int32 nIndex = 0; 277 sal_Int32 nLen = mpData->mnLen; 278 const sal_Char* pStr = mpData->maStr; 279 while ( nIndex < nLen ) 280 { 281 if ( !(((*pStr >= 97) && (*pStr <= 122)) || 282 ((*pStr >= 65) && (*pStr <= 90)) || 283 ((*pStr >= 48) && (*pStr <= 57))) ) 284 return sal_False; 285 286 ++pStr, 287 ++nIndex; 288 } 289 290 return sal_True; 291 } 292