react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/benchmarks/competition/utf8lut/src/buffer/BaseBufferProcessor.h

@@ -1,210 +0,0 @@
-#pragma once
-
-#include <string.h>
-#include <assert.h>
-
-class BasePlugin;
-
-// BaseBufferProcessor: base class for any processor, which can convert buffers of data.
-// As soon as you have created a suitable processor object,
-// only this common interface is necessary to work with it.
-// See ProcessorSelector.h for information about choosing and creating a processor.
-//
-// Most of the methods of processor are used only to get information or to configure it.
-// The method 'Process' is the only one which actually performs the conversion.
-// Everything must be properly configured by the time it is called.
-// Among the state-configuring methods, only the following ones are mandatory (unless you use plugins):
-//   SetInputBuffer, SetOutputBuffer;
-// Among the info-quering methods, you will surely need the following ones:
-//   GetOutputBufferMinSize, GetInputDoneSize, GetOutputDoneSize;
-//
-// One input buffer and one (or several) output buffer(s) must be set for conversion.
-// Note that processor neither has any buffers within it, nor owns the buffers passed to it.
-// The caller is responsible for managing lifetime of the buffers, processor only saves references to them.
-//
-// Each call of 'Process' method performs conversion of the input buffer.
-// Below you can see the plan of all the buffers and how they are filled during 'Process' call.
-// There is a major difference here between single-stream and multi-stream conversion.
-// In multi-stream case, the input data is split into chunks, which are converted simultaneously,
-// Each stream converts its own chunk and writes conversion result to its own output buffer.
-//
-// 
-//           input buffer                                     input buffer                         ;
-//      +-------------------+                 \          +-----------------|-+                     ;
-//      |%%%%%%%%%%%%%%%%%%%|                  \         |.................|%|                     ;
-//      +-------------------+         ----------\        +-----------------|-+                     ;
-//                                      Process  >                         ^                       ;
-//           output buffer            ----------/             output buffer                        ;
-//   +---------------------------+             /      +------------------|--------+                ;
-//   |...........................|            /       |##################|........|                ;
-//   +---------------------------+                    +------------------|--------+                ;
-//                                                     0123456789ABCDEFGH^
-// (above: single-stream conversion)
-//   '.' -- nonexisting, undefined, or no-longer-necessary data
-//   '%' -- the input data, to be converted
-//   '#' -- the output data, already converted
-//   '^' -- a pointer showing how many bytes were read or written
-//   '012...AB...' --- the order of output data (within the message)
-// (below: multi-stream conversion, 4 streams)
-//
-//           input buffer                                     input buffer                         ;
-//         +--------------+                   \             +-------------|+                       ;
-//         |%%%%%%%%%%%%%%|                    \            |.............||                       ;
-//         +--------------+           ----------\           +-------------|+                       ;
-//                                      Process  >                        ^                        ;
-//           output buffers           ----------/             output buffers                       ;
-//  +-----+ +-----+ +-----+ +-----+            /     +---|-+ +--|--+ +----|+ +---|-+               ;
-//  |.....| |.....| |.....| |.....|           /      |###|.| |##|..| |####|| |###|.|               ;
-//  +-----+ +-----+ +-----+ +-----+                  +---|-+ +--|--+ +----|+ +---|-+               ;
-//                                                    012^    34^     5678^   9AB^                 ;
-//
-//
-// Plugins can be used to simplify setting input and output buffers,
-// but their usage is completely optional.
-// Each plugin has two methods: both of them are called inside 'Process' method.
-// One of them is called before conversion, and one of them is called after it.
-// See more details in ProcessorPlugins.h.
-//
-// When an encoding error is met in the input data,
-// the default behavior of a validating processor is to simply stop before it.
-// If you want to convert invalid input by fixing the encoding errors, then you should set an error callback.
-// You can read more about it and find some ready-to-use error callbacks in ProcessorSelector.h.
-// 
-class BaseBufferProcessor {
-public:
-    //maximum possible number of output streams among all available processors
-    static const int MaxStreamsCount = 4;
-    //a hard cap on the number of plugins that may be attached to a processor
-    static const int MaxPluginsCount = 2;
-
-    virtual ~BaseBufferProcessor();
-
-    // Resets processor to its default state.
-    // Exception: error callback is NOT changed (see details below).
-    void Clear();
-
-    // Returns how many output buffers are used.
-    // Usually a processor uses only one output buffer (i.e. single stream).
-    // The only exception is 4-stream buffer decoder, which converts to 4 buffers.
-    // Note: the same value is always returned for a given processor.
-    virtual int GetStreamsCount() const = 0;
-
-    // Specifies where to get input data from.
-    // A pointer to an external buffer must be passed.
-    // Note: here and below all buffer sizes are in bytes.
-    void SetInputBuffer(const char *ptr, int size);
-
-    // Specifies where to write output data to (for single stream).
-    // A pointer to an external buffer must be passed.
-    // Parameter 'index' is the index of the output stream being configured.
-    // In case of single-stream processor, only one output buffer is set.
-    // In case of multi-stream processor, output buffer must be set separately for each stream.
-    void SetOutputBuffer(char *ptr, int size, int index = 0);
-
-    // Checks whether all input + output buffers are configured correctly.
-    // Returns false if:
-    //   * one of the buffers is not set;
-    //   * one of the buffers has invalid size (empty or insanely large);
-    //   * the output buffers are not large enough to hold converted result;
-    //   * some buffers overlap;
-    bool CheckBuffers() const;
-
-    // Returns the recommended size of an input buffer.
-    // This size is considered to be good for performance.
-    // Using much smaller of much larger buffer would slow down conversion.
-    virtual int GetInputBufferRecommendedSize() const = 0;
-
-    // Returns minimal allowed size of each output buffer, given the size of the input buffer.
-    // In case of a multi-stream processor, every ONE output buffer
-    // must have at least this size (and NOT all of them together).
-    // This function does NOT depend on the state of processor,
-    // and for a given processor it always returns the same number given the same argument.
-    // The output depends on the input almost linearly (plus some constant overhead and some rounding).
-    // Note: the argument may exceed maximal allowed buffer size.
-    virtual long long GetOutputBufferMinSize(long long inputSize) const = 0;
-
-    // Returns maximal allowed size of any buffer involved.
-    // This size cap is orders of magnitude greater that the recommended size anyway.
-    // The returned value always stays the same for a given processor.
-    int GetBufferMaxSize() const;
-
-    // Sets a hint whether the next block of data would be the last one or not.
-    // If set to true, then maximum number of code points is always converted (a few bytes may remain).
-    // If you set it to false, then processor may leave a few complete code points unconverted (only in case of success).
-    // If the input data is invalid, then the hint does not matter (as if hint = true).
-    // Note: the last call of 'Process' method must be done with this hint set to true!
-    void SetHint(bool isLastBlock = true);
-
-    // Runs convertion of the preconfigured input buffer.
-    // The output is written into preconfigured output buffer (or bufferS in multi-stream case).
-    // The method returns:
-    //   'true':
-    //      Some prefix of the input buffer has been successfully converted.
-    //      See method SetHint for details about how the length of the prefix is chosen.
-    //   'false':
-    //      Some prefix of the input buffer has been successfully converted,
-    //      but the data immediately after it cannot be converted (because it is invalid).
-    // Note that if you set error callback (see below), then even invalid data is converted successfully.
-    // In order to learn how many bytes were converted, use methods GetInputDoneSize and GetOutputDoneSize.
-    bool Process();
-
-    // Returns how many bytes from the input buffer were successfully converted during the last 'Process' call.
-    int GetInputDoneSize() const;
-
-    // Returns how many bytes were written to the output buffer during the last 'Process' call.
-    // In case of multi-stream processor, you must specify 'index' of the output buffer.
-    // Then number of bytes written to this specific buffer is returned.
-    // If you concatenate the data written to all the output buffers (in their natural order),
-    // you will obtain the real result of the conversion.
-    int GetOutputDoneSize(int index = 0) const;
-
-    // Adds a plugin to processor.
-    // You should NOT call this method directly,
-    // because it is usually called in plugin's constructor.
-    // See ProcessorPlugins.h for more information.
-    void AddPlugin(BasePlugin &addedPlugin);
-
-    // The error callback receives an opaque value of this type.
-    typedef void *ctxErrorCallback;
-    // This is the type of the error callback function.
-    //   context: the opaque value set alongside the function pointer
-    //   srcBuffer: current pointer to the input data (everything before it has been converted)
-    //   srcBytes: how many bytes of input data remain ahead (unconverted yet)
-    //   dstBuffer: current pointer to the output data (the converted data is exactly before it)
-    //   dstBytes: how many bytes of space are left in the output buffer
-    // If true is returned, then conversion is continued as if no error happened.
-    // If false is returned, then conversion stops (just like it stops if no error callback is set)
-    // Both srcBuffer and dstBuffer can be updated by the callback,
-    // but note that moving output pointer too far may lead to buffer overflows in future.
-    typedef bool (*pfErrorCallback)(ctxErrorCallback context, const char *&srcBuffer, int srcBytes, char *&dstBuffer, int dstBytes);
-    // Sets a callback which would be fired each time processor detects invalid input data.
-    // The 'context' argument is passed to the callback function on every call.
-    // Error correction is not supported for processors with multi-stream output.
-    // Note: error callback is NOT cleared when 'Clear' method is called.
-    bool SetErrorCallback(pfErrorCallback callback = 0, ctxErrorCallback context = 0);
-    
-private:
-    virtual bool _Process() = 0;
-
-    //plugins attached
-    BasePlugin *plugins[MaxPluginsCount];
-    int pluginsCount;
-    //error callback (if present)
-    pfErrorCallback errorCallback;
-    ctxErrorCallback errorContext;
-
-protected:  //accessed in implementations
-    BaseBufferProcessor();
-
-    //input buffer
-    const char *inputBuffer;
-    int inputSize;
-    //output buffers (one per stream)
-    char *outputBuffer[MaxStreamsCount];
-    int outputSize[MaxStreamsCount];
-    //the hint: would next block be last
-    bool lastBlockMode;
-    //how much bytes were processed
-    int inputDone;
-    int outputDone[MaxStreamsCount];
-};

