react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/scripts/benchmark-all.py

@@ -1,119 +0,0 @@
-#!/usr/bin/env python3
-
-from pathlib import Path
-import sys
-import argparse
-import json
-import subprocess
-import re
-
-
-def main():
-    args = parse_args()
-
-    benchmark = args.build_dir / 'benchmarks' / 'benchmark'
-    if not benchmark.is_file():
-        raise RuntimeError(f"{benchmark} not found, was simdutf compiled with `-DSIMDUTF_BENCHMARKS=ON`?")
-
-    # load registered tests
-    simdutf_tests = [entry for entry in json.loads(execute([benchmark, "--json"])) if entry["simdutf"]]
-    maxlen = max(len(entry['name']) for entry in simdutf_tests)
-    count = len(simdutf_tests)
-
-    for id, test in enumerate(simdutf_tests, 1):
-        name = test["name"]
-        encodings = test["encodings"]
-
-        print(f"[{id}/{count}] {name:{maxlen}}... ", end='')
-        sys.stdout.flush()
-
-        if args.filter and not re.search(args.filter, name):
-            print(f"skipping, does not match filter '{args.filter}'")
-            continue
-
-        if len(encodings) > 1:
-            print(f"skipping, requires multiple input encodings ({encodings})")
-            continue
-
-        report_name = (name + '.txt')
-        report_path = args.output_dir / report_name
-        if report_path.exists():
-            print("already benchmarked")
-            continue
-
-        enc = encodings[0]
-        cmd = [benchmark, "-P", name, "-F"] + input_files(args.lipsum_dir, enc)
-        result = execute(cmd)
-        print(f"creating {report_path}")
-        report_path.write_bytes(result)
-
-
-def input_files(lipsum_dir, encoding):
-    dir = lipsum_dir / 'wikipedia_mars'
-    return list(dir.glob(patterns[encoding]))
-
-
-# in unicode_ipsum/wikipedia_mars
-patterns = {
-    'latin1'    : '*.latin1.txt',
-    'utf8'      : '*.utf8.txt',
-    'utf16le'   : '*.utf16.txt',
-    'utf16be'   : '*.utf16be.txt',
-    'utf32le'   : '*.utf32.txt',
-}
-
-
-def parse_args():
-    p = argparse.ArgumentParser("SIMDUTF tool for benchmarking")
-    p.add_argument("--build-dir",
-                   required=True,
-                   type=existing_dir,
-                   metavar="DIR",
-                   help="simdutf build directory")
-    p.add_argument("--lipsum-dir",
-                   required=True,
-                   type=existing_dir,
-                   metavar="DIR",
-                   help="unicode lorem lipsum directory")
-    p.add_argument("--output-dir",
-                   required=True,
-                   type=existing_dir,
-                   metavar="DIR",
-                   help="output directory")
-    p.add_argument("--filter",
-                   type=str,
-                   metavar="PATTERN",
-                   help="only run benchmarks whose name matches this regex pattern")
-
-    args = p.parse_args()
-
-    return args
-
-
-def existing_dir(s):
-    path = Path(s).expanduser().absolute()
-    if not path.is_dir():
-        raise argparse.ArgumentError("'{path}' is not a directory")
-
-    return path
-
-
-def execute(params):
-    cmd = [str(param) for param in params]
-    result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    if result.returncode != 0:
-        print(' '.join(cmd))
-        if result.stderr:
-            print("stderr:")
-            print(result.stderr)
-        if result.stdout:
-            print("stdout:")
-            print(result.stdout)
-        print(f"return code: {result.returncode}")
-        raise ValueError("command failed")
-
-    return result.stdout
-
-
-if __name__ == '__main__':
-    main()

package/deps/simdutf/scripts/benchmark_print.py

