koffi 2.12.1 → 2.12.3

package/doc/flat/static.js

@@ -1,161 +0,0 @@
-// Copyright (C) 2024  Niels Martignène <niels.martignene@protonmail.com>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-window.addEventListener('load', e => {
-    initDeploy();
-    initMenu();
-    initSide();
-    initScroll();
-});
-
-function initDeploy() {
-    let el = document.querySelector('#deploy');
-
-    if (el != null)
-        el.addEventListener('click', deploy);
-}
-
-function deploy() {
-    let top = document.querySelector('nav#top');
-    top.classList.toggle('active');
-}
-
-function initMenu() {
-    let items = document.querySelectorAll('nav#top li');
-
-    document.body.addEventListener('click', e => {
-        if (e.target.tagName == 'DIV' && findParent(e.target, el => el.id == 'top'))
-            return;
-
-        // Expand top menu categories
-        {
-            let target = findParent(e.target, el => el.tagName == 'LI');
-
-            if (target?.querySelector('div') != null) {
-                for (let item of items) {
-                    if (item == target) {
-                        item.classList.toggle('active');
-                    } else {
-                        item.classList.remove('active');
-                    }
-                }
-            }
-        }
-
-        if (e.target.tagName == 'A' && e.target.getAttribute('href') == '#')
-            e.preventDefault();
-    });
-}
-
-function initSide() {
-    // Find all side menu items, and the pointed to elements
-    let links = [].slice.call(document.querySelectorAll('nav#side a'));
-    let items = [].slice.call(links).map(link => {
-        let anchor = document.querySelector(link.getAttribute('href'));
-        return [link, anchor];
-    });
-    if (!items.length)
-        return;
-
-    let pending_request = false;
-    let active_idx = null;
-    function highlight(idx) {
-        if (pending_request)
-            return;
-
-        window.requestAnimationFrame(() => {
-            pending_request = false;
-
-            if (idx !== active_idx) {
-                if (active_idx !== null)
-                    items[active_idx][0].classList.remove('active');
-                items[idx][0].classList.add('active');
-                active_idx = idx;
-            }
-        });
-        pending_request = true;
-    }
-
-    // Event handlers, for clicks
-    let ignore_scroll = false;
-    function highlightOnClick(idx) {
-        highlight(idx);
-        setTimeout(() => { ignore_scroll = false; }, 50);
-        ignore_scroll = true;
-    }
-    function highlightOnScroll() {
-        if (ignore_scroll)
-            return;
-
-        let style = window.getComputedStyle(document.documentElement);
-        let treshold = parseFloat(style.getPropertyValue('scroll-padding-top')) + 10;
-
-        let idx;
-        for (idx = 0; idx < items.length; idx++) {
-            let rect = items[idx][1].getBoundingClientRect();
-            if (rect.top >= treshold)
-                break;
-        }
-        if (idx)
-            idx--;
-
-        highlight(idx);
-    }
-
-    // The scroll handler is not enough because it does not work for
-    // small sections at the end of the page.
-    for (let i = 0; i < items.length; i++) {
-        items[i][0].addEventListener('click', highlightOnClick.bind(this, i));
-    }
-
-    // Enable only on big screens, when the side menu is fixed
-    let mql = window.matchMedia('(min-width: 801px)');
-    if (mql.matches) {
-        window.addEventListener('scroll', highlightOnScroll);
-        highlightOnScroll();
-    }
-    mql.addListener(mql => {
-        if (mql.matches) {
-            window.addEventListener('scroll', highlightOnScroll);
-            highlightOnScroll();
-        } else {
-            window.removeEventListener('scroll', highlightOnScroll);
-        }
-    });
-}
-
-function initScroll() {
-    window.addEventListener('scroll', adjust_top);
-    adjust_top();
-
-    function adjust_top() {
-        let top = document.querySelector('nav#top');
-
-        if (top != null)
-            top.classList.toggle('border', window.pageYOffset >= 20);
-    }
-}
-
-function findParent(el, func) {
-    while (el && !func(el))
-        el = el.parentElement;
-    return el;
-}
-
-
-document.documentElement.classList.remove('nojs');
-document.documentElement.classList.add('js');
-
-export { deploy }

package/src/core/libcc/brotli.cc

