1
0

str.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511
  1. /** @file str.c
  2. * @brief String related functions
  3. *
  4. * This file implements some often used string functions.
  5. * Some functions are more portable versions of standard
  6. * functions but others are original ones.
  7. */
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include "faux/ctype.h"
  11. #include "faux/str.h"
  12. /* TODO: Are that vars really needed? */
  13. //const char *lub_string_esc_default = "`|$<>&()#;\\\"!";
  14. //const char *lub_string_esc_regex = "^$.*+[](){}";
  15. //const char *lub_string_esc_quoted = "\\\"";
  16. /** @brief Free the memory allocated for the string.
  17. *
  18. * Safely free the memory allocated for the string. You can use NULL
  19. * pointer with this function. POSIX's free() checks for the NULL pointer
  20. * but not all systems do so.
  21. *
  22. * @param [in] str String to free
  23. */
  24. void faux_str_free(char *str) {
  25. faux_free(str);
  26. }
  27. /** @brief Duplicates the string.
  28. *
  29. * Duplicates the string. Same as standard strdup() function. Allocates
  30. * memory with malloc(). Checks for NULL pointer.
  31. *
  32. * @warning Resulting string must be freed by faux_str_free().
  33. *
  34. * @param [in] str String to duplicate.
  35. * @return Pointer to allocated string or NULL.
  36. */
  37. char *faux_str_dup(const char *str) {
  38. if (!str)
  39. return NULL;
  40. return strdup(str);
  41. }
  42. /** @brief Duplicates the first n bytes of the string.
  43. *
  44. * Duplicates at most n bytes of the string. Allocates
  45. * memory with malloc(). Checks for NULL pointer. Function will allocate
  46. * n + 1 bytes to store string and terminating null byte.
  47. *
  48. * @warning Resulting string must be freed by faux_str_free().
  49. *
  50. * @param [in] str String to duplicate.
  51. * @param [in] n Number of bytes to copy.
  52. * @return Pointer to allocated string or NULL.
  53. */
  54. char *faux_str_dupn(const char *str, size_t n) {
  55. char *res = NULL;
  56. size_t len = 0;
  57. if (!str)
  58. return NULL;
  59. len = strlen(str);
  60. len = (len < n) ? len : n;
  61. res = faux_zmalloc(len + 1);
  62. if (!res)
  63. return NULL;
  64. strncpy(res, str, len);
  65. res[len] = '\0';
  66. return res;
  67. }
  68. /** @brief Generates lowercase copy of input string.
  69. *
  70. * Allocates the copy of input string and convert that copy to lowercase.
  71. *
  72. * @warning Resulting string must be freed by faux_str_free().
  73. *
  74. * @param [in] str String to convert.
  75. * @return Pointer to lowercase string copy or NULL.
  76. */
  77. char *faux_str_tolower(const char *str)
  78. {
  79. char *res = faux_str_dup(str);
  80. char *p = res;
  81. if (!res)
  82. return NULL;
  83. while (*p) {
  84. *p = faux_ctype_tolower(*p);
  85. p++;
  86. }
  87. return res;
  88. }
  89. /** @brief Generates uppercase copy of input string.
  90. *
  91. * Allocates the copy of input string and convert that copy to uppercase.
  92. *
  93. * @warning Resulting string must be freed by faux_str_free().
  94. *
  95. * @param [in] str String to convert.
  96. * @return Pointer to lowercase string copy or NULL.
  97. */
  98. char *faux_str_toupper(const char *str)
  99. {
  100. char *res = faux_str_dup(str);
  101. char *p = res;
  102. if (!res)
  103. return NULL;
  104. while (*p) {
  105. *p = faux_ctype_toupper(*p);
  106. p++;
  107. }
  108. return res;
  109. }
  110. /** @brief Add n bytes of text to existent string.
  111. *
  112. * Concatenate two strings. Add n bytes of second string to the end of the
  113. * first one. The first argument is address of string pointer. The pointer
  114. * can be changed due to realloc() features. The first pointer can be NULL.
  115. * In this case the memory will be malloc()-ed and stored to the first pointer.
  116. *
  117. * @param [in,out] str Address of first string pointer.
  118. * @param [in] text Text to add to the first string.
  119. * @param [in] n Number of bytes to add.
  120. * @return Pointer to resulting string or NULL.
  121. */
  122. char *faux_str_catn(char **str, const char *text, size_t n) {
  123. size_t str_len = 0;
  124. size_t text_len = 0;
  125. char *res = NULL;
  126. char *p = NULL;
  127. if (!text)
  128. return *str;
  129. str_len = (*str) ? strlen(*str) : 0;
  130. text_len = strlen(text);
  131. text_len = (text_len < n) ? text_len : n;
  132. res = realloc(*str, str_len + text_len + 1);
  133. if (!res)
  134. return NULL;
  135. p = res + str_len;
  136. strncpy(p, text, text_len);
  137. p[text_len] = '\0';
  138. *str = res;
  139. return res;
  140. }
  141. /** @brief Add some text to existent string.
  142. *
  143. * Concatenate two strings. Add second string to the end of the first one.
  144. * The first argument is address of string pointer. The pointer can be
  145. * changed due to realloc() features. The first pointer can be NULL. In this
  146. * case the memory will be malloc()-ed and stored to the first pointer.
  147. *
  148. * @param [in,out] str Address of first string pointer.
  149. * @param [in] text Text to add to the first string.
  150. * @return Pointer to resulting string or NULL.
  151. */
  152. char *faux_str_cat(char **str, const char *text) {
  153. size_t len = 0;
  154. if (!text)
  155. return *str;
  156. len = strlen(text);
  157. return faux_str_catn(str, text, len);
  158. }
  159. /** @brief Service function to compare to chars in right way.
  160. *
  161. * The problem is char type can be signed or unsigned on different
  162. * platforms. So stright comparision can return different results.
  163. *
  164. * @param [in] char1 First char
  165. * @param [in] char2 Second char
  166. * @return
  167. * < 0 if char1 < char2
  168. * = 0 if char1 = char2
  169. * > 0 if char1 > char2
  170. */
  171. static int faux_str_cmp_chars(char char1, char char2) {
  172. unsigned char ch1 = (unsigned char)char1;
  173. unsigned char ch2 = (unsigned char)char2;
  174. return (int)ch1 - (int)ch2;
  175. }
  176. /** @brief Compare n first characters of two strings ignoring case.
  177. *
  178. * The difference beetween this function an standard strncasecmp() is
  179. * faux function uses faux ctype functions. It can be important for
  180. * portability.
  181. *
  182. * @param [in] str1 First string to compare.
  183. * @param [in] str2 Second string to compare.
  184. * @param [in] n Number of characters to compare.
  185. * @return < 0, 0, > 0, see the strcasecmp().
  186. */
  187. int faux_str_ncasecmp(const char *str1, const char *str2, size_t n) {
  188. const char *p1 = str1;
  189. const char *p2 = str2;
  190. size_t num = n;
  191. while (*p1 != '\0' && *p2 != '\0' && num != 0) {
  192. int res = faux_str_cmp_chars(faux_ctype_tolower(*p1),
  193. faux_ctype_tolower(*p2));
  194. if (res != 0)
  195. return res;
  196. p1++;
  197. p2++;
  198. num--;
  199. }
  200. if (0 == n) // It means n first characters are equal.
  201. return 0;
  202. return faux_str_cmp_chars(faux_ctype_tolower(*p1),
  203. faux_ctype_tolower(*p2));
  204. }
  205. /** @brief Compare two strings ignoring case.
  206. *
  207. * The difference beetween this function an standard strcasecmp() is
  208. * faux function uses faux ctype functions. It can be important for
  209. * portability.
  210. *
  211. * @param [in] str1 First string to compare.
  212. * @param [in] str2 Second string to compare.
  213. * @return < 0, 0, > 0, see the strcasecmp().
  214. */
  215. int faux_str_casecmp(const char *str1, const char *str2) {
  216. const char *p1 = str1;
  217. const char *p2 = str2;
  218. while (*p1 != '\0' && *p2 != '\0') {
  219. int res = faux_str_cmp_chars(faux_ctype_tolower(*p1),
  220. faux_ctype_tolower(*p2));
  221. if (res != 0)
  222. return res;
  223. p1++;
  224. p2++;
  225. }
  226. return faux_str_cmp_chars(faux_ctype_tolower(*p1),
  227. faux_ctype_tolower(*p2));
  228. }
  229. const char *lub_string_nocasestr(const char *cs, const char *ct)
  230. {
  231. const char *p = NULL;
  232. const char *result = NULL;
  233. while (*cs) {
  234. const char *q = cs;
  235. p = ct;
  236. while (*p && *q
  237. && (faux_ctype_tolower(*p) == faux_ctype_tolower(*q))) {
  238. p++, q++;
  239. }
  240. if (0 == *p) {
  241. break;
  242. }
  243. cs++;
  244. }
  245. if (p && !*p) {
  246. result = cs;
  247. }
  248. return result;
  249. }
  250. // TODO: Is it needed?
  251. /*
  252. char *lub_string_ndecode(const char *string, unsigned int len)
  253. {
  254. const char *s = string;
  255. char *res, *p;
  256. int esc = 0;
  257. if (!string)
  258. return NULL;
  259. p = res = faux_zmalloc(len + 1);
  260. while (*s && (s < (string +len))) {
  261. if (!esc) {
  262. if ('\\' == *s)
  263. esc = 1;
  264. else
  265. *p = *s;
  266. } else {
  267. // switch (*s) {
  268. // case 'r':
  269. // case 'n':
  270. // *p = '\n';
  271. // break;
  272. // case 't':
  273. // *p = '\t';
  274. // break;
  275. // default:
  276. // *p = *s;
  277. // break;
  278. // }
  279. // *p = *s;
  280. esc = 0;
  281. }
  282. if (!esc)
  283. p++;
  284. s++;
  285. }
  286. *p = '\0';
  287. return res;
  288. }
  289. */
  290. // TODO: Is it needed?
  291. /*
  292. inline char *lub_string_decode(const char *string)
  293. {
  294. return lub_string_ndecode(string, strlen(string));
  295. }
  296. */
  297. // TODO: Is it needed?
  298. /*----------------------------------------------------------- */
  299. /*
  300. * This needs to escape any dangerous characters within the command line
  301. * to prevent gaining access to the underlying system shell.
  302. */
  303. /*
  304. char *lub_string_encode(const char *string, const char *escape_chars)
  305. {
  306. char *result = NULL;
  307. const char *p;
  308. if (!escape_chars)
  309. return lub_string_dup(string);
  310. if (string && !(*string)) // Empty string
  311. return lub_string_dup(string);
  312. for (p = string; p && *p; p++) {
  313. // find any special characters and prefix them with '\'
  314. size_t len = strcspn(p, escape_chars);
  315. lub_string_catn(&result, p, len);
  316. p += len;
  317. if (*p) {
  318. lub_string_catn(&result, "\\", 1);
  319. lub_string_catn(&result, p, 1);
  320. } else {
  321. break;
  322. }
  323. }
  324. return result;
  325. }
  326. */
  327. // TODO: Is it needed?
  328. /*--------------------------------------------------------- */
  329. /*
  330. unsigned int lub_string_equal_part(const char *str1, const char *str2,
  331. bool_t utf8)
  332. {
  333. unsigned int cnt = 0;
  334. if (!str1 || !str2)
  335. return cnt;
  336. while (*str1 && *str2) {
  337. if (*str1 != *str2)
  338. break;
  339. cnt++;
  340. str1++;
  341. str2++;
  342. }
  343. if (!utf8)
  344. return cnt;
  345. // UTF8 features
  346. if (cnt && (UTF8_11 == (*(str1 - 1) & UTF8_MASK)))
  347. cnt--;
  348. return cnt;
  349. }
  350. */
  351. // TODO: Is it needed?
  352. /*--------------------------------------------------------- */
  353. /*
  354. const char *lub_string_suffix(const char *string)
  355. {
  356. const char *p1, *p2;
  357. p1 = p2 = string;
  358. while (*p1) {
  359. if (faux_ctype_isspace(*p1)) {
  360. p2 = p1;
  361. p2++;
  362. }
  363. p1++;
  364. }
  365. return p2;
  366. }
  367. */
  368. // TODO: Is it needed?
  369. /*--------------------------------------------------------- */
  370. /*
  371. const char *lub_string_nextword(const char *string,
  372. size_t *len, size_t *offset, size_t *quoted)
  373. {
  374. const char *word;
  375. *quoted = 0;
  376. // Find the start of a word (not including an opening quote)
  377. while (*string && isspace(*string)) {
  378. string++;
  379. (*offset)++;
  380. }
  381. // Is this the start of a quoted string ?
  382. if (*string == '"') {
  383. *quoted = 1;
  384. string++;
  385. }
  386. word = string;
  387. *len = 0;
  388. // Find the end of the word
  389. while (*string) {
  390. if (*string == '\\') {
  391. string++;
  392. (*len)++;
  393. if (*string) {
  394. (*len)++;
  395. string++;
  396. }
  397. continue;
  398. }
  399. // End of word
  400. if (!*quoted && isspace(*string))
  401. break;
  402. if (*string == '"') {
  403. // End of a quoted string
  404. *quoted = 2;
  405. break;
  406. }
  407. (*len)++;
  408. string++;
  409. }
  410. return word;
  411. }
  412. */
  413. // TODO: Is it needed?
  414. /*--------------------------------------------------------- */
  415. /*
  416. unsigned int lub_string_wordcount(const char *line)
  417. {
  418. const char *word;
  419. unsigned int result = 0;
  420. size_t len = 0, offset = 0;
  421. size_t quoted;
  422. for (word = lub_string_nextword(line, &len, &offset, &quoted);
  423. *word || quoted;
  424. word = lub_string_nextword(word + len, &len, &offset, &quoted)) {
  425. // account for the terminating quotation mark
  426. len += quoted ? quoted - 1 : 0;
  427. result++;
  428. }
  429. return result;
  430. }
  431. */