code_c/Maasha/src/lib/strings.c

   1 #include "common.h"
   2 #include "strings.h"
   3
   4
   5 size_t chop( char *string )
   6 {
   7     /* Martin A. Hansen, June 2008 */
   8
   9     /* Unit test done.*/
  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     /* Unit test done.*/
  32
  33     /* Removes the last char from a string if the char is a newline. */
  34     /* Returns the length of the chomped string or -1 is no newline was found. */
  35
  36     int len;
  37
  38     assert( string != NULL );
  39     assert( string[ 0 ] != '\0' );
  40
  41     len = strlen( string );
  42
  43     if ( string[ len - 1 ] == '\n' )
  44     {
  45         string[ len - 1 ] = '\0';
  46
  47         return len - 1;
  48     }
  49     else
  50     {
  51         return -1;
  52     }
  53 }
  54
  55
  56 size_t match_substr( size_t pos, char *str, size_t str_len, char *substr, size_t substr_len, size_t mismatch )
  57 {
  58     /* Martin A. Hansen, August 2008. */
  59
  60     /* Unit test done.*/
  61
  62     /* Locate a substr in a str starting at pos allowing for a given number of mismatches. */
  63     /* Returns position of match begin or -1 if not found. */
  64
  65     size_t i;
  66     size_t j;
  67     size_t count;
  68
  69     assert( pos >= 0 );
  70     assert( pos < str_len );
  71     assert( str != NULL );
  72     assert( substr != NULL );
  73     assert( str_len > 0 );
  74     assert( substr_len > 0 );
  75     assert( strlen( str ) == str_len );
  76     assert( strlen( substr ) == substr_len );
  77     assert( mismatch >= 0 );
  78     assert( mismatch < substr_len );
  79     assert( substr_len <= str_len );
  80     assert( str[ str_len ] == '\0' );
  81     assert( substr[ substr_len ] == '\0' );
  82
  83     for ( i = pos; i < str_len - substr_len + 1; i++ )
  84     {
  85         count = 0;
  86
  87         for ( j = 0; j < substr_len; j++ )
  88         {
  89             if ( str[ i + j ] != substr[ j ] )
  90             {
  91                 count++;
  92
  93                 if ( count > mismatch ) {
  94                     break;
  95                 }
  96             }
  97         }
  98
  99         if ( count <= mismatch ) {
 100             return i;
 101         }
 102     }
 103
 104     return -1;
 105 }
 106
 107
 108 size_t match_substr_rev( size_t pos, char *str, size_t str_len, char *substr, size_t substr_len, size_t mismatch )
 109 {
 110     /* Martin A. Hansen, August 2008. */
 111
 112     /* Unit test done.*/
 113
 114     /* Locate a substr in a str backwards starting at the end of */
 115     /* str minus pos allowing for a given number of mismatches. */
 116     /* Returns position of match begin or -1 if not found. */
 117
 118     size_t i;
 119     size_t j;
 120     size_t count;
 121
 122     assert( pos >= 0 );
 123     assert( pos < str_len );
 124     assert( str != NULL );
 125     assert( substr != NULL );
 126     assert( str_len > 0 );
 127     assert( substr_len > 0 );
 128     assert( strlen( str ) == str_len );
 129     assert( strlen( substr ) == substr_len );
 130     assert( mismatch >= 0 );
 131     assert( mismatch < substr_len );
 132     assert( substr_len <= str_len );
 133     assert( str[ str_len ] == '\0' );
 134     assert( substr[ substr_len ] == '\0' );
 135
 136     for ( i = str_len - pos - 1; i >= substr_len - 1; i-- )
 137     {
 138         count = 0;
 139
 140         for ( j = substr_len - 1; j > 0; j-- )
 141         {
 142             if ( str[ i - ( substr_len - j - 1 ) ] != substr[ j ] )
 143             {
 144                 /* printf( "i:%ld  j:%ld  count:%ld  str:%c  substr:%c\n", i, j, count, str[ i - ( substr_len - j - 1 ) ], substr[ j ] ); // DEBUG */
 145                 count++;
 146
 147                 if ( count > mismatch ) {
 148                     break;
 149                 }
 150             }
 151         }
 152
 153         if ( count <= mismatch ) {
 154             return i - substr_len + 1;
 155         }
 156     }
 157
 158     return -1;
 159 }