@@ -1,324 +0,0 @@
-#!/usr/bin/env python3
-
-import sys
-from pathlib import Path
-from table import Table
-
-
-class Input:
-    def __init__(self):
-        self.procedure = None
-        self.input_size = None
-        self.iterations = None
-        self.dataset = None
-
-    @property
-    def dataset_name(self):
-        if self.dataset:
-            return self.dataset.stem
-        else:
-            return 'none'
-
-    def __str__(self):
-        return '<Input: %s, size: %d, iterations: %s, dataset: %s>' % \
-                (self.procedure, self.input_size, self.iterations, self.dataset)
-
-    __repr__ = __str__
-
-
-class Result:
-    def __init__(self):
-        self.instruction_per_byte = None
-        self.instruction_per_char = None
-        self.instruction_per_cycle = None
-        self.cycle_per_byte = None
-        self.cycle_per_char = None
-        self.bytes_per_char = None
-        self.speed_gigabytes = None
-        self.speed_gigachars = None
-        self.freq = None
-        self.time = None
-
-    def update_from_dict(self, D):
-        while D:
-            unit, value = D.popitem()
-            field = unit2field[unit]
-            if field is not None:
-                setattr(self, field, value)
-
-
-unit2field = {
-    'ins/byte'      : 'instruction_per_byte',
-    'ins/char'      : 'instruction_per_char',
-    'ins/cycle'     : 'instruction_per_cycle',
-    'cycle/byte'    : 'cycle_per_byte',
-    'cycle/char'    : 'cycle_per_char',
-    'byte/char'     : 'byte_per_char',
-    'GHz'           : 'freq',
-    'GB/s'          : 'speed_gigabytes',
-    'Gc/s'          : 'speed_gigachars',
-    'ns'            : 'time',
-    '%'             : None,
-}
-
-
-def parse(file):
-    result = []
-    for line in file:
-        for item in parse_line(line):
-            if isinstance(item, Input):
-                result.append([item, None])
-            else:
-                assert isinstance(item, dict)
-                if result[-1][1] is None:
-                    result[-1][1] = Result()
-
-                result[-1][1].update_from_dict(item)
-
-    return [(input, result) for (input, result) in result if result is not None]
-
-
-def parse_line(line):
-    if 'input size' in line:
-        yield parse_input(normalize_line(line))
-    elif 'GB/s' in line or 'ins/byte' in line or 'ins/char' in line:
-        yield parse_results(normalize_line(line))
-
-
-def normalize_line(line):
-    line = line.replace(',', ' ')
-    line = line.replace(':', ' ')
-    line = line.replace('(', ' ')
-    line = line.replace(')', ' ')
-
-    return line.split()
-
-
-def parse_input(fields):
-    input = Input()
-    input.procedure = fields.pop(0)
-
-    assert fields.pop(0) == 'input'
-    assert fields.pop(0) == 'size'
-    input.input_size = int(fields.pop(0))
-
-    assert fields.pop(0) == 'iterations'
-    input.iterations = int(fields.pop(0))
-
-    try:
-        assert fields.pop(0) == 'dataset'
-        input.dataset = Path(fields.pop(0))
-    except IndexError:
-        pass
-
-    return input
-
-
-def try_float(s):
-    try:
-        return float(s)
-    except ValueError:
-        return
-
-
-def parse_results(fields):
-    """Consumes pairs "number unit" from the list"""
-    D = {}
-
-    while fields:
-        value = try_float(fields.pop(0))
-        if value is not None and fields:
-            D[fields.pop(0)] = value
-
-    return D
-
-
-def speed_comparison(data):
-    procedures = set()
-    datasets = set()
-    results = {}
-
-    for input, result in data:
-        procedures.add(input.procedure)
-        datasets.add(input.dataset_name)
-        results[(input.procedure, input.dataset_name)] = result
-
-    datasets = list(sorted(datasets))
-    procedures = list(sorted(procedures))
-
-    def by_procedure():
-        table = Table()
-        table.set_header(['procedure'] + datasets)
-
-        for procedure in procedures:
-            row = []
-            row.append(procedure)
-            for dataset in datasets:
-                try:
-                    result = results[(procedure, dataset)]
-                    row.append('%0.3f GB/s' % (result.speed_gbs))
-                except KeyError:
-                    row.append('--')
-
-            table.add_row(row)
-
-        return table
-
-    def by_dataset():
-        table = Table()
-        table.set_header(['dataset'] + procedures)
-
-        for dataset in datasets:
-            row = []
-            row.append(dataset)
-            for procedure in procedures:
-                try:
-                    result = results[(procedure, dataset)]
-                    row.append('%0.3f GB/s' % (result.speed_gigabytes))
-                except KeyError:
-                    row.append('--')
-
-            table.add_row(row)
-
-        return table
-
-    if len(procedures) >= len(datasets):
-        return by_procedure()
-    else:
-        return by_dataset()
-
-
-def compare(old, new):
-    collate = {}
-    for input, result in old:
-        key = str(input)
-        collate[key] = [input, result, None]
-
-    for input, result in new:
-        key = str(input)
-        if key not in collate:
-            collate[key] = [input, None, result]
-        else:
-            collate[key][-1] = result
-
-    grouped = {}
-    for _, (input, old, new) in collate.items():
-        if input.procedure not in grouped:
-            grouped[input.procedure] = []
-
-        grouped[input.procedure].append((input, old, new))
-
-    NA = '--'
-    table = Table()
-    table.set_header(["dataset", "size [B]", "iterations", "old GB/s", "new GB/s", "speedup"])
-    for procedure, values in grouped.items():
-        table.add_row([(procedure, 6)])
-        for input, old, new in values:
-            old_speed = old.speed_gigabytes
-            new_speed = new.speed_gigabytes
-            if old_speed is None or new_speed is None:
-                speedup = NA
-            else:
-                speedup = '%0.2fx' % (new_speed / old_speed)
-
-            if old_speed is None:
-                old_speed = NA
-            else:
-                old_speed = '%0.2f' % old_speed
-
-            if new_speed is None:
-                new_speed = NA
-            else:
-                new_speed = '%0.2f' % new_speed
-
-            table.add_row([
-                input.dataset.stem,
-                '%s' % input.input_size,
-                '%s' % input.iterations,
-                old_speed,
-                new_speed,
-                speedup,
-            ])
-
-    return table
-
-
-HELP = """Format output of the benchmark utility
-
-When running a benchmark redirect its output to file (with > or `tee`), like:
-
-$ cd build/benchmarks
-$ ./benchmark [...] > results.txt
-$ ./benchmark [...] | tee results.txt
-
-To summarize results, use:
-
-$ ./benchmark_print.py results.txt
-|     dataset      | utf8_length_from_utf32+fallback | utf8_length_from_utf32+haswell | utf8_length_from_utf32+westmere |
-| ---------------- | ------------------------------- | ------------------------------ | ------------------------------- |
-| arabic.utf32     | 3.190 GB/s                      | 15.638 GB/s                    | 7.879 GB/s                      |
-| chinese.utf32    | 3.179 GB/s                      | 15.349 GB/s                    | 7.644 GB/s                      |
-| czech.utf32      | 3.178 GB/s                      | 15.721 GB/s                    | 7.801 GB/s                      |
-...
-| thai.utf32       | 3.191 GB/s                      | 15.455 GB/s                    | 7.842 GB/s                      |
-| turkish.utf32    | 3.191 GB/s                      | 15.086 GB/s                    | 7.809 GB/s                      |
-| vietnamese.utf32 | 3.182 GB/s                      | 15.317 GB/s                    | 7.807 GB/s                      |
-
-To compare results, use:
-
-$ ./benchmark_print.py old.txt new.txt
-|             dataset             | size [B] | iterations | old GB/s | new GB/s | speedup |
-| ------------------------------- | -------- | ---------- | -------- | -------- | ------- |
-| convert_utf32_to_latin1+haswell                                                         |
-| esperanto.utflatin32            |   328672 |      30000 |    77.14 |    88.81 | 1.15x   |
-| french.utflatin32               |  1729220 |      30000 |    75.26 |    92.39 | 1.23x   |
-| german.utflatin32               |   797324 |      30000 |    76.11 |    79.84 | 1.05x   |
-| portuguese.utflatin32           |  1086972 |      30000 |    84.12 |    92.64 | 1.10x   |
-"""
-
-
-def parse_file(path):
-    with open(path, 'r') as f:
-        return parse(f)
-
-
-def self_test():
-    rootdir = Path(__file__).parent / 'tests'
-
-    data = parse_file(rootdir / 'results.txt')
-    speed_comparison(data)
-
-    old = parse_file(rootdir / 'old.txt')
-    new = parse_file(rootdir / 'old.txt')
-    compare(new, old)
-
-
-def main():
-    args = sys.argv[1:]
-    if "-h" in args or "--help" in args:
-        print(HELP)
-        return
-
-    if "--test" in args:
-        print("running tests...")
-        self_test()
-        print("all OK")
-        return
-
-    n = len(args)
-
-    if n == 1:
-        data = parse_file(args[0])
-
-        print(speed_comparison(data))
-    elif n == 2:
-        old = parse_file(args[0])
-        new = parse_file(args[1])
-
-        print(compare(old, new))
-    else:
-        print(HELP)
-
-
-if __name__ == '__main__':
-    main()

