leptris 1.9.201.0-arm-linux → 1.9.201.2-arm-linux

data/vendor-src/utf8proc/data/data_generator.jl

@@ -0,0 +1,498 @@
+using OffsetArrays: Origin
+
+parsehex(str) = parse(UInt32, str, base=16)
+
+function parse_hex_range(line)
+    m = match(r"^([0-9A-F]+)(\.\.([0-9A-F]+))? +; +([^#]+)", line)
+    if isnothing(m)
+        return nothing
+    end
+    i = parsehex(m[1])
+    j = !isnothing(m[3]) ? parsehex(m[3]) : i
+    desc = rstrip(m[4])
+    return (i:j, desc)
+end
+
+function read_hex_ranges(filename)
+    [r for r in parse_hex_range.(readlines(filename)) if !isnothing(r)]
+end
+
+function collect_codepoints(range_desc, description)
+    list = UInt32[]
+    for (r,d) in range_desc
+        if d == description
+            append!(list, r)
+        end
+    end
+    list
+end
+
+function set_all!(d, keys, value)
+    for k in keys
+        d[k] = value
+    end
+end
+
+#-------------------------------------------------------------------------------
+
+derived_core_properties = read_hex_ranges("DerivedCoreProperties.txt")
+
+ignorable = Set(collect_codepoints(derived_core_properties, "Default_Ignorable_Code_Point"))
+uppercase = Set(collect_codepoints(derived_core_properties, "Uppercase"))
+lowercase = Set(collect_codepoints(derived_core_properties, "Lowercase"))
+
+
+#-------------------------------------------------------------------------------
+function derive_indic_conjunct_break(derived_core_properties)
+    props = Dict{UInt32, String}()
+    set_all!(props, collect_codepoints(derived_core_properties, "InCB; Linker"),    "LINKER")
+    set_all!(props, collect_codepoints(derived_core_properties, "InCB; Consonant"), "CONSONANT")
+    set_all!(props, collect_codepoints(derived_core_properties, "InCB; Extend"),    "EXTEND")
+    props
+end
+
+let indic_conjunct_break = derive_indic_conjunct_break(derived_core_properties)
+    global function get_indic_conjunct_break(code)
+        get(indic_conjunct_break, code, "NONE")
+    end
+end
+
+#-------------------------------------------------------------------------------
+function read_grapheme_boundclasses(grapheme_break_filename, emoji_data_filename)
+    grapheme_boundclass = Dict{UInt32, String}()
+    for (r,desc) in read_hex_ranges(grapheme_break_filename)
+        set_all!(grapheme_boundclass, r, Base.uppercase(desc))
+    end
+    for (r,desc) in read_hex_ranges(emoji_data_filename)
+        if desc == "Extended_Pictographic"
+            set_all!(grapheme_boundclass, r, "EXTENDED_PICTOGRAPHIC")
+        elseif desc == "Emoji_Modifier"
+            set_all!(grapheme_boundclass, r, "EXTEND")
+        end
+    end
+    return grapheme_boundclass
+end
+
+let grapheme_boundclasses = read_grapheme_boundclasses("GraphemeBreakProperty.txt", "emoji-data.txt")
+    global function get_grapheme_boundclass(code)
+        get(grapheme_boundclasses, code, "OTHER")
+    end
+end
+
+#-------------------------------------------------------------------------------
+function read_composition_exclusions(pattern)
+    section = match(pattern, read("CompositionExclusions.txt",String)).match
+    es = UInt32[]
+    for line in split(section, '\n')
+        m = match(r"^([0-9A-F]+) +#"i, line)
+        if !isnothing(m)
+            push!(es, parsehex(m[1]))
+        end
+    end
+    es
+end
+
+exclusions = Set(read_composition_exclusions(r"# \(1\) Script Specifics.*?# Total code points:"s))
+excl_version = Set(read_composition_exclusions(r"# \(2\) Post Composition Version precomposed characters.*?# Total code points:"s))
+
+#-------------------------------------------------------------------------------
+function read_case_folding(filename)
+    case_folding = Dict{UInt32,Vector{UInt32}}()
+    for line in readlines(filename)
+        m = match(r"^([0-9A-F]+); [CF]; ([0-9A-F ]+);"i, line)
+        !isnothing(m) || continue
+        case_folding[parsehex(m[1])] = parsehex.(split(m[2]))
+    end
+    case_folding
+end
+
+let case_folding = read_case_folding("CaseFolding.txt")
+    global function get_case_folding(code)
+        get(case_folding, code, nothing)
+    end
+end
+
+#-------------------------------------------------------------------------------
+# Utilities for reading per-char properties from UnicodeData.txt
+function split_unicode_data_line(line)
+    m = match(r"""
+      ([0-9A-F]+);        # code
+      ([^;]+);            # name
+      ([A-Z]+);           # general category
+      ([0-9]+);           # canonical combining class
+      ([A-Z]+);           # bidi class
+      (<([A-Z]*)>)?       # decomposition type
+      ((\ ?[0-9A-F]+)*);  # decompomposition mapping
+      ([0-9]*);           # decimal digit
+      ([0-9]*);           # digit
+      ([^;]*);            # numeric
+      ([YN]*);            # bidi mirrored
+      ([^;]*);            # unicode 1.0 name
+      ([^;]*);            # iso comment
+      ([0-9A-F]*);        # simple uppercase mapping
+      ([0-9A-F]*);        # simple lowercase mapping
+      ([0-9A-F]*)$        # simple titlecase mapping
+    """ix, line)
+    @assert !isnothing(m)
+    code = parse(UInt32, m[1], base=16)
+    (code             = code,
+     name             = m[2],
+     category         = m[3],
+     combining_class  = parse(Int, m[4]),
+     bidi_class       = m[5],
+     decomp_type      = m[7],
+     decomp_mapping   = m[8] == "" ? nothing : parsehex.(split(m[8])),
+     bidi_mirrored    = m[13] == "Y",
+     # issue #130: use nonstandard uppercase ß -> ẞ
+     # issue #195: if character is uppercase but has no lowercase mapping,
+     #             then make lowercase mapping = itself (vice versa for lowercase)
+     uppercase_mapping = m[16] != ""                      ? parsehex(m[16]) :
+                         code  == 0x000000df              ? 0x00001e9e      :
+                         m[17] == "" && code in lowercase ? code            :
+                         nothing,
+     lowercase_mapping = m[17] != ""                      ? parsehex(m[17]) :
+                         m[16] == "" && code in uppercase ? code            :
+                         nothing,
+     titlecase_mapping = m[18] != ""         ? parsehex(m[18]) :
+                         code  == 0x000000df ? 0x00001e9e      :
+                         nothing,
+    )
+end
+
+function read_unicode_data(filename)
+    raw_char_props = split_unicode_data_line.(readlines(filename))
+    char_props = Origin(0)(Vector{eltype(raw_char_props)}())
+    @assert issorted(raw_char_props, by=c->c.code)
+    raw_char_props = Iterators.Stateful(raw_char_props)
+    while !isempty(raw_char_props)
+        c = popfirst!(raw_char_props)
+        if occursin(", First>", c.name)
+            nc = popfirst!(raw_char_props)
+            @assert occursin(", Last>", nc.name)
+            name = replace(c.name, ", First"=>"")
+            for i in c.code:nc.code
+                push!(char_props, (; c..., name=name, code=i))
+            end
+        else
+            push!(char_props, c)
+        end
+    end
+    return char_props
+end
+
+char_props = read_unicode_data("UnicodeData.txt")
+char_hash = Dict(c.code=>c for c in char_props)
+
+#-------------------------------------------------------------------------------
+# Read character widths from UAX #11: East Asian Width
+function read_east_asian_widths(filename)
+    ea_widths = Dict{UInt32,Int}()
+    for (rng,widthcode) in read_hex_ranges(filename)
+        w = widthcode == "W" || widthcode == "F" ? 2 : # wide or full
+            widthcode == "Na"|| widthcode == "H" ? 1 : # narrow or half-width
+            widthcode == "A"  ? -1 : # ambiguous width
+            nothing
+        if !isnothing(w)
+            set_all!(ea_widths, rng, w)
+        end
+    end
+    return ea_widths
+end
+
+let ea_widths = read_east_asian_widths("EastAsianWidth.txt")
+    # Following work by @jiahao, we compute character widths using a combination of
+    #   * character category
+    #   * UAX 11: East Asian Width
+    #   * a few exceptions as needed
+    # Adapted from http://nbviewer.ipython.org/gist/jiahao/07e8b08bf6d8671e9734
+    global function derive_char_width(code, category)
+        # Use a default width of 1 for all character categories that are
+        # letter/symbol/number-like, as well as for unassigned/private-use chars.
+        # This provides a useful nonzero fallback for new codepoints when a new
+        # Unicode version has been released.
+        width = 1
+
+        # Various zero-width categories
+        #
+        # "Sk" not included in zero width - see issue #167
+        if category in ("Mn", "Mc", "Me", "Zl", "Zp", "Cc", "Cf", "Cs")
+            width = 0
+        end
+
+        # Widths from UAX #11: East Asian Width
+        eaw = get(ea_widths, code, nothing)
+        if !isnothing(eaw)
+            width = eaw < 0 ? 1 : eaw
+        end
+
+        # A few exceptional cases, found by manual comparison to other wcwidth
+        # functions and similar checks.
+        if category == "Mn"
+            width = 0
+        end
+
+        if code == 0x00ad
+            # Soft hyphen is typically printed as a hyphen (-) in terminals.
+            width = 1
+        elseif code == 0x2028 || code == 0x2029
+            #By definition, should have zero width (on the same line)
+            #0x002028 '\u2028' category: Zl name: LINE SEPARATOR/
+            #0x002029 '\u2029' category: Zp name: PARAGRAPH SEPARATOR/
+            width = 0
+        end
+
+        return width
+    end
+    global function is_ambiguous_width(code)
+        return get(ea_widths, code, 0) < 0
+    end
+end
+
+#-------------------------------------------------------------------------------
+# Construct data tables which will drive libutf8proc
+#
+# These tables are "compressed" with an ad-hoc compression scheme (largely some
+# simple deduplication and indexing) which can easily and efficiently be
+# decompressed on the C side at runtime.
+
+# Inverse decomposition mapping tables for combining two characters into a single one.
+comb_mapping = Dict{UInt32, Dict{UInt32, UInt32}}()
+comb_issecond = Set{UInt32}()
+for char in char_props
+    # What happens with decompositions that are longer than 2?
+    if isnothing(char.decomp_type) && !isnothing(char.decomp_mapping) &&
+            length(char.decomp_mapping) == 2 && !isnothing(char_hash[char.decomp_mapping[1]]) &&
+            char_hash[char.decomp_mapping[1]].combining_class == 0 &&
+            (char.code ∉ exclusions && char.code ∉ excl_version)
+        dm0 = char.decomp_mapping[1]
+        dm1 = char.decomp_mapping[2]
+        if !haskey(comb_mapping, dm0)
+            comb_mapping[dm0] = Dict{UInt32, UInt32}()
+        end
+        comb_mapping[dm0][dm1] = char.code
+        push!(comb_issecond, dm1)
+    end
+end
+
+comb_index = Dict{UInt32, UInt32}()
+comb_length = Dict{UInt32, UInt32}()
+let
+    ind = 0
+    for dm0 in sort!(collect(keys(comb_mapping)))
+        comb_index[dm0] = ind
+        len = length(comb_mapping[dm0])
+        comb_length[dm0] = len
+        ind += len
+    end
+end
+
+utf16_encode(utf32_seq) = transcode(UInt16, transcode(String, utf32_seq))
+
+# Utility for packing all UTF-16 encoded sequences into one big array
+struct UTF16Sequences
+    storage::Vector{UInt16}
+    indices::Dict{Vector{UInt16},Int}
+end
+UTF16Sequences() = UTF16Sequences(UInt16[], Dict{Vector{UInt16},Int}())
+
+"""
+Return "sequence code" (seqindex in the C code) for a sequence: a UInt16 where
+* The 14 low bits are the index into the `sequences.storage` array where the
+  sequence resides
+* The two top bits are the length of the sequence, or if equal to 3, the first
+  entry of the sequence itself contains the length.
+"""
+function encode_sequence!(sequences::UTF16Sequences, utf32_seq::Vector)
+    if length(utf32_seq) == 0
+        return typemax(UInt16)
+    end
+    # lencode contains the length of the UTF-32 sequence after decoding
+    # No sequence has len 0, so we encode len 1 as 0, len 2 as 1.
+    # We have only 2 bits for the length, though, so longer sequences are
+    # encoded in the sequence data itself.
+    seq_lencode = length(utf32_seq) - 1
+    utf16_seq = utf16_encode(utf32_seq)
+    idx = get!(sequences.indices, utf16_seq) do
+        i = length(sequences.storage)
+        utf16_seq_enc = seq_lencode < 3 ? utf16_seq :
+                        pushfirst!(copy(utf16_seq), seq_lencode)
+        append!(sequences.storage, utf16_seq_enc)
+        i
+    end
+    @assert idx <= 0x3FFF
+    seq_code = idx | (min(seq_lencode, 3) << 14)
+    return seq_code
+end
+
+function encode_sequence!(sequences::UTF16Sequences, code::Integer)
+    encode_sequence!(sequences, [code])
+end
+
+function encode_sequence!(sequences::UTF16Sequences, ::Nothing)
+    return typemax(UInt16)
+end
+
+function char_table_properties!(sequences, char)
+    code = char.code
+
+    return (
+        category             = char.category,
+        combining_class      = char.combining_class,
+        bidi_class           = char.bidi_class,
+        decomp_type          = char.decomp_type,
+        decomp_seqindex      = encode_sequence!(sequences, char.decomp_mapping),
+        casefold_seqindex    = encode_sequence!(sequences, get_case_folding(code)),
+        uppercase_seqindex   = encode_sequence!(sequences, char.uppercase_mapping),
+        lowercase_seqindex   = encode_sequence!(sequences, char.lowercase_mapping),
+        titlecase_seqindex   = encode_sequence!(sequences, char.titlecase_mapping),
+        comb_index           = get(comb_index, code, 0x3FF), # see utf8proc_property_struct::comb_index
+        comb_length          = get(comb_length, code, 0),
+        comb_issecond        = code in comb_issecond,
+        bidi_mirrored        = char.bidi_mirrored,
+        comp_exclusion       = code in exclusions || code in excl_version,
+        ignorable            = code in ignorable,
+        control_boundary     = char.category in ("Zl", "Zp", "Cc", "Cf") &&
+                               !(char.code in (0x200C, 0x200D)),
+        charwidth            = derive_char_width(code, char.category),
+        ambiguous_width      = is_ambiguous_width(code),
+        boundclass           = get_grapheme_boundclass(code),
+        indic_conjunct_break = get_indic_conjunct_break(code),
+    )
+end
+
+# Many character properties are duplicates. Deduplicate them, constructing a
+# per-character array of indicies into the properties array
+sequences = UTF16Sequences()
+char_table_props = [char_table_properties!(sequences, cp) for cp in char_props]
+
+deduplicated_props = Origin(0)(Vector{eltype(char_table_props)}())
+char_property_indices = Origin(0)(zeros(Int, 0x00110000))
+let index_map = Dict{eltype(char_table_props),Int}()
+    for (char, table_props) in zip(char_props, char_table_props)
+        entry_idx = get!(index_map, table_props) do
+            idx = length(deduplicated_props)
+            push!(deduplicated_props, table_props)
+            idx
+        end
+        # Add 1 because unassigned codes occupy slot at index 0
+        char_property_indices[char.code] = entry_idx + 1
+    end
+end
+
+# Now compress char_property_indices by breaking it into pages and
+# deduplicating those (this works as compression because there are large
+# contiguous ranges of code space with identical properties)
+prop_page_indices = Int[]
+prop_pages = Int[]
+let
+    page_size = 0x100
+    page_index_map = Dict{Vector{Int}, Int}()
+    for page in Iterators.partition(char_property_indices, page_size)
+        page_idx = get!(page_index_map, page) do
+            idx = length(prop_pages)
+            append!(prop_pages, page)
+            idx
+        end
+        push!(prop_page_indices, page_idx)
+    end
+end
+
+#-------------------------------------------------------------------------------
+function write_c_index_array(io, array, linelen)
+    print(io, "{\n  ")
+    i = 0
+    for x in array
+        i += 1
+        if i == linelen
+            i = 0
+            print(io, "\n  ")
+        end
+        print(io, x, ", ")
+    end
+    print(io, "};\n\n")
+end
+
+function c_enum_name(prefix, str)
+    if isnothing(str)
+        return "0"
+    else
+        return "UTF8PROC_$(prefix)_$(Base.uppercase(str))"
+    end
+end
+
+function c_uint16(seqindex)
+    if seqindex == typemax(UInt16)
+        return "UINT16_MAX"
+    else
+        return string(seqindex)
+    end
+end
+
+function print_c_data_tables(io, sequences, prop_page_indices, prop_pages, deduplicated_props,
+                             comb_index, comb_length, comb_issecond)
+    print(io, "static const utf8proc_uint16_t utf8proc_sequences[] = ")
+    write_c_index_array(io, sequences.storage, 8)
+    print(io, "static const utf8proc_uint16_t utf8proc_stage1table[] = ")
+    write_c_index_array(io, prop_page_indices, 8)
+    print(io, "static const utf8proc_uint16_t utf8proc_stage2table[] = ")
+    write_c_index_array(io, prop_pages, 8)
+
+    print(io, """
+        static const utf8proc_property_t utf8proc_properties[] = {
+          {0, 0, 0, 0, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX, UINT16_MAX,  0x3FF,0,false,  false,false,false,false, 1, 0, 0, UTF8PROC_BOUNDCLASS_OTHER, UTF8PROC_INDIC_CONJUNCT_BREAK_NONE},
+        """)
+    for prop in deduplicated_props
+        print(io, "  {",
+              c_enum_name("CATEGORY", prop.category), ", ",
+              prop.combining_class, ", ",
+              c_enum_name("BIDI_CLASS", prop.bidi_class), ", ",
+              c_enum_name("DECOMP_TYPE", prop.decomp_type), ", ",
+              c_uint16(prop.decomp_seqindex), ", ",
+              c_uint16(prop.casefold_seqindex), ", ",
+              c_uint16(prop.uppercase_seqindex), ", ",
+              c_uint16(prop.lowercase_seqindex), ", ",
+              c_uint16(prop.titlecase_seqindex), ", ",
+              c_uint16(prop.comb_index), ", ",
+              c_uint16(prop.comb_length), ", ",
+              prop.comb_issecond, ", ",
+              prop.bidi_mirrored, ", ",
+              prop.comp_exclusion, ", ",
+              prop.ignorable, ", ",
+              prop.control_boundary, ", ",
+              prop.charwidth, ", ",
+              prop.ambiguous_width, ", ",
+              "0, ", # bitfield padding
+              c_enum_name("BOUNDCLASS", prop.boundclass), ", ",
+              c_enum_name("INDIC_CONJUNCT_BREAK", prop.indic_conjunct_break),
+              "},\n"
+        )
+    end
+    print(io, "};\n\n")
+
+    print(io, "static const utf8proc_int32_t utf8proc_combinations_second[] = {\n")
+    for dm0 in sort!(collect(keys(comb_mapping)))
+        print(io, " ");
+        for dm1 in sort!(collect(keys(comb_mapping[dm0])))
+            print(io, " ", dm1, ",")
+        end
+        print(io, "\n");
+    end
+    print(io, "};\n\n")
+
+    print(io, "static const utf8proc_int32_t utf8proc_combinations_combined[] = {\n")
+    for dm0 in sort!(collect(keys(comb_mapping)))
+        print(io, " ");
+        for dm1 in sort!(collect(keys(comb_mapping[dm0])))
+            code = comb_mapping[dm0][dm1]
+            print(io, " ", code, ",")
+        end
+        print(io, "\n");
+    end
+    print(io, "};\n\n")
+end
+
+
+if !isinteractive()
+    print_c_data_tables(stdout, sequences, prop_page_indices, prop_pages, deduplicated_props,
+                        comb_index, comb_length, comb_issecond)
+end

