Squash commits for public release

libs/libfoundation/BUILD.gn

@@ -0,0 +1,19 @@
+import("//build/libs/TEMPLATE.gni")
+
+xOS_static_library("libfoundation") {
+  sources = [
+    "src/EventLoop.cpp",
+    "src/Logger.cpp",
+    "src/ProcessInfo.cpp",
+    "src/compress/puff.c",
+    "src/json/Lexer.cpp",
+    "src/json/Parser.cpp",
+  ]
+
+  deplibs = [ "libcxx" ]
+  configs = [ "//build/libs:libcxx_flags" ]
+
+  if (host == "llvm") {
+    cflags = [ "-flto" ]
+  }
+}

libs/libfoundation/include/libfoundation/ByteOrder.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <cstddef>
+
+namespace LFoundation {
+
+class ByteOrder {
+public:
+    template <typename T>
+    [[gnu::always_inline]] static inline T from_network(T value)
+    {
+        if constexpr (sizeof(T) == 8) {
+            return __builtin_bswap64(value);
+        }
+        if constexpr (sizeof(T) == 4) {
+            return __builtin_bswap32(value);
+        }
+        if constexpr (sizeof(T) == 2) {
+            return __builtin_bswap16(value);
+        }
+        if constexpr (sizeof(T) == 1) {
+            return value;
+        }
+    }
+};
+
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/Event.h

@@ -0,0 +1,38 @@
+#pragma once
+
+namespace LFoundation {
+
+class Event {
+public:
+    enum Type {
+        Invalid = 0,
+        FdWaiterRead,
+        FdWaiterWrite,
+        DeferredInvoke,
+        Other,
+    };
+
+    explicit Event(int type)
+        : m_type(type)
+    {
+    }
+
+    bool operator==(const Event& other)
+    {
+        return m_type == other.m_type;
+    }
+
+    bool operator!=(const Event& other)
+    {
+        return m_type != other.m_type;
+    }
+
+    ~Event() = default;
+
+    int type() const { return m_type; }
+
+private:
+    int m_type;
+};
+
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/EventLoop.h

@@ -0,0 +1,85 @@
+#pragma once
+#include <functional>
+#include <libfoundation/Event.h>
+#include <libfoundation/EventReceiver.h>
+#include <libfoundation/Receivers.h>
+#include <list>
+#include <memory>
+#include <vector>
+
+namespace LFoundation {
+
+class QueuedEvent {
+public:
+    friend class EventLoop;
+    QueuedEvent(EventReceiver& rec, Event* ptr)
+        : event(ptr)
+        , receiver(rec)
+    {
+    }
+
+    QueuedEvent(QueuedEvent&& qe)
+        : event(std::move(qe.event))
+        , receiver(qe.receiver)
+    {
+    }
+
+    QueuedEvent& operator=(QueuedEvent&& qe)
+    {
+        event = std::move(qe.event);
+        receiver = qe.receiver;
+        return *this;
+    }
+
+    ~QueuedEvent() = default;
+
+    EventReceiver& receiver;
+    std::unique_ptr<Event> event { nullptr };
+};
+
+class EventLoop {
+public:
+    inline static EventLoop& the()
+    {
+        extern EventLoop* s_LFoundation_EventLoop_the;
+        return *s_LFoundation_EventLoop_the;
+    }
+
+    EventLoop();
+
+    inline void add(int fd, std::function<void(void)> on_read, std::function<void(void)> on_write)
+    {
+        m_waiting_fds.push_back(FDWaiter(fd, on_read, on_write));
+    }
+
+    inline void add(const Timer& timer)
+    {
+        m_timers.push_back(timer);
+    }
+
+    inline void add(Timer&& timer)
+    {
+        m_timers.push_back(std::move(timer));
+    }
+
+    inline void add(EventReceiver& rec, Event* ptr)
+    {
+        m_event_queue.push_back(QueuedEvent(rec, ptr));
+    }
+
+    inline void stop(int exit_code) { m_exit_code = exit_code, m_stop_flag = true; }
+    int run();
+
+private:
+    void pump();
+    void cleanup_timers();
+    void check_fds();
+    void check_timers();
+
+    bool m_stop_flag { false };
+    int m_exit_code { 0 };
+    std::vector<FDWaiter> m_waiting_fds;
+    std::list<Timer> m_timers;
+    std::vector<QueuedEvent> m_event_queue;
+};
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/EventReceiver.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <libfoundation/Event.h>
+#include <memory>
+
+namespace LFoundation {
+
+class EventReceiver {
+public:
+    EventReceiver() = default;
+    ~EventReceiver() = default;
+    virtual void receive_event(std::unique_ptr<Event> event) { }
+
+private:
+};
+
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/FileManager.h

@@ -0,0 +1,56 @@
+#pragma once
+#include <dirent.h>
+#include <string>
+#include <unistd.h>
+#include <vector>
+
+namespace LFoundation {
+
+class FileManager {
+public:
+    FileManager() = default;
+    ~FileManager() = default;
+
+    template <typename Callback>
+    int foreach_object(const std::string& path, Callback callback) const
+    {
+        const size_t temporal_buffer_size = 1024;
+        char* temporal_buffer = new char[temporal_buffer_size];
+
+        struct linux_dirent {
+            uint32_t inode;
+            uint16_t rec_len;
+            uint8_t name_len;
+            uint8_t file_type;
+            char* name;
+        }* d;
+
+        int fd = open(path.c_str(), O_RDONLY | O_DIRECTORY);
+        if (fd < 0) {
+            return -1;
+        }
+
+        for (;;) {
+            int nread = getdents(fd, temporal_buffer, temporal_buffer_size);
+            if (nread == 0) {
+                break;
+            }
+
+            for (int bpos = 0; bpos < nread;) {
+                d = (struct linux_dirent*)(temporal_buffer + bpos);
+                if (((char*)&d->name)[0] != '.') {
+                    callback((char*)&d->name);
+                }
+                bpos += d->rec_len;
+            }
+        }
+
+        close(fd);
+        delete[] temporal_buffer;
+        return 0;
+    }
+
+private:
+};
+
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/KeyboardMapping.h

@@ -0,0 +1,171 @@
+#pragma once
+
+namespace LFoundation {
+enum Keycode {
+
+    // Alphanumeric keys ////////////////
+    KEY_CTRLC = '\003',
+
+    KEY_SPACE = ' ',
+    KEY_0 = '0',
+    KEY_1 = '1',
+    KEY_2 = '2',
+    KEY_3 = '3',
+    KEY_4 = '4',
+    KEY_5 = '5',
+    KEY_6 = '6',
+    KEY_7 = '7',
+    KEY_8 = '8',
+    KEY_9 = '9',
+
+    KEY_A = 'a',
+    KEY_B = 'b',
+    KEY_C = 'c',
+    KEY_D = 'd',
+    KEY_E = 'e',
+    KEY_F = 'f',
+    KEY_G = 'g',
+    KEY_H = 'h',
+    KEY_I = 'i',
+    KEY_J = 'j',
+    KEY_K = 'k',
+    KEY_L = 'l',
+    KEY_M = 'm',
+    KEY_N = 'n',
+    KEY_O = 'o',
+    KEY_P = 'p',
+    KEY_Q = 'q',
+    KEY_R = 'r',
+    KEY_S = 's',
+    KEY_T = 't',
+    KEY_U = 'u',
+    KEY_V = 'v',
+    KEY_W = 'w',
+    KEY_X = 'x',
+    KEY_Y = 'y',
+    KEY_Z = 'z',
+
+    KEY_RETURN = '\r',
+    KEY_ESCAPE = 0x1001,
+    KEY_BACKSPACE = '\b',
+
+    // Arrow keys ////////////////////////
+
+    KEY_UP = 0x1100,
+    KEY_DOWN = 0x1101,
+    KEY_LEFT = 0x1102,
+    KEY_RIGHT = 0x1103,
+
+    // Function keys /////////////////////
+
+    KEY_F1 = 0x1201,
+    KEY_F2 = 0x1202,
+    KEY_F3 = 0x1203,
+    KEY_F4 = 0x1204,
+    KEY_F5 = 0x1205,
+    KEY_F6 = 0x1206,
+    KEY_F7 = 0x1207,
+    KEY_F8 = 0x1208,
+    KEY_F9 = 0x1209,
+    KEY_F10 = 0x120a,
+    KEY_F11 = 0x120b,
+    KEY_F12 = 0x120b,
+    KEY_F13 = 0x120c,
+    KEY_F14 = 0x120d,
+    KEY_F15 = 0x120e,
+
+    KEY_DOT = '.',
+    KEY_COMMA = ',',
+    KEY_COLON = ':',
+    KEY_SEMICOLON = ';',
+    KEY_SLASH = '/',
+    KEY_BACKSLASH = '\\',
+    KEY_PLUS = '+',
+    KEY_MINUS = '-',
+    KEY_ASTERISK = '*',
+    KEY_EXCLAMATION = '!',
+    KEY_QUESTION = '?',
+    KEY_QUOTEDOUBLE = '\"',
+    KEY_QUOTE = '\'',
+    KEY_EQUAL = '=',
+    KEY_HASH = '#',
+    KEY_PERCENT = '%',
+    KEY_AMPERSAND = '&',
+    KEY_UNDERSCORE = '_',
+    KEY_LEFTPARENTHESIS = '(',
+    KEY_RIGHTPARENTHESIS = ')',
+    KEY_LEFTBRACKET = '[',
+    KEY_RIGHTBRACKET = ']',
+    KEY_LEFTCURL = '{',
+    KEY_RIGHTCURL = '}',
+    KEY_DOLLAR = '$',
+    KEY_POUND = 0,
+    KEY_EURO = '$',
+    KEY_LESS = '<',
+    KEY_GREATER = '>',
+    KEY_BAR = '|',
+    KEY_GRAVE = '`',
+    KEY_TILDE = '~',
+    KEY_AT = '@',
+    KEY_CARRET = '^',
+
+    // Numeric keypad //////////////////////
+
+    KEY_KP_0 = '0',
+    KEY_KP_1 = '1',
+    KEY_KP_2 = '2',
+    KEY_KP_3 = '3',
+    KEY_KP_4 = '4',
+    KEY_KP_5 = '5',
+    KEY_KP_6 = '6',
+    KEY_KP_7 = '7',
+    KEY_KP_8 = '8',
+    KEY_KP_9 = '9',
+    KEY_KP_PLUS = '+',
+    KEY_KP_MINUS = '-',
+    KEY_KP_DECIMAL = '.',
+    KEY_KP_DIVIDE = '/',
+    KEY_KP_ASTERISK = '*',
+    KEY_KP_NUMLOCK = 0x300f,
+    KEY_KP_ENTER = 0x3010,
+
+    KEY_TAB = 0x4000,
+    KEY_CAPSLOCK = 0x4001,
+
+    // Modify keys ////////////////////////////
+
+    KEY_LSHIFT = 0x4002,
+    KEY_LCTRL = 0x4003,
+    KEY_LALT = 0x4004,
+    KEY_LWIN = 0x4005,
+    KEY_RSHIFT = 0x4006,
+    KEY_RCTRL = 0x4007,
+    KEY_RALT = 0x4008,
+    KEY_RWIN = 0x4009,
+
+    KEY_INSERT = 0x400a,
+    KEY_DELETE = 0x400b,
+    KEY_HOME = 0x400c,
+    KEY_END = 0x400d,
+    KEY_PAGEUP = 0x400e,
+    KEY_PAGEDOWN = 0x400f,
+    KEY_SCROLLLOCK = 0x4010,
+    KEY_PAUSE = 0x4011,
+
+    // Multimedia keys ////////////////////////
+
+    KEY_PREV_TRACK = 0x5001,
+    KEY_NEXT_TRACK = 0x5002,
+    KEY_MUTE = 0x5003,
+    KEY_CALC = 0x5004,
+    KEY_PLAY = 0x5005,
+    KEY_STOP = 0x5006,
+    KEY_VOL_DOWN = 0x5007,
+    KEY_VOL_UP = 0x5008,
+
+    KEY_WWW_HOME = 0x500a,
+
+    KEY_UNKNOWN,
+    KEY_NUMKEYCODES
+};
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/Logger.h

@@ -0,0 +1,11 @@
+#include <ostream>
+
+namespace LFoundation::Logger {
+
+extern std::ostream debug;
+
+} // namespace LFoundation::Logger
+
+namespace Logger {
+using LFoundation::Logger::debug;
+} // namespace Logger

libs/libfoundation/include/libfoundation/Math.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <cstddef>
+
+namespace LFoundation {
+
+[[gnu::always_inline]] inline float fast_inv_sqrt(float x)
+{
+    float xhalf = 0.5f * x;
+    int i = *(int*)&x;
+    i = 0x5f3759df - (i >> 1);
+    x = *(float*)&i;
+    x = x * (1.5f - xhalf * x * x);
+    return x;
+}
+
+[[gnu::always_inline]] inline float fast_sqrt(float x)
+{
+    return 1.0 / fast_inv_sqrt(x);
+}
+
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/Memory.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <cstddef>
+
+namespace LFoundation {
+
+[[gnu::always_inline]] inline void fast_copy(uint32_t* dest, const uint32_t* src, std::size_t count)
+{
+#if defined(__i386__) || defined(__x86_64__)
+    asm volatile(
+        "rep movsl\n"
+        : "=S"(src), "=D"(dest), "=c"(count)
+        : "S"(src), "D"(dest), "c"(count)
+        : "memory");
+#elif __arm__
+    while (count--) {
+        asm("pld [%0, #128]" ::"r"(src));
+        *dest++ = *src++;
+    }
+#elif __aarch64__
+    while (count--) {
+        *dest++ = *src++;
+    }
+#elif defined(__riscv) && (__riscv_xlen == 64)
+    while (count--) {
+        *dest++ = *src++;
+    }
+#endif
+}
+
+[[gnu::always_inline]] inline void fast_set(uint32_t* dest, uint32_t val, std::size_t count)
+{
+#if defined(__i386__) || defined(__x86_64__)
+    asm volatile(
+        "rep stosl\n"
+        : "=D"(dest), "=c"(count)
+        : "D"(dest), "c"(count), "a"(val)
+        : "memory");
+#elif __arm__
+    asm volatile(
+        "cmp     %[count], #0\n"
+        "beq     fast_set_exit%=\n"
+        "tst     %[ptr], #15\n"
+        "beq     fast_set_16bytes_aligned_entry%=\n"
+        "fast_set_4bytes_aligned_loop%=:\n"
+        "subs	 %[count], %[count], #1\n"
+        "str     %[value], [%[ptr]], #4\n"
+        "beq     fast_set_exit%=\n"
+        "tst     %[ptr], #15\n"
+        "bne     fast_set_4bytes_aligned_loop%=\n"
+        "fast_set_16bytes_aligned_entry%=:\n"
+        "cmp     %[count], #4\n"
+        "blt     fast_set_16bytes_aligned_exit%=\n"
+        "fast_set_16bytes_aligned_preloop%=:\n"
+        "mov     r4, %[value]\n"
+        "mov     r5, %[value]\n"
+        "mov     r6, %[value]\n"
+        "mov     r7, %[value]\n"
+        "fast_set_16bytes_aligned_loop%=:\n"
+        "subs	 %[count], %[count], #4\n"
+        "stmia	 %[ptr]!, {r4,r5,r6,r7}\n"
+        "cmp     %[count], #4\n"
+        "bge     fast_set_16bytes_aligned_loop%=\n"
+        "fast_set_16bytes_aligned_exit%=:\n"
+        "cmp     %[count], #0\n"
+        "beq     fast_set_exit%=\n"
+        "fast_set_4bytes_aligned_loop_2_%=:\n"
+        "subs	 %[count], %[count], #1\n"
+        "str     %[value], [%[ptr]], #4\n"
+        "bne     fast_set_4bytes_aligned_loop_2_%=\n"
+        "fast_set_exit%=:"
+        : [value] "=r"(val),
+        [ptr] "=r"(dest),
+        [count] "=r"(count)
+        : "[value]"(val),
+        "[ptr]"(dest),
+        "[count]"(count)
+        : "r4", "r5", "r6", "r7", "memory", "cc");
+#elif __aarch64__
+    while (count--) {
+        *dest++ = val;
+    }
+#elif defined(__riscv) && (__riscv_xlen == 64)
+    while (count--) {
+        *dest++ = val;
+    }
+#endif
+}
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/Object.h

@@ -0,0 +1,12 @@
+#pragma once
+#include <libfoundation/EventReceiver.h>
+
+namespace LFoundation {
+
+class Object : public LFoundation::EventReceiver {
+public:
+    Object() = default;
+    ~Object() = default;
+};
+
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/ProcessInfo.h

@@ -0,0 +1,39 @@
+#pragma once
+#include <string>
+#include <unistd.h>
+#include <vector>
+
+namespace LFoundation {
+
+class ProcessInfo {
+public:
+    inline static ProcessInfo& the()
+    {
+        extern ProcessInfo* s_LFoundation_ProcessInfo_the;
+        return *s_LFoundation_ProcessInfo_the;
+    }
+
+    ProcessInfo(int argc, char** argv);
+    ~ProcessInfo() = default;
+
+    std::vector<std::string>& arguments() { return m_args; }
+    const std::vector<std::string>& arguments() const { return m_args; }
+
+    const std::string& process_name() const { return m_process_name; }
+    const std::string& bundle_id() const { return m_bundle_id; }
+
+    int processor_count();
+
+    bool mobile_app_on_desktop() { return false; }
+
+private:
+    // TODO: Maybe move out info file parsing to a seperate file?
+    void parse_info_file();
+
+    std::vector<std::string> m_args;
+    std::string m_process_name;
+    std::string m_bundle_id;
+    int m_processor_count { -1 };
+};
+
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/Receivers.h

@@ -0,0 +1,200 @@
+#pragma once
+#include <ctime>
+#include <libfoundation/Event.h>
+#include <libfoundation/EventReceiver.h>
+#include <libfoundation/Logger.h>
+#include <memory>
+#include <vector>
+
+namespace LFoundation {
+
+class FDWaiterReadEvent final : public Event {
+public:
+    FDWaiterReadEvent()
+        : Event(Event::Type::FdWaiterRead)
+    {
+    }
+    ~FDWaiterReadEvent() = default;
+};
+
+class FDWaiterWriteEvent final : public Event {
+public:
+    FDWaiterWriteEvent()
+        : Event(Event::Type::FdWaiterWrite)
+    {
+    }
+    ~FDWaiterWriteEvent() = default;
+};
+
+class FDWaiter : public EventReceiver {
+public:
+    friend class EventLoop;
+
+    FDWaiter(int fd, std::function<void(void)> on_read, std::function<void(void)> on_write)
+        : EventReceiver()
+        , m_fd(fd)
+        , m_on_read(on_read)
+        , m_on_write(on_write)
+    {
+    }
+
+    FDWaiter(FDWaiter&& fdw)
+        : EventReceiver()
+        , m_fd(fdw.m_fd)
+        , m_on_read(fdw.m_on_read)
+        , m_on_write(fdw.m_on_write)
+    {
+    }
+
+    FDWaiter& operator=(const FDWaiter& fdw)
+    {
+        m_fd = fdw.m_fd;
+        m_on_read = fdw.m_on_read;
+        m_on_write = fdw.m_on_write;
+        return *this;
+    }
+
+    FDWaiter& operator=(FDWaiter&& fdw)
+    {
+        m_fd = fdw.m_fd;
+        m_on_read = fdw.m_on_read;
+        m_on_write = fdw.m_on_write;
+        return *this;
+    }
+
+    void receive_event(std::unique_ptr<Event> event) override
+    {
+        if (event->type() == Event::Type::FdWaiterRead) {
+            m_on_read();
+        } else if (event->type() == Event::Type::FdWaiterWrite) {
+            m_on_write();
+        }
+    }
+
+    inline int fd() const { return m_fd; }
+
+private:
+    int m_fd;
+    std::function<void(void)> m_on_read;
+    std::function<void(void)> m_on_write;
+};
+
+class TimerEvent final : public Event {
+public:
+    TimerEvent()
+        : Event(Event::Type::DeferredInvoke)
+    {
+    }
+    ~TimerEvent() = default;
+};
+
+class Timer : public EventReceiver {
+public:
+    static const bool Once = false;
+    static const bool Repeat = true;
+
+    friend class EventLoop;
+
+    explicit Timer(std::function<void(void)> callback, std::time_t time_interval, bool repeat = false)
+        : EventReceiver()
+        , m_callback(callback)
+        , m_time_interval(time_interval)
+        , m_repeat(repeat)
+        , m_valid(true)
+    {
+        clock_gettime(CLOCK_MONOTONIC, &m_expire_time);
+        reload(m_expire_time);
+    }
+
+    Timer(const Timer& fdw)
+        : EventReceiver()
+        , m_callback(fdw.m_callback)
+        , m_time_interval(fdw.m_time_interval)
+        , m_repeat(fdw.m_repeat)
+        , m_expire_time(fdw.m_expire_time)
+        , m_valid(fdw.m_valid)
+    {
+    }
+
+    Timer(Timer&& fdw)
+        : EventReceiver()
+        , m_callback(fdw.m_callback)
+        , m_time_interval(fdw.m_time_interval)
+        , m_repeat(fdw.m_repeat)
+        , m_expire_time(fdw.m_expire_time)
+        , m_valid(fdw.m_valid)
+    {
+    }
+
+    Timer& operator=(const Timer& fdw)
+    {
+        m_callback = fdw.m_callback;
+        return *this;
+    }
+
+    Timer& operator=(Timer&& fdw)
+    {
+        m_callback = fdw.m_callback;
+        return *this;
+    }
+
+    inline bool valid() const { return m_valid; }
+    inline bool repeated() const { return m_repeat; }
+    inline bool expired(const std::timespec& now) const
+    {
+        return now.tv_sec > m_expire_time.tv_sec || (now.tv_sec == m_expire_time.tv_sec && now.tv_nsec >= m_expire_time.tv_nsec);
+    }
+
+    void reload(const std::timespec& now)
+    {
+        std::time_t secs = now.tv_nsec + (m_time_interval % 1000) * 1000000;
+        m_expire_time.tv_nsec = (secs % 1000000000);
+        m_expire_time.tv_sec = now.tv_sec + m_time_interval / 1000 + (secs / 1000000000);
+    }
+
+    void receive_event(std::unique_ptr<Event> event) override
+    {
+        m_callback();
+    }
+
+private:
+    inline void mark_invalid() { m_valid = false; }
+
+    std::function<void(void)> m_callback;
+    std::timespec m_expire_time;
+    std::time_t m_time_interval;
+    bool m_valid { true };
+    bool m_repeat { false };
+};
+
+class CallEvent final : public Event {
+public:
+    CallEvent(void (*callback)())
+        : Event(Event::Type::DeferredInvoke)
+        , m_callback(callback)
+    {
+    }
+    ~CallEvent() = default;
+
+private:
+    void (*m_callback)();
+};
+
+// class Caller : public EventReceiver {
+// public:
+//     friend class EventLoop;
+
+//     Caller()
+//         : EventReceiver()
+//     {
+//     }
+
+//     void receive_event(std::unique_ptr<Event> event) override
+//     {
+//         if (event->type() == Event::Type::DeferredInvoke) {
+
+//         }
+//     }
+// };
+
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/SharedBuffer.h

@@ -0,0 +1,74 @@
+#pragma once
+#include <x/shared_buffer.h>
+
+namespace LFoundation {
+
+template <typename T>
+class SharedBuffer {
+public:
+    SharedBuffer() = default;
+    SharedBuffer(size_t size)
+        : m_size(size)
+    {
+        m_id = shared_buffer_create((uint8_t**)&m_data, m_size * sizeof(T));
+    }
+
+    SharedBuffer(int id)
+        : m_id(id)
+    {
+        if (shared_buffer_get(m_id, (uint8_t**)&m_data) != 0) {
+            m_id = -1;
+        }
+    }
+
+    ~SharedBuffer()
+    {
+    }
+
+    inline void create(size_t size)
+    {
+        m_size = size;
+        m_id = shared_buffer_create((uint8_t**)&m_data, m_size * sizeof(T));
+    }
+
+    inline void open(int id)
+    {
+        m_id = id;
+        if (shared_buffer_get(m_id, (uint8_t**)&m_data) != 0) {
+            m_id = -1;
+        }
+    }
+
+    void free()
+    {
+        if (alive()) {
+            shared_buffer_free(id());
+            m_id = -1;
+        }
+    }
+
+    inline void resize(size_t new_size)
+    {
+        free();
+        create(new_size);
+    }
+
+    inline bool alive() const { return m_id >= 0; }
+
+    inline const T& at(size_t i) const { return data()[i]; }
+    inline T& at(size_t i) { return data()[i]; }
+
+    inline size_t size() const { return m_size; }
+
+    inline const T& operator[](size_t i) const { return at(i); }
+    inline T& operator[](size_t i) { return at(i); }
+
+    inline int id() const { return m_id; }
+    inline T* data() { return m_data; }
+
+private:
+    int m_id { -1 };
+    size_t m_size { 0 };
+    T* m_data { nullptr };
+};
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/URL.h

@@ -0,0 +1,35 @@
+#pragma once
+#include <string>
+#include <unistd.h>
+#include <vector>
+
+namespace LFoundation {
+
+class URL {
+public:
+    enum Scheme {
+        Http,
+        Https,
+        File,
+    };
+
+    explicit URL(const std::string& url)
+        : m_url(url)
+    {
+        m_scheme = parse_scheme(url);
+    }
+    ~URL() = default;
+
+    bool is_file() { return m_scheme == Scheme::File; }
+
+    const std::string& url() const { return m_url; }
+    const Scheme& scheme() const { return m_scheme; }
+
+private:
+    Scheme parse_scheme(const std::string& path);
+
+    std::string m_url;
+    Scheme m_scheme;
+};
+
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/compress/puff.h

@@ -0,0 +1,47 @@
+#pragma once
+
+/* puff.h
+  Copyright (C) 2002-2013 Mark Adler, all rights reserved
+  version 2.3, 21 Jan 2013
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the author be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Mark Adler    madler@alumni.caltech.edu
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <sys/types.h>
+
+/*
+ * See puff.c for purpose and usage.
+ */
+#ifndef NIL
+#define NIL ((unsigned char*)0) /* for no output option */
+#endif
+
+int puff(unsigned char* dest, /* pointer to destination pointer */
+    size_t* destlen, /* amount of output space */
+    const unsigned char* source, /* pointer to source data pointer */
+    size_t* sourcelen); /* amount of input available */
+
+#ifdef __cplusplus
+}
+#endif

libs/libfoundation/include/libfoundation/helpers/LoggerStreamBuf.h

@@ -0,0 +1,15 @@
+#include <__std_streambuffer>
+
+namespace LFoundation::Logger {
+
+class StreamBuf : public std::__stdoutbuf<char> {
+public:
+    StreamBuf(FILE* file)
+        : __stdoutbuf<char>(file)
+    {
+    }
+
+    ~StreamBuf() = default;
+};
+
+} // namespace LFoundation::Logger

libs/libfoundation/include/libfoundation/json/Lexer.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <cctype>
+#include <string>
+#include <unistd.h>
+
+namespace LFoundation::Json {
+
+class Lexer {
+public:
+    Lexer() = default;
+    Lexer(const std::string& filepath)
+        : m_text_data()
+        , m_pointer(0)
+    {
+        set_file(filepath);
+    }
+
+    ~Lexer() = default;
+
+    int set_file(const std::string& filepath);
+
+    bool is_eof() const { return m_pointer >= m_text_data.size(); }
+
+    int lookup_char() const
+    {
+        if (is_eof()) {
+            return EOF;
+        }
+        return m_text_data[m_pointer];
+    }
+
+    int next_char()
+    {
+        if (is_eof()) {
+            return EOF;
+        }
+        return m_text_data[m_pointer++];
+    }
+
+    void skip_spaces()
+    {
+        while (std::isspace(lookup_char())) {
+            next_char();
+        }
+    }
+
+    bool eat_string(std::string& word)
+    {
+        // TODO: Fix stop at "
+        while (std::isprint(lookup_char()) && lookup_char() != '\"') {
+            word.push_back(next_char());
+        };
+        return true;
+    }
+
+    bool eat_token(char what)
+    {
+        skip_spaces();
+        return next_char() == what;
+    }
+
+private:
+    int m_pointer;
+    std::string m_text_data;
+};
+
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/json/Object.h

@@ -0,0 +1,162 @@
+#pragma once
+
+#include <cassert>
+#include <cstddef>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace LFoundation::Json {
+
+class Object {
+public:
+    enum Type {
+        Array,
+        String,
+        Number,
+        Dict,
+        List,
+        Null,
+        Bool,
+        Invalid,
+    };
+    constexpr static Object::Type ObjType = Type::Invalid;
+
+    Object() = default;
+    Object(Type type)
+        : m_type(type)
+    {
+    }
+
+    virtual ~Object() = default;
+
+    Type type() const { return m_type; }
+    bool invalid() const { return type() == Type::Invalid; }
+
+    template <class ObjectT>
+    Object* assert_object()
+    {
+        assert(ObjectT::ObjType == m_type);
+        return this;
+    }
+
+    template <class ObjectT>
+    ObjectT* cast_to_no_assert() { return (ObjectT*)this; }
+
+    template <class ObjectT>
+    ObjectT* cast_to() { return (ObjectT*)assert_object<ObjectT>(); }
+
+private:
+    Type m_type { Invalid };
+};
+
+class StringObject : public Object {
+public:
+    constexpr static Object::Type ObjType = Type::String;
+
+    StringObject()
+        : Object(ObjType)
+    {
+    }
+
+    ~StringObject() = default;
+
+    std::string& data() { return m_data; }
+    const std::string& data() const { return m_data; }
+
+private:
+    std::string m_data;
+};
+
+class DictObject : public Object {
+public:
+    constexpr static Object::Type ObjType = Type::Dict;
+
+    DictObject()
+        : Object(ObjType)
+    {
+    }
+
+    ~DictObject()
+    {
+        // TODO: Add iterators to map.
+        // for (auto it : m_data) {
+        // delete it.second;
+        // }
+    }
+
+    std::map<std::string, Object*>& data() { return m_data; }
+    const std::map<std::string, Object*>& data() const { return m_data; }
+
+private:
+    std::map<std::string, Object*> m_data;
+};
+
+class ListObject : public Object {
+public:
+    constexpr static Object::Type ObjType = Type::List;
+
+    ListObject()
+        : Object(ObjType)
+    {
+    }
+
+    ~ListObject()
+    {
+        for (auto& i : m_data) {
+            delete i;
+        }
+    }
+
+    std::vector<Object*>& data() { return m_data; }
+    const std::vector<Object*>& data() const { return m_data; }
+
+private:
+    std::vector<Object*> m_data;
+};
+
+class NullObject : public Object {
+public:
+    constexpr static Object::Type ObjType = Type::Null;
+
+    NullObject()
+        : Object(ObjType)
+    {
+    }
+
+    ~NullObject() = default;
+
+private:
+};
+
+class BoolObject : public Object {
+public:
+    constexpr static Object::Type ObjType = Type::Bool;
+
+    BoolObject()
+        : Object(ObjType)
+    {
+    }
+
+    ~BoolObject() = default;
+
+    bool& data() { return m_data; }
+    const bool& data() const { return m_data; }
+
+private:
+    bool m_data;
+};
+
+class InvalidObject : public Object {
+public:
+    constexpr static Object::Type ObjType = Type::Invalid;
+
+    InvalidObject()
+        : Object(ObjType)
+    {
+    }
+
+    ~InvalidObject() = default;
+};
+
+} // namespace LFoundation

libs/libfoundation/include/libfoundation/json/Parser.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <libfoundation/json/Lexer.h>
+#include <libfoundation/json/Object.h>
+#include <string>
+
+namespace LFoundation::Json {
+
+class Parser {
+public:
+    Parser(const std::string& filepath)
+    {
+        int err = m_lexer.set_file(filepath);
+        if (err) {
+            m_root_object = new InvalidObject();
+        }
+    }
+
+    ~Parser() = default;
+
+    Object* object()
+    {
+        if (!m_root_object) {
+            m_root_object = parse_object();
+        }
+        return m_root_object;
+    }
+
+private:
+    StringObject* parse_string();
+    DictObject* parse_dict();
+    ListObject* parse_list();
+    BoolObject* parse_bool();
+    NullObject* parse_null();
+    Object* parse_object();
+
+    Object* m_root_object { nullptr };
+    Lexer m_lexer;
+};
+
+} // namespace LFoundation

libs/libfoundation/src/EventLoop.cpp

@@ -0,0 +1,127 @@
+#include <cstring>
+#include <ctime>
+#include <iostream>
+#include <libfoundation/EventLoop.h>
+#include <libfoundation/Logger.h>
+#include <memory>
+#include <sched.h>
+#include <sys/select.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+namespace LFoundation {
+
+EventLoop* s_LFoundation_EventLoop_the = nullptr;
+
+EventLoop::EventLoop()
+{
+    s_LFoundation_EventLoop_the = this;
+}
+
+void EventLoop::check_fds()
+{
+    if (m_waiting_fds.empty()) {
+        return;
+    }
+    fd_set_t readfds;
+    fd_set_t writefds;
+    FD_ZERO(&readfds);
+    FD_ZERO(&writefds);
+    int nfds = -1;
+    for (int i = 0; i < m_waiting_fds.size(); i++) {
+        if (m_waiting_fds[i].m_on_read) {
+            FD_SET(m_waiting_fds[i].m_fd, &readfds);
+        }
+        if (m_waiting_fds[i].m_on_write) {
+            FD_SET(m_waiting_fds[i].m_fd, &writefds);
+        }
+        if (nfds < m_waiting_fds[i].m_fd) {
+            nfds = m_waiting_fds[i].m_fd;
+        }
+    }
+
+    // For now, that means, that we don't wait for fds.
+    timeval_t timeout;
+    timeout.tv_sec = 0;
+    timeout.tv_usec = 0;
+
+    int err = select(nfds + 1, &readfds, &writefds, nullptr, &timeout);
+    if (err) {
+        return;
+    }
+
+    for (int i = 0; i < m_waiting_fds.size(); i++) {
+        if (m_waiting_fds[i].m_on_read) {
+            if (FD_ISSET(m_waiting_fds[i].m_fd, &readfds)) {
+                m_event_queue.push_back(QueuedEvent(m_waiting_fds[i], new FDWaiterReadEvent()));
+            }
+        }
+        if (m_waiting_fds[i].m_on_write) {
+            if (FD_ISSET(m_waiting_fds[i].m_fd, &writefds)) {
+                m_event_queue.push_back(QueuedEvent(m_waiting_fds[i], new FDWaiterWriteEvent()));
+            }
+        }
+    }
+}
+
+void EventLoop::check_timers()
+{
+    if (m_timers.empty()) {
+        return;
+    }
+
+    std::timespec tp;
+    clock_gettime(CLOCK_MONOTONIC, &tp);
+
+    for (auto& timer : m_timers) {
+        if (!timer.expired(tp)) {
+            continue;
+        }
+
+        m_event_queue.push_back(QueuedEvent(timer, new TimerEvent()));
+
+        if (timer.repeated()) {
+            timer.reload(tp);
+        } else {
+            timer.mark_invalid();
+        }
+    }
+}
+
+void EventLoop::cleanup_timers()
+{
+    for (auto it = m_timers.begin(); it != m_timers.end();) {
+        auto& timer = *it;
+        if (!timer.valid()) {
+            it = m_timers.erase(it);
+        } else {
+            it++;
+        }
+    }
+}
+
+[[gnu::flatten]] void EventLoop::pump()
+{
+    check_fds();
+    check_timers();
+    std::vector<QueuedEvent> events_to_dispatch(std::move(m_event_queue));
+    m_event_queue.clear();
+    for (auto& event : events_to_dispatch) {
+        event.receiver.receive_event(std::move(event.event));
+    }
+
+    cleanup_timers();
+    if (!events_to_dispatch.size()) {
+        sched_yield();
+    }
+}
+
+int EventLoop::run()
+{
+    while (!m_stop_flag) {
+        pump();
+    }
+    return m_exit_code;
+}
+
+} // namespace LFoundation

libs/libfoundation/src/Logger.cpp

@@ -0,0 +1,32 @@
+#include <libfoundation/helpers/LoggerStreamBuf.h>
+#include <ostream>
+
+namespace LFoundation {
+
+namespace Logger {
+    _ALIGNAS_TYPE(std::ostream)
+    char debug[sizeof(std::ostream)];
+    _ALIGNAS_TYPE(std::ostream)
+    char info[sizeof(std::ostream)];
+    _ALIGNAS_TYPE(std::ostream)
+    char error[sizeof(std::ostream)];
+};
+
+class LoggerInit final {
+public:
+    LoggerInit()
+    {
+        m_ldebug_ptr = new (Logger::debug) std::ostream(new Logger::StreamBuf(stdout));
+    };
+
+    ~LoggerInit()
+    {
+    }
+
+private:
+    std::ostream* m_ldebug_ptr;
+};
+
+static LoggerInit logger_init;
+
+}

libs/libfoundation/src/ProcessInfo.cpp

@@ -0,0 +1,84 @@
+#include <cstring>
+#include <iostream>
+#include <libfoundation/Logger.h>
+#include <libfoundation/ProcessInfo.h>
+#include <libfoundation/json/Parser.h>
+#include <memory>
+#include <unistd.h>
+
+namespace LFoundation {
+
+ProcessInfo* s_LFoundation_ProcessInfo_the = nullptr;
+
+ProcessInfo::ProcessInfo(int argc, char** argv)
+{
+    s_LFoundation_ProcessInfo_the = this;
+
+    // Parse argv[0] to get a process name.
+    int process_name_start = 0;
+    for (int i = 0; i < strlen(argv[0]) - 1; i++) {
+        if (argv[0][i] == '/') {
+            process_name_start = i + 1;
+        }
+    }
+    m_process_name = std::string(&argv[0][process_name_start]);
+
+    for (int i = 1; i < argc; i++) {
+        m_args.push_back(std::string(argv[i]));
+    }
+
+    parse_info_file();
+}
+
+int ProcessInfo::processor_count()
+{
+    // TODO: Temp solution. Until sysctl.
+    if (m_processor_count < 0) {
+        m_processor_count = 0;
+        char buf[256];
+        int fd_proc_stat = open("/proc/stat", O_RDONLY);
+        int offset = 0;
+        int rd = 1;
+        read(fd_proc_stat, buf, sizeof(buf));
+        while (rd > 0) {
+            int num, user_time, system_time, idle_time;
+            rd = sscanf(buf + offset, "cpu%d %d 0 %d %d\n", &num, &user_time, &system_time, &idle_time);
+            offset += rd;
+            if (rd > 0) {
+                m_processor_count++;
+            }
+        }
+        close(fd_proc_stat);
+    }
+    return m_processor_count;
+}
+
+void ProcessInfo::parse_info_file()
+{
+    char execpath[256];
+    char infofile[256];
+    char bundleid[256];
+
+    int fd = open("/proc/self/exe", O_RDONLY);
+    int rd = read(fd, execpath, sizeof(execpath));
+    close(fd);
+    int start = 0;
+    for (int i = rd - 1; i >= 0; i--) {
+        if (execpath[i] == '/') {
+            start = i + 1;
+            break;
+        }
+    }
+    memcpy(&execpath[start], "info.json", sizeof("info.json"));
+
+    auto json_parser = LFoundation::Json::Parser(execpath);
+    LFoundation::Json::Object* jobj_root = json_parser.object();
+    if (jobj_root->invalid()) {
+        return;
+    }
+
+    auto* jdict_root = jobj_root->cast_to<LFoundation::Json::DictObject>();
+    m_bundle_id = jdict_root->data()["bundle_id"]->cast_to<LFoundation::Json::StringObject>()->data();
+}
+
+} // namespace LFoundation

libs/libfoundation/src/URL.cpp

@@ -0,0 +1,20 @@
+#include <libfoundation/URL.h>
+#include <string>
+
+namespace LFoundation {
+
+URL::Scheme URL::parse_scheme(const std::string& path)
+{
+    if (path.starts_with("file://")) {
+        return Scheme::File;
+    } else if (path.starts_with("http://")) {
+        return Scheme::Http;
+    } else if (path.starts_with("https://")) {
+        return Scheme::Https;
+    }
+
+    // Unknown scheme.
+    std::abort();
+}
+
+} // namespace LFoundation

libs/libfoundation/src/compress/puff.c

@@ -0,0 +1,832 @@
+/*
+ * puff.c
+ * Copyright (C) 2002-2013 Mark Adler
+ * For conditions of distribution and use, see copyright notice in puff.h
+ * version 2.3, 21 Jan 2013
+ *
+ * puff.c is a simple inflate written to be an unambiguous way to specify the
+ * deflate format.  It is not written for speed but rather simplicity.  As a
+ * side benefit, this code might actually be useful when small code is more
+ * important than speed, such as bootstrap applications.  For typical deflate
+ * data, zlib's inflate() is about four times as fast as puff().  zlib's
+ * inflate compiles to around 20K on my machine, whereas puff.c compiles to
+ * around 4K on my machine (a PowerPC using GNU cc).  If the faster decode()
+ * function here is used, then puff() is only twice as slow as zlib's
+ * inflate().
+ *
+ * All dynamically allocated memory comes from the stack.  The stack required
+ * is less than 2K bytes.  This code is compatible with 16-bit int's and
+ * assumes that long's are at least 32 bits.  puff.c uses the short data type,
+ * assumed to be 16 bits, for arrays in order to conserve memory.  The code
+ * works whether integers are stored big endian or little endian.
+ *
+ * In the comments below are "Format notes" that describe the inflate process
+ * and document some of the less obvious aspects of the format.  This source
+ * code is meant to supplement RFC 1951, which formally describes the deflate
+ * format:
+ *
+ *    http://www.zlib.org/rfc-deflate.html
+ */
+
+/*
+ * Change history:
+ *
+ * 1.0  10 Feb 2002     - First version
+ * 1.1  17 Feb 2002     - Clarifications of some comments and notes
+ *                      - Update puff() dest and source pointers on negative
+ *                        errors to facilitate debugging deflators
+ *                      - Remove longest from struct huffman -- not needed
+ *                      - Simplify offs[] index in construct()
+ *                      - Add input size and checking, using longjmp() to
+ *                        maintain easy readability
+ *                      - Use short data type for large arrays
+ *                      - Use pointers instead of long to specify source and
+ *                        destination sizes to avoid arbitrary 4 GB limits
+ * 1.2  17 Mar 2002     - Add faster version of decode(), doubles speed (!),
+ *                        but leave simple version for readabilty
+ *                      - Make sure invalid distances detected if pointers
+ *                        are 16 bits
+ *                      - Fix fixed codes table error
+ *                      - Provide a scanning mode for determining size of
+ *                        uncompressed data
+ * 1.3  20 Mar 2002     - Go back to lengths for puff() parameters [Gailly]
+ *                      - Add a puff.h file for the interface
+ *                      - Add braces in puff() for else do [Gailly]
+ *                      - Use indexes instead of pointers for readability
+ * 1.4  31 Mar 2002     - Simplify construct() code set check
+ *                      - Fix some comments
+ *                      - Add FIXLCODES #define
+ * 1.5   6 Apr 2002     - Minor comment fixes
+ * 1.6   7 Aug 2002     - Minor format changes
+ * 1.7   3 Mar 2003     - Added test code for distribution
+ *                      - Added zlib-like license
+ * 1.8   9 Jan 2004     - Added some comments on no distance codes case
+ * 1.9  21 Feb 2008     - Fix bug on 16-bit integer architectures [Pohland]
+ *                      - Catch missing end-of-block symbol error
+ * 2.0  25 Jul 2008     - Add #define to permit distance too far back
+ *                      - Add option in TEST code for puff to write the data
+ *                      - Add option in TEST code to skip input bytes
+ *                      - Allow TEST code to read from piped stdin
+ * 2.1   4 Apr 2010     - Avoid variable initialization for happier compilers
+ *                      - Avoid unsigned comparisons for even happier compilers
+ * 2.2  25 Apr 2010     - Fix bug in variable initializations [Oberhumer]
+ *                      - Add const where appropriate [Oberhumer]
+ *                      - Split if's and ?'s for coverage testing
+ *                      - Break out test code to separate file
+ *                      - Move NIL to puff.h
+ *                      - Allow incomplete code only if single code length is 1
+ *                      - Add full code coverage test to Makefile
+ * 2.3  21 Jan 2013     - Check for invalid code length codes in dynamic blocks
+ */
+
+#include <libfoundation/compress/puff.h> /* prototype for puff() */
+#include <setjmp.h> /* for setjmp(), longjmp(), and jmp_buf */
+
+#define local static /* for local function definitions */
+
+/*
+ * Maximums for allocations and loops.  It is not useful to change these --
+ * they are fixed by the deflate format.
+ */
+#define MAXBITS 15 /* maximum bits in a code */
+#define MAXLCODES 286 /* maximum number of literal/length codes */
+#define MAXDCODES 30 /* maximum number of distance codes */
+#define MAXCODES (MAXLCODES + MAXDCODES) /* maximum codes lengths to read */
+#define FIXLCODES 288 /* number of fixed literal/length codes */
+
+/* input and output state */
+struct state {
+    /* output state */
+    unsigned char* out; /* output buffer */
+    unsigned long outlen; /* available space at out */
+    unsigned long outcnt; /* bytes written to out so far */
+
+    /* input state */
+    const unsigned char* in; /* input buffer */
+    unsigned long inlen; /* available input at in */
+    unsigned long incnt; /* bytes read so far */
+    int bitbuf; /* bit buffer */
+    int bitcnt; /* number of bits in bit buffer */
+
+    /* input limit error return state for bits() and decode() */
+    jmp_buf env;
+};
+
+/*
+ * Return need bits from the input stream.  This always leaves less than
+ * eight bits in the buffer.  bits() works properly for need == 0.
+ *
+ * Format notes:
+ *
+ * - Bits are stored in bytes from the least significant bit to the most
+ *   significant bit.  Therefore bits are dropped from the bottom of the bit
+ *   buffer, using shift right, and new bytes are appended to the top of the
+ *   bit buffer, using shift left.
+ */
+local int bits(struct state* s, int need)
+{
+    long val; /* bit accumulator (can use up to 20 bits) */
+
+    /* load at least need bits into val */
+    val = s->bitbuf;
+    while (s->bitcnt < need) {
+        if (s->incnt == s->inlen)
+            longjmp(s->env, 1); /* out of input */
+        val |= (long)(s->in[s->incnt++]) << s->bitcnt; /* load eight bits */
+        s->bitcnt += 8;
+    }
+
+    /* drop need bits and update buffer, always zero to seven bits left */
+    s->bitbuf = (int)(val >> need);
+    s->bitcnt -= need;
+
+    /* return need bits, zeroing the bits above that */
+    return (int)(val & ((1L << need) - 1));
+}
+
+/*
+ * Process a stored block.
+ *
+ * Format notes:
+ *
+ * - After the two-bit stored block type (00), the stored block length and
+ *   stored bytes are byte-aligned for fast copying.  Therefore any leftover
+ *   bits in the byte that has the last bit of the type, as many as seven, are
+ *   discarded.  The value of the discarded bits are not defined and should not
+ *   be checked against any expectation.
+ *
+ * - The second inverted copy of the stored block length does not have to be
+ *   checked, but it's probably a good idea to do so anyway.
+ *
+ * - A stored block can have zero length.  This is sometimes used to byte-align
+ *   subsets of the compressed data for random access or partial recovery.
+ */
+local int stored(struct state* s)
+{
+    unsigned len; /* length of stored block */
+
+    /* discard leftover bits from current byte (assumes s->bitcnt < 8) */
+    s->bitbuf = 0;
+    s->bitcnt = 0;
+
+    /* get length and check against its one's complement */
+    if (s->incnt + 4 > s->inlen)
+        return 2; /* not enough input */
+    len = s->in[s->incnt++];
+    len |= s->in[s->incnt++] << 8;
+    if (s->in[s->incnt++] != (~len & 0xff) || s->in[s->incnt++] != ((~len >> 8) & 0xff))
+        return -2; /* didn't match complement! */
+
+    /* copy len bytes from in to out */
+    if (s->incnt + len > s->inlen)
+        return 2; /* not enough input */
+    if (s->out != NIL) {
+        if (s->outcnt + len > s->outlen)
+            return 1; /* not enough output space */
+        while (len--)
+            s->out[s->outcnt++] = s->in[s->incnt++];
+    } else { /* just scanning */
+        s->outcnt += len;
+        s->incnt += len;
+    }
+
+    /* done with a valid stored block */
+    return 0;
+}
+
+/*
+ * Huffman code decoding tables.  count[1..MAXBITS] is the number of symbols of
+ * each length, which for a canonical code are stepped through in order.
+ * symbol[] are the symbol values in canonical order, where the number of
+ * entries is the sum of the counts in count[].  The decoding process can be
+ * seen in the function decode() below.
+ */
+struct huffman {
+    short* count; /* number of symbols of each length */
+    short* symbol; /* canonically ordered symbols */
+};
+
+/*
+ * Decode a code from the stream s using huffman table h.  Return the symbol or
+ * a negative value if there is an error.  If all of the lengths are zero, i.e.
+ * an empty code, or if the code is incomplete and an invalid code is received,
+ * then -10 is returned after reading MAXBITS bits.
+ *
+ * Format notes:
+ *
+ * - The codes as stored in the compressed data are bit-reversed relative to
+ *   a simple integer ordering of codes of the same lengths.  Hence below the
+ *   bits are pulled from the compressed data one at a time and used to
+ *   build the code value reversed from what is in the stream in order to
+ *   permit simple integer comparisons for decoding.  A table-based decoding
+ *   scheme (as used in zlib) does not need to do this reversal.
+ *
+ * - The first code for the shortest length is all zeros.  Subsequent codes of
+ *   the same length are simply integer increments of the previous code.  When
+ *   moving up a length, a zero bit is appended to the code.  For a complete
+ *   code, the last code of the longest length will be all ones.
+ *
+ * - Incomplete codes are handled by this decoder, since they are permitted
+ *   in the deflate format.  See the format notes for fixed() and dynamic().
+ */
+#ifdef SLOW
+local int decode(struct state* s, const struct huffman* h)
+{
+    int len; /* current number of bits in code */
+    int code; /* len bits being decoded */
+    int first; /* first code of length len */
+    int count; /* number of codes of length len */
+    int index; /* index of first code of length len in symbol table */
+
+    code = first = index = 0;
+    for (len = 1; len <= MAXBITS; len++) {
+        code |= bits(s, 1); /* get next bit */
+        count = h->count[len];
+        if (code - count < first) /* if length len, return symbol */
+            return h->symbol[index + (code - first)];
+        index += count; /* else update for next length */
+        first += count;
+        first <<= 1;
+        code <<= 1;
+    }
+    return -10; /* ran out of codes */
+}
+
+/*
+ * A faster version of decode() for real applications of this code.   It's not
+ * as readable, but it makes puff() twice as fast.  And it only makes the code
+ * a few percent larger.
+ */
+#else /* !SLOW */
+local int decode(struct state* s, const struct huffman* h)
+{
+    int len; /* current number of bits in code */
+    int code; /* len bits being decoded */
+    int first; /* first code of length len */
+    int count; /* number of codes of length len */
+    int index; /* index of first code of length len in symbol table */
+    int bitbuf; /* bits from stream */
+    int left; /* bits left in next or left to process */
+    short* next; /* next number of codes */
+
+    bitbuf = s->bitbuf;
+    left = s->bitcnt;
+    code = first = index = 0;
+    len = 1;
+    next = h->count + 1;
+    while (1) {
+        while (left--) {
+            code |= bitbuf & 1;
+            bitbuf >>= 1;
+            count = *next++;
+            if (code - count < first) { /* if length len, return symbol */
+                s->bitbuf = bitbuf;
+                s->bitcnt = (s->bitcnt - len) & 7;
+                return h->symbol[index + (code - first)];
+            }
+            index += count; /* else update for next length */
+            first += count;
+            first <<= 1;
+            code <<= 1;
+            len++;
+        }
+        left = (MAXBITS + 1) - len;
+        if (left == 0)
+            break;
+        if (s->incnt == s->inlen)
+            longjmp(s->env, 1); /* out of input */
+        bitbuf = s->in[s->incnt++];
+        if (left > 8)
+            left = 8;
+    }
+    return -10; /* ran out of codes */
+}
+#endif /* SLOW */
+
+/*
+ * Given the list of code lengths length[0..n-1] representing a canonical
+ * Huffman code for n symbols, construct the tables required to decode those
+ * codes.  Those tables are the number of codes of each length, and the symbols
+ * sorted by length, retaining their original order within each length.  The
+ * return value is zero for a complete code set, negative for an over-
+ * subscribed code set, and positive for an incomplete code set.  The tables
+ * can be used if the return value is zero or positive, but they cannot be used
+ * if the return value is negative.  If the return value is zero, it is not
+ * possible for decode() using that table to return an error--any stream of
+ * enough bits will resolve to a symbol.  If the return value is positive, then
+ * it is possible for decode() using that table to return an error for received
+ * codes past the end of the incomplete lengths.
+ *
+ * Not used by decode(), but used for error checking, h->count[0] is the number
+ * of the n symbols not in the code.  So n - h->count[0] is the number of
+ * codes.  This is useful for checking for incomplete codes that have more than
+ * one symbol, which is an error in a dynamic block.
+ *
+ * Assumption: for all i in 0..n-1, 0 <= length[i] <= MAXBITS
+ * This is assured by the construction of the length arrays in dynamic() and
+ * fixed() and is not verified by construct().
+ *
+ * Format notes:
+ *
+ * - Permitted and expected examples of incomplete codes are one of the fixed
+ *   codes and any code with a single symbol which in deflate is coded as one
+ *   bit instead of zero bits.  See the format notes for fixed() and dynamic().
+ *
+ * - Within a given code length, the symbols are kept in ascending order for
+ *   the code bits definition.
+ */
+local int construct(struct huffman* h, const short* length, int n)
+{
+    int symbol; /* current symbol when stepping through length[] */
+    int len; /* current length when stepping through h->count[] */
+    int left; /* number of possible codes left of current length */
+    short offs[MAXBITS + 1]; /* offsets in symbol table for each length */
+
+    /* count number of codes of each length */
+    for (len = 0; len <= MAXBITS; len++)
+        h->count[len] = 0;
+    for (symbol = 0; symbol < n; symbol++)
+        (h->count[length[symbol]])++; /* assumes lengths are within bounds */
+    if (h->count[0] == n) /* no codes! */
+        return 0; /* complete, but decode() will fail */
+
+    /* check for an over-subscribed or incomplete set of lengths */
+    left = 1; /* one possible code of zero length */
+    for (len = 1; len <= MAXBITS; len++) {
+        left <<= 1; /* one more bit, double codes left */
+        left -= h->count[len]; /* deduct count from possible codes */
+        if (left < 0)
+            return left; /* over-subscribed--return negative */
+    } /* left > 0 means incomplete */
+
+    /* generate offsets into symbol table for each length for sorting */
+    offs[1] = 0;
+    for (len = 1; len < MAXBITS; len++)
+        offs[len + 1] = offs[len] + h->count[len];
+
+    /*
+     * put symbols in table sorted by length, by symbol order within each
+     * length
+     */
+    for (symbol = 0; symbol < n; symbol++)
+        if (length[symbol] != 0)
+            h->symbol[offs[length[symbol]]++] = symbol;
+
+    /* return zero for complete set, positive for incomplete set */
+    return left;
+}
+
+/*
+ * Decode literal/length and distance codes until an end-of-block code.
+ *
+ * Format notes:
+ *
+ * - Compressed data that is after the block type if fixed or after the code
+ *   description if dynamic is a combination of literals and length/distance
+ *   pairs terminated by and end-of-block code.  Literals are simply Huffman
+ *   coded bytes.  A length/distance pair is a coded length followed by a
+ *   coded distance to represent a string that occurs earlier in the
+ *   uncompressed data that occurs again at the current location.
+ *
+ * - Literals, lengths, and the end-of-block code are combined into a single
+ *   code of up to 286 symbols.  They are 256 literals (0..255), 29 length
+ *   symbols (257..285), and the end-of-block symbol (256).
+ *
+ * - There are 256 possible lengths (3..258), and so 29 symbols are not enough
+ *   to represent all of those.  Lengths 3..10 and 258 are in fact represented
+ *   by just a length symbol.  Lengths 11..257 are represented as a symbol and
+ *   some number of extra bits that are added as an integer to the base length
+ *   of the length symbol.  The number of extra bits is determined by the base
+ *   length symbol.  These are in the static arrays below, lens[] for the base
+ *   lengths and lext[] for the corresponding number of extra bits.
+ *
+ * - The reason that 258 gets its own symbol is that the longest length is used
+ *   often in highly redundant files.  Note that 258 can also be coded as the
+ *   base value 227 plus the maximum extra value of 31.  While a good deflate
+ *   should never do this, it is not an error, and should be decoded properly.
+ *
+ * - If a length is decoded, including its extra bits if any, then it is
+ *   followed a distance code.  There are up to 30 distance symbols.  Again
+ *   there are many more possible distances (1..32768), so extra bits are added
+ *   to a base value represented by the symbol.  The distances 1..4 get their
+ *   own symbol, but the rest require extra bits.  The base distances and
+ *   corresponding number of extra bits are below in the static arrays dist[]
+ *   and dext[].
+ *
+ * - Literal bytes are simply written to the output.  A length/distance pair is
+ *   an instruction to copy previously uncompressed bytes to the output.  The
+ *   copy is from distance bytes back in the output stream, copying for length
+ *   bytes.
+ *
+ * - Distances pointing before the beginning of the output data are not
+ *   permitted.
+ *
+ * - Overlapped copies, where the length is greater than the distance, are
+ *   allowed and common.  For example, a distance of one and a length of 258
+ *   simply copies the last byte 258 times.  A distance of four and a length of
+ *   twelve copies the last four bytes three times.  A simple forward copy
+ *   ignoring whether the length is greater than the distance or not implements
+ *   this correctly.  You should not use memcpy() since its behavior is not
+ *   defined for overlapped arrays.  You should not use memmove() or bcopy()
+ *   since though their behavior -is- defined for overlapping arrays, it is
+ *   defined to do the wrong thing in this case.
+ */
+local int codes(struct state* s,
+    const struct huffman* lencode,
+    const struct huffman* distcode)
+{
+    int symbol; /* decoded symbol */
+    int len; /* length for copy */
+    unsigned dist; /* distance for copy */
+    static const short lens[29] = { /* Size base for length codes 257..285 */
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258
+    };
+    static const short lext[29] = { /* Extra bits for length codes 257..285 */
+        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+        3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
+    };
+    static const short dists[30] = { /* Offset base for distance codes 0..29 */
+        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+        8193, 12289, 16385, 24577
+    };
+    static const short dext[30] = { /* Extra bits for distance codes 0..29 */
+        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
+        7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
+        12, 12, 13, 13
+    };
+
+    /* decode literals and length/distance pairs */
+    do {
+        symbol = decode(s, lencode);
+        if (symbol < 0)
+            return symbol; /* invalid symbol */
+        if (symbol < 256) { /* literal: symbol is the byte */
+            /* write out the literal */
+            if (s->out != NIL) {
+                if (s->outcnt == s->outlen)
+                    return 1;
+                s->out[s->outcnt] = symbol;
+            }
+            s->outcnt++;
+        } else if (symbol > 256) { /* length */
+            /* get and compute length */
+            symbol -= 257;
+            if (symbol >= 29)
+                return -10; /* invalid fixed code */
+            len = lens[symbol] + bits(s, lext[symbol]);
+
+            /* get and check distance */
+            symbol = decode(s, distcode);
+            if (symbol < 0)
+                return symbol; /* invalid symbol */
+            dist = dists[symbol] + bits(s, dext[symbol]);
+#ifndef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+            if (dist > s->outcnt)
+                return -11; /* distance too far back */
+#endif
+
+            /* copy length bytes from distance bytes back */
+            if (s->out != NIL) {
+                if (s->outcnt + len > s->outlen)
+                    return 1;
+                while (len--) {
+                    s->out[s->outcnt] =
+#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+                        dist > s->outcnt ? 0 :
+#endif
+                                         s->out[s->outcnt - dist];
+                    s->outcnt++;
+                }
+            } else
+                s->outcnt += len;
+        }
+    } while (symbol != 256); /* end of block symbol */
+
+    /* done with a valid fixed or dynamic block */
+    return 0;
+}
+
+/*
+ * Process a fixed codes block.
+ *
+ * Format notes:
+ *
+ * - This block type can be useful for compressing small amounts of data for
+ *   which the size of the code descriptions in a dynamic block exceeds the
+ *   benefit of custom codes for that block.  For fixed codes, no bits are
+ *   spent on code descriptions.  Instead the code lengths for literal/length
+ *   codes and distance codes are fixed.  The specific lengths for each symbol
+ *   can be seen in the "for" loops below.
+ *
+ * - The literal/length code is complete, but has two symbols that are invalid
+ *   and should result in an error if received.  This cannot be implemented
+ *   simply as an incomplete code since those two symbols are in the "middle"
+ *   of the code.  They are eight bits long and the longest literal/length\
+ *   code is nine bits.  Therefore the code must be constructed with those
+ *   symbols, and the invalid symbols must be detected after decoding.
+ *
+ * - The fixed distance codes also have two invalid symbols that should result
+ *   in an error if received.  Since all of the distance codes are the same
+ *   length, this can be implemented as an incomplete code.  Then the invalid
+ *   codes are detected while decoding.
+ */
+local int fixed(struct state* s)
+{
+    static int virgin = 1;
+    static short lencnt[MAXBITS + 1], lensym[FIXLCODES];
+    static short distcnt[MAXBITS + 1], distsym[MAXDCODES];
+    static struct huffman lencode, distcode;
+
+    /* build fixed huffman tables if first call (may not be thread safe) */
+    if (virgin) {
+        int symbol;
+        short lengths[FIXLCODES];
+
+        /* construct lencode and distcode */
+        lencode.count = lencnt;
+        lencode.symbol = lensym;
+        distcode.count = distcnt;
+        distcode.symbol = distsym;
+
+        /* literal/length table */
+        for (symbol = 0; symbol < 144; symbol++)
+            lengths[symbol] = 8;
+        for (; symbol < 256; symbol++)
+            lengths[symbol] = 9;
+        for (; symbol < 280; symbol++)
+            lengths[symbol] = 7;
+        for (; symbol < FIXLCODES; symbol++)
+            lengths[symbol] = 8;
+        construct(&lencode, lengths, FIXLCODES);
+
+        /* distance table */
+        for (symbol = 0; symbol < MAXDCODES; symbol++)
+            lengths[symbol] = 5;
+        construct(&distcode, lengths, MAXDCODES);
+
+        /* do this just once */
+        virgin = 0;
+    }
+
+    /* decode data until end-of-block code */
+    return codes(s, &lencode, &distcode);
+}
+
+/*
+ * Process a dynamic codes block.
+ *
+ * Format notes:
+ *
+ * - A dynamic block starts with a description of the literal/length and
+ *   distance codes for that block.  New dynamic blocks allow the compressor to
+ *   rapidly adapt to changing data with new codes optimized for that data.
+ *
+ * - The codes used by the deflate format are "canonical", which means that
+ *   the actual bits of the codes are generated in an unambiguous way simply
+ *   from the number of bits in each code.  Therefore the code descriptions
+ *   are simply a list of code lengths for each symbol.
+ *
+ * - The code lengths are stored in order for the symbols, so lengths are
+ *   provided for each of the literal/length symbols, and for each of the
+ *   distance symbols.
+ *
+ * - If a symbol is not used in the block, this is represented by a zero as
+ *   as the code length.  This does not mean a zero-length code, but rather
+ *   that no code should be created for this symbol.  There is no way in the
+ *   deflate format to represent a zero-length code.
+ *
+ * - The maximum number of bits in a code is 15, so the possible lengths for
+ *   any code are 1..15.
+ *
+ * - The fact that a length of zero is not permitted for a code has an
+ *   interesting consequence.  Normally if only one symbol is used for a given
+ *   code, then in fact that code could be represented with zero bits.  However
+ *   in deflate, that code has to be at least one bit.  So for example, if
+ *   only a single distance base symbol appears in a block, then it will be
+ *   represented by a single code of length one, in particular one 0 bit.  This
+ *   is an incomplete code, since if a 1 bit is received, it has no meaning,
+ *   and should result in an error.  So incomplete distance codes of one symbol
+ *   should be permitted, and the receipt of invalid codes should be handled.
+ *
+ * - It is also possible to have a single literal/length code, but that code
+ *   must be the end-of-block code, since every dynamic block has one.  This
+ *   is not the most efficient way to create an empty block (an empty fixed
+ *   block is fewer bits), but it is allowed by the format.  So incomplete
+ *   literal/length codes of one symbol should also be permitted.
+ *
+ * - If there are only literal codes and no lengths, then there are no distance
+ *   codes.  This is represented by one distance code with zero bits.
+ *
+ * - The list of up to 286 length/literal lengths and up to 30 distance lengths
+ *   are themselves compressed using Huffman codes and run-length encoding.  In
+ *   the list of code lengths, a 0 symbol means no code, a 1..15 symbol means
+ *   that length, and the symbols 16, 17, and 18 are run-length instructions.
+ *   Each of 16, 17, and 18 are follwed by extra bits to define the length of
+ *   the run.  16 copies the last length 3 to 6 times.  17 represents 3 to 10
+ *   zero lengths, and 18 represents 11 to 138 zero lengths.  Unused symbols
+ *   are common, hence the special coding for zero lengths.
+ *
+ * - The symbols for 0..18 are Huffman coded, and so that code must be
+ *   described first.  This is simply a sequence of up to 19 three-bit values
+ *   representing no code (0) or the code length for that symbol (1..7).
+ *
+ * - A dynamic block starts with three fixed-size counts from which is computed
+ *   the number of literal/length code lengths, the number of distance code
+ *   lengths, and the number of code length code lengths (ok, you come up with
+ *   a better name!) in the code descriptions.  For the literal/length and
+ *   distance codes, lengths after those provided are considered zero, i.e. no
+ *   code.  The code length code lengths are received in a permuted order (see
+ *   the order[] array below) to make a short code length code length list more
+ *   likely.  As it turns out, very short and very long codes are less likely
+ *   to be seen in a dynamic code description, hence what may appear initially
+ *   to be a peculiar ordering.
+ *
+ * - Given the number of literal/length code lengths (nlen) and distance code
+ *   lengths (ndist), then they are treated as one long list of nlen + ndist
+ *   code lengths.  Therefore run-length coding can and often does cross the
+ *   boundary between the two sets of lengths.
+ *
+ * - So to summarize, the code description at the start of a dynamic block is
+ *   three counts for the number of code lengths for the literal/length codes,
+ *   the distance codes, and the code length codes.  This is followed by the
+ *   code length code lengths, three bits each.  This is used to construct the
+ *   code length code which is used to read the remainder of the lengths.  Then
+ *   the literal/length code lengths and distance lengths are read as a single
+ *   set of lengths using the code length codes.  Codes are constructed from
+ *   the resulting two sets of lengths, and then finally you can start
+ *   decoding actual compressed data in the block.
+ *
+ * - For reference, a "typical" size for the code description in a dynamic
+ *   block is around 80 bytes.
+ */
+local int dynamic(struct state* s)
+{
+    int nlen, ndist, ncode; /* number of lengths in descriptor */
+    int index; /* index of lengths[] */
+    int err; /* construct() return value */
+    short lengths[MAXCODES]; /* descriptor code lengths */
+    short lencnt[MAXBITS + 1], lensym[MAXLCODES]; /* lencode memory */
+    short distcnt[MAXBITS + 1], distsym[MAXDCODES]; /* distcode memory */
+    struct huffman lencode, distcode; /* length and distance codes */
+    static const short order[19] = /* permutation of code length codes */
+        { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
+
+    /* construct lencode and distcode */
+    lencode.count = lencnt;
+    lencode.symbol = lensym;
+    distcode.count = distcnt;
+    distcode.symbol = distsym;
+
+    /* get number of lengths in each table, check lengths */
+    nlen = bits(s, 5) + 257;
+    ndist = bits(s, 5) + 1;
+    ncode = bits(s, 4) + 4;
+    if (nlen > MAXLCODES || ndist > MAXDCODES)
+        return -3; /* bad counts */
+
+    /* read code length code lengths (really), missing lengths are zero */
+    for (index = 0; index < ncode; index++)
+        lengths[order[index]] = bits(s, 3);
+    for (; index < 19; index++)
+        lengths[order[index]] = 0;
+
+    /* build huffman table for code lengths codes (use lencode temporarily) */
+    err = construct(&lencode, lengths, 19);
+    if (err != 0) /* require complete code set here */
+        return -4;
+
+    /* read length/literal and distance code length tables */
+    index = 0;
+    while (index < nlen + ndist) {
+        int symbol; /* decoded value */
+        int len; /* last length to repeat */
+
+        symbol = decode(s, &lencode);
+        if (symbol < 0)
+            return symbol; /* invalid symbol */
+        if (symbol < 16) /* length in 0..15 */
+            lengths[index++] = symbol;
+        else { /* repeat instruction */
+            len = 0; /* assume repeating zeros */
+            if (symbol == 16) { /* repeat last length 3..6 times */
+                if (index == 0)
+                    return -5; /* no last length! */
+                len = lengths[index - 1]; /* last length */
+                symbol = 3 + bits(s, 2);
+            } else if (symbol == 17) /* repeat zero 3..10 times */
+                symbol = 3 + bits(s, 3);
+            else /* == 18, repeat zero 11..138 times */
+                symbol = 11 + bits(s, 7);
+            if (index + symbol > nlen + ndist)
+                return -6; /* too many lengths! */
+            while (symbol--) /* repeat last or zero symbol times */
+                lengths[index++] = len;
+        }
+    }
+
+    /* check for end-of-block code -- there better be one! */
+    if (lengths[256] == 0)
+        return -9;
+
+    /* build huffman table for literal/length codes */
+    err = construct(&lencode, lengths, nlen);
+    if (err && (err < 0 || nlen != lencode.count[0] + lencode.count[1]))
+        return -7; /* incomplete code ok only for single length 1 code */
+
+    /* build huffman table for distance codes */
+    err = construct(&distcode, lengths + nlen, ndist);
+    if (err && (err < 0 || ndist != distcode.count[0] + distcode.count[1]))
+        return -8; /* incomplete code ok only for single length 1 code */
+
+    /* decode data until end-of-block code */
+    return codes(s, &lencode, &distcode);
+}
+
+/*
+ * Inflate source to dest.  On return, destlen and sourcelen are updated to the
+ * size of the uncompressed data and the size of the deflate data respectively.
+ * On success, the return value of puff() is zero.  If there is an error in the
+ * source data, i.e. it is not in the deflate format, then a negative value is
+ * returned.  If there is not enough input available or there is not enough
+ * output space, then a positive error is returned.  In that case, destlen and
+ * sourcelen are not updated to facilitate retrying from the beginning with the
+ * provision of more input data or more output space.  In the case of invalid
+ * inflate data (a negative error), the dest and source pointers are updated to
+ * facilitate the debugging of deflators.
+ *
+ * puff() also has a mode to determine the size of the uncompressed output with
+ * no output written.  For this dest must be (unsigned char *)0.  In this case,
+ * the input value of *destlen is ignored, and on return *destlen is set to the
+ * size of the uncompressed output.
+ *
+ * The return codes are:
+ *
+ *   2:  available inflate data did not terminate
+ *   1:  output space exhausted before completing inflate
+ *   0:  successful inflate
+ *  -1:  invalid block type (type == 3)
+ *  -2:  stored block length did not match one's complement
+ *  -3:  dynamic block code description: too many length or distance codes
+ *  -4:  dynamic block code description: code lengths codes incomplete
+ *  -5:  dynamic block code description: repeat lengths with no first length
+ *  -6:  dynamic block code description: repeat more than specified lengths
+ *  -7:  dynamic block code description: invalid literal/length code lengths
+ *  -8:  dynamic block code description: invalid distance code lengths
+ *  -9:  dynamic block code description: missing end-of-block code
+ * -10:  invalid literal/length or distance code in fixed or dynamic block
+ * -11:  distance is too far back in fixed or dynamic block
+ *
+ * Format notes:
+ *
+ * - Three bits are read for each block to determine the kind of block and
+ *   whether or not it is the last block.  Then the block is decoded and the
+ *   process repeated if it was not the last block.
+ *
+ * - The leftover bits in the last byte of the deflate data after the last
+ *   block (if it was a fixed or dynamic block) are undefined and have no
+ *   expected values to check.
+ */
+int puff(unsigned char* dest, /* pointer to destination pointer */
+    size_t* destlen, /* amount of output space */
+    const unsigned char* source, /* pointer to source data pointer */
+    size_t* sourcelen) /* amount of input available */
+{
+    struct state s; /* input/output state */
+    int last, type; /* block information */
+    int err; /* return value */
+
+    /* initialize output state */
+    s.out = dest;
+    s.outlen = *destlen; /* ignored if dest is NIL */
+    s.outcnt = 0;
+
+    /* initialize input state */
+    s.in = source;
+    s.inlen = *sourcelen;
+    s.incnt = 0;
+    s.bitbuf = 0;
+    s.bitcnt = 0;
+
+    /* return if bits() or decode() tries to read past available input */
+    if (setjmp(s.env) != 0) /* if came back here via longjmp() */
+        err = 2; /* then skip do-loop, return error */
+    else {
+        /* process blocks until last block or error */
+        do {
+            last = bits(&s, 1); /* one if last block */
+            type = bits(&s, 2); /* block type 0..3 */
+            err = type == 0 ? stored(&s) : (type == 1 ? fixed(&s) : (type == 2 ? dynamic(&s) : -1)); /* type == 3, invalid */
+            if (err != 0)
+                break; /* return with error */
+        } while (!last);
+    }
+
+    /* update the lengths and return */
+    if (err <= 0) {
+        *destlen = s.outcnt;
+        *sourcelen = s.incnt;
+    }
+    return err;
+}

libs/libfoundation/src/json/Lexer.cpp

@@ -0,0 +1,38 @@
+#include <libfoundation/json/Lexer.h>
+#include <unistd.h>
+
+namespace LFoundation::Json {
+
+int Lexer::set_file(const std::string& filepath)
+{
+    char tmpbuf[1024];
+    m_pointer = 0;
+
+    int fd = open(filepath.c_str(), O_RDONLY);
+    if (fd < 0) {
+        return -1;
+    }
+
+    ssize_t read_cnt;
+    while ((read_cnt = read(fd, tmpbuf, sizeof(tmpbuf)))) {
+        if (read_cnt <= 0) {
+            return -2;
+        }
+        size_t buf_size = m_text_data.size();
+        m_text_data.resize(buf_size + read_cnt);
+        memcpy((uint8_t*)&m_text_data.data()[buf_size], (uint8_t*)tmpbuf, read_cnt);
+        if (read_cnt < sizeof(tmpbuf)) {
+            break;
+        }
+    }
+
+    if (m_text_data.empty()) {
+        return -3;
+    }
+
+    m_text_data.push_back('\0');
+    close(fd);
+    return 0;
+}
+
+}

libs/libfoundation/src/json/Parser.cpp

@@ -0,0 +1,112 @@
+#include <cassert>
+#include <libfoundation/json/Parser.h>
+#include <unistd.h>
+
+namespace LFoundation::Json {
+
+StringObject* Parser::parse_string()
+{
+    auto* res = new StringObject();
+
+    m_lexer.skip_spaces();
+    assert(m_lexer.eat_token('\"'));
+    m_lexer.eat_string(res->data());
+    assert(m_lexer.eat_token('\"'));
+    return res;
+}
+
+DictObject* Parser::parse_dict()
+{
+    auto* res = new DictObject();
+
+    m_lexer.skip_spaces();
+    assert(m_lexer.eat_token('{'));
+    for (;;) {
+        auto left = parse_string();
+        assert(m_lexer.eat_token(':'));
+        auto right_obj = parse_object();
+        res->data()[left->data()] = right_obj;
+
+        if (m_lexer.lookup_char() == ',') {
+            assert(m_lexer.eat_token(','));
+        } else {
+            break;
+        }
+    }
+    assert(m_lexer.eat_token('}'));
+    return res;
+}
+
+ListObject* Parser::parse_list()
+{
+    auto* res = new ListObject();
+
+    m_lexer.skip_spaces();
+    assert(m_lexer.eat_token('['));
+    for (;;) {
+        auto obj = parse_object();
+        res->data().push_back(obj);
+
+        if (m_lexer.lookup_char() == ',') {
+            assert(m_lexer.eat_token(','));
+        } else {
+            break;
+        }
+    }
+    assert(m_lexer.eat_token(']'));
+    return res;
+}
+
+BoolObject* Parser::parse_bool()
+{
+    auto* res = new BoolObject();
+
+    m_lexer.skip_spaces();
+
+    std::string tmp;
+    m_lexer.eat_string(tmp);
+
+    if (tmp == "true") {
+        res->data() = true;
+    } else if (tmp == "false") {
+        res->data() = false;
+    } else {
+        assert(false);
+    }
+
+    return res;
+}
+
+NullObject* Parser::parse_null()
+{
+    m_lexer.skip_spaces();
+    std::string tmp;
+    m_lexer.eat_string(tmp);
+    assert(tmp == "null");
+    return new NullObject();
+}
+
+Object* Parser::parse_object()
+{
+    m_lexer.skip_spaces();
+    switch (m_lexer.lookup_char()) {
+    case '{':
+        return parse_dict();
+    case '\"':
+        return parse_string();
+    case '[':
+        return parse_list();
+    case 'n':
+        // Only null is expected to start with n
+        return parse_null();
+    case 't':
+    case 'f':
+        // Only true or false is expected to start with n
+        return parse_bool();
+    default:
+        assert(false);
+    }
+    return new DictObject();
+}
+
+}