package/deps/simdutf/scripts/check_feature_macros.py

@@ -1,156 +0,0 @@
-#!/usr/bin/env python3
-import subprocess
-import re
-import os
-import argparse
-import sys
-from typing import List, Tuple
-
-def get_git_files(limit_to_src_include: bool) -> List[str]:
-    """Retrieve list of .cpp and .h files checked into the Git repository."""
-    try:
-        patterns = ['src/*.cpp', 'src/*.h', 'include/*.cpp', 'include/*.h'] if limit_to_src_include else ['*.cpp', '*.h']
-        result = subprocess.run(
-            ['git', 'ls-files'] + patterns,
-            capture_output=True,
-            text=True,
-            check=True
-        )
-        files = result.stdout.splitlines()
-        if limit_to_src_include:
-            files = [f for f in files if f.startswith(('src/', 'include/'))]
-        return files
-    except subprocess.CalledProcessError as e:
-        print(f"Error running git ls-files: {e}")
-        return []
-
-def is_preprocessor_directive(line: str) -> bool:
-    """Check if the line contains a preprocessor directive (not in a comment)."""
-    line = re.sub(r'//.*$', '', line)
-    return bool(re.match(r'^\s*#', line))
-
-def extract_directive(lines: List[str], line_number: int) -> Tuple[str, str]:
-    """Extract directive type and condition (if any) from a preprocessor line."""
-    line = lines[line_number].strip()
-    # Sometimes, the condition may span multiple lines due to backslashes
-    # Handle multi-line conditions for #if directives
-    # We recursively gather lines if they end with a backslash
-    def build_full_condition(comment: str, line_number: int) -> str:
-        if comment.endswith('\\') and line_number + 1 < len(lines):
-            line_number += 1
-            return comment[:-1].strip() + ' ' + build_full_condition(lines[line_number].strip(), line_number)
-        else:
-            return comment.strip()
-    if line.startswith('#if '):
-        return 'if', build_full_condition(line[4:].strip(), line_number)
-    elif line.startswith('#ifdef '):
-        return 'ifdef', build_full_condition(line[7:].strip(), line_number)
-    elif line.startswith('#ifndef '):
-        return 'ifndef', build_full_condition(line[8:].strip(), line_number)
-    elif line.startswith('#endif'):
-        match = re.match(r'#endif\s*(?://\s*(.*))?$', line)
-        ## In some instances, the comment may be on the next line(s)
-        ## We use the following loop to gather such comments
-        ## The heuristic is that the next line starts with '//' and contains 'SIMDUTF_FEATURE'
-        ## Note that if we don't check for SIMDUTF_FEATURE, we may pick up unrelated comments.
-        comment = match.group(1).strip() if match and match.group(1) else ''
-        while line_number + 1 < len(lines):
-            next_line = lines[line_number + 1].strip()
-            if next_line.startswith('//') and 'SIMDUTF_FEATURE' in next_line:
-                comment_part = next_line[2:].strip()
-                comment = (comment + ' ' + comment_part).strip() if comment else comment_part
-                line_number += 1
-            else:
-                break
-        return 'endif', comment
-    return '', ''
-
-def is_feature_if_directive(condition: str) -> bool:
-    """Check if the #if condition contains a macro starting with SIMDUTF_FEATURE."""
-    return bool(re.search(r'\bSIMDUTF_FEATURE\w*\b', condition))
-
-def check_file(filename: str) -> List[str]:
-    """Check #if directives with SIMDUTF_FEATURE macros for matching #endif comments."""
-    errors = []
-    stack = []  # Stack of (directive, condition, is_feature, line_number)
-    statistics = {'if': 0, 'ifdef': 0, 'ifndef': 0, 'endif': 0}
-
-    try:
-        with open(filename, 'r', encoding='utf-8') as f:
-            lines = f.readlines()
-
-        for line_number, line in enumerate(lines):
-            if not is_preprocessor_directive(line):
-                continue
-
-            directive, condition = extract_directive(lines, line_number)
-            if not directive:
-                continue
-            statistics[directive] += 1
-
-            if directive in ('if', 'ifdef', 'ifndef'):
-                is_feature = directive == 'if' and is_feature_if_directive(condition)
-                stack.append((directive, condition, is_feature, line_number))
-            elif directive == 'endif' and stack:
-                orig_directive, orig_condition, is_feature, orig_line = stack.pop()
-                if is_feature:
-                    if not condition:
-                        errors.append(
-                            f"\033[31mERROR: {filename}:{line_number}: #endif missing comment (expected '{orig_condition}')\033[0m"
-                        )
-                    elif not re.match(r'SIMDUTF_FEATURE\w*', condition):
-                        errors.append(
-                            f"\033[31mERROR: {filename}:{line_number}: #endif comment '{condition}' does not start with SIMDUTF_FEATURE "
-                            f"(expected '{orig_condition}')\033[0m"
-                        )
-                    elif condition != orig_condition:
-                        errors.append(
-                            f"\033[31mERROR: {filename}:{line_number}: #endif comment '{condition}' does not match "
-                            f"#if condition '{orig_condition}' at line {orig_line}\033[0m"
-                        )
-
-        # Check for unclosed feature-related #if directives
-        for directive, condition, is_feature, line in stack:
-            if is_feature:
-                red_warning = f"\033[31mWARNING: {filename}:{line}: Unclosed #if '{condition}' at end of file\033[0m"
-                errors.append(red_warning)
-
-        return errors, statistics
-
-    except FileNotFoundError:
-        return [f"{filename}: File not found"], statistics
-    except UnicodeDecodeError:
-        return [f"{filename}: Unable to decode file (invalid encoding)"], statistics
-
-def main():
-    """Main function to check .cpp and .h files for SIMDUTF feature #if...#endif pairs."""
-    parser = argparse.ArgumentParser(description="Check #if...#endif pairs for SIMDUTF feature macros in .cpp and .h files.")
-    parser.add_argument('--limit', action='store_true', help="Limit checks to files in src/ and include/ directories")
-    args = parser.parse_args()
-
-    files = get_git_files(args.limit)
-    if not files:
-        print("No .cpp or .h files found in the Git repository" + (" in src/ or include/" if args.limit else "") + ".")
-        sys.exit(142)  # Exit with special code if no files are found, see https://github.com/simdutf/simdutf/issues/921
-
-    all_errors = []
-    statistics = {'if': 0, 'ifdef': 0, 'ifndef': 0, 'endif': 0}
-    for filename in files:
-        errors, file_stats = check_file(filename)
-        all_errors.extend(errors)
-        for key in statistics:
-            statistics[key] += file_stats.get(key, 0)
-
-    if all_errors:
-        print("Errors found:")
-        for error in all_errors:
-            print(error)
-        sys.exit(1)  # Exit with error code if errors are found
-    else:
-        for key, count in statistics.items():
-            print(f"Total #{key} directives: {count}")
-        print("All #if...#endif pairs for SIMDUTF feature macros are correctly matched with valid comments.")
-        sys.exit(0)  # Exit with success code
-
-if __name__ == "__main__":
-    main()

