strutil.h 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611
  1. #ifndef MC_STRUTIL_H
  2. #define MC_STRUTIL_H
  3. #include "lib/global.h" /* include glib.h */
  4. #include <sys/types.h>
  5. #include <inttypes.h>
  6. #include <string.h>
  7. #ifdef HAVE_ASSERT_H
  8. #include <assert.h> /* assert() */
  9. #endif
  10. /* Header file for strutil.c, strutilascii.c, strutil8bit.c, strutilutf8.c.
  11. * There are two sort of functions:
  12. * 1. functions for working with growing strings and conversion strings between
  13. * different encodings.
  14. * (implemented directly in strutil.c)
  15. * 2. functions, that hide differences between encodings derived from ASCII.
  16. * (implemented separately in strutilascii.c, strutil8bit.c, strutilutf8.c)
  17. * documentation is made for UTF-8 version of functions.
  18. */
  19. /* invalid strings
  20. * function, that works with invalid strings are marked with "I"
  21. * in documentation
  22. * invalid bytes of string are handled as one byte characters with width 1, they
  23. * are displayed as questionmarks, I-maked comparing functions try to keep
  24. * the original value of these bytes.
  25. */
  26. /* combining characters
  27. * displaynig: all handled as zero with characters, expect combing character
  28. * at the begin of string, this character has with one (space add before),
  29. * so str_term_width is not good for computing width of singles characters
  30. * (never return zero, expect emtpy string)
  31. * for compatibility are strings composed before displaynig
  32. * comparing: comparing decompose all string before comparing, n-compare
  33. * functions do not work as is usual, because same strings do not have to be
  34. * same length in UTF-8. So they return 0 if one string is prefix of the other
  35. * one.
  36. * str_prefix is used to determine, how many characters from one string are
  37. * prefix in second string. However, str_prefix return number of characters in
  38. * decompose form. (used in do_search (screen.c))
  39. */
  40. /*** typedefs(not structures) and defined constants **********************************************/
  41. #define IS_FIT(x) ((x) & 0x0010)
  42. #define MAKE_FIT(x) ((x) | 0x0010)
  43. #define HIDE_FIT(x) ((x) & 0x000f)
  44. #define INVALID_CONV ((GIConv) (-1))
  45. /*** enums ***************************************************************************************/
  46. /* results of conversion function
  47. */
  48. typedef enum
  49. {
  50. /* success means, that convertion has been finished successully
  51. */
  52. ESTR_SUCCESS = 0,
  53. /* problem means, that not every characters was successfully converted (They are
  54. * replaced with questionmark). So is impossible convert string back.
  55. */
  56. ESTR_PROBLEM = 1,
  57. /* failure means, that conversion is not possible (example: wrong encoding
  58. * of input string)
  59. */
  60. ESTR_FAILURE = 2
  61. } estr_t;
  62. /* alignment strings on terminal
  63. */
  64. typedef enum
  65. {
  66. J_LEFT = 0x01,
  67. J_RIGHT = 0x02,
  68. J_CENTER = 0x03,
  69. /* if there is enough space for string on terminal,
  70. * string is centered otherwise is aligned to left */
  71. J_CENTER_LEFT = 0x04,
  72. /* fit alignment, if string is to long, is truncated with '~' */
  73. J_LEFT_FIT = 0x11,
  74. J_RIGHT_FIT = 0x12,
  75. J_CENTER_FIT = 0x13,
  76. J_CENTER_LEFT_FIT = 0x14
  77. } align_crt_t;
  78. /* string-to-integer parsing results
  79. */
  80. typedef enum
  81. {
  82. LONGINT_OK = 0,
  83. /* These two values can be ORed together, to indicate that both errors occurred. */
  84. LONGINT_OVERFLOW = 1,
  85. LONGINT_INVALID_SUFFIX_CHAR = 2,
  86. LONGINT_INVALID_SUFFIX_CHAR_WITH_OVERFLOW = (LONGINT_INVALID_SUFFIX_CHAR | LONGINT_OVERFLOW),
  87. LONGINT_INVALID = 4
  88. } strtol_error_t;
  89. /*** structures declarations (and typedefs of structures)*****************************************/
  90. /* all functions in str_class must be defined for every encoding */
  91. struct str_class
  92. {
  93. gchar *(*conv_gerror_message) (GError * error, const char *def_msg);
  94. /*I*/ estr_t (*vfs_convert_to) (GIConv coder, const char *string, int size, GString * buffer);
  95. /*I*/ void (*insert_replace_char) (GString * buffer);
  96. int (*is_valid_string) (const char *);
  97. /*I*/ int (*is_valid_char) (const char *, size_t);
  98. /*I*/ void (*cnext_char) (const char **);
  99. void (*cprev_char) (const char **);
  100. void (*cnext_char_safe) (const char **);
  101. /*I*/ void (*cprev_char_safe) (const char **);
  102. /*I*/ int (*cnext_noncomb_char) (const char **text);
  103. /*I*/ int (*cprev_noncomb_char) (const char **text, const char *begin);
  104. /*I*/ int (*char_isspace) (const char *);
  105. /*I*/ int (*char_ispunct) (const char *);
  106. /*I*/ int (*char_isalnum) (const char *);
  107. /*I*/ int (*char_isdigit) (const char *);
  108. /*I*/ int (*char_isprint) (const char *);
  109. /*I*/ gboolean (*char_iscombiningmark) (const char *);
  110. /*I*/ int (*length) (const char *);
  111. /*I*/ int (*length2) (const char *, int);
  112. /*I*/ int (*length_noncomb) (const char *);
  113. /*I*/ int (*char_toupper) (const char *, char **, size_t *);
  114. int (*char_tolower) (const char *, char **, size_t *);
  115. void (*fix_string) (char *);
  116. /*I*/ const char *(*term_form) (const char *);
  117. /*I*/ const char *(*fit_to_term) (const char *, int, align_crt_t);
  118. /*I*/ const char *(*term_trim) (const char *text, int width);
  119. /*I*/ const char *(*term_substring) (const char *, int, int);
  120. /*I*/ int (*term_width1) (const char *);
  121. /*I*/ int (*term_width2) (const char *, size_t);
  122. /*I*/ int (*term_char_width) (const char *);
  123. /*I*/ const char *(*trunc) (const char *, int);
  124. /*I*/ int (*offset_to_pos) (const char *, size_t);
  125. /*I*/ int (*column_to_pos) (const char *, size_t);
  126. /*I*/ char *(*create_search_needle) (const char *, int);
  127. void (*release_search_needle) (char *, int);
  128. const char *(*search_first) (const char *, const char *, int);
  129. const char *(*search_last) (const char *, const char *, int);
  130. int (*compare) (const char *, const char *);
  131. /*I*/ int (*ncompare) (const char *, const char *);
  132. /*I*/ int (*casecmp) (const char *, const char *);
  133. /*I*/ int (*ncasecmp) (const char *, const char *);
  134. /*I*/ int (*prefix) (const char *, const char *);
  135. /*I*/ int (*caseprefix) (const char *, const char *);
  136. /*I*/ char *(*create_key) (const char *text, int case_sen);
  137. /*I*/ char *(*create_key_for_filename) (const char *text, int case_sen);
  138. /*I*/ int (*key_collate) (const char *t1, const char *t2, int case_sen);
  139. /*I*/ void (*release_key) (char *key, int case_sen);
  140. /*I*/};
  141. /*** global variables defined in .c file *********************************************************/
  142. /* standard convertors */
  143. extern GIConv str_cnv_to_term;
  144. extern GIConv str_cnv_from_term;
  145. /* from terminal encoding to terminal encoding */
  146. extern GIConv str_cnv_not_convert;
  147. /*** declarations of public functions ************************************************************/
  148. struct str_class str_utf8_init (void);
  149. struct str_class str_8bit_init (void);
  150. struct str_class str_ascii_init (void);
  151. /* create convertor from "from_enc" to terminal encoding
  152. * if "from_enc" is not supported return INVALID_CONV
  153. */
  154. GIConv str_crt_conv_from (const char *);
  155. /* create convertor from terminal encoding to "to_enc"
  156. * if "to_enc" is not supported return INVALID_CONV
  157. */
  158. GIConv str_crt_conv_to (const char *);
  159. /* close convertor, do not close str_cnv_to_term, str_cnv_from_term,
  160. * str_cnv_not_convert
  161. */
  162. void str_close_conv (GIConv);
  163. /* return on of not used buffers (.used == 0) or create new
  164. * returned buffer has set .used to 1
  165. */
  166. /* convert string using coder, result of conversion is appended at end of buffer
  167. * return ESTR_SUCCESS if there was no problem.
  168. * otherwise return ESTR_PROBLEM or ESTR_FAILURE
  169. */
  170. estr_t str_convert (GIConv, const char *, GString *);
  171. estr_t str_nconvert (GIConv, const char *, int, GString *);
  172. /* convert GError message (which in UTF-8) to terminal charset
  173. * def_char is used if result of error->str conversion if ESTR_FAILURE
  174. * return new allocated null-terminated string, which is need to be freed
  175. * I
  176. */
  177. gchar *str_conv_gerror_message (GError * error, const char *def_msg);
  178. /* return only ESTR_SUCCESS or ESTR_FAILURE, because vfs must be able to convert
  179. * result to original string. (so no replace with questionmark)
  180. * if coder is str_cnv_from_term or str_cnv_not_convert, string is only copied,
  181. * so is possible to show file, that is not valid in terminal encoding
  182. */
  183. estr_t str_vfs_convert_from (GIConv, const char *, GString *);
  184. /* if coder is str_cnv_to_term or str_cnv_not_convert, string is only copied,
  185. * does replace with questionmark
  186. * I
  187. */
  188. estr_t str_vfs_convert_to (GIConv, const char *, int, GString *);
  189. /* printf function for str_buffer, append result of printf at the end of buffer
  190. */
  191. void str_printf (GString *, const char *, ...);
  192. /* add standard replacement character in terminal encoding
  193. */
  194. void str_insert_replace_char (GString *);
  195. /* init strings and set terminal encoding,
  196. * if is termenc NULL, detect terminal encoding
  197. * create all str_cnv_* and set functions for terminal encoding
  198. */
  199. void str_init_strings (const char *termenc);
  200. /* free all str_buffer and all str_cnv_*
  201. */
  202. void str_uninit_strings (void);
  203. /* try convert characters in ch to output using conv
  204. * ch_size is size of ch, can by (size_t)(-1) (-1 only for ASCII
  205. * compatible encoding, for other must be set)
  206. * return ESTR_SUCCESS if conversion was successfully,
  207. * ESTR_PROBLEM if ch contains only part of characters,
  208. * ESTR_FAILURE if conversion is not possible
  209. */
  210. estr_t str_translate_char (GIConv conv, const char *ch, size_t ch_size,
  211. char *output, size_t out_size);
  212. /* test, if text is valid in terminal encoding
  213. * I
  214. */
  215. int str_is_valid_string (const char *text);
  216. /* test, if first char of ch is valid
  217. * size, how many bytes characters occupied, could be (size_t)(-1)
  218. * return 1 if it is valid, -1 if it is invalid or -2 if it is only part of
  219. * multibyte character
  220. * I
  221. */
  222. int str_is_valid_char (const char *ch, size_t size);
  223. /* return next characters after text, do not call on the end of string
  224. */
  225. char *str_get_next_char (char *text);
  226. const char *str_cget_next_char (const char *text);
  227. /* return previous characters before text, do not call on the start of strings
  228. */
  229. char *str_get_prev_char (char *text);
  230. const char *str_cget_prev_char (const char *text);
  231. /* set text to next characters, do not call on the end of string
  232. */
  233. void str_next_char (char **text);
  234. void str_cnext_char (const char **text);
  235. /* set text to previous characters, do not call on the start of strings
  236. */
  237. void str_prev_char (char **text);
  238. void str_cprev_char (const char **text);
  239. /* return next characters after text, do not call on the end of string
  240. * works with invalid string
  241. * I
  242. */
  243. char *str_get_next_char_safe (char *text);
  244. const char *str_cget_next_char_safe (const char *text);
  245. /* return previous characters before text, do not call on the start of strings
  246. * works with invalid string
  247. * I
  248. */
  249. char *str_get_prev_char_safe (char *text);
  250. const char *str_cget_prev_char_safe (const char *text);
  251. /* set text to next characters, do not call on the end of string
  252. * works with invalid string
  253. * I
  254. */
  255. void str_next_char_safe (char **text);
  256. void str_cnext_char_safe (const char **text);
  257. /* set text to previous characters, do not call on the start of strings
  258. * works with invalid string
  259. * I
  260. */
  261. void str_prev_char_safe (char **text);
  262. void str_cprev_char_safe (const char **text);
  263. /* set text to next noncombining characters, check the end of text
  264. * return how many characters was skipped
  265. * works with invalid string
  266. * I
  267. */
  268. int str_next_noncomb_char (char **text);
  269. int str_cnext_noncomb_char (const char **text);
  270. /* set text to previous noncombining characters, search stop at begin
  271. * return how many characters was skipped
  272. * works with invalid string
  273. * I
  274. */
  275. int str_prev_noncomb_char (char **text, const char *begin);
  276. int str_cprev_noncomb_char (const char **text, const char *begin);
  277. /* if first characters in ch is space, tabulator or new lines
  278. * I
  279. */
  280. int str_isspace (const char *ch);
  281. /* if first characters in ch is punctuation or symbol
  282. * I
  283. */
  284. int str_ispunct (const char *ch);
  285. /* if first characters in ch is alphanum
  286. * I
  287. */
  288. int str_isalnum (const char *ch);
  289. /* if first characters in ch is digit
  290. * I
  291. */
  292. int str_isdigit (const char *ch);
  293. /* if first characters in ch is printable
  294. * I
  295. */
  296. int str_isprint (const char *ch);
  297. /* if first characters in ch is a combining mark (only in utf-8)
  298. * combining makrs are assumed to be zero width
  299. * I
  300. */
  301. gboolean str_iscombiningmark (const char *ch);
  302. /* write lower from of fisrt characters in ch into out
  303. * decrase remain by size of returned characters
  304. * if out is not big enough, do nothing
  305. */
  306. int str_toupper (const char *ch, char **out, size_t * remain);
  307. /* write upper from of fisrt characters in ch into out
  308. * decrase remain by size of returned characters
  309. * if out is not big enough, do nothing
  310. */
  311. int str_tolower (const char *ch, char **out, size_t * remain);
  312. /* return length of text in characters
  313. * I
  314. */
  315. int str_length (const char *text);
  316. /* return length of text in characters, limit to size
  317. * I
  318. */
  319. int str_length2 (const char *text, int size);
  320. /* return length of one char
  321. * I
  322. */
  323. int str_length_char (const char *);
  324. /* return length of text in characters, count only noncombining characters
  325. * I
  326. */
  327. int str_length_noncomb (const char *text);
  328. /* replace all invalid characters in text with questionmark
  329. * after return, text is valid string in terminal encoding
  330. * I
  331. */
  332. void str_fix_string (char *text);
  333. /* replace all invalid characters in text with questionmark
  334. * replace all unprintable characters with '.'
  335. * return static allocated string, "text" is not changed
  336. * returned string do not need to be freed
  337. * I
  338. */
  339. const char *str_term_form (const char *text);
  340. /* like str_term_form, but text can be alignment to width
  341. * alignment is specified in just_mode (J_LEFT, J_LEFT_FIT, ...)
  342. * result is completed with spaces to width
  343. * I
  344. */
  345. const char *str_fit_to_term (const char *text, int width, align_crt_t just_mode);
  346. /* like str_term_form, but when text is wider than width, three dots are
  347. * inserted at begin and result is completed with suffix of text
  348. * no additional spaces are inserted
  349. * I
  350. */
  351. const char *str_term_trim (const char *text, int width);
  352. /* like str_term_form, but return only specified substring
  353. * start - column (position) on terminal, where substring begin
  354. * result is completed with spaces to width
  355. * I
  356. */
  357. const char *str_term_substring (const char *text, int start, int width);
  358. /* return width, that will be text occupied on terminal
  359. * I
  360. */
  361. int str_term_width1 (const char *text);
  362. /* return width, that will be text occupied on terminal
  363. * text is limited by length in characters
  364. * I
  365. */
  366. int str_term_width2 (const char *text, size_t length);
  367. /* return width, that will be character occupied on terminal
  368. * combining characters are always zero width
  369. * I
  370. */
  371. int str_term_char_width (const char *text);
  372. /* convert position in characters to position in bytes
  373. * I
  374. */
  375. int str_offset_to_pos (const char *text, size_t length);
  376. /* convert position on terminal to position in characters
  377. * I
  378. */
  379. int str_column_to_pos (const char *text, size_t pos);
  380. /* like str_fit_to_term width just_mode = J_LEFT_FIT,
  381. * but do not insert additional spaces
  382. * I
  383. */
  384. const char *str_trunc (const char *text, int width);
  385. /* create needle, that will be searched in str_search_fist/last,
  386. * so needle can be reused
  387. * in UTF-8 return normalized form of needle
  388. */
  389. char *str_create_search_needle (const char *needle, int case_sen);
  390. /* free needle returned by str_create_search_needle
  391. */
  392. void str_release_search_needle (char *needle, int case_sen);
  393. /* search for first occurrence of search in text
  394. */
  395. const char *str_search_first (const char *text, const char *needle, int case_sen);
  396. /* search for last occurrence of search in text
  397. */
  398. const char *str_search_last (const char *text, const char *needle, int case_sen);
  399. /* case sensitive compare two strings
  400. * I
  401. */
  402. int str_compare (const char *t1, const char *t2);
  403. /* case sensitive compare two strings
  404. * if one string is prefix of the other string, return 0
  405. * I
  406. */
  407. int str_ncompare (const char *t1, const char *t2);
  408. /* case insensitive compare two strings
  409. * I
  410. */
  411. int str_casecmp (const char *t1, const char *t2);
  412. /* case insensitive compare two strings
  413. * if one string is prefix of the other string, return 0
  414. * I
  415. */
  416. int str_ncasecmp (const char *t1, const char *t2);
  417. /* return, how many bytes are are same from start in text and prefix
  418. * both strings are decomposed before comparing and return value is counted
  419. * in decomposed form, too. calling with prefix, prefix, you get size in bytes
  420. * of prefix in decomposed form,
  421. * I
  422. */
  423. int str_prefix (const char *text, const char *prefix);
  424. /* case insensitive version of str_prefix
  425. * I
  426. */
  427. int str_caseprefix (const char *text, const char *prefix);
  428. /* create a key that is used by str_key_collate
  429. * I
  430. */
  431. char *str_create_key (const char *text, int case_sen);
  432. /* create a key that is used by str_key_collate
  433. * should aware dot '.' in text
  434. * I
  435. */
  436. char *str_create_key_for_filename (const char *text, int case_sen);
  437. /* compare two string using LC_COLLATE, if is possible
  438. * if case_sen is set, comparing is case sensitive,
  439. * case_sen must be same for str_create_key, str_key_collate and str_release_key
  440. * I
  441. */
  442. int str_key_collate (const char *t1, const char *t2, int case_sen);
  443. /* release_key created by str_create_key, only rigth way to release key
  444. * I
  445. */
  446. void str_release_key (char *key, int case_sen);
  447. /* return TRUE if codeset_name is utf8 or utf-8
  448. * I
  449. */
  450. gboolean str_isutf8 (const char *codeset_name);
  451. const char *str_detect_termencoding (void);
  452. int str_verscmp (const char *s1, const char *s2);
  453. /* return how many lines and columns will text occupy on terminal
  454. */
  455. void str_msg_term_size (const char *text, int *lines, int *columns);
  456. /**
  457. * skip first needle's in haystack
  458. *
  459. * @param haystack pointer to string
  460. * @param needle pointer to string
  461. * @param skip_count skip first bytes
  462. *
  463. * @return pointer to skip_count+1 needle (or NULL if not found).
  464. */
  465. char *strrstr_skip_count (const char *haystack, const char *needle, size_t skip_count);
  466. char *str_replace_all (const char *haystack, const char *needle, const char *replacement);
  467. strtol_error_t xstrtoumax (const char *s, char **ptr, int base, uintmax_t * val,
  468. const char *valid_suffixes);
  469. uintmax_t parse_integer (const char *str, gboolean * invalid);
  470. /* --------------------------------------------------------------------------------------------- */
  471. /*** inline functions ****************************************************************************/
  472. /* --------------------------------------------------------------------------------------------- */
  473. static inline void
  474. str_replace (char *s, char from, char to)
  475. {
  476. for (; *s != '\0'; s++)
  477. {
  478. if (*s == from)
  479. *s = to;
  480. }
  481. }
  482. /* --------------------------------------------------------------------------------------------- */
  483. /*
  484. * strcpy is unsafe on overlapping memory areas, so define memmove-alike
  485. * string function.
  486. * Have sense only when:
  487. * * dest <= src
  488. * AND
  489. * * dest and str are pointers to one object (as Roland Illig pointed).
  490. *
  491. * We can't use str*cpy funs here:
  492. * http://kerneltrap.org/mailarchive/openbsd-misc/2008/5/27/1951294
  493. *
  494. * @param dest pointer to string
  495. * @param src pointer to string
  496. *
  497. * @return newly allocated string
  498. *
  499. */
  500. static inline char *
  501. str_move (char *dest, const char *src)
  502. {
  503. size_t n;
  504. #ifdef HAVE_ASSERT_H
  505. assert (dest <= src);
  506. #endif
  507. n = strlen (src) + 1; /* + '\0' */
  508. return (char *) memmove (dest, src, n);
  509. }
  510. /* --------------------------------------------------------------------------------------------- */
  511. #endif /* MC_STRUTIL_H */