data/vendor-src/utf8proc/libutf8proc.pc.cmakein

@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_FULL_BINDIR@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: libutf8proc
+Description: UTF8 processing
+Version: @PROJECT_VERSION@
+Libs: -L${libdir} -lutf8proc
+Cflags: -I${includedir} -DUTF8PROC_EXPORTS

data/vendor-src/utf8proc/libutf8proc.pc.in

@@ -0,0 +1,10 @@
+prefix=PREFIX
+exec_prefix=${prefix}
+libdir=${prefix}/LIBDIR
+includedir=${prefix}/INCLUDEDIR
+
+Name: libutf8proc
+Description: UTF8 processing
+Version: VERSION
+Libs: -L${libdir} -lutf8proc
+Cflags: -I${includedir} -DUTF8PROC_EXPORTS

data/vendor-src/utf8proc/lump.md

@@ -0,0 +1,27 @@
+```
+U+0020      <-- all space characters (general category Zs)
+U+0027  '   <-- left/right single quotation mark U+2018..2019,
+                modifier letter apostrophe U+02BC,
+                modifier letter vertical line U+02C8
+U+002D  -   <-- all dash characters (general category Pd),
+                minus U+2212
+U+002F  /   <-- fraction slash U+2044,
+                division slash U+2215
+U+003A  :   <-- ratio U+2236
+U+003C  <   <-- single left-pointing angle quotation mark U+2039,
+                left-pointing angle bracket U+2329,
+                left angle bracket U+3008
+U+003E  >   <-- single right-pointing angle quotation mark U+203A,
+                right-pointing angle bracket U+232A,
+                right angle bracket U+3009
+U+005C  \   <-- set minus U+2216
+U+005E  ^   <-- modifier letter up arrowhead U+02C4,
+                modifier letter circumflex accent U+02C6,
+                caret U+2038,
+                up arrowhead U+2303
+U+005F  _   <-- all connector characters (general category Pc),
+                modifier letter low macron U+02CD
+U+0060  `   <-- modifier letter grave accent U+02CB
+U+007C  |   <-- divides U+2223
+U+007E  ~   <-- tilde operator U+223C
+```

data/vendor-src/utf8proc/test/app/CMakeLists.txt

@@ -0,0 +1,6 @@
+# This is a test app to test consuming utf8proc with CMake.
+cmake_minimum_required(VERSION 3.16)
+project(utf8proc-test)
+find_package(utf8proc REQUIRED)
+add_executable(app app.c)
+target_link_libraries(app utf8proc::utf8proc)

data/vendor-src/utf8proc/test/app/app.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <utf8proc.h>
+
+int
+main(void)
+{
+  printf("%s\n", utf8proc_version());
+  return 0;
+}

data/vendor-src/utf8proc/test/case.c

@@ -0,0 +1,76 @@
+#include "tests.h"
+#include <wctype.h>
+
+int main(int argc, char **argv)
+{
+     int error = 0, better = 0;
+     utf8proc_int32_t c;
+
+     (void) argc; /* unused */
+     (void) argv; /* unused */
+
+     /* some simple sanity tests of the character widths */
+     for (c = 0; c <= 0x110000; ++c) {
+          utf8proc_int32_t l = utf8proc_tolower(c);
+          utf8proc_int32_t u = utf8proc_toupper(c);
+          utf8proc_int32_t t = utf8proc_totitle(c);
+
+          check(l == c || utf8proc_codepoint_valid(l), "invalid tolower");
+          check(u == c || utf8proc_codepoint_valid(u), "invalid toupper");
+          check(t == c || utf8proc_codepoint_valid(t), "invalid totitle");
+
+          if (utf8proc_codepoint_valid(c) && (l == u) != (l == t) &&
+              /* Unicode 11: Georgian Mkhedruli chars have uppercase but no titlecase. */
+              !(((c >= 0x10d0 && c <= 0x10fa) || c >= (0x10fd && c <= 0x10ff)) && l != u)) {
+               fprintf(stderr, "unexpected titlecase %x for lowercase %x / uppercase %x\n", t, l, c);
+               ++error;
+          }
+
+          if (sizeof(wint_t) > 2 || (c < (1<<16) && u < (1<<16) && l < (1<<16))) {
+               wint_t l0 = towlower((wint_t)c), u0 = towupper((wint_t)c);
+
+               /* OS unicode tables may be out of date.  But if they
+                  do have a lower/uppercase mapping, hopefully it
+                  is correct? */
+               if (l0 != (wint_t)c && l0 != (wint_t)l) {
+                    fprintf(stderr, "MISMATCH %x != towlower(%x) == %x\n",
+                            l, c, l0);
+                    ++error;
+               }
+               else if (l0 != (wint_t)l) { /* often true for out-of-date OS unicode */
+                    ++better;
+                    /* printf("%x != towlower(%x) == %x\n", l, c, l0); */
+               }
+               if (u0 != (wint_t)c && u0 != (wint_t)u) {
+                    fprintf(stderr, "MISMATCH %x != towupper(%x) == %x\n",
+                            u, c, u0);
+                    ++error;
+               }
+               else if (u0 != (wint_t)u) { /* often true for out-of-date OS unicode */
+                    ++better;
+                    /* printf("%x != towupper(%x) == %x\n", u, c, u0); */
+               }
+          }
+     }
+     check(!error, "utf8proc case conversion FAILED %d tests.", error);
+
+     /* issue #130 */
+     check(utf8proc_toupper(0x00df) == 0x1e9e &&
+           utf8proc_totitle(0x00df) == 0x1e9e &&
+           utf8proc_tolower(0x00df) == 0x00df &&
+           utf8proc_tolower(0x1e9e) == 0x00df &&
+           utf8proc_toupper(0x1e9e) == 0x1e9e,
+           "incorrect 0x00df/0x1e9e case conversions");
+     utf8proc_uint8_t str_00df[] = {0xc3, 0x9f, 0x00};
+     utf8proc_uint8_t str_1e9e[] = {0xe1, 0xba, 0x9e, 0x00};
+     utf8proc_uint8_t *s1 = utf8proc_NFKC_Casefold(str_00df);
+     utf8proc_uint8_t *s2 = utf8proc_NFKC_Casefold(str_1e9e);
+     check(!strcmp((char*)s1, "ss") &&
+           !strcmp((char*)s2, "ss"),
+           "incorrect 0x00df/0x1e9e casefold normalization");
+     free(s1);
+     free(s2);
+     printf("More up-to-date than OS unicode tables for %d tests.\n", better);
+     printf("utf8proc case conversion tests SUCCEEDED.\n");
+     return 0;
+}