react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/scripts/sse_utf8_utf16_decode.py

@@ -1,186 +0,0 @@
-#!/usr/bin/env python3
-from common import *
-
-
-def is_bit_set(mask, i):
-    return (mask & ( 1<<i )) == ( 1<<i )
-
-# computes the location of the 0 bits (index starts at zero)
-def compute_locations(mask):
-    answer = []
-    i = 0
-    while( (mask >> i) > 0 ):
-        if(is_bit_set(mask,i)):
-            answer.append(i)
-        i += 1
-    return answer
-
-
-# computes the gaps between the 1, assuming we had an initial 1
-def compute_code_point_size(mask):
-    positions = compute_locations(mask)
-    answer = []
-    oldx = -1
-    for i in range(len(positions)):
-        x = positions[i]
-        answer.append(x-oldx)
-        oldx = x
-    return answer
-
-## check that we have 6 1-2 byte (at least)
-def easy_case12(code_point_size):
-    if(len(code_point_size)<6):
-        return False
-    return max(code_point_size[:6])<=2
-
-## check that we have 4 1-2-3 byte (at least)
-def easy_case123(code_point_size):
-    if(len(code_point_size)<4):
-        return False
-    return max(code_point_size[:4])<=3
-
-## check that we have 4 1-2-3 byte (at least)
-def easy_case1234(code_point_size):
-    if(len(code_point_size)<3):
-        return False
-    return max(code_point_size[:3])<=4
-
-def grab_easy_case12_code_point_size(code_point_size):
-    return code_point_size[:6]
-
-def grab_easy_case123_code_point_size(code_point_size):
-    return code_point_size[:4]
-
-def grab_easy_case1234_code_point_size(code_point_size):
-    return code_point_size[:3]
-
-def buildshuf12_twobytes(sizes):
-    answer = [0 for i in range(16)]
-    pos = 0
-    for i in range(len(sizes)):
-        if(sizes[i] == 1):
-            answer[2*i] = pos
-            answer[2*i+1] = 0xff
-            pos += 1
-        else:
-            answer[2*i] = pos + 1
-            answer[2*i+1] = pos
-            pos += 2
-    return answer
-
-def buildshuf123_threebytes(sizes):
-    answer = [0 for i in range(16)]
-    pos = 0
-    for i in range(len(sizes)): # 4 * 4 = 16
-        if(sizes[i] == 1):
-            answer[4*i] = pos
-            answer[4*i+1] = 0xff
-            answer[4*i+2] = 0xff
-            answer[4*i+3] = 0xff
-            pos += 1
-        elif(sizes[i] == 2):
-            answer[4*i] = pos + 1
-            answer[4*i+1] = pos
-            answer[4*i+2] = 0xff
-            answer[4*i+3] = 0xff
-            pos += 2
-        else: # must be three
-            answer[4*i] = pos + 2
-            answer[4*i+1] = pos + 1
-            answer[4*i+2] = pos
-            answer[4*i+3] = 0xff
-            pos += 3
-    return answer
-
-def buildshuf1234_fourbytes(sizes):
-    answer = [0 for i in range(16)]
-    pos = 0
-    for i in range(len(sizes)): # 3 * 4 = 12
-        if(sizes[i] == 1):
-            answer[4*i] = pos
-            answer[4*i+1] = 0xff
-            answer[4*i+2] = 0xff
-            answer[4*i+3] = 0xff
-            pos += 1
-        elif(sizes[i] == 2):
-            answer[4*i] = pos + 1
-            answer[4*i+1] = pos
-            answer[4*i+2] = 0xff
-            answer[4*i+3] = 0xff
-            pos += 2
-        elif(sizes[i] == 3):
-            answer[4*i] = pos + 2
-            answer[4*i+1] = pos + 1
-            answer[4*i+2] = pos
-            answer[4*i+3] = 0xff
-            pos += 3
-        else: # must be four
-            answer[4*i] = pos + 3
-            answer[4*i+1] = pos + 2
-            answer[4*i+2] = pos + 1
-            answer[4*i+3] = pos
-            pos += 4
-    return answer
-
-
-def main():
-  easycase12 = set()
-  easycase123 = set()
-  easycase1234 = set()
-  for x in range(1<<12):
-    sizes = compute_code_point_size(x)
-    if(easy_case12(sizes)):
-        z1 = grab_easy_case12_code_point_size(sizes)
-        easycase12.add(tuple(z1))
-    elif(easy_case123(sizes)):
-        z1 = grab_easy_case123_code_point_size(sizes)
-        easycase123.add(tuple(z1))
-    elif(easy_case1234(sizes)):
-        z1 = grab_easy_case1234_code_point_size(sizes)
-        easycase1234.add(tuple(z1))
-  easycase12sorted = [x for x in easycase12]
-  easycase12sorted.sort()
-  easycase123sorted = [x for x in easycase123]
-  easycase123sorted.sort()
-  easycase1234sorted = [x for x in easycase1234]
-  easycase1234sorted.sort()
-
-  print("#include <cstdint>")
-  allshuf = [buildshuf12_twobytes(z) for z in  easycase12sorted] + [buildshuf123_threebytes(z) for z in  easycase123sorted] + [buildshuf1234_fourbytes(z) for z in  easycase1234sorted]
-  print("const uint8_t shufutf8["+str(len(easycase12sorted+easycase123sorted+easycase1234sorted))+"][16] = ")
-  print(cpp_arrayarray_initializer(allshuf), end=";\n")
-  print("/* number of two bytes : "+ str(len(easycase12sorted))+ " */")
-  print("/* number of two + three bytes : "+ str(len(easycase12sorted+easycase123sorted))+ " */")
-  print("/* number of two + three + four bytes : "+ str(len(easycase12sorted+easycase123sorted+easycase1234sorted))+ " */")
-  c = 0
-  index = {}
-  for t in easycase12sorted + easycase123sorted + easycase1234sorted:
-      index[t] = c
-      c = c + 1
-  arrg=[]
-  for x in range(1<<12):
-    sizes = compute_code_point_size(x)
-    if(easy_case12(sizes)):
-        z1 = grab_easy_case12_code_point_size(sizes)
-        idx = index[tuple(z1)]
-        s = sum(z1)
-        arrg.append((idx,s))
-    elif(easy_case123(sizes)):
-        z1 = grab_easy_case123_code_point_size(sizes)
-        idx = index[tuple(z1)]
-        s = sum(z1)
-        arrg.append((idx,s))
-    elif(easy_case1234(sizes)):
-        z1 = grab_easy_case1234_code_point_size(sizes)
-        idx = index[tuple(z1)]
-        s = sum(z1)
-        arrg.append((idx,s))
-    else:
-        # we are in error, use a bogus index
-        arrg.append((209,12))
-  print("const uint8_t utf8bigindex["+str(len(arrg))+"][2] = ")
-  print(cpp_arrayarray_initializer(arrg), end=";\n")
-
-
-if __name__ == '__main__':
-    main()

