1 files changed, 232 insertions, 0 deletions
diff --git a/vendor/nunicode/include/libnu/strcoll_internal.h b/vendor/nunicode/include/libnu/strcoll_internal.h
new file mode 100644
index 0000000000..570cb14f87
--- /dev/null
+++ b/vendor/nunicode/include/libnu/strcoll_internal.h
@@ -0,0 +1,232 @@
+#ifndef NU_STRCOLL_INTERNAL_H
+#define NU_STRCOLL_INTERNAL_H
+
+/** @defgroup collation_internal Internal collation functions
+ *
+ * Functions in this group are mostly for the internal use. PLease use them
+ * with care.
+ */
+
+#include <libnu/config.h>
+#include <libnu/casemap.h>
+#include <libnu/defines.h>
+#include <libnu/strings.h>
+
+#if defined (__cplusplus) || defined (c_plusplus)
+extern "C" {
+#endif
+
+/** Read (decode) iterator with transformation applied inside of it
+ *
+ * @ingroup collation_internal
+ * @see nu_default_compound_read
+ * @see nu_nocase_compound_read
+ */
+typedef const char* (*nu_compound_read_t)(
+	const char *encoded, const char *encoded_limit, nu_read_iterator_t encoded_read,
+	uint32_t *unicode, const char **tail);
+
+/** Weight unicode codepoint (or several codepoints)
+ *
+ * 0 should always be weighted to 0. If your weight function need more
+ * than one codepoint - return negative value, which will be passed back to
+ * this function along with next codepoint.
+ *
+ * When function decided on weight and returned positive result, it has to
+ * fill weight with how many (Unicode) codepoints nunicode should rollback.
+ * E.g. function consumed "ZZS" and decided weight (in Hungarian collation),
+ * it fills 0 to \*weight because no rollback is needed. Then function
+ * consumed "ZZZ" and no weight available for such contraction - it
+ * returns weight for "Z" and fills \*weight with 2, to rollback
+ * redundant "ZZ".
+ *
+ * If string suddenly ends before weight function can decide (string limit
+ * reached), 0 will be passed additionally to the previous string to signal
+ * end of the string.
+ *
+ * @ingroup collation_internal
+ * @param u unicode codepoint to weight
+ * @param weight 0 at first call or (on sequential calls) pointer to negative
+ * weight previously returned by this function
+ * @param context pointer passed to _nu_strcoll() or _nu_strstr()
+ * @return positive codepoint weight or negative value if function need more
+ * codepoints
+ */
+typedef int32_t (*nu_codepoint_weight_t)(uint32_t u, int32_t *weight, void *context);
+
+#if (defined NU_WITH_Z_COLLATION) || (defined NU_WITH_N_COLLATION)
+
+/** Default compound read, equal to simply calling encoded_read(encoded, &unicode)
+ *
+ * @ingroup collation_internal
+ * @param encoded encoded string
+ * @param encoded_limit upper limit for encoded. NU_UNLIMITED for 0-terminated
+ * strings
+ * @param encoded_read read (decode) function
+ * @param unicode output unicode codepoint
+ * @param tail output pointer to compound tail, should never be 0
+ * @return pointer to next encoded codepoint
+ */
+static inline
+const char* nu_default_compound_read(const char *encoded, const char *encoded_limit,
+	nu_read_iterator_t encoded_read, uint32_t *unicode,
+	const char **tail) {
+	(void)(encoded_limit);
+	(void)(tail);
+
+	return encoded_read(encoded, unicode);
+}
+
+/** Case-ignoring compound read, equal to calling
+ * encoded_read(encoded, &unicode) with nu_toupper() applied internally
+ *
+ * @ingroup collation_internal
+ * @param encoded encoded string
+ * @param encoded_limit upper limit for encoded. NU_UNLIMITED for 0-terminated
+ * strings
+ * @param encoded_read read (decode) function
+ * @param unicode output unicode codepoint
+ * @param tail output pointer to compound tail, should never be 0
+ * @return pointer to next encoded codepoint
+ */
+static inline
+const char* nu_nocase_compound_read(const char *encoded, const char *encoded_limit,
+	nu_read_iterator_t encoded_read, uint32_t *unicode,
+	const char **tail) {
+
+	/* re-entry with tail != 0 */
+	if (*tail != 0) {
+		*tail = nu_casemap_read(*tail, unicode);
+
+		if (*unicode != 0) {
+			return encoded;
+		}
+
+		*tail = 0; // fall thru
+	}
+
+	if (encoded >= encoded_limit) {
+		*unicode = 0;
+		return encoded;
+	}
+
+	const char *p = encoded_read(encoded, unicode);
+
+	if (*unicode == 0) {
+		return p;
+	}
+
+	const char *map = NU_FOLDING_FUNCTION(*unicode);
+	if (map != 0) {
+		*tail = nu_casemap_read(map, unicode);
+	}
+
+	return p;
+}
+
+/** Internal interface for nu_strcoll
+ *
+ * @ingroup collation_internal
+ * @param lhs left-hand side encoded string
+ * @param lhs_limit upper limit for lhs, use NU_UNLIMITED for 0-terminated
+ * strings
+ * @param rhs right-hand side encoded string
+ * @param rhs_limit upper limit for rhs, use NU_UNLIMITED for 0-terminated
+ * strings
+ * @param it1 lhs read (decoding) function
+ * @param it2 rhs read (decoding) function
+ * @param com1 lhs compound read function
+ * @param com2 rhs compound read function
+ * @param weight codepoint weighting function
+ * @param context pointer which will be passed to weight
+ * @param collated_left (optional) number of codepoints collated in lhs
+ * @param collated_right (optional) number of codepoints collated in rhs
+ *
+ * @see nu_strcoll
+ * @see nu_default_compound_read
+ * @see nu_nocase_compound_read
+ * @see nu_ducet_weight
+ */
+NU_EXPORT
+int _nu_strcoll(const char *lhs, const char *lhs_limit,
+	const char *rhs, const char *rhs_limit,
+	nu_read_iterator_t it1, nu_read_iterator_t it2,
+	nu_compound_read_t com1, nu_compound_read_t com2,
+	nu_codepoint_weight_t weight, void *context,
+	ssize_t *collated_left, ssize_t *collated_right);
+
+/** Internal interface for nu_strchr
+ *
+ * @ingroup collation_internal
+ * @param lhs left-hand side encoded string
+ * @param lhs_limit upper limit for lhs, use NU_UNLIMITED for 0-terminated
+ * strings
+ * @param c unicode codepoint to look for
+ * @param read lhs read (decoding) function
+ * @param com lhs compound read function
+ * @param casemap casemapping function
+ * @param casemap_read casemapping result decoding function
+ *
+ * @see nu_strchr
+ * @see nu_default_compound_read
+ * @see nu_nocase_compound_read
+ * @see nu_toupper
+ * @see nu_tolower
+ */
+NU_EXPORT
+const char* _nu_strchr(const char *lhs, const char *lhs_limit,
+	uint32_t c, nu_read_iterator_t read,
+	nu_compound_read_t com,
+	nu_casemapping_t casemap, nu_read_iterator_t casemap_read);
+
+/** Internal interface for nu_strchr
+ *
+ * @ingroup collation_internal
+ * @see _nu_strchr
+ */
+NU_EXPORT
+const char* _nu_strrchr(const char *encoded, const char *limit,
+	uint32_t c, nu_read_iterator_t read,
+	nu_compound_read_t com,
+	nu_casemapping_t casemap, nu_read_iterator_t casemap_read);
+
+/** Internal interface for nu_strcoll
+ *
+ * @ingroup collation_internal
+ * @param haystack encoded haystack
+ * @param haystack_limit upper limit for haystack, use NU_UNLIMITED for
+ * 0-terminated strings
+ * @param needle encoded needle string
+ * @param needle_limit upper limit for needle, use NU_UNLIMITED for
+ * 0-terminated strings
+ * @param it1 haystack read (decoding) function
+ * @param it2 needle read (decoding) function
+ * @param com1 haystack compound read function
+ * @param com2 needle compound read function
+ * @param casemap casemapping function
+ * @param casemap_read casemapping result decoding function
+ * @param weight codepoint weighting function
+ * @param context pointer which will be passed to weight
+ *
+ * @see nu_strstr
+ * @see nu_default_compound_read
+ * @see nu_nocase_compound_read
+ * @see nu_toupper
+ * @see nu_tolower
+ * @see nu_ducet_weight
+ */
+NU_EXPORT
+const char* _nu_strstr(const char *haystack, const char *haystack_limit,
+	const char *needle, const char *needle_limit,
+	nu_read_iterator_t it1, nu_read_iterator_t it2,
+	nu_compound_read_t com1, nu_compound_read_t com2,
+	nu_casemapping_t casemap, nu_read_iterator_t casemap_read,
+	nu_codepoint_weight_t weight, void *context);
+
+#endif /* (defined NU_WITH_Z_COLLATION) || (defined NU_WITH_N_COLLATION) */
+
+#if defined (__cplusplus) || defined (c_plusplus)
+}
+#endif
+
+#endif /* NU_STRCOLL_INTERNAL_H */