package/deps/simdutf/scripts/check_typos.sh

@@ -1,13 +0,0 @@
-#!/bin/sh
-
-#
-# checks for typos. run from the root dir.
-
-set -eu
-
-# this exits with nonzero status if it finds something, which terminates the script
-codespell \
-    --skip="./benchmarks/competition,./build,./fuzz/work"  \
-    -L vie,persan,fo,ans,larg,indx,shft,carryin
-
-echo "no typos detected!"

package/deps/simdutf/scripts/clang_format.sh

@@ -1,35 +0,0 @@
-#!/bin/sh
-#
-# clang formats all files in the repository.
-# certain files are excluded via .clang-format-ignore files
-# supported from clang format 18 upwards.
-
-set -eu
-
-cf=clang-format-18
-
-# Check if clang-format is installed
-if ! command -v $cf 2>&1 >/dev/null
-then
-    echo "Error: $cf not found. Please install Clang version 18."
-    echo "We recommend using the clang_format_docker.sh script."
-    exit 1
-fi
-
-if ! command -v git 2>&1 >/dev/null
-then
-    echo "Error: Git not found. Please install Git to use this script."
-    echo "You can get Git from:"
-    echo "  - Linux: Most distributions include Git; use your package manager (e.g., 'sudo apt-get install git')"
-    echo "  - macOS: Use Homebrew with 'brew install git'"
-    echo "  - Windows: Download from the official Git website"
-    exit 1
-fi
-
-gitroot="$(git rev-parse --show-toplevel)"
-
-cd "$gitroot"
-
-git ls-files -z | \
-    grep -z -E '(\.c|\.cpp|\.h)$' |\
-    xargs --null -P $(nproc) -n1 $cf -i

