react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/scripts/add_function.py

@@ -0,0 +1,330 @@
+#!/usr/bin/env python3
+"""
+Script to automate adding a new function to the simdutf library.
+This script reads a file containing the function signatures and documentation,
+then adds the functions to the appropriate files in the codebase.
+
+Usage:
+    python add_function.py <signature_file>
+
+Where <signature_file> is a file containing the function signatures, wrapped in a feature macro block, e.g.:
+    #if SIMDUTF_FEATURE_UTF8 && SIMDUTF_FEATURE_UTF16
+    /**
+     * Documentation for first function.
+     */
+    simdutf_warn_unused size_t utf8_length_from_utf16le(
+        const char16_t *buf, size_t len) noexcept;
+
+    /**
+     * Documentation for second function.
+     */
+    simdutf_warn_unused size_t utf8_length_from_utf16be(
+        const char16_t *buf, size_t len) noexcept;
+    #endif
+"""
+
+import sys
+import os
+import re
+import glob
+
+def read_signature_file(file_path):
+    """Read and parse the signature file."""
+    with open(file_path, 'r') as f:
+        content = f.read()
+    
+    # Extract the feature macro (e.g., SIMDUTF_FEATURE_UTF8 && SIMDUTF_FEATURE_UTF16)
+    feature_match = re.search(r'#if\s+(.+)', content)
+    feature_macro = feature_match.group(1).strip() if feature_match else None
+    
+    # Extract the content between #if and #endif
+    if_match = re.search(r'#if\s+.+?(#endif)', content, re.DOTALL)
+    if not if_match:
+        raise ValueError("Could not find #if/#endif block.")
+    
+    block_content = if_match.group(0)
+    
+    # Extract all function signatures (documentation + signature)
+    sig_matches = re.findall(r'(/\*\*.*?\*/)\s*(.*?);', block_content, re.DOTALL)
+    if not sig_matches:
+        raise ValueError("Could not parse function signatures from file.")
+    
+    functions = []
+    for doc, sig in sig_matches:
+        doc = doc.strip()
+        signature = sig.strip() + ';'
+        # Extract function name
+        name_match = re.search(r'\s+(\w+)\s*\(', signature)
+        func_name = name_match.group(1) if name_match else None
+        functions.append((doc, signature, func_name))
+    
+    return feature_macro, functions
+
+def add_to_implementation_h(repo_root, feature_macro, functions):
+    """Add to include/simdutf/implementation.h"""
+    file_path = os.path.join(repo_root, 'include/simdutf/implementation.h')
+    
+    with open(file_path, 'r') as f:
+        content = f.read()
+    
+    # Check for existing #if block for standalone functions (after namespace)
+    ns_start = content.find('namespace simdutf {')
+    if ns_start == -1:
+        raise ValueError("Could not find namespace in implementation.h")
+    
+    existing_if = content.find(f'#if {feature_macro}', ns_start)
+    if existing_if != -1:
+        # Find the corresponding #endif
+        endif_pos = content.find('#endif', existing_if)
+        if endif_pos != -1:
+            insert_pos = endif_pos
+        else:
+            insert_pos = len(content)
+    else:
+        insert_pos = ns_start + len('namespace simdutf {')
+    
+    # Insert standalone functions
+    standalone = ""
+    for doc, signature, func_name in functions:
+        standalone_sig = signature.replace(' const ', ' ')
+        standalone += f"""{doc}
+
+{standalone_sig}
+
+
+"""
+    content = content[:insert_pos] + standalone + content[insert_pos:]
+    
+    # Now for virtual functions in class
+    class_start = content.find('class implementation {')
+    public_start = content.find('public:', class_start)
+    if public_start == -1:
+        raise ValueError("Could not find public section in implementation class")
+    
+    existing_if_class = content.find(f'#if {feature_macro}', public_start)
+    if existing_if_class != -1:
+        endif_pos_class = content.find('#endif', existing_if_class)
+        if endif_pos_class != -1:
+            insert_pos_class = endif_pos_class
+        else:
+            insert_pos_class = len(content)
+    else:
+        insert_pos_class = public_start + len('public:')
+    
+    # Insert virtual functions
+    virtual = ""
+    for doc, signature, func_name in functions:
+        # Normalize signature for virtual
+        clean_sig = re.sub(r'\s*;?\s*$', '', signature).strip()
+        virtual += f"""{doc}
+  virtual {clean_sig} = 0;
+
+
+"""
+    content = content[:insert_pos_class] + virtual + content[insert_pos_class:]
+    
+    with open(file_path, 'w') as f:
+        f.write(content)
+
+def add_to_src_implementation_cpp(repo_root, feature_macro, functions):
+    """Add to src/implementation.cpp"""
+    file_path = os.path.join(repo_root, 'src/implementation.cpp')
+    
+    with open(file_path, 'r') as f:
+        content = f.read()
+    
+    # For detect class
+    detect_start = content.find('class detect_best_supported_implementation_on_first_use')
+    if detect_start != -1:
+        existing_if = content.find(f'#if {feature_macro}', detect_start)
+        if existing_if != -1:
+            endif_pos = content.find('#endif', existing_if)
+            insert_pos = endif_pos if endif_pos != -1 else len(content)
+        else:
+            brace_pos = content.find('{', detect_start)
+            insert_pos = brace_pos + 1 if brace_pos != -1 else len(content)
+    else:
+        insert_pos = len(content)
+    
+    detect_impl = ""
+    for doc, signature, func_name in functions:
+        params = [p.strip().split()[-1].lstrip('*') for p in signature.split('(')[1].split(')')[0].split(',') if p.strip()]
+        param_list = ', '.join(params)
+        detect_impl += f"""{re.sub(r';$', ' {', signature.replace(' const noexcept', ' const noexcept final override'))}
+  return set_best()->{func_name}({param_list});
+}}
+
+
+"""
+    content = content[:insert_pos] + detect_impl + content[insert_pos:]
+    
+    # For unsupported class
+    unsupported_start = content.find('class unsupported_implementation final : public implementation {')
+    if unsupported_start != -1:
+        existing_if = content.find(f'#if {feature_macro}', unsupported_start)
+        if existing_if != -1:
+            endif_pos = content.find('#endif', existing_if)
+            insert_pos_unsup = endif_pos if endif_pos != -1 else len(content)
+        else:
+            insert_pos_unsup = unsupported_start + len('class unsupported_implementation final : public implementation {')
+    else:
+        insert_pos_unsup = len(content)
+    
+    unsupported_impl = ""
+    for doc, signature, func_name in functions:
+        return_stmt = "return nullptr;" if "const char" in signature.split('(')[0] or "char16_t" in signature.split('(')[0] else "return 0;"
+        unsupported_impl += f"""{re.sub(r';$', ' {', signature.replace(' const noexcept', ' const noexcept final override'))}
+  {return_stmt}  // Not supported
+}}
+
+
+"""
+    content = content[:insert_pos_unsup] + unsupported_impl + content[insert_pos_unsup:]
+    
+    # For standalone functions at end
+    existing_if_end = content.rfind(f'#if {feature_macro}')
+    if existing_if_end != -1:
+        endif_pos = content.find('#endif', existing_if_end)
+        insert_pos_end = endif_pos if endif_pos != -1 else len(content)
+    else:
+        insert_pos_end = len(content)
+    
+    standalone = ""
+    for doc, signature, func_name in functions:
+        params = [p.strip().split()[-1].lstrip('*') for p in signature.split('(')[1].split(')')[0].split(',') if p.strip()]
+        param_list = ', '.join(params)
+        # Remove const for standalone functions
+        standalone_sig = signature.replace(' const noexcept', ' noexcept')
+        standalone += f"""{re.sub(r';$', ' {', standalone_sig)}
+  return get_default_implementation()->{func_name}({param_list});
+}}
+
+
+"""
+    content = content[:insert_pos_end] + standalone + content[insert_pos_end:]
+    
+    with open(file_path, 'w') as f:
+        f.write(content)
+
+def add_to_impl_files(file_path, functions, feature_macro):
+    with open(file_path, 'r') as f:
+        content = f.read()
+    
+    impl = ""
+    for doc, signature, func_name in functions:
+        modified_signature = re.sub(re.escape(func_name), f'implementation::{func_name}', signature)
+        if ' const ' not in modified_signature:
+            modified_signature = modified_signature.replace(' noexcept', ' const noexcept')
+        modified_signature = modified_signature.replace(' const noexcept', ' const noexcept final override')
+        impl += f"""{re.sub(r';$', ' {', modified_signature)}
+  // TODO: implement
+}}
+
+
+"""
+    
+    existing_if = content.rfind(f'#if {feature_macro}')
+    if existing_if != -1:
+        endif_pos = content.find('#endif', existing_if)
+        insert_pos = endif_pos if endif_pos != -1 else len(content)
+        content = content[:insert_pos] + impl + content[insert_pos:]
+    else:
+        impl = f"#if {feature_macro}\n{impl}#endif // {feature_macro}\n"
+        content += impl
+    
+    with open(file_path, 'w') as f:
+        f.write(content)
+
+def add_declarations_to_impl_h(file_path, functions, feature_macro):
+    print(f"Adding declarations to {file_path}...")
+    # Now add declarations to the corresponding .h file
+    arch = os.path.basename(os.path.dirname(file_path))
+    h_file = file_path
+    with open(h_file, 'r') as f:
+        h_content = f.read()
+        
+    
+    insert_pos = h_content.rfind('};')
+    if insert_pos == -1:
+        print(f"}}; in {h_file}")
+    if insert_pos != -1:
+        print(f"Inserting declarations at position {insert_pos}...")
+        decl = ""
+        for doc, signature, func_name in functions:
+            modified_signature = signature
+            if ' const ' not in modified_signature:
+                modified_signature = modified_signature.replace(' noexcept', ' const noexcept')
+            decl += f"{modified_signature};\n"
+        
+        # Wrap with #if
+        existing_if_h = h_content.rfind(f'#if {feature_macro}')
+        if existing_if_h != -1:
+            endif_pos_h = h_content.find('#endif', existing_if_h)
+            insert_pos_h = endif_pos_h if endif_pos_h != -1 else insert_pos
+            h_content = h_content[:insert_pos_h] + decl + h_content[insert_pos_h:]
+        else:
+            decl = f"#if {feature_macro}\n{decl}#endif // {feature_macro}\n"
+            h_content = h_content[:insert_pos] + decl + h_content[insert_pos:]
+        print(f"Updating {h_file}...")
+        with open(h_file, 'w') as f:
+            f.write(h_content)
+
+def add_to_all_impl_files(repo_root, feature_macro, functions):
+    """Add to all src/**/implementation.cpp files"""
+    impl_files = glob.glob(os.path.join(repo_root, 'src', '**', 'implementation.cpp'), recursive=True)
+    # Exclude src/implementation.cpp as it's handled separately
+    impl_files = [f for f in impl_files if os.path.dirname(f) != os.path.join(repo_root, 'src')]
+    print(f"Found {len(impl_files)} implementation.cpp files to update.")
+    
+    for file_path in impl_files:
+        print(f"Updating {file_path}...")
+        add_to_impl_files(file_path, functions, feature_macro)
+
+def add_declaration_to_all_impl_files(repo_root, feature_macro, functions):
+    """Add declarations to all src/simdutf/**/implementation.h files"""
+    impl_files = glob.glob(os.path.join(repo_root, 'src/simdutf', '**', 'implementation.h'), recursive=True)
+    # Exclude src/implementation.cpp as it's handled separately
+    impl_files = [f for f in impl_files if os.path.dirname(f) != os.path.join(repo_root, 'src')]
+    print(f"Found {len(impl_files)} implementation.h files to update.")
+    
+    for file_path in impl_files:
+        print(f"Updating declarations for {file_path}...")
+        add_declarations_to_impl_h(file_path, functions, feature_macro)
+
+def main():
+    if len(sys.argv) != 2:
+        print("Usage: python add_function.py <signature_file>")
+        sys.exit(1)
+    
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    repo_root = os.path.abspath(os.path.join(script_dir, '..'))
+    
+    sig_file = sys.argv[1]
+    feature_macro, functions = read_signature_file(sig_file)
+    
+    # Ensure all signatures have const
+    updated_functions = []
+    for doc, sig, name in functions:
+        if ' const ' not in sig:
+            sig = sig.replace(' noexcept', ' const noexcept')
+        updated_functions.append((doc, sig, name))
+    functions = updated_functions
+    
+    if not feature_macro or not functions:
+        print("Error: Could not extract feature macro or functions.")
+        sys.exit(1)
+    
+    #add_to_implementation_h(repo_root, feature_macro, functions)
+    #add_to_src_implementation_cpp(repo_root, feature_macro, functions)
+    #add_to_all_impl_files(repo_root, feature_macro, functions)
+    add_declaration_to_all_impl_files(repo_root, feature_macro, functions)
+    
+    func_names = [name for _, _, name in functions]
+    print(f"Functions '{', '.join(func_names)}' added successfully.")
+    print("Please remember to implement the functions in the respective implementation.cpp files.")
+    print("Also, consider adding tests for the new functions.")
+    print("Run formatting tools to ensure code style consistency: ./scripts/clang_format_docker.sh ")
+    print("Done.")
+
+if __name__ == '__main__':
+    main()