package/deps/simdutf/scripts/sse_validate_utf16le_proof.py

@@ -1,137 +0,0 @@
-# Note: Validation is done for 8-word input, we just need to check 3^8 = 6561 cases
-#       Validation for 16-word inputs requires 3**16 = 43'046'721 checks
-
-ELEMENTS_COUNT   = 8
-ALL_MASK         = (1 << ELEMENTS_COUNT) - 1
-ALL_BUT_ONE_MASK = (ALL_MASK >> 1)
-
-# 'V' - single-word character (always valid)
-# 'L' - low surrogate (must be followed by the high surrogate)
-# 'H' - high surrogate
-def all_sequences():
-    index = ['V'] * ELEMENTS_COUNT
-
-    def increment():
-        nonlocal index
-        for i in range(ELEMENTS_COUNT):
-            if index[i] == 'V':
-                index[i] = 'L'
-                return False
-
-            if index[i] == 'L':
-                index[i] = 'H'
-                return False
-
-            if index[i] == 'H':
-                index[i] = 'V' # wrap around
-                pass
-
-        return True
-
-    overflow = False
-    while not overflow:
-        yield index
-        overflow = increment()
-
-
-def find_error_in_words(words):
-    prev = None
-
-    if words[0] == 'H':
-        # We assume that our vector algorithm loads proper data into vectors.
-        # In the case low surrogate was the last item in the previous iteration.
-        return 'high surrogate must not start a chunk'
-
-    for i, kind in enumerate(words):
-        if kind == 'V':
-            if prev == 'L':
-                return f'low surrogate {i - 1} must be followed by high surrogate'
-        elif kind == 'L':
-            if prev == 'L':
-                return f'low surrogate {i - 1} must be followed by high surrogate'
-        elif kind == 'H':
-            if prev != 'L':
-                return f'high surrogate {i} must be preceded by low surrogate'
-
-        prev = kind
-
-    return ''
-
-
-def bitmask(words, state):
-    result = 0
-    for bit, type in enumerate(words):
-        if type == state:
-            # In SSE vector algorithm we compare 2 x 16 higher bytes of input
-            # words, which yields a 16-bit mask.
-            result |= 1 << bit
-
-    return result
-
-
-def mask(words):
-    L = bitmask(words, 'L')
-    H = bitmask(words, 'H')
-    V = (~(L | H)) & ALL_MASK
-
-    a = L & (H >> 1)
-    b = a << 1
-    c = V | a | b
-
-    return c
-
-
-def dump():
-    for words in all_sequences():
-
-        c = mask(words)
-
-        words_image = "[ %s ]" % ' | '.join(words)
-        error = find_error_in_words(words)
-        if error == '':
-            valid_image = 'T'
-        else:
-            valid_image = ' '
-
-        print(words_image, valid_image, '{:016b} {:04x}'.format(c, c))
-
-
-def proof():
-    case1_hit = False
-    case2_hit = False
-    for words in all_sequences():
-
-        c = mask(words)
-
-        if c == ALL_MASK:
-            case1_hit = True
-            # all 16 words are valid (either 'V' or pairs 'L', 'H')
-            assert find_error_in_words(words) == '', (words, find_error_in_words(words))
-
-        if c == ALL_BUT_ONE_MASK:
-            case2_hit = True
-            # all 15 words are valid (either 'V' or pairs 'L', 'H')
-            # the last words is either 'L' or 'H' (the word will be
-            # re-examined in the next iteration of an algorithm)
-            if words[-1] == 'H':
-                assert find_error_in_words(words) == 'high surrogate 7 must be preceded by low surrogate'
-            elif words[-1] == 'L':
-                assert find_error_in_words(words) == ''
-            else:
-                assert False
-
-    assert case1_hit
-    assert case2_hit
-
-    print("All OK")
-
-
-def main():
-    if 0:
-        dump()
-    else:
-        proof()
-
-
-if __name__ == '__main__':
-    main()

