react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/benchmarks/competition/utf8lut/src/iconv/iconv.h

@@ -1,74 +0,0 @@
-#ifndef ICONV_UTF8LUT_HEADER
-#define ICONV_UTF8LUT_HEADER
-
-//cross-platform export/import macro for shared library
-#ifdef _WIN32
-    #if defined(ICONV_UTF8LUT_BUILD) || defined(iconv_u8l_EXPORTS)
-        #define ICONV_UTF8LUT_EXPORT __declspec(dllexport) // Note: actually gcc seems to also supports this syntax.
-    #else
-        #define ICONV_UTF8LUT_EXPORT __declspec(dllimport) // Note: actually gcc seems to also supports this syntax.
-    #endif
-#else
-    #define ICONV_UTF8LUT_EXPORT __attribute__ ((visibility ("default")))
-#endif
-
-#include <stddef.h>
-
-//global var "errno" used to report errors
-#include <errno.h>
-//any valid iconv_t descriptor is actually a pointer to BaseBufferProcessor object
-typedef void *iconv_t;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-    // see manual at http://man7.org/linux/man-pages/man3/iconv_open.3.html
-    // Supported conversion modes are: from "UTF-8" to ("UTF-16LE" or "UTF-32LE") and vice versa.
-    //
-    ICONV_UTF8LUT_EXPORT iconv_t iconv_open(const char *tocode, const char *fromcode);
-
-    // see manual at http://man7.org/linux/man-pages/man3/iconv.3.html
-    //
-    // Breaking differences from the official iconv interface are:
-    //  1. If input is fully converted without errors, then just "1" is returned
-    //     (instead of the total number of characters converted).
-    //  2. If output buffer is not big enough to hold converted data for any valid input of size *inbytesleft (plus overhead),
-    //     then E2BIG verdict may be returned with considerable amount of input data left unprocessed (usually up to 64KB)
-    //     (while original interface guarantees that maximal possible number of input characters is processed).
-    //     In order to avoid this problem, allocate sufficiently large output buffer (see also p.3 below).
-    //
-    // Interface extension:
-    //  3. If inbuf and *inbuf are NOT null, and either outbuf or *outbuf is null, then:
-    //     maximal possible size of converted output (plus overhead) for input data of size *inbytesleft is stored into *outbytesleft.
-    //     If you start conversion with the same value of *inbytesleft, and such a value of *outbytesleft (or greater),
-    //     then the verdict E2BIG will surely NOT happen.
-    //     Note: inbuf parameter is NOT used in this case, and no actual conversion happens.
-    //
-    // Here is a code sample showing how to allocate output buffer, so that E2BIG verdict does NOT happen (see p.2 and p.3):
-    //     size_t inbufsize = {...}, outbufsize;
-    //     char *outbuf = (char*)0xDEADBEEF;
-    //     iconv(
-    //       cd,           //conversion descriptor
-    //       &outbuf,      //not used, but must be non-NULL
-    //       &inbufsize,   //size of input buffer
-    //       NULL,         //must be NULL
-    //       &outbufsize   //correct size of output buffer would be here
-    //     );
-    //     outbuf = malloc(outbufsize);
-    //     ...
-    //     char *inbuf = {...};
-    //     iconv(cd, &inbuf, &inbufsize, &outbuf, &outbufsize);
-    //     ...
-    //  
-    ICONV_UTF8LUT_EXPORT size_t iconv(iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
-
-    // see manual at http://man7.org/linux/man-pages/man3/iconv_close.3.html
-    //
-    ICONV_UTF8LUT_EXPORT int iconv_close(iconv_t cd);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

package/deps/simdutf/benchmarks/competition/utf8lut/src/message/MessageConverter.cpp

@@ -1,65 +0,0 @@
-#include "../message/MessageConverter.h"
-#include <stdio.h>
-
-//=====================================================================================================
-
-ConversionResult ConvertInMemory(BaseBufferProcessor &processor, const char *inputBuffer, long long inputSize, char *outputBuffer, long long outputSize) {
-    ConversionResult result;
-    result.status = (ConversionStatus)-1;
-    result.inputSize = 0;
-    result.outputSize = 0;
-    
-    if (inputSize < 0 || (!inputBuffer && inputSize != 0)) {
-        result.status = csInputOutputNoAccess;
-        return result;
-    }
-    if (outputSize < 0 || (!outputBuffer && outputSize != 0)) {
-        result.status = csInputOutputNoAccess;
-        return result;
-    }
-
-    long long reqSize = ContiguousOutput::GetMaxOutputSize(processor, inputSize);
-    if (outputSize < reqSize) {
-        result.status = csOverflowPossible;
-        return result;
-    }
-
-    processor.Clear();
-    ContiguousInput input(processor, inputBuffer, inputSize);
-    ContiguousOutput output(processor, outputBuffer, outputSize);
-
-    while (!input.Finished()) {
-        //do all the work
-        bool ok = processor.Process();
-
-        //check if hard error occurred
-        if (!ok) {
-            result.status = csIncorrectData;
-            break;
-        }
-    }
-
-    result.inputSize = input.GetProcessedInputSize();
-    result.outputSize = output.GetFilledOutputSize();
-
-    if (result.status == csIncorrectData) {
-        //hard error occured inside loop
-    }
-    else if (input.GetRemainingDataSize() != 0) {
-        //some bytes remain in the input
-        result.status = csIncompleteData;
-    }
-    else {
-        //everything is OK
-        result.status = csSuccess;
-    }
-
-    return result;
-}
-/*
-long long ConvertInMemorySize(BaseBufferProcessor &processor, long long inputSize, char **outputBuffer) {
-    long long reqSize = ContiguousOutput::GetMaxOutputSize(processor, inputSize);
-    if (outputBuffer && *outputBuffer == 0)
-        *outputBuffer = new char[reqSize];
-    return reqSize;
-}*/

package/deps/simdutf/benchmarks/competition/utf8lut/src/message/MessageConverter.h

@@ -1,91 +0,0 @@
-#pragma once
-
-#include "../buffer/BaseBufferProcessor.h"
-#include "../buffer/ProcessorPlugins.h"
-
-
-enum ConversionStatus {
-    csSuccess = 0,
-    // Conversion performed successfully.
-    // The input data is correct and complete.
-    // Output was properly written.
-
-    csOverflowPossible = 1,
-    // Conversion not attempted.
-    // Output buffer is not large enough to hold any potential converted output.
-
-    csIncompleteData = 2,
-    // Input data is correct but INCOMPLETE.
-    // All complete code points were converted and written to the output.
-
-    csIncorrectData = 3,
-    // Input data is INCORRECT.
-    // Conversion is done partially, but cannot be finished due to invalid input.
-    // Maximal prefix consisting of full and valid code points was converted (and written to output).
-
-    csInputOutputNoAccess = 4,
-    // Cannot work with given input/output.
-    // In case of files: cannot find or open input file, or cannot write to output file.
-    // In case of buffers: some non-empty buffer has zero pointer, or some buffer has negative size.
-
-    csNotImplemented = 5,
-    // Conversion with specified settings not yet implemented on current platform.
-    // For example, if you use ConvertFile with memory mapping, then OS-specific code is needed.
-};
-
-struct ConversionResult {
-    //overall result of conversion (see above)
-    ConversionStatus status;
-    //number of bytes read from input and successfully converted
-    long long inputSize;
-    //number of bytes written to output being the result of conversion
-    long long outputSize;
-};
-
-
-//======================================= In-memory conversion ====================================
-
-// Convert data from one contiguous buffer in memory into another contiguous buffer in memory.
-// The buffers must not overlap, both buffer sizes are given in bytes.
-// Output buffer must be sufficiently large, otherwise csOverflowPossible error would be returned.
-// You can determine a suitable size of output buffer by calling ConvertInMemorySize function (see below).
-// In order to get a processor object, use ProcessorSelector from the same-named header file.
-ConversionResult ConvertInMemory(BaseBufferProcessor &processor, const char *inputBuffer, long long inputSize, char *outputBuffer, long long outputSize);
-
-// Request information about the required size of the output buffer in ConvertInMemory routine.
-// Returns the minimal allowed size of the output buffer (in bytes).
-// It is surely enough to contain conversion output for any possible input buffer of specified size.
-// Additionally, if outputBuffer points to char* with null value, then:
-//    1. a buffer of that size will be allocated (with new char[]);
-//    2. pointer to this new buffer will be saved into *outputBuffer;
-//long long ConvertInMemorySize(BaseBufferProcessor &processor, long long inputSize, char **outputBuffer = 0);
-
-
-//===================================== File-to-file conversion ===================================
-
-enum FileIOType {
-    ftLibC = 0,
-    // Use fopen + fread + fwrite + fclose.
-    // Cross-platform.
-
-    ftMemoryMapWhole = 1,
-    // Map whole file into virtual address space.
-    // Uses OS-specific API.
-
-    //TODO: perhaps implement some other types?
-    //ftPosix,
-    //ftWinApi,
-    //ftPosixAsync,
-    //ftWinApiAsync,
-    //...
-};
-
-struct ConvertFilesSettings {
-    //which functions to use for IO
-    FileIOType type;
-
-    //TODO: should we allow to set buffer size?
-    //int bufferSize;
-
-    ConvertFilesSettings() : type(ftLibC)/*, bufferSize(0)*/ {}
-};