code_c/Maasha/src/lib/strings.c

   1 /* Martin Asser Hansen (mail@maasha.dk) Copyright (C) 2008 - All right reserved */
   2
   3 #include "common.h"
   4 #include "strings.h"
   5
   6
   7 size_t chop( char *string )
   8 {
   9     /* Martin A. Hansen, June 2008 */
  10
  11     /* Remove the last char from a string. */
  12     /* Returns the length of the chopped string.*/
  13
  14     assert( string != NULL );
  15     assert( string[ 0 ] != '\0' );
  16
  17     size_t len;
  18
  19     len = strlen( string );
  20
  21     string[ len - 1 ] = '\0';
  22
  23     return len - 1;
  24 }
  25
  26
  27 size_t chomp( char *string )
  28 {
  29     /* Martin A. Hansen, June 2008 */
  30
  31     /* Removes the last char from a string if the char is a newline. */
  32     /* Returns the length of the chomped string or -1 is no newline was found. */
  33
  34     size_t len;
  35
  36     assert( string != NULL );
  37     assert( string[ 0 ] != '\0' );
  38
  39     len = strlen( string );
  40
  41     if ( string[ len - 1 ] == '\n' )
  42     {
  43         string[ len - 1 ] = '\0';
  44
  45         return len - 1;
  46     }
  47     else
  48     {
  49         return -1;
  50     }
  51 }
  52
  53
  54 size_t strchr_total( const char *string, const char c )
  55 {
  56     /* Martin A. Hansen, September 2008 */
  57
  58     /* Returns the total number of a given char in a given string. */
  59
  60     int count[ 256 ] = { 0 };   /* Integer array spanning the ASCII alphabet */
  61     int i;
  62
  63     for ( i = 0; i < strlen( string ); i++ ) {
  64         count[ ( int ) string[ i ] ]++;
  65     }
  66
  67     return count[ ( int ) c ];
  68 }
  69
  70
  71 size_t match_substr( size_t pos, char *str, size_t str_len, char *substr, size_t substr_len, size_t mismatch )
  72 {
  73     /* Martin A. Hansen, August 2008 */
  74
  75     /* Locate a substr in a str starting at pos allowing for a given number of mismatches. */
  76     /* Returns position of match begin or -1 if not found. */
  77
  78     size_t i;
  79     size_t j;
  80     size_t count;
  81
  82     assert( pos >= 0 );
  83     assert( pos < str_len );
  84     assert( str != NULL );
  85     assert( substr != NULL );
  86     assert( str_len > 0 );
  87     assert( substr_len > 0 );
  88     assert( strlen( str ) == str_len );
  89     assert( strlen( substr ) == substr_len );
  90     assert( mismatch >= 0 );
  91     assert( mismatch < substr_len );
  92     assert( substr_len <= str_len );
  93     assert( str[ str_len ] == '\0' );
  94     assert( substr[ substr_len ] == '\0' );
  95
  96     for ( i = pos; i < str_len - substr_len + 1; i++ )
  97     {
  98         count = 0;
  99
 100         for ( j = 0; j < substr_len; j++ )
 101         {
 102             if ( str[ i + j ] != substr[ j ] )
 103             {
 104                 count++;
 105
 106                 if ( count > mismatch ) {
 107                     break;
 108                 }
 109             }
 110         }
 111
 112         if ( count <= mismatch ) {
 113             return i;
 114         }
 115     }
 116
 117     return -1;
 118 }
 119
 120
 121 size_t match_substr_rev( size_t pos, char *str, size_t str_len, char *substr, size_t substr_len, size_t mismatch )
 122 {
 123     /* Martin A. Hansen, August 2008 */
 124
 125     /* Locate a substr in a str backwards starting at the end of */
 126     /* str minus pos allowing for a given number of mismatches. */
 127     /* Returns position of match begin or -1 if not found. */
 128
 129     size_t i;
 130     size_t j;
 131     size_t count;
 132
 133     assert( pos >= 0 );
 134     assert( pos < str_len );
 135     assert( str != NULL );
 136     assert( substr != NULL );
 137     assert( str_len > 0 );
 138     assert( substr_len > 0 );
 139     assert( strlen( str ) == str_len );
 140     assert( strlen( substr ) == substr_len );
 141     assert( mismatch >= 0 );
 142     assert( mismatch < substr_len );
 143     assert( substr_len <= str_len );
 144     assert( str[ str_len ] == '\0' );
 145     assert( substr[ substr_len ] == '\0' );
 146
 147     for ( i = str_len - pos - 1; i >= substr_len - 1; i-- )
 148     {
 149         count = 0;
 150
 151         for ( j = substr_len - 1; j > 0; j-- )
 152         {
 153             if ( str[ i - ( substr_len - j - 1 ) ] != substr[ j ] )
 154             {
 155                 /* printf( "i:%ld  j:%ld  count:%ld  str:%c  substr:%c\n", i, j, count, str[ i - ( substr_len - j - 1 ) ], substr[ j ] ); // DEBUG */
 156                 count++;
 157
 158                 if ( count > mismatch ) {
 159                     break;
 160                 }
 161             }
 162         }
 163
 164         if ( count <= mismatch ) {
 165             return i - substr_len + 1;
 166         }
 167     }
 168
 169     return -1;
 170 }
 171
 172