package/deps/simdutf/scripts/amalgamation_tests.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+#
+# runs a test to ensure amalagamation works
+
+import subprocess
+import tempfile
+import argparse
+import datetime
+import itertools
+import math
+import random
+
+
+def test_one(args, features):
+    print(f"testing with these features enabled: {', '.join(features)}")
+    builddir = tempfile.TemporaryDirectory(delete=not args.keep_tmpdirs)
+    t0 = datetime.datetime.now()
+    subprocess.run(
+        [
+            "python3",
+            "singleheader/amalgamate.py",
+            "--source-dir",
+            "src",
+            "--include-dir",
+            "include",
+            "--output-dir",
+            builddir.name,
+            "--no-zip",
+            "--no-readme",
+        ]
+        + [f"--with-{feature}" for feature in features],
+        stdout=subprocess.DEVNULL,
+        check=True,
+    )
+    print(f"amalgamated in {builddir.name}")
+    if args.warnings:
+        warnings = [
+            "-Wall",
+            "-Wextra",
+            "-Werror",
+            "-Wno-error=unused-function",
+            "-Wno-error=unused-const-variable",
+        ]
+    else:
+        warnings = []
+    subprocess.run(
+        [args.compiler, "-c", "simdutf.cpp", "-I", ".", f"-std=c++{args.standard}"]
+        + warnings,
+        check=True,
+        cwd=builddir.name,
+    )
+    print(f"compiled in {builddir.name}")
+
+
+allfeatures = ["utf8", "utf16", "utf32", "base64", "detect-enc", "ascii", "latin1"]
+
+
+def test_combinations(args, include_count):
+    total = math.comb(len(allfeatures), include_count)
+    print(f"testing all {total} possible selections of {include_count} features")
+    for i, combo in enumerate(itertools.combinations(allfeatures, include_count)):
+        test_one(args, combo)
+        print(f"tested {i + 1} of {total}")
+
+
+def generate_subset():
+    s = allfeatures
+    for subset in itertools.chain.from_iterable(
+        itertools.combinations(s, r) for r in range(len(s) + 1)
+    ):
+        yield subset
+
+
+def test_random(args, N):
+    subsets = [s for s in generate_subset()]
+    random.shuffle(subsets)
+    if N > 0 and N < len(subsets):
+        subsets = subsets[0:N]
+    total = len(subsets)
+    for i, subset in enumerate(subsets):
+        print(f"testing {i + 1} of {total} subsets: {subset}")
+        test_one(args, subset)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="amalgamation test", description="ensures that amalgamation works"
+    )
+    parser.add_argument("--standard", type=int, default=23)
+    parser.add_argument("--keep-tmpdirs", action="store_true")
+    parser.add_argument("--compiler", type=str, default="c++")
+    parser.add_argument("--warnings", action="store_true")
+    parser.add_argument(
+        "--test-implicit-all",
+        action="store_true",
+        help="test giving no features, meaning all features are implicitly on",
+    )
+    parser.add_argument(
+        "--test-explicit-all", action="store_true", help="test giving all features"
+    )
+    parser.add_argument(
+        "--test-singles", action="store_true", help="test one feature at a time"
+    )
+    parser.add_argument(
+        "--test-random",
+        type=int,
+        default=-1,
+        help="tests up to the given amount of random subsets. 0 means all. negative means don't do this.",
+    )
+    parser.add_argument(
+        "--test-pairs", action="store_true", help="tests all pairs of features"
+    )
+    parser.add_argument(
+        "--test-triplets", action="store_true", help="tests all triplets of features"
+    )
+    parser.add_argument(
+        "--test-all-but-one",
+        action="store_true",
+        help="tests all possible feature sets with one disabled",
+    )
+
+    args = parser.parse_args()
+
+    if args.test_implicit_all:
+        print("test all enabled, implicitly")
+        test_one(args, [])
+
+    if args.test_explicit_all:
+        print("test all enabled, explicitly")
+        test_one(args, allfeatures)
+
+    if args.test_singles:
+        print("test one single feature at a time")
+        test_combinations(args, 1)
+
+    if args.test_random >= 0:
+        print("test random")
+        test_random(args, args.test_random)
+
+    if args.test_pairs:
+        print("test all pairs")
+        test_combinations(args, 2)
+
+    if args.test_triplets:
+        print("test all triplets")
+        test_combinations(args, 3)
+
+    if args.test_all_but_one:
+        print("test all but one single feature at a time")
+        test_combinations(args, len(allfeatures) - 1)
+
+    print("all seems to have gone well. bye bye!")
+
+
+if __name__ == "__main__":
+    main()