package/deps/simdutf/scripts/sse_validate_utf16le_testcases.py

@@ -1,129 +0,0 @@
-from itertools import product
-from random import randint, seed
-from sse_validate_utf16le_proof import bitmask
-
-
-# This is a copy from sse_validate_utf16le_proof.py with
-# adjusted the mask for the 16-bit base
-def mask(words):
-    L = bitmask(words, 'L')
-    H = bitmask(words, 'H')
-    V = (~(L | H)) & 0xffff
-
-    a = L & (H >> 1)
-    b = a << 1
-    c = V | a | b
-
-    return c
-
-
-class Record:
-    def __init__(self):
-        self.words = []
-
-
-    def add(self, word):
-        self.words.append(word)
-
-
-    @property
-    def is_valid(self):
-        c = mask(self.words)
-
-        if c == 0xffff:
-          return True
-
-        if c == 0x7fff:
-          # in test we reject cases when 'L' or 'H' ends a chunk
-          if self.words[-1] in ('L', 'H'):
-            return False
-          else:
-            return True
-
-        return False
-
-
-    def __str__(self):
-        words = ''.join(self.words)
-        if self.is_valid:
-            return 'T' + words
-        else:
-            return 'F' + words
-
-
-def test_words():
-    collection = set()
-    for seq in test_words_aux():
-        collection.add(tuple(seq))
-
-    return sorted(collection)
-
-
-def test_words_aux():
-    # 1. all valid
-    yield ['V'] * 16
-
-    # 2. only low surrogates
-    yield ['L'] * 16
-
-    # 3. only high surrogates
-    yield ['H'] * 16
-
-    # 4. sole low surrogate
-    for i in range(16):
-        seq = ['V'] * 16
-        seq[i] = 'L'
-        yield seq
-
-    # 5. sole high surrogate
-    for i in range(16):
-        seq = ['V'] * 16
-        seq[i] = 'H'
-        yield seq
-
-    # 6. scattered three surrogates
-    for i in range(16):
-        for j in range(16):
-            for k in range(16):
-                    seq = ['V'] * 16
-                    for a, b, c in product('LH', repeat=3):
-                        seq[i] = a
-                        seq[j] = b
-                        seq[k] = c
-                        yield seq
-
-    # To cover all 16-byte inputs we would need 3**16 cases (43'046'721)
-    # Instead, we cover all possible 6-element combinations (3**6 = 729)
-    # and move it within 16-element input. This yields 729 * 10 cases.
-    k = 6
-    for combination in product('VLH', repeat=k):
-        for position in range(16 - k):
-            seq = ['V'] * 16
-            for i, v in enumerate(combination):
-                seq[i + position] = v
-
-            yield seq
-
-
-TXT = """# generated by scripts/sse_validate_utf16le_testcases.py
-"""
-
-def write_file(file):
-    file.write(TXT)
-    for words in test_words():
-        record = Record()
-        for word in words:
-            record.add(word)
-
-        file.write(str(record))
-        file.write('\n')
-
-
-def main():
-    seed(0)
-    with open('validate_utf16_testcases.txt', 'w') as f:
-        write_file(f)
-
-
-if __name__ == '__main__':
-    main()