package/deps/simdutf/scripts/clang_format_docker.sh

@@ -1,38 +0,0 @@
-#!/bin/sh
-#
-# clang formats all files in the repository, using
-# a specific docker image.
-
-set -eu
-
-# Check if Docker is installed
-if ! command -v docker 2>&1 >/dev/null
-then
-    echo "Error: Docker not found. Please install Docker to use this script."
-    echo "You can get Docker from:"
-    echo "  - Linux: https://docs.docker.com/engine/install/"
-    echo "  - macOS: Use Homebrew with 'brew install --cask docker'"
-    echo "  - Windows: Download from Docker Desktop website"
-    exit 1
-fi
-
-# Check if Git is installed
-if ! command -v git 2>&1 >/dev/null
-then
-    echo "Error: Git not found. Please install Git to use this script."
-    echo "You can get Git from:"
-    echo "  - Linux: Most distributions include Git; use your package manager (e.g., 'sudo apt-get install git')"
-    echo "  - macOS: Use Homebrew with 'brew install git'"
-    echo "  - Windows: Download from the official Git website"
-    exit 1
-fi
-
-gitroot="$(git rev-parse --show-toplevel)"
-
-cd "$gitroot"
-
-docker run -v"$(pwd):/src"  \
-       --workdir /src \
-       -u "$(id -u $USER):$(id -g $USER)" \
-       ghcr.io/pauldreik/clang-format-18:latest \
-       scripts/clang_format.sh