package/deps/simdutf/scripts/base64/Makefile

@@ -0,0 +1,2 @@
+lint:
+	python -m mypy *.py

package/deps/simdutf/scripts/base64/README.md

@@ -0,0 +1,2 @@
+The scripts in this directory are for reference only. They were use to check
+the algorithms we are using.

package/deps/simdutf/scripts/base64/avx512.py

@@ -0,0 +1,76 @@
+lookup_0 = [0 for i in range(64)]
+lookup_1 = [0 for i in range(64)]
+for i in range(64):
+    lookup_0[i] = 0x80
+    lookup_1[i] = 0x80
+lookup = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+for i in range(64):
+    val = ord(lookup[i])
+    bit6 = val & 0x40
+    bits05 = val & 0x3f
+    if bit6:
+        lookup_1[bits05] = i
+    else:
+        lookup_0[bits05] = i
+allowed = "\t\r\n "
+for z in allowed:
+    lookup_0[ord(z)] = 0xff
+def sign8(x):
+    if x >= 128:
+        return x - 256
+    return x
+lookup_0.reverse()
+lookup_1.reverse()
+print("lookup0:")
+print(", ".join([str(sign8(i)) for i in lookup_0]))
+print("lookup1:")
+print(", ".join([str(sign8(i)) for i in lookup_1]))
+lookupn = [0 for i in range(64)]
+output = 0
+for ifrom in range(16):
+    lookupn[ifrom*4 + 0] = output + 3
+    lookupn[ifrom*4 + 1] = output + 2
+    lookupn[ifrom*4 + 2] = output + 1
+    lookupn[ifrom*4 + 3] = output + 0
+    output += 4
+lookupn.reverse()
+print("reverse:")
+print(", ".join([str(i) for i in lookupn]))
+
+print("====")
+
+lookup_0 = [0 for i in range(64)]
+lookup_1 = [0 for i in range(64)]
+for i in range(64):
+    lookup_0[i] = 0x80
+    lookup_1[i] = 0x80
+lookup = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
+for i in range(64):
+    val = ord(lookup[i])
+    bit6 = val & 0x40
+    bits05 = val & 0x3f
+    if bit6:
+        lookup_1[bits05] = i
+    else:
+        lookup_0[bits05] = i
+allowed = "\0\t\r\n "
+for z in allowed:
+    lookup_0[ord(z)] = 0xff
+
+lookup_0.reverse()
+lookup_1.reverse()
+print("lookup0:")
+print(", ".join([str(sign8(i)) for i in lookup_0]))
+print("lookup1:")
+print(", ".join([str(sign8(i)) for i in lookup_1]))
+lookupn = [0 for i in range(64)]
+output = 0
+for ifrom in range(16):
+    lookupn[ifrom*4 + 0] = output + 3
+    lookupn[ifrom*4 + 1] = output + 2
+    lookupn[ifrom*4 + 2] = output + 1
+    lookupn[ifrom*4 + 3] = output + 0
+    output += 4
+lookupn.reverse()
+print("reverse:")
+print(", ".join([str(i) for i in lookupn]))