package/deps/simdutf/scripts/table.py

@@ -1,207 +0,0 @@
-class TableBase(object):
-    def __init__(self):
-        self.headers = []
-        self.rows    = []
-
-    def set_header(self, header):
-        assert len(header) > 0
-        self.headers = [self.normalize(header)]
-
-    def add_row(self, row):
-        assert len(row) > 0
-        self.rows.append(self.normalize(row))
-
-    def normalize(self, row):
-        tmp = []
-        for text, count in self.iter_spans(row):
-            assert count >= 1
-            if count == 1:
-                tmp.append(text)
-            else:
-                tmp.append((text, count))
-
-        return tmp
-
-    def is_raw(self, row):
-        return all(isinstance(val, str) for val in row)
-
-    def iter_spans(self, row):
-        for item in row:
-            if type(item) is tuple:
-                text  = item[0]
-                count = item[1]
-            else:
-                text  = item
-                count = 1
-
-            yield (text, count)
-
-
-class TableValidator(object):
-    def __init__(self, table):
-        self.table = table
-        self.columns = self.get_table_columns_count()
-        if self.columns is None:
-            raise ValueError("Table doesn't have header which define column layout")
-        self.validate()
-
-    def get_table_columns_count(self):
-        # only from headers
-        for header in self.table.headers:
-            if self.table.is_raw(header):
-                return len(header)
-
-    def validate(self):
-        for i, header in enumerate(self.table.headers):
-            n = self.get_columns_count(header)
-            if n != self.columns:
-                raise ValueError("header #%d has %d column(s), expected %d: %s" % (i, n, self.columns, header))
-
-        for i, row in enumerate(self.table.rows):
-            n = self.get_columns_count(row)
-            if n != self.columns:
-                raise ValueError("row #%d has %d column(s), expected %d: %s" % (i, n, self.columns, row))
-
-    def get_columns_count(self, row):
-        n = 0
-        for _, count in self.table.iter_spans(row):
-            n += count
-
-        return n
-
-
-ALIGN_RIGHT = '>'
-ALIGN_LEFT = '<'
-CENTER = '^'
-
-
-class MarkdownTableRenderer(object):
-    def __init__(self, table):
-        if len(table.headers) > 1:
-            raise ValueError("Markdown does not support multiple header rows")
-
-        self.validator  = TableValidator(table)
-        self.table      = table
-        self.padding    = 1
-        self.widths     = self._calculate_widths()
-
-    def get_headers(self):
-        return self.table.headers
-
-    def get_rows(self):
-        return self.table.rows
-
-    def _calculate_widths(self):
-        width = [0] * self.validator.columns
-
-        # get width from fixed
-        for row in self.get_headers() + self.get_rows():
-            index = 0
-            for text, count in self.table.iter_spans(row):
-                w = len(text)
-                width[index] = max(w, width[index])
-                index += 1
-
-        return width
-
-    def _get_columns_width(self, start, count):
-        assert count >= 1
-
-        w = 0
-        for index in range(start, start + count):
-            w += self.widths[index]
-            w += 2 * self.padding
-
-        w += (count - 1)  # for the columns spacing '|'
-        return w
-
-    def _render_separator(self, row, fill):
-        assert len(fill) == 1
-
-        result = '|'
-        index = 0
-        for text, count in self.table.iter_spans(row):
-            result += ' '
-            result += fill * (self._get_columns_width(index, count) - 2)
-            result += ' '
-            result += '|'
-            index  += count
-
-        return result
-
-    def _render_row(self, row, align=None):
-        if align is not None:
-            def get_align(text):
-                return align
-        else:
-            def get_align(text):
-                if is_float_or_int(text):
-                    return ALIGN_RIGHT
-                else:
-                    return ALIGN_LEFT
-
-        result = '|'
-        index = 0
-        for text, count in self.table.iter_spans(row):
-            width   = self._get_columns_width(index, count)
-            width  -= 2 * self.padding
-            result += ' ' * self.padding
-            result += u'{:{align}{width}}'.format(text, align=get_align(text), width=width)
-            result += ' ' * self.padding
-            result += '|'
-
-            index  += count
-
-        return result
-
-    def get_image(self):
-        lines = []
-
-        if self.table.headers:
-            header = self.table.headers[0]
-            lines.append(self._render_row(header, CENTER))
-            lines.append(self._render_separator(header, '-'))
-
-        for row in self.get_rows():
-            lines.append(self._render_row(row))
-
-        return '\n'.join(lines)
-
-
-class Table(TableBase):
-    def __unicode__(self):
-        renderer = MarkdownTableRenderer(self)
-        return renderer.get_image()
-
-    def __str__(self):
-        renderer = MarkdownTableRenderer(self)
-        return renderer.get_image()
-
-
-def is_float_or_int(text):
-    try:
-        float(text)
-        return True
-    except ValueError:
-        return False
-
-
-if __name__ == '__main__':
-
-    table = Table()
-
-    table.set_header(["procedure", "size", "time"])
-    table.add_row(["foo", "100", "0.5"])
-    table.add_row(["bar", "105", "1.5"])
-    table.add_row(["baz", "111", "0.2"])
-
-    print(table)
-
-    table2 = Table()
-    table2.set_header(["size1", "size2", "proc1", "proc2", "proc3"])
-    table2.add_row(["1", "2", "a", "b", "c"])
-    table2.add_row(["9", "3", "A", "B", "C"])
-    table2.add_row(["42", "-", ("N/A", 3)])
-
-    print()
-    print(table2)

