Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members  

cstring.c

00001 /*
00002 *******************************************************************************
00003 *
00004 *   Copyright (C) 1997-1999, International Business Machines
00005 *   Corporation and others.  All Rights Reserved.
00006 *
00007 *******************************************************************************
00008 *
00009 * File CSTRING.C
00010 *
00011 * @author       Helena Shih
00012 *
00013 * Modification History:
00014 *
00015 *   Date        Name        Description
00016 *   6/18/98     hshih       Created
00017 *   09/08/98    stephen     Added include for ctype, for Mac Port
00018 *   11/15/99    helena      Integrated S/390 IEEE changes. 
00019 *****************************************************************************************
00020 */
00021 
00022 
00023 
00024 #include <stdio.h>
00025 #include <stdlib.h>
00026 #include <ctype.h>
00027 #include "unicode/utypes.h"
00028 #include "unicode/putil.h"
00029 #include "cmemory.h"
00030 #include "cstring.h"
00031 
00032 char*
00033 T_CString_toLowerCase(char* str)
00034 {
00035     char* origPtr = str;
00036 
00037     if (str) {
00038         do
00039             *str = (char)tolower(*str);
00040         while (*(str++));
00041     }
00042 
00043     return origPtr;
00044 }
00045 
00046 char*
00047 T_CString_toUpperCase(char* str)
00048 {
00049     char* origPtr = str;
00050 
00051     if (str) {
00052         do
00053             *str = (char)toupper(*str);
00054         while (*(str++));
00055     }
00056 
00057     return origPtr;
00058 }
00059 
00060 /*Takes a int32_t and     fills in  a char* string with that number "radix"-based*/
00061 
00062 void T_CString_integerToString(char* buffer, int32_t i, int32_t radix)
00063 {
00064   int32_t length=0;
00065   int32_t num = 0;
00066   int8_t digit;
00067   char temp;
00068 
00069   while (i>=radix)
00070     {
00071       num = i/radix;
00072       digit = (int8_t)(i - num*radix);
00073       buffer[length++] = (char)(T_CString_itosOffset(digit));
00074       i = num;
00075     }
00076 
00077   buffer[length] = (char)(T_CString_itosOffset(i));
00078   buffer[length+1] = '\0';
00079 
00080 
00081   /*Reverses the string*/
00082   for (i = 0; i < length; ++i, --length) {
00083     temp = buffer[length];
00084     buffer[length] = buffer[i];
00085     buffer[i] = temp;
00086   }
00087 
00088   return;
00089 }
00090 
00091 #include <stdio.h>
00092 
00093 int32_t
00094 T_CString_stringToInteger(const char *integerString, int32_t radix)
00095 {
00096     char *end;
00097     return strtoul(integerString, &end, radix);
00098 
00099 }
00100     
00101 U_CAPI int U_EXPORT2
00102 T_CString_stricmp(const char *str1, const char *str2) {
00103     if(str1==NULL) {
00104         if(str2==NULL) {
00105             return 0;
00106         } else {
00107             return -1;
00108         }
00109     } else if(str2==NULL) {
00110         return 1;
00111     } else {
00112         /* compare non-NULL strings lexically with lowercase */
00113         int rc;
00114         unsigned char c1, c2;
00115 
00116         for(;;) {
00117             c1=(unsigned char)*str1;
00118             c2=(unsigned char)*str2;
00119             if(c1==0) {
00120                 if(c2==0) {
00121                     return 0;
00122                 } else {
00123                     return -1;
00124                 }
00125             } else if(c2==0) {
00126                 return 1;
00127             } else {
00128                 /* compare non-zero characters with lowercase */
00129                 rc=(int)(unsigned char)uprv_tolower(c1)-(int)(unsigned char)uprv_tolower(c2);
00130                 if(rc!=0) {
00131                     return rc;
00132                 }
00133             }
00134             ++str1;
00135             ++str2;
00136         }
00137     }
00138 }
00139 
00140 U_CAPI int U_EXPORT2
00141 T_CString_strnicmp(const char *str1, const char *str2, uint32_t n) {
00142     if(str1==NULL) {
00143         if(str2==NULL) {
00144             return 0;
00145         } else {
00146             return -1;
00147         }
00148     } else if(str2==NULL) {
00149         return 1;
00150     } else {
00151         /* compare non-NULL strings lexically with lowercase */
00152         int rc;
00153         unsigned char c1, c2;
00154 
00155         for(; n--;) {
00156             c1=(unsigned char)*str1;
00157             c2=(unsigned char)*str2;
00158             if(c1==0) {
00159                 if(c2==0) {
00160                     return 0;
00161                 } else {
00162                     return -1;
00163                 }
00164             } else if(c2==0) {
00165                 return 1;
00166             } else {
00167                 /* compare non-zero characters with lowercase */
00168                 rc=(int)(unsigned char)uprv_tolower(c1)-(int)(unsigned char)uprv_tolower(c2);
00169                 if(rc!=0) {
00170                     return rc;
00171                 }
00172             }
00173             ++str1;
00174             ++str2;
00175         }
00176     }
00177 
00178     return 0;
00179 }
00180 
00181 U_CAPI char *uprv_strdup(const char *src) {
00182     size_t len = strlen(src) + 1;
00183     char *dup = (char *) malloc(len);
00184 
00185     if (dup) {
00186         uprv_memcpy(dup, src, len);
00187     }
00188 
00189     return dup;
00190 }
00191 
00192 #if !U_HAVE_WCHAR_H
00193 U_CAPI wchar_t *uprv_wcscat(wchar_t *dst, const wchar_t *src) {
00194     wchar_t *start=dst;
00195     while(*dst!=0) {
00196         ++dst;
00197     }
00198     while((*dst=*src)!=0) {
00199         ++dst;
00200         ++src;
00201     }
00202     return start;
00203 }
00204 
00205 U_CAPI wchar_t *uprv_wcscpy(wchar_t *dst, const wchar_t *src) {
00206     wchar_t *start=dst;
00207     while((*dst=*src)!=0) {
00208         ++dst;
00209         ++src;
00210     }
00211     return start;
00212 }
00213 
00214 U_CAPI size_t uprv_wcslen(const wchar_t *src) {
00215     const wchar_t *start=src;
00216     while(*src!=0) {
00217         ++src;
00218     }
00219     return src-start;
00220 }
00221 #endif

Generated at Tue Dec 5 10:47:44 2000 for ICU by doxygen1.2.3 written by Dimitri van Heesch, © 1997-2000