@@ -1,186 +0,0 @@
-// Copyright 2023 Niels Martignène <niels.martignene@protonmail.com>
-
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the “Software”), to deal in 
-// the Software without restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-// Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-
-#include "libcc.hh"
-
-#include "vendor/brotli/c/include/brotli/decode.h"
-#include "vendor/brotli/c/include/brotli/encode.h"
-
-namespace RG {
-
-class BrotliDecompressor: public StreamDecoder {
-    BrotliDecoderState *state = nullptr;
-    bool done = false;
-
-    uint8_t in_buf[256 * 1024];
-    Size in_len = 0;
-
-    uint8_t out_buf[256 * 1024];
-    Size out_len = 0;
-
-public:
-    BrotliDecompressor(StreamReader *reader, CompressionType type);
-    ~BrotliDecompressor();
-
-    Size Read(Size max_len, void *out_buf) override;
-};
-
-BrotliDecompressor::BrotliDecompressor(StreamReader *reader, CompressionType)
-    : StreamDecoder(reader)
-{
-    state = BrotliDecoderCreateInstance(nullptr, nullptr, nullptr);
-    if (!state)
-        throw std::bad_alloc();
-}
-
-BrotliDecompressor::~BrotliDecompressor()
-{
-    BrotliDecoderDestroyInstance(state);
-}
-
-Size BrotliDecompressor::Read(Size max_len, void *user_buf)
-{
-    for (;;) {
-        if (out_len || done) {
-            Size copy_len = std::min(max_len, out_len);
-
-            out_len -= copy_len;
-            memcpy(user_buf, out_buf, copy_len);
-            memmove(out_buf, out_buf + copy_len, out_len);
-
-            SetEOF(!out_len && done);
-            return copy_len;
-        }
-
-        if (in_len < RG_SIZE(in_buf)) {
-            Size raw_len = ReadRaw(RG_SIZE(in_buf) - in_len, in_buf + in_len);
-            if (raw_len < 0)
-                return -1;
-            in_len += raw_len;
-        }
-
-        const uint8_t *next_in = in_buf;
-        uint8_t *next_out = out_buf + out_len;
-        size_t avail_in = (size_t)in_len;
-        size_t avail_out = (size_t)(RG_SIZE(out_buf) - out_len);
-
-        BrotliDecoderResult ret = BrotliDecoderDecompressStream(state, &avail_in, &next_in,
-                                                                &avail_out, &next_out, nullptr);
-
-        if (ret == BROTLI_DECODER_RESULT_SUCCESS) {
-            done = true;
-        } else if (ret == BROTLI_DECODER_RESULT_ERROR) {
-            LogError("Malformed Brotli stream in '%1'", GetFileName());
-            return -1;
-        }
-
-        memmove_safe(in_buf, next_in, (size_t)avail_in);
-        in_len = avail_in;
-
-        out_len = next_out - out_buf - out_len;
-    }
-
-    RG_UNREACHABLE();
-}
-
-class BrotliCompressor: public StreamEncoder {
-    BrotliEncoderStateStruct *state = nullptr;
-
-public:
-    BrotliCompressor(StreamWriter *writer, CompressionType type, CompressionSpeed speed);
-    ~BrotliCompressor();
-
-    bool Write(Span<const uint8_t> buf) override;
-    bool Finalize() override;
-};
-
-BrotliCompressor::BrotliCompressor(StreamWriter *writer, CompressionType, CompressionSpeed speed)
-    : StreamEncoder(writer)
-{
-    state = BrotliEncoderCreateInstance(nullptr, nullptr, nullptr);
-    if (!state)
-        throw std::bad_alloc();
-
-    static_assert(BROTLI_MIN_QUALITY == 0 && BROTLI_MAX_QUALITY == 11);
-
-    switch (speed) {
-        case CompressionSpeed::Default: { BrotliEncoderSetParameter(state, BROTLI_PARAM_QUALITY, 6); } break;
-        case CompressionSpeed::Slow: { BrotliEncoderSetParameter(state, BROTLI_PARAM_QUALITY, 11); } break;
-        case CompressionSpeed::Fast: { BrotliEncoderSetParameter(state, BROTLI_PARAM_QUALITY, 0); } break;
-    }
-}
-
-BrotliCompressor::~BrotliCompressor()
-{
-    BrotliEncoderDestroyInstance(state);
-}
-
-bool BrotliCompressor::Write(Span<const uint8_t> buf)
-{
-    uint8_t output_buf[2048];
-
-    while (buf.len || BrotliEncoderHasMoreOutput(state)) {
-        const uint8_t *next_in = buf.ptr;
-        uint8_t *next_out = output_buf;
-        size_t avail_in = (size_t)buf.len;
-        size_t avail_out = RG_SIZE(output_buf);
-
-        if (!BrotliEncoderCompressStream(state, BROTLI_OPERATION_PROCESS,
-                                         &avail_in, &next_in, &avail_out, &next_out, nullptr)) {
-            LogError("Failed to compress '%1' with Brotli", GetFileName());
-            return false;
-        }
-        if (!WriteRaw(MakeSpan(output_buf, next_out - output_buf)))
-            return false;
-
-        buf.len -= next_in - buf.ptr;
-        buf.ptr = next_in;
-    }
-
-    return true;
-}
-
-bool BrotliCompressor::Finalize()
-{
-    uint8_t output_buf[2048];
-
-    do {
-        const uint8_t *next_in = nullptr;
-        uint8_t *next_out = output_buf;
-        size_t avail_in = 0;
-        size_t avail_out = RG_SIZE(output_buf);
-
-        if (!BrotliEncoderCompressStream(state, BROTLI_OPERATION_FINISH,
-                                         &avail_in, &next_in, &avail_out, &next_out, nullptr)) {
-            LogError("Failed to compress '%1' with Brotli", GetFileName());
-            return false;
-        }
-        if (!WriteRaw(MakeSpan(output_buf, next_out - output_buf)))
-            return false;
-    } while (BrotliEncoderHasMoreOutput(state));
-
-    return true;
-}
-
-RG_REGISTER_DECOMPRESSOR(CompressionType::Brotli, BrotliDecompressor);
-RG_REGISTER_COMPRESSOR(CompressionType::Brotli, BrotliCompressor);
-
-}