package/deps/simdutf/scripts/tests/new.txt

@@ -1,33 +0,0 @@
-We define the number of bytes to be the number of *input* bytes.
-We define a 'char' to be a code point (between 1 and 4 bytes).
-===========================
-Using ICU version 72.1
-testcases: 4
-input detected as UTF16 little-endian
-current system detected as haswell
-===========================
-convert_utf32_to_latin1+haswell, input size: 328672, iterations: 30000, dataset: unicode_lipsum/wikipedia_mars/esperanto.utflatin32.txt
-   0.149 ins/byte,    0.051 cycle/byte,   88.806 GB/s (38.6 %),     4.504 GHz,    2.944 ins/cycle 
-   0.597 ins/char,    0.203 cycle/char,   22.202 Gc/s (38.6 %)     4.00 byte/char   3701.0 ns
-WARNING: Measurements are noisy, try increasing iteration count (-I).
-input detected as UTF16 little-endian
-current system detected as haswell
-===========================
-convert_utf32_to_latin1+haswell, input size: 1729220, iterations: 30000, dataset: unicode_lipsum/wikipedia_mars/french.utflatin32.txt
-   0.149 ins/byte,    0.048 cycle/byte,   92.388 GB/s (43.9 %),     4.430 GHz,    3.099 ins/cycle 
-   0.594 ins/char,    0.192 cycle/char,   23.097 Gc/s (43.9 %)     4.00 byte/char  18717.0 ns
-WARNING: Measurements are noisy, try increasing iteration count (-I).
-input detected as UTF16 little-endian
-current system detected as haswell
-===========================
-convert_utf32_to_latin1+haswell, input size: 797324, iterations: 30000, dataset: unicode_lipsum/wikipedia_mars/german.utflatin32.txt
-   0.149 ins/byte,    0.050 cycle/byte,   79.836 GB/s (49.2 %),     4.020 GHz,    2.953 ins/cycle 
-   0.595 ins/char,    0.201 cycle/char,   19.959 Gc/s (49.2 %)     4.00 byte/char   9987.0 ns
-WARNING: Measurements are noisy, try increasing iteration count (-I).
-input detected as UTF16 little-endian
-current system detected as haswell
-===========================
-convert_utf32_to_latin1+haswell, input size: 1086972, iterations: 30000, dataset: unicode_lipsum/wikipedia_mars/portuguese.utflatin32.txt
-   0.149 ins/byte,    0.049 cycle/byte,   92.642 GB/s (17.6 %),     4.569 GHz,    3.016 ins/cycle 
-   0.595 ins/char,    0.197 cycle/char,   23.161 Gc/s (17.6 %)     4.00 byte/char  11733.0 ns
-WARNING: Measurements are noisy, try increasing iteration count (-I).