package/deps/simdutf/benchmarks/competition/utf8lut/src/buffer/BufferDecoder.h

@@ -1,158 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <assert.h>
-#include "../base/PerfDefs.h"
-#include "../core/DecoderLut.h"
-#include "../core/DecoderProcess.h"
-#include "../core/ProcessTrivial.h"
-#include "../base/Timing.h"
-#include "../buffer/BaseBufferProcessor.h"
-
-FORCEINLINE const char *FindUtf8Border(const char *pSource) {
-    for (int i = 0; i < 4; i++) {
-        uint8_t byte = pSource[i];
-        if ((byte & 0x80U) == 0x00U)
-            return pSource + i;
-        if ((byte & 0xC0U) == 0xC0U)
-            return pSource + i;
-    }
-    //four continuation bytes in a row
-    //split at the end, so that left half is surely invalid
-    return pSource + 4;
-}
-
-/**params:
- * MaxBytes = 0, 1, 2, 3
- * StreamsNum = 1, 4
- * Mode = fast, full, validate
- * OutputType = 2, 4
- */
-
-enum DecoderMode {
-    dmFast,     //decode only byte lengths under limit, no checks
-    dmFull,     //decode any UTF-8 chars (with fallback to slow version)
-    dmValidate, //decode any UTF-8 chars, validate input
-    dmAllCount, //helper
-};
-
-template<int MaxBytes, int OutputType, int Mode, int StreamsNum>
-class BufferDecoder : public BaseBufferProcessor {
-public:
-    static const int StreamsNumber = DMAX(StreamsNum, 1);
-
-private:
-    static const bool Validate = (Mode == dmValidate);
-
-    static FORCEINLINE bool ProcessSimple(const char *&inputPtr, const char *inputEnd, char *&outputPtr, bool isLastBlock) {
-        bool ok = true;
-        const DecoderLutEntry<Validate> *RESTRICT ptrTable = DecoderLutTable<Validate>::GetArray();
-        while (inputPtr <= inputEnd - 16) {
-            ok = DecoderCore<MaxBytes, Mode != dmFast, Mode == dmValidate, OutputType>()(inputPtr, outputPtr, ptrTable);
-            if (!ok) {
-                if (Mode != dmFast)
-                    ok = DecodeTrivial<OutputType>(inputPtr, inputPtr + 16, outputPtr);
-                if (!ok) break;
-            }
-        }
-        if (isLastBlock)
-            ok = DecodeTrivial<OutputType>(inputPtr, inputEnd, outputPtr);
-        return ok;
-    }
-
-    static FORCEINLINE void SplitRange(const char *buffer, int size, const char *splits[]) {
-        splits[0] = buffer;
-        splits[StreamsNumber] = buffer + size;
-        for (int k = 1; k < StreamsNumber; k++)
-            splits[k] = FindUtf8Border(buffer + uint32_t(k * size) / StreamsNumber);
-    }
-public:
-
-    BufferDecoder() {
-        static_assert(MaxBytes >= 0 && MaxBytes <= 3, "MaxBytes must be between 0 and 3");
-        static_assert(OutputType == 2 || OutputType == 4, "OutputType must be either 2 or 4");
-        static_assert(Mode >= 0 && Mode <= dmAllCount, "Mode must be from DecoderMode enum");
-        static_assert(StreamsNum == 1 || StreamsNum == 4, "StreamsNum can be only 1 or 4");
-        static_assert(MaxBytes > 0 || StreamsNum == 1, "StreamNum must be 1 when MaxBytes = 0");
-    }
-
-    virtual int GetStreamsCount() const {
-        return StreamsNumber;
-    }
-    virtual int GetInputBufferRecommendedSize() const {
-        return 1<<16;   //64KB
-    }
-    virtual long long GetOutputBufferMinSize(long long inputSize) const {
-        return (inputSize / StreamsNumber + 4) * OutputType;
-    }
-
-    virtual bool _Process() {
-        TIMING_START(DECODE);
-        static const int MinBytesPerStream = 32;    //more than 16 after split
-        if (StreamsNum > 1 && inputSize >= StreamsNum * MinBytesPerStream) {
-            assert(StreamsNum == 4);
-            const char *splits[StreamsNum + 1];
-            SplitRange(inputBuffer, inputSize, splits);
-            const DecoderLutEntry<Validate> *RESTRICT ptrTable = DecoderLutTable<Validate>::GetArray();
-            #define STREAM_START(k) \
-                const char *inputStart##k = splits[k]; \
-                const char *inputEnd##k = splits[k+1]; \
-                const char *inputPtr##k = inputStart##k; \
-                char *outputPtr##k = outputBuffer[k]; \
-                bool ok##k;
-            STREAM_START(0)
-            STREAM_START(1)
-            STREAM_START(2)
-            STREAM_START(3)
-            while (1) {
-                #define STREAM_CHECK(k) \
-                    if (inputPtr##k > inputEnd##k - 16) \
-                        break;
-                STREAM_CHECK(0);
-                STREAM_CHECK(1);
-                STREAM_CHECK(2);
-                STREAM_CHECK(3);
-                #define STREAM_STEP(k) \
-                    ok##k = DecoderCore<MaxBytes, Mode != dmFast, Mode == dmValidate, OutputType>()(inputPtr##k, outputPtr##k, ptrTable); \
-                    if (!ok##k) goto slow;
-                STREAM_STEP(0);
-                STREAM_STEP(1);
-                STREAM_STEP(2);
-                STREAM_STEP(3);
-slow:
-                #define STREAM_SLOW(k) \
-                    if (!ok##k && Mode != dmFast) \
-                        ok##k = DecodeTrivial<OutputType>(inputPtr##k, inputPtr##k + 16, outputPtr##k); \
-                    if (!ok##k) break;
-                STREAM_SLOW(0);
-                STREAM_SLOW(1);
-                STREAM_SLOW(2);
-                STREAM_SLOW(3);
-            }
-            #define STREAM_FINISH(k) \
-                ok##k = ProcessSimple(inputPtr##k, inputEnd##k, outputPtr##k, true); \
-                inputDone = int(inputPtr##k - inputBuffer); \
-                outputDone[k] = int(outputPtr##k - outputBuffer[k]); \
-                if (!ok##k || (k+1 < StreamsNum && inputPtr##k != inputEnd##k)) \
-                    return false;
-            STREAM_FINISH(0);
-            STREAM_FINISH(1);
-            STREAM_FINISH(2);
-            STREAM_FINISH(3);
-        }
-        else {
-            const char *inputPtr = inputBuffer + inputDone;
-            char *outputPtr = outputBuffer[0] + outputDone[0];
-            bool ok;
-            if (MaxBytes > 0)
-                ok = ProcessSimple(inputPtr, inputBuffer + inputSize, outputPtr, lastBlockMode);
-            else
-                ok = DecodeTrivial<OutputType>(inputPtr, inputBuffer + inputSize, outputPtr);
-            inputDone = int(inputPtr - inputBuffer);
-            outputDone[0] = int(outputPtr - outputBuffer[0]);
-            if (!ok) return false;
-        }
-        TIMING_END(DECODE, inputDone);
-        return true;
-    }
-};

package/deps/simdutf/benchmarks/competition/utf8lut/src/buffer/BufferEncoder.h

@@ -1,104 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <assert.h>
-#include "../base/PerfDefs.h"
-#include "../core/EncoderLut.h"
-#include "../core/EncoderProcess.h"
-#include "../core/ProcessTrivial.h"
-#include "../base/Timing.h"
-#include "../buffer/BaseBufferProcessor.h"
-
-/**params:
- * MaxBytes = 0, 1, 2, 3
- * UnrollNum = 1, 4
- * Mode = fast, full, validate
- * InputType = 2, 4
- */
-
-enum EncoderMode {
-    emFast,     //encode only byte lengths under limit, no checks
-    emFull,     //encode any UTF-8 chars (with fallback to slow version)
-    emValidate, //encode any UTF-8 chars, validate input
-    emAllCount, //helper
-};
-//Note: emValidate and emFull are completely equivalent
-
-template<int MaxBytes, int InputType, int Mode, int UnrollNum>
-class BufferEncoder : public BaseBufferProcessor {
-public:
-    static const int StreamsNumber = 1;
-
-private:
-    static const int InputMinChunk = 8 * InputType;
-    static const int InputUnrollChunk = InputMinChunk * (UnrollNum > 0 ? UnrollNum : 1);
-    static const bool ThreeBytes = (MaxBytes >= 3);
-
-    static FORCEINLINE bool ProcessSimple(const char *&inputPtr, const char *inputEnd, char *&outputPtr, bool isLastBlock) {
-        bool ok = true;
-        const EncoderLutEntry *RESTRICT ptrTable = EncoderLutTable<ThreeBytes>::GetArray();
-        while (inputPtr <= inputEnd - InputMinChunk) {
-            ok = EncoderCore<MaxBytes, Mode != dmFast, InputType>()(inputPtr, outputPtr, ptrTable);
-            if (!ok) {
-                if (Mode != dmFast)
-                    ok = EncodeTrivial<InputType>(inputPtr, inputPtr + InputMinChunk, outputPtr);
-                if (!ok) break;
-            }
-        }
-        if (isLastBlock)
-            ok = EncodeTrivial<InputType>(inputPtr, inputEnd, outputPtr);
-        return ok;
-    }
-
-public:
-
-    BufferEncoder() {
-        static_assert(MaxBytes >= 0 && MaxBytes <= 3, "MaxBytes must be between 0 and 3");
-        static_assert(InputType == 2 || InputType == 4, "InputType must be either 2 or 4");
-        static_assert(Mode >= 0 && Mode <= emAllCount, "Mode must be from EncoderMode enum");
-        static_assert(UnrollNum == 1 || UnrollNum == 4, "UnrollNum must be 1 or 4");
-        static_assert(MaxBytes > 0 || UnrollNum == 1, "UnrollNum must 1 when MaxBytes = 0");
-    }
-
-
-    virtual int GetStreamsCount() const {
-        return StreamsNumber;
-    }
-    virtual int GetInputBufferRecommendedSize() const {
-        return 1<<16;   //64KB
-    }
-    virtual long long GetOutputBufferMinSize(long long inputSize) const {
-        return (inputSize / InputType) * (InputType == 2 ? 3 : 4) + 16;
-    }
-
-    virtual bool _Process() {
-        TIMING_START(ENCODE);
-
-        const char *inputPtr = inputBuffer + inputDone;
-        char *outputPtr = outputBuffer[0] + outputDone[0];
-
-        if (UnrollNum == 4) {
-            const EncoderLutEntry *RESTRICT ptrTable = EncoderLutTable<ThreeBytes>::GetArray();
-            for (int i = 0; i < inputSize / InputUnrollChunk; i++) {
-                bool ok = 
-                    EncoderCore<MaxBytes, Mode != dmFast, InputType>()(inputPtr, outputPtr, ptrTable) &&
-                    EncoderCore<MaxBytes, Mode != dmFast, InputType>()(inputPtr, outputPtr, ptrTable) &&
-                    EncoderCore<MaxBytes, Mode != dmFast, InputType>()(inputPtr, outputPtr, ptrTable) &&
-                    EncoderCore<MaxBytes, Mode != dmFast, InputType>()(inputPtr, outputPtr, ptrTable);
-                if (!ok) break;
-            }
-        }
-
-        bool ok;
-        if (MaxBytes > 0)
-            ok = ProcessSimple(inputPtr, inputBuffer + inputSize, outputPtr, lastBlockMode);
-        else
-            ok = EncodeTrivial<InputType>(inputPtr, inputBuffer + inputSize, outputPtr);
-        inputDone = int(inputPtr - inputBuffer);
-        outputDone[0] = int(outputPtr - outputBuffer[0]);
-        if (!ok) return false;
-
-        TIMING_END(ENCODE, inputDone);
-        return true;
-    }
-};