API tools faq
paste
pmc0903

x_str.h - string functions

pmc0903
Aug 9th, 2025 (edited)
841
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 6.60 KB | Source Code | 0 0
raw download clone embed print report
  1. // 2025-08-10a
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5.  
  6. unsigned char gi_str_uc[256] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255};
  7. unsigned char gi_str_lc[256] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255};
  8.  
  9. char* x_sfn_str_cat(char* ps_1, char* ps_2) {
  10.     // 2021-09-01
  11.     long    i_len;
  12.     i_len = strlen(ps_1)+strlen(ps_2)+1;
  13.     char*   ps_r = malloc(i_len);
  14.     strcpy(ps_r,ps_1);
  15.     strcat(ps_r,ps_2);
  16.     return(ps_r);
  17. }
  18. char* x_sfn_str_upper(char* ps_1) {
  19.     // 2021-12-21
  20.     long i_len = strlen(ps_1)+1;
  21.     char* ps_r = malloc(i_len);
  22.     strcpy(ps_r,ps_1);
  23.     unsigned long i;
  24.     unsigned char j;
  25.     for (i = 0; ps_r[i] != 0; i++) {
  26.         j = ps_r[i];
  27.         ps_r[i] = gi_str_uc[j];
  28.     }
  29.     ps_r[i_len] = 0;
  30.     return(ps_r);
  31. }
  32. void x_fn_str_upper(char* ps_1) {
  33.     // 2021-12-21
  34.     unsigned long i;
  35.     unsigned char j;
  36.     for (i = 0; ps_1[i] != 0; i++) {
  37.         j = ps_1[i];
  38.         ps_1[i] = gi_str_uc[j];
  39.     }
  40. }
  41. char* x_sfn_str_lower(char* ps_1) {
  42.     // 2021-12-21
  43.     long i_len = strlen(ps_1)+1;
  44.     char* ps_r = malloc(i_len);
  45.     strcpy(ps_r,ps_1);
  46.     unsigned long i;
  47.     unsigned char j;
  48.     for (i = 0; ps_r[i] != 0; i++) {
  49.         j = ps_r[i];
  50.         ps_r[i] = gi_str_lc[j];
  51.     }
  52.     ps_r[i_len] = 0;
  53.     return(ps_r);
  54. }
  55. void x_fn_str_lower(char* ps_1) {
  56.     // 2021-12-21
  57.     unsigned long i;
  58.     unsigned char j;
  59.     for (i = 0; ps_1[i] != 0; i++) {
  60.         j = ps_1[i];
  61.         ps_1[i] = gi_str_lc[j];
  62.     }
  63. }
  64. char* x_sfn_str_left(char* ps_1, unsigned long pi) {
  65.     // 2021-12-21
  66.     unsigned long i_len = strlen(ps_1);
  67.     if ( i_len < pi ) { pi = i_len; }
  68.     char* ps_r = malloc(pi+1);
  69.     strncpy(ps_r,ps_1,pi);
  70.     ps_r[pi] = 0;
  71.     return(ps_r);
  72. }
  73. char* x_sfn_str_right(char* ps_1, unsigned long pi) {
  74.     // 2021-12-21
  75.     unsigned long i_len = strlen(ps_1);
  76.     if ( i_len < pi ) { pi = i_len; }
  77.     char* ps_r = malloc(pi+1);
  78.     strncpy(ps_r,&ps_1[i_len-pi],pi);
  79.     ps_r[pi] = 0;
  80.     return(ps_r);
  81. }
  82. void x_fn_str_reverse(char* ps_1) {
  83.     // 2021-12-21
  84.     char c;
  85.     unsigned long i;
  86.     unsigned long i_len = strlen(ps_1);
  87.     unsigned long i_len_half = (i_len/2);
  88.     for (i = 0; i < i_len_half; i++) {
  89.         c = ps_1[i];
  90.         ps_1[i] = ps_1[i_len - i - 1];
  91.         ps_1[i_len - i - 1] = c;
  92.     }
  93. }
  94. char* x_sfn_str_reverse(char* ps_1) {
  95.     // 2021-12-21
  96.     unsigned long i;
  97.     unsigned long i_len = strlen(ps_1);
  98.     unsigned long i_len_half = (i_len/2);
  99.     char* ps_r = malloc(i_len+1);
  100.     for (i=0; i < i_len_half; i++) {
  101.         ps_r[i] = ps_1[i_len - i - 1];
  102.         ps_r[i_len - i - 1] = ps_1[i];
  103.     }
  104.     if ((i_len % 2) == 1) {
  105.         ps_r[(i_len_half)] = ps_1[(i_len_half)];
  106.     }
  107.     ps_r[i_len] = 0;
  108.     return(ps_r);
  109. }
  110. char* x_sfn_str_left_chr(char* ps_1, char c) {
  111.     // 2021-12-21
  112.     unsigned long i_len = strlen(ps_1);
  113.     char* s_2 = strchr(ps_1,c);
  114.     unsigned long i = 0;
  115.     char* ps_r = NULL;
  116.     if (s_2 != NULL) {
  117.         i = s_2 - ps_1;
  118.         if (i_len < i) {i = i_len;}
  119.         ps_r = malloc(i+1);
  120.         strncpy(ps_r,ps_1,i);
  121.         ps_r[i] = 0;
  122.     }
  123.     return(ps_r);
  124. }
  125. char* x_sfn_str_right_chr(char* ps_1, char c) {
  126.     // 2021-12-21
  127.     // unsigned long i_len = strlen(ps_1);
  128.     char* s_2_alloc = strdup(ps_1);
  129.     x_fn_str_reverse(s_2_alloc);
  130.     char* ps_r = x_sfn_str_left_chr(s_2_alloc,c);
  131.     if ( ps_r != NULL ) {
  132.         x_fn_str_reverse(ps_r);
  133.     }
  134.     free(s_2_alloc);
  135.     return(ps_r);
  136. }
  137. long x_ifn_str_index_chr(char* ps_1, char c) {
  138.     char* s_2 = strchr(ps_1,c);
  139.     unsigned long i_r = -1;
  140.     if (s_2 != NULL) {
  141.         i_r = s_2 - ps_1;
  142.     }
  143.     return(i_r);
  144. }
  145. long x_ifn_str_index(char* ps_1, char* ps_2) {
  146.     char* s_2 = strstr(ps_1,ps_2);
  147.     unsigned long i_r = -1;
  148.     if (s_2 != NULL) {
  149.         i_r = s_2 - ps_1;
  150.     }
  151.     return(i_r);
  152. }
  153. char* x_sfn_str_substr(char* ps_1, long pi_idx, long pi_len ) {
  154.     unsigned long i_idx = pi_idx;
  155.     unsigned long i_len = strlen(ps_1);
  156.     if ( pi_idx < 0 ) {
  157.         i_idx = i_len + pi_idx;
  158.         i_len = 0 - pi_idx;
  159.     } else {
  160.         i_len = i_len - pi_idx;
  161.     }
  162.     if ( pi_len < 1 ) {
  163.         i_len = i_len + pi_len;
  164.     } else {
  165.         i_len = pi_len;
  166.     }
  167.     char* ps_r = malloc(i_len+1);
  168.     strncpy(ps_r,&ps_1[i_idx],i_len);
  169.     ps_r[i_len] = 0;
  170.     return(ps_r);
  171. }
  172. unsigned long x_ifn_str_replace_chr( char* ps, char ps_find, char ps_replace ) {
  173.     // 2025-08-10
  174.     // Replace all occurences of a single character {ps_find} in string {ps} with a single character {ps_replace}
  175.     // - modifies the supplied string
  176.     // - returns number of replacements made
  177.     unsigned long i_count = 0;
  178.     char *s_pos = strchr( ps, ps_find );
  179.     while ( s_pos ) {
  180.         i_count++;
  181.         *s_pos = ps_replace;
  182.         s_pos = strchr (s_pos + 1, ps_find);
  183.     }
  184.     return( i_count );
  185. }
  186.  
Tags: strings
Advertisement
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!