package/src/core/libcc/lz4.cc

@@ -1,197 +0,0 @@
-// Copyright 2023 Niels Martignène <niels.martignene@protonmail.com>
-
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the “Software”), to deal in 
-// the Software without restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-// Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-
-#include "libcc.hh"
-
-#include "vendor/lz4/lib/lz4.h"
-#include "vendor/lz4/lib/lz4hc.h"
-#include "vendor/lz4/lib/lz4frame.h"
-
-namespace RG {
-
-class LZ4Decompressor: public StreamDecoder {
-    LZ4F_dctx *decoder = nullptr;
-    bool done = false;
-
-    uint8_t in_buf[256 * 1024];
-    Size in_len = 0;
-    Size in_hint = RG_SIZE(in_buf);
-
-    uint8_t out_buf[256 * 1024];
-    Size out_len = 0;
-
-public:
-    LZ4Decompressor(StreamReader *reader, CompressionType type);
-    ~LZ4Decompressor();
-
-    Size Read(Size max_len, void *out_buf) override;
-};
-
-LZ4Decompressor::LZ4Decompressor(StreamReader *reader, CompressionType)
-    : StreamDecoder(reader) 
-{
-    LZ4F_errorCode_t err = LZ4F_createDecompressionContext(&decoder, LZ4F_VERSION);
-    if (LZ4F_isError(err))
-        throw std::bad_alloc();
-}
-
-LZ4Decompressor::~LZ4Decompressor()
-{
-    LZ4F_freeDecompressionContext(decoder);
-}
-
-Size LZ4Decompressor::Read(Size max_len, void *user_buf)
-{
-    for (;;) {
-        if (out_len || done) {
-            Size copy_len = std::min(max_len, out_len);
-
-            out_len -= copy_len;
-            memcpy(user_buf, out_buf, copy_len);
-            memmove(out_buf, out_buf + copy_len, out_len);
-
-            SetEOF(!out_len && done);
-            return copy_len;
-        }
-
-        if (in_len < in_hint) {
-            Size raw_len = ReadRaw(in_hint - in_len, in_buf + in_len);
-            if (raw_len < 0)
-                return -1;
-            in_len += raw_len;
-        }
-
-        const uint8_t *next_in = in_buf;
-        uint8_t *next_out = out_buf + out_len;
-        size_t avail_in = (size_t)in_len;
-        size_t avail_out = (size_t)(RG_SIZE(out_buf) - out_len);
-
-        LZ4F_decompressOptions_t opt = {};
-        size_t ret = LZ4F_decompress(decoder, next_out, &avail_out, next_in, &avail_in, &opt);
-
-        if (!ret) {
-            done = true;
-        } else if (LZ4F_isError(ret)) {
-            LogError("Malformed LZ4 stream in '%1': %2", GetFileName(), LZ4F_getErrorName(ret));
-            return -1;
-        }
-
-        memmove_safe(in_buf, in_buf + avail_in, (size_t)in_len - avail_in);
-        in_len -= avail_in;
-        in_hint = std::min(RG_SIZE(in_buf), (Size)ret);
-
-        out_len += (Size)avail_out;
-    }
-
-    RG_UNREACHABLE();
-}
-
-class LZ4Compressor: public StreamEncoder {
-    LZ4F_cctx *encoder = nullptr;
-    LZ4F_preferences_t prefs = {};
-
-    HeapArray<uint8_t> dynamic_buf;
-
-public:
-    LZ4Compressor(StreamWriter *writer, CompressionType type, CompressionSpeed speed);
-    ~LZ4Compressor();
-
-    bool Write(Span<const uint8_t> buf) override;
-    bool Finalize() override;
-};
-
-LZ4Compressor::LZ4Compressor(StreamWriter *writer, CompressionType, CompressionSpeed speed)
-    : StreamEncoder(writer)
-{
-    LZ4F_errorCode_t err = LZ4F_createCompressionContext(&encoder, LZ4F_VERSION);
-    if (LZ4F_isError(err))
-        throw std::bad_alloc();
-
-    switch (speed) {
-        case CompressionSpeed::Default: { prefs.compressionLevel = LZ4HC_CLEVEL_MIN; } break;
-        case CompressionSpeed::Slow: { prefs.compressionLevel = LZ4HC_CLEVEL_MAX; } break;
-        case CompressionSpeed::Fast: { prefs.compressionLevel = 0; } break;
-    }
-
-    dynamic_buf.Grow(LZ4F_HEADER_SIZE_MAX);
-
-    size_t ret = LZ4F_compressBegin(encoder, dynamic_buf.end(), dynamic_buf.capacity - dynamic_buf.len, &prefs);
-    if (LZ4F_isError(ret))
-        throw std::bad_alloc();
-
-    dynamic_buf.len += ret;
-}
-
-LZ4Compressor::~LZ4Compressor()
-{
-    LZ4F_freeCompressionContext(encoder);
-}
-
-bool LZ4Compressor::Write(Span<const uint8_t> buf)
-{
-    size_t needed = LZ4F_compressBound((size_t)buf.len, &prefs);
-    dynamic_buf.Grow((Size)needed);
-
-    size_t ret = LZ4F_compressUpdate(encoder, dynamic_buf.end(), (size_t)(dynamic_buf.capacity - dynamic_buf.len),
-                                     buf.ptr, (size_t)buf.len, nullptr);
-
-    if (LZ4F_isError(ret)) {
-        LogError("Failed to write LZ4 stream for '%1': %2", GetFileName(), LZ4F_getErrorName(ret));
-        return false;
-    }
-
-    dynamic_buf.len += (Size)ret;
-
-    if (dynamic_buf.len >= 512) {
-        if (!WriteRaw(dynamic_buf))
-            return false;
-        dynamic_buf.len = 0;
-    }
-
-    return true;
-}
-
-bool LZ4Compressor::Finalize()
-{
-    size_t needed = LZ4F_compressBound(0, &prefs);
-    dynamic_buf.Grow((Size)needed);
-
-    size_t ret = LZ4F_compressEnd(encoder, dynamic_buf.end(),
-                                  (size_t)(dynamic_buf.capacity - dynamic_buf.len), nullptr);
-
-    if (LZ4F_isError(ret)) {
-        LogError("Failed to finalize LZ4 stream for '%1': %2", GetFileName(), LZ4F_getErrorName(ret));
-        return false;
-    }
-
-    dynamic_buf.len += (Size)ret;
-
-    if (!WriteRaw(dynamic_buf))
-        return false;
-    dynamic_buf.len = 0;
-
-    return true;
-}
-
-RG_REGISTER_DECOMPRESSOR(CompressionType::LZ4, LZ4Decompressor);
-RG_REGISTER_COMPRESSOR(CompressionType::LZ4, LZ4Compressor);
-
-}