cbtcommon/text_util.c

   1 /*
   2  * Copyright 2001, 2002, 2003 David Mansfield and Cobite, Inc.
   3  * See COPYING file for license information
   4  */
   5
   6 /**
   7  * Copyright (c) 1998 Cobite, Inc. All Rights Reserved.
   8  * @author Karl LaRocca
   9  * @created Fri Nov  6 14:33:29 1998
  10  * @version $Revision: 1.9 $$Date: 2001/10/25 18:36:11 $
  11  */
  12 #include <ctype.h>
  13 #include <string.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16
  17 #include "text_util.h"
  18 #include "rcsid.h"
  19
  20 RCSID("$Id: text_util.c,v 1.9 2001/10/25 18:36:11 adam Exp $");
  21
  22 char*
  23 chop( char* src )
  24 {
  25   char* p = src + strlen(src) - 1;
  26
  27   while( p >= src )
  28   {
  29     if ( *p == '\n' || *p == '\r' )
  30     {
  31       *p-- = 0;
  32     }
  33
  34     else
  35     {
  36       break;
  37     }
  38   }
  39
  40   return( src );
  41 }
  42
  43 char*
  44 digits( char* src )
  45 {
  46   char* start = src;
  47   char* check = src;
  48
  49   while( *check )
  50   {
  51     if ( isdigit( *check ) )
  52     {
  53       *start++ = *check;
  54     }
  55
  56     check++;
  57   }
  58
  59   *start = 0;
  60
  61   return( src );
  62 }
  63
  64 char*
  65 lower_case( char* src )
  66 {
  67   char* p = src;
  68
  69   while( *p )
  70   {
  71       *p = tolower( *p );
  72       p++;
  73   }
  74
  75   return( src );
  76 }
  77
  78 char*
  79 reverse( char* src )
  80 {
  81   int  i;
  82   int  len = strlen( src );
  83   char tmp;
  84
  85   for( i = len / 2; --i >= 0; )
  86   {
  87     tmp = src[ i ];
  88     src[ i ] = src[ len - i - 1 ];
  89     src[ len - i - 1 ] = tmp;
  90   }
  91
  92   return( src );
  93 }
  94
  95 char*
  96 trim( char* src )
  97 {
  98   char *p = src + strlen(src) - 1;
  99
 100   while( p >= src && isspace(*p) )
 101       *p-- = '\0';
 102
 103   return src;
 104 }
 105
 106 char*
 107 upper_case( char* src )
 108 {
 109   char* p = src;
 110
 111   while( *p )
 112   {
 113     *p = toupper(*p);
 114     p++;
 115   }
 116
 117   return( src );
 118 }
 119
 120 int
 121 strrcmp( const char* haystack, const char* needle )
 122 {
 123     int hlen = strlen( haystack );
 124     int nlen = strlen( needle );
 125     if( hlen < nlen )
 126         return( -1 );
 127     else
 128         return( strcmp( haystack + hlen - nlen, needle ) );
 129 }
 130
 131 /*
 132  * Finding a - anywhere in the string makes it money negative.
 133  * all characters other than digits, '-', and '.' are ignored, so:
 134  * ab36-.g98 = -36.98
 135  * This is fair, I think, if we don't want to reject anything as
 136  * improperly formatted.
 137  */
 138 long
 139 money2cents( const char* money )
 140 {
 141     long retval = 0;
 142     int decimal_places = -1;
 143     int neg = 0;
 144
 145     while( *money && decimal_places < 2 )
 146     {
 147         if ( isdigit( *money ) )
 148         {
 149             if ( decimal_places >= 0 )
 150                 decimal_places++;
 151
 152             retval *= 10;
 153             retval += (*money) - '0';
 154         }
 155
 156         else if ( *money == '.' )
 157             decimal_places = 0;
 158
 159         else if ( *money == '-' )
 160             neg = 1;
 161
 162         money++;
 163     }
 164
 165     if ( decimal_places == 1 )
 166         retval *= 10;
 167
 168     else if ( decimal_places <= 0 )
 169         retval *= 100;
 170
 171     return( neg ? -retval : retval );
 172 }
 173
 174 const char*
 175 cents2money( long cents )
 176 {
 177   static char buff[ 64 ];
 178   int idx = 0;
 179   char* d = buff;
 180
 181   if ( cents == 0 )
 182   {
 183     strcpy( buff, "0.00" );
 184   }
 185
 186   else if ( cents < 100 )
 187   {
 188     sprintf( buff, "0.%2.2ld", cents );
 189   }
 190
 191   else
 192   {
 193     while( cents > 0 )
 194     {
 195       *d++ = '0' + ( cents % 10 );
 196       cents = cents / 10;
 197
 198       if ( idx == 1 )
 199       {
 200         *d++ = '.';
 201       }
 202
 203       else if ( cents > 0 && ( idx - 1 ) % 3 == 0 )
 204       {
 205         *d++ = ',';
 206       }
 207
 208       idx++;
 209     }
 210
 211     *d++ = 0;
 212
 213     reverse( buff );
 214   }
 215
 216   return( buff );
 217 }
 218
 219 void trim_zeros_after_decimal( char* src )
 220 {
 221     char * end = src + strlen( src ) - 1;
 222
 223     while( end != src )
 224     {
 225         if( *end == '0' )
 226             *end = 0;
 227         else if( *end == '.' )
 228         {
 229             *end = 0;
 230             break;
 231         }
 232         else
 233             break;
 234
 235         end--;
 236     }
 237 }
 238
 239 #ifdef linux
 240 extern void *memfrob(void *, size_t);
 241 #else
 242 static void * memfrob(void * mem, size_t len)
 243 {
 244     size_t i;
 245     char *c = (char *)mem;
 246
 247     for (i = 0; i < len; i++)
 248     {
 249         *c = *c ^ 42;
 250         c++;
 251     }
 252
 253     return mem;
 254 }
 255 #endif
 256
 257 // simple functions to obfuscate strings in a binary
 258 char* frobstr( char* src )
 259 {
 260     char* retval = (char*)malloc( strlen(src) * 2 + 1 );
 261
 262     memfrob( src, strlen( src ) );
 263     str2hex( retval, src, 0 );
 264     memfrob( src, strlen( src ) );
 265
 266     return( retval );
 267 }
 268
 269 char* unfrobstr( char* src )
 270 {
 271     int slen = strlen( src ) / 2;
 272     char* retval = (char*)malloc( slen + 1 );
 273
 274     hex2str( retval, src, 0 );
 275     memfrob( retval, slen );
 276
 277     return( retval );
 278 }
 279
 280 void str2hex( char* dest, const char* src, int slen )
 281 {
 282     int i;
 283     char* p = dest;
 284
 285     if( slen == 0 )
 286         slen = strlen( src );
 287
 288     for ( i = 0; i < slen; i++ )
 289     {
 290         sprintf( p, "%02x", src[i] );
 291         p += 2;
 292     }
 293
 294     *p = 0;
 295 }
 296
 297 void hex2str( char* dest, const char* src, int slen )
 298 {
 299     const char* p = src;
 300     int i;
 301     unsigned int v;
 302
 303     if( slen == 0 )
 304         slen = strlen( src );
 305
 306     slen /= 2;
 307
 308     for( i = 0; i < slen; i++ )
 309     {
 310         sscanf( p, "%02x", &v );
 311         dest[i] = (char)v;
 312         p += 2;
 313     }
 314
 315     dest[ slen ] = 0;
 316 }
 317