ucx: comparison src/ucx/string.h

-:353d71349e61
+:90b6d69bb499
 #define PRIsstr ".*s"
 #ifdef	__cplusplus
 extern "C" {
 #endif
 /**
 * The UCX string structure.
 */
 typedef struct {
 /** A reference to the string (<b>not necessarily  <code>NULL</code>
 char   *ptr;
 /** The length of the string */
 size_t length;
 } sstr_t;
+typedef struct {
+const char *ptr;
+size_t     length;
+} scstr_t;
+#ifdef	__cplusplus
+}
+#endif
+#ifdef __cplusplus
+inline scstr_t s2scstr(sstr_t s) {
+scstr_t c;
+c.ptr = s.ptr;
+c.length = s.ptr;
+return c;
+}
+inline scstr_t s2scstr(scstr_t c) {
+return c;
+}
+#define SCSTR s2scstr
+#else
+scstr_t ucx_sc2sc(scstr_t c);
+scstr_t ucx_ss2sc(sstr_t str);
+#if __STDC_VERSION__ >= 201112L
+#define SCSTR(str) _Generic(str, sstr_t: ucx_ss2sc, scstr_t: ucx_sc2sc)(str)
+#elif defined(__GNUC__) || defined(__clang__)
+#define SCSTR(str) __builtin_choose_expr( \
+__builtin_types_compatible_p(typeof(str), sstr_t), \
+ucx_ss2sc, \
+ucx_sc2sc)(str)
+#elif defined(__sun)
+#define SCSTR(str) ({typeof(str) ucx_tmp_var_str = str; \
+	scstr_t ucx_tmp_var_c; \
+	ucx_tmp_var_c.ptr = ucx_tmp_var_str.ptr;\
+	ucx_tmp_var_c.length = ucx_tmp_var_str.length;\
+	ucx_tmp_var_c; })
+#else
+scstr_t ucx_ss2c_s();
+#define SCSTR ucx_ss2c_s
+#endif /* C11 feature test */
+#endif /* C++ */
+#ifdef	__cplusplus
+extern "C" {
+#endif
 /**
 * Creates a new sstr_t based on a C string.
 *
 * The length is implicitly inferred by using a call to <code>strlen()</code>.
 *
 * @see sstr()
 * @see S()
 */
 sstr_t sstrn(char *cstring, size_t length);
+scstr_t scstr(const char *cstring);
+scstr_t scstrn(const char *cstring, size_t length);
 /**
 * Returns the cumulated length of all specified strings.
 *
 * At least one string must be specified.
 * @param count    the total number of specified strings (so at least 1)
 * @param string   the first string
 * @param ...      all other strings
 * @return the cumulated length of all strings
 */
-size_t sstrnlen(size_t count, sstr_t string, ...);
+size_t ucx_strnlen(size_t count, ...);
+#define sstrnlen(count, ...) ucx_strnlen(count, __VA_ARGS__)
 /**
 * Concatenates two or more strings.
 *
 * The resulting string will be allocated by standard <code>malloc()</code>.
 * The sstr_t.ptr of the return value will <i>always</i> be <code>NULL</code>-
 * terminated.
 *
 * @param count   the total number of strings to concatenate
 * @param s1      first string
-* @param s2      second string
 * @param ...     all remaining strings
 * @return the concatenated string
 */
-sstr_t sstrcat(size_t count, sstr_t s1, sstr_t s2, ...);
+sstr_t ucx_strcat(size_t count, scstr_t s1, ...);
+#define sstrcat(count, s1, ...) ucx_strcat(count, SCSTR(s1), __VA_ARGS__)
 /**
 * Concatenates two or more strings using a UcxAllocator.
 *
 * See sstrcat() for details.
 *
 * @param a       the allocator to use
 * @param count   the total number of strings to concatenate
 * @param s1      first string
-* @param s2      second string
 * @param ...     all remaining strings
 * @return the concatenated string
 */
-sstr_t sstrcat_a(UcxAllocator *a, size_t count, sstr_t s1, sstr_t s2, ...);
+sstr_t ucx_strcat_a(UcxAllocator *a, size_t count, scstr_t s1, ...);
+#define sstrcat_a(count, s1, ...) ucx_strcat_a(count, SCSTR(s1), __VA_ARGS__)
 /**
 * Returns a substring starting at the specified location.
 *
 * <b>Attention:</b> the new string references the same memory area as the
 * @see sstrsubs()
 * @see sstrchr()
 */
 sstr_t sstrsubsl(sstr_t string, size_t start, size_t length);
+scstr_t scstrsubs(scstr_t s, size_t start);
+scstr_t scstrsubsl(scstr_t string, size_t start, size_t length);
+int ucx_strchr(const char *string, size_t length, int chr, size_t *pos);
+int ucx_strrchr(const char *string, size_t length, int chr, size_t *pos);
 /**
 * Returns a substring starting at the location of the first occurrence of the
 * specified character.
 *
 * If the string does not contain the character, an empty string is returned.
 * @return       a substring starting at the last location of <code>chr</code>
 *
 * @see sstrsubs()
 */
 sstr_t sstrrchr(sstr_t string, int chr);
+scstr_t scstrchr(scstr_t string, int chr);
+scstr_t scstrrchr(scstr_t string, int chr);
+const char* ucx_strstr(
+const char *str,
+size_t length,
+const char *match,
+size_t matchlen,
+size_t *newlen);
 /**
 * Returns a substring starting at the location of the first occurrence of the
 * specified string.
 *
 * @param match  string containing the sequence of characters to match
 * @return       a substring starting at the first occurrence of
 *               <code>match</code>, or an empty string, if the sequence is not
 *               present in <code>string</code>
 */
-sstr_t sstrstr(sstr_t string, sstr_t match);
+sstr_t ucx_sstrstr(sstr_t string, scstr_t match);
+#define sstrstr(string, match) ucx_sstrstr(string, SCSTR(match))
+scstr_t ucx_scstrstr(scstr_t string, scstr_t match);
+#define scstrstr(string, match) ucx_scstrstr(string, SCSTR(match))
 /**
 * Splits a string into parts by using a delimiter string.
 *
 * This function will return <code>NULL</code>, if one of the following happens:
 * @return a sstr_t array containing the split strings or
 *         <code>NULL</code> on error
 *
 * @see sstrsplit_a()
 */
-sstr_t* sstrsplit(sstr_t string, sstr_t delim, ssize_t *count);
+sstr_t* ucx_strsplit(scstr_t string, scstr_t delim, ssize_t *count);
+#define sstrsplit(s, delim, count) ucx_strsplit(SCSTR(s), SCSTR(delim), count)
 /**
 * Performing sstrsplit() using a UcxAllocator.
 *
 * <i>Read the description of sstrsplit() for details.</i>
 * @return a sstr_t array containing the split strings or
 *         <code>NULL</code> on error
 *
 * @see sstrsplit()
 */
-sstr_t* sstrsplit_a(UcxAllocator *allocator, sstr_t string, sstr_t delim,
+sstr_t* ucx_strsplit_a(UcxAllocator *allocator, scstr_t string, scstr_t delim,
 ssize_t *count);
+#define sstrsplit_a(a, s, d, c) ucx_strsplit_a(a, SCSTR(s), SCSTR(d, c))
 /**
 * Compares two UCX strings with standard <code>memcmp()</code>.
 *
 * At first it compares the sstr_t.length attribute of the two strings. The
 * @param s2 the second string
 * @return -1, if the length of s1 is less than the length of s2 or 1, if the
 * length of s1 is greater than the length of s2 or the result of
 * <code>memcmp()</code> otherwise (i.e. 0 if the strings match)
 */
-int sstrcmp(sstr_t s1, sstr_t s2);
+int ucx_str_cmp(scstr_t s1, scstr_t s2);
+#define sstrcmp(s1, s2) ucx_str_cmp(SCSTR(s1), SCSTR(s2))
 /**
 * Compares two UCX strings ignoring the case.
 *
 * At first it compares the sstr_t.length attribute of the two strings. If and
 * @return -1, if the length of s1 is less than the length of s2 or 1, if the
 * length of s1 is greater than the length of s2 or the difference between the
 * first two differing characters otherwise (i.e. 0 if the strings match and
 * no characters differ)
 */
-int sstrcasecmp(sstr_t s1, sstr_t s2);
+int ucx_str_casecmp(scstr_t s1, scstr_t s2);
+#define sstrcasecmp(s1, s2) ucx_str_casecmp(SCSTR(s1), SCSTR(s2))
 /**
 * Creates a duplicate of the specified string.
 *
 * The new sstr_t will contain a copy allocated by standard
 *
 * @param string the string to duplicate
 * @return a duplicate of the string
 * @see sstrdup_a()
 */
-sstr_t sstrdup(sstr_t string);
+sstr_t scstrdup(scstr_t string);
+#define sstrdup(s) scstrdup(SCSTR(s))
 /**
 * Creates a duplicate of the specified string using a UcxAllocator.
 *
 * The new sstr_t will contain a copy allocated by the allocators
 * @param allocator a valid instance of a UcxAllocator
 * @param string the string to duplicate
 * @return a duplicate of the string
 * @see sstrdup()
 */
-sstr_t sstrdup_a(UcxAllocator *allocator, sstr_t string);
+sstr_t scstrdup_a(UcxAllocator *allocator, scstr_t string);
+#define sstrdup_a(allocator, s) scstrdup_a(allocator, SCSTR(s))
+size_t ucx_strtrim(const char *str, size_t length, size_t *newlen);
 /**
 * Omits leading and trailing spaces.
 *
 * This function returns a new sstr_t containing a trimmed version of the
 * @param string the string that shall be trimmed
 * @return a new sstr_t containing the trimmed string
 */
 sstr_t sstrtrim(sstr_t string);
+scstr_t scstrtrim(scstr_t string);
 /**
 * Checks, if a string has a specific prefix.
 * @param string the string to check
 * @param prefix the prefix the string should have
 * @return 1, if and only if the string has the specified prefix, 0 otherwise
 */
-int sstrprefix(sstr_t string, sstr_t prefix);
+int ucx_strprefix(scstr_t string, scstr_t prefix);
+#define sstrprefix(string, prefix) ucx_strprefix(SCSTR(string), SCSTR(prefix))
 /**
 * Checks, if a string has a specific suffix.
 * @param string the string to check
 * @param suffix the suffix the string should have
 * @return 1, if and only if the string has the specified suffix, 0 otherwise
 */
-int sstrsuffix(sstr_t string, sstr_t suffix);
+int ucx_strsuffix(scstr_t string, scstr_t suffix);
+#define sstrsuffix(string, prefix) ucx_strsuffix(SCSTR(string), SCSTR(prefix))
 /**
 * Returns a lower case version of a string.
 *
 * This function creates a duplicate of the input string, first. See the
 *
 * @param string the input string
 * @return the resulting lower case string
 * @see sstrdup()
 */
-sstr_t sstrlower(sstr_t string);
+sstr_t ucx_strlower(scstr_t string);
+#define sstrlower(string) ucx_strlower(SCSTR(string))
 /**
 * Returns a lower case version of a string.
 *
 * This function creates a duplicate of the input string, first. See the
 * @param allocator the allocator used for duplicating the string
 * @param string the input string
 * @return the resulting lower case string
 * @see sstrdup_a()
 */
-sstr_t sstrlower_a(UcxAllocator *allocator, sstr_t string);
+sstr_t ucx_strlower_a(UcxAllocator *allocator, scstr_t string);
+#define sstrlower_a(allocator, string) ucx_strlower_a(allocator, SCSTR(string))
 /**
 * Returns a upper case version of a string.
 *
 * This function creates a duplicate of the input string, first. See the
 *
 * @param string the input string
 * @return the resulting upper case string
 * @see sstrdup()
 */
-sstr_t sstrupper(sstr_t string);
+sstr_t ucx_strupper(scstr_t string);
+#define sstrupper(string) ucx_strupper(SCSTR(string))
 /**
 * Returns a upper case version of a string.
 *
 * This function creates a duplicate of the input string, first. See the
 * @param allocator the allocator used for duplicating the string
 * @param string the input string
 * @return the resulting upper case string
 * @see sstrdup_a()
 */
-sstr_t sstrupper_a(UcxAllocator *allocator, sstr_t string);
+sstr_t ucx_strupper_a(UcxAllocator *allocator, scstr_t string);
+#define sstrupper_a(allocator, string) ucx_strupper_a(allocator, string)
 #ifdef	__cplusplus
 }
 #endif

Mercurial > hg > ucx / file comparison

comparison: src/ucx/string.h

src/ucx/string.h