[DROP] disable SH runners for jshooks

- replace shell script with more peformant python script
- master header includes build/jshooks/generated/test.hook.$hash.inc files
  - looks for // @hook comment in hooks and places next to include
  - less annoying when running git diff without explicit ignore
  - first looks in usual location
- cmake locates or builds qjsc
  - searches for qjsc in previous place or honours QJSC_BINARY file
  - if not found builds from https://github.com/RichardAH/quickjslite

.gitattributes

@@ -11,3 +11,6 @@ LICENSE binary
 *.vcxproj   text eol=crlf
 *.props     text eol=crlf
 *.filters   text eol=crlf
+
+# Mark it as generated and folded out by default
+src/test/app/SetJSHook_wasm.h linguist-generated=true

.githooks/pre-commit

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# Pre-commit hook that runs the suspicious patterns check on staged files
+
+# Get the repository's root directory
+repo_root=$(git rev-parse --show-toplevel)
+
+# Run the suspicious patterns script in pre-commit mode
+"$repo_root/suspicious_patterns.sh" --pre-commit
+
+# Exit with the same code as the script
+exit $?

.githooks/setup.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+echo "Configuring git to use .githooks directory..."
+git config core.hooksPath .githooks

.github/actions/xahau-configure-ccache/action.yml

@@ -0,0 +1,31 @@
+name: 'Configure ccache'
+description: 'Sets up ccache with consistent configuration'
+
+inputs:
+  max_size:
+    description: 'Maximum cache size'
+    required: false
+    default: '2G'
+  hash_dir:
+    description: 'Whether to include directory paths in hash'
+    required: false
+    default: 'true'
+  compiler_check:
+    description: 'How to check compiler for changes'
+    required: false
+    default: 'content'
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Configure ccache
+      shell: bash
+      run: |
+        mkdir -p ~/.ccache
+        export CONF_PATH="${CCACHE_CONFIGPATH:-${CCACHE_DIR:-$HOME/.ccache}/ccache.conf}"
+        mkdir -p $(dirname "$CONF_PATH")
+        echo "max_size = ${{ inputs.max_size }}" > "$CONF_PATH"
+        echo "hash_dir = ${{ inputs.hash_dir }}" >> "$CONF_PATH"
+        echo "compiler_check = ${{ inputs.compiler_check }}" >> "$CONF_PATH"
+        ccache -p # Print config for verification
+        ccache -z # Zero statistics before the build

.github/actions/xahau-ga-build/action.yml

@@ -0,0 +1,108 @@
+name: build
+description: 'Builds the project with ccache integration'
+
+inputs:
+  generator:
+    description: 'CMake generator to use'
+    required: true
+  configuration:
+    description: 'Build configuration (Debug, Release, etc.)'
+    required: true
+  build_dir:
+    description: 'Directory to build in'
+    required: false
+    default: '.build'
+  cc:
+    description: 'C compiler to use'
+    required: false
+    default: ''
+  cxx:
+    description: 'C++ compiler to use'
+    required: false
+    default: ''
+  compiler-id:
+    description: 'Unique identifier for compiler/version combination used for cache keys'
+    required: false
+    default: ''
+  cache_version:
+    description: 'Cache version for invalidation'
+    required: false
+    default: '1'
+  ccache_enabled:
+    description: 'Whether to use ccache'
+    required: false
+    default: 'true'
+  main_branch:
+    description: 'Main branch name for restore keys'
+    required: false
+    default: 'dev'
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Generate safe branch name
+      if: inputs.ccache_enabled == 'true'
+      id: safe-branch
+      shell: bash
+      run: |
+        SAFE_BRANCH=$(echo "${{ github.ref_name }}" | tr -c 'a-zA-Z0-9_.-' '-')
+        echo "name=${SAFE_BRANCH}" >> $GITHUB_OUTPUT
+
+    - name: Restore ccache directory
+      if: inputs.ccache_enabled == 'true'
+      id: ccache-restore
+      uses: actions/cache/restore@v4
+      with:
+        path: ~/.ccache
+        key: ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-${{ steps.safe-branch.outputs.name }}
+        restore-keys: |
+          ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-${{ inputs.main_branch }}
+          ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-
+          ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-
+          ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-
+
+    - name: Configure project
+      shell: bash
+      run: |
+        mkdir -p ${{ inputs.build_dir }}
+        cd ${{ inputs.build_dir }}
+        
+        # Set compiler environment variables if provided
+        if [ -n "${{ inputs.cc }}" ]; then
+          export CC="${{ inputs.cc }}"
+        fi
+        
+        if [ -n "${{ inputs.cxx }}" ]; then
+          export CXX="${{ inputs.cxx }}"
+        fi
+        
+        # Configure ccache launcher args
+        CCACHE_ARGS=""
+        if [ "${{ inputs.ccache_enabled }}" = "true" ]; then
+          CCACHE_ARGS="-DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache"
+        fi
+        
+        # Run CMake configure
+        cmake .. \
+          -G "${{ inputs.generator }}" \
+          $CCACHE_ARGS \
+          -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+          -DCMAKE_BUILD_TYPE=${{ inputs.configuration }}
+
+    - name: Build project
+      shell: bash
+      run: |
+        cd ${{ inputs.build_dir }}
+        cmake --build . --config ${{ inputs.configuration }} --parallel $(nproc)
+
+    - name: Show ccache statistics
+      if: inputs.ccache_enabled == 'true'
+      shell: bash
+      run: ccache -s
+
+    - name: Save ccache directory
+      if: inputs.ccache_enabled == 'true'
+      uses: actions/cache/save@v4
+      with:
+        path: ~/.ccache
+        key: ${{ steps.ccache-restore.outputs.cache-primary-key }}

.github/actions/xahau-ga-dependencies/action.yml

@@ -0,0 +1,86 @@
+name: dependencies
+description: 'Installs build dependencies with caching'
+
+inputs:
+  configuration:
+    description: 'Build configuration (Debug, Release, etc.)'
+    required: true
+  build_dir:
+    description: 'Directory to build dependencies in'
+    required: false
+    default: '.build'
+  compiler-id:
+    description: 'Unique identifier for compiler/version combination used for cache keys'
+    required: false
+    default: ''
+  cache_version:
+    description: 'Cache version for invalidation'
+    required: false
+    default: '1'
+  cache_enabled:
+    description: 'Whether to use caching'
+    required: false
+    default: 'true'
+  main_branch:
+    description: 'Main branch name for restore keys'
+    required: false
+    default: 'dev'
+
+outputs:
+  cache-hit:
+    description: 'Whether there was a cache hit'
+    value: ${{ steps.cache-restore-conan.outputs.cache-hit }}
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Generate safe branch name
+      if: inputs.cache_enabled == 'true'
+      id: safe-branch
+      shell: bash
+      run: |
+        SAFE_BRANCH=$(echo "${{ github.ref_name }}" | tr -c 'a-zA-Z0-9_.-' '-')
+        echo "name=${SAFE_BRANCH}" >> $GITHUB_OUTPUT
+
+    - name: Restore Conan cache
+      if: inputs.cache_enabled == 'true'
+      id: cache-restore-conan
+      uses: actions/cache/restore@v4
+      with:
+        path: |
+          ~/.conan
+          ~/.conan2
+        key: ${{ runner.os }}-conan-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ hashFiles('**/conanfile.txt', '**/conanfile.py') }}-${{ inputs.configuration }}
+        restore-keys: |
+          ${{ runner.os }}-conan-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ hashFiles('**/conanfile.txt', '**/conanfile.py') }}-
+          ${{ runner.os }}-conan-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-
+          ${{ runner.os }}-conan-v${{ inputs.cache_version }}-
+
+    - name: Export custom recipes
+      shell: bash
+      run: |
+        conan export external/snappy snappy/1.1.9@
+        conan export external/soci soci/4.0.3@
+
+    - name: Install dependencies
+      shell: bash
+      run: |
+        # Create build directory
+        mkdir -p ${{ inputs.build_dir }}
+        cd ${{ inputs.build_dir }}
+        
+        # Install dependencies using conan
+        conan install \
+          --output-folder . \
+          --build missing \
+          --settings build_type=${{ inputs.configuration }} \
+          ..
+
+    - name: Save Conan cache
+      if: inputs.cache_enabled == 'true' && steps.cache-restore-conan.outputs.cache-hit != 'true'
+      uses: actions/cache/save@v4
+      with:
+        path: |
+          ~/.conan
+          ~/.conan2
+        key: ${{ steps.cache-restore-conan.outputs.cache-primary-key }}

.github/workflows/build-in-docker.yml

@@ -1,26 +0,0 @@
-name: Build using Docker
-
-on:
-  push:
-    branches: [ "dev", "candidate", "release" ]
-  pull_request:
-    branches: [ "dev", "candidate", "release" ]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  builder:
-    runs-on: [self-hosted, vanity]
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        clean: false
-    - name: Check for suspicious patterns
-      run: /bin/bash suspicious_patterns.sh
-    - name: Build using Docker
-      run: /bin/bash release-builder.sh
-    - name: Unit tests
-      run: /bin/bash docker-unit-tests.sh
-

.github/workflows/clang-format.yml

@@ -4,21 +4,32 @@ on: [push, pull_request]
 
 jobs:
   check:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     env:
       CLANG_VERSION: 10
     steps:
     - uses: actions/checkout@v3
-    - name: Install clang-format
+    # - name: Install clang-format
+    #   run: |
+    #     codename=$( lsb_release --codename --short )
+    #     sudo tee /etc/apt/sources.list.d/llvm.list >/dev/null <<EOF
+    #     deb http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
+    #     deb-src http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
+    #     EOF
+    #     wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add
+    #     sudo apt-get update -y
+    #     sudo apt-get install -y clang-format-${CLANG_VERSION}
+
+    # Temporary fix until this commit is merged
+    # https://github.com/XRPLF/rippled/commit/552377c76f55b403a1c876df873a23d780fcc81c
+    - name: Download and install clang-format
       run: |
-        codename=$( lsb_release --codename --short )
-        sudo tee /etc/apt/sources.list.d/llvm.list >/dev/null <<EOF
-        deb http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
-        deb-src http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
-        EOF
-        wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add
-        sudo apt-get update
-        sudo apt-get install clang-format-${CLANG_VERSION}
+        sudo apt-get update -y
+        sudo apt-get install -y libtinfo5
+        curl -LO https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.1/clang+llvm-10.0.1-x86_64-linux-gnu-ubuntu-16.04.tar.xz
+        tar -xf clang+llvm-10.0.1-x86_64-linux-gnu-ubuntu-16.04.tar.xz
+        sudo mv clang+llvm-10.0.1-x86_64-linux-gnu-ubuntu-16.04 /opt/clang-10
+        sudo ln -s /opt/clang-10/bin/clang-format /usr/local/bin/clang-format-10
     - name: Format src/ripple
       run: find src/ripple -type f \( -name '*.cpp' -o -name '*.h' -o -name '*.ipp' \) -print0 | xargs -0 clang-format-${CLANG_VERSION} -i
     - name: Format src/test
@@ -30,7 +41,7 @@ jobs:
         git diff --exit-code | tee "clang-format.patch"
     - name: Upload patch
       if: failure() && steps.assert.outcome == 'failure'
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       continue-on-error: true
       with:
         name: clang-format.patch

.github/workflows/doxygen.yml

@@ -1,25 +0,0 @@
-name: Build and publish Doxygen documentation
-on:
-  push:
-    branches:
-      - dev
-
-jobs:
-  job:
-    runs-on: ubuntu-latest
-    container:
-      image: docker://rippleci/rippled-ci-builder:2944b78d22db
-    steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: build
-        run: |
-          mkdir build
-          cd build
-          cmake -DBoost_NO_BOOST_CMAKE=ON ..
-          cmake --build . --target docs --parallel $(nproc)
-      - name: publish
-        uses: peaceiris/actions-gh-pages@v3
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: build/docs/html

.github/workflows/levelization.yml

@@ -18,7 +18,7 @@ jobs:
         git diff --exit-code | tee "levelization.patch"
     - name: Upload patch
       if: failure() && steps.assert.outcome == 'failure'
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       continue-on-error: true
       with:
         name: levelization.patch

.github/workflows/xahau-ga-macos.yml

@@ -0,0 +1,116 @@
+name: MacOS - GA Runner
+
+on:
+  push:
+    branches: ["dev", "candidate", "release"]
+  pull_request:
+    branches: ["dev", "candidate", "release", "jshooks"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        generator:
+          - Ninja
+        configuration:
+          - Debug
+    runs-on: macos-15
+    env:
+      build_dir: .build
+      # Bump this number to invalidate all caches globally.
+      CACHE_VERSION: 1
+      MAIN_BRANCH_NAME: dev
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Conan
+        run: |
+          brew install conan@1
+          # Add Conan 1 to the PATH for this job
+          echo "$(brew --prefix conan@1)/bin" >> $GITHUB_PATH
+
+      - name: Install Coreutils
+        run: |
+          brew install coreutils
+          echo "Num proc: $(nproc)"
+
+      - name: Install Ninja
+        if: matrix.generator == 'Ninja'
+        run: brew install ninja
+
+      - name: Install Python
+        run: |
+          if which python3 > /dev/null 2>&1; then
+              echo "Python 3 executable exists"
+              python3 --version
+          else
+              brew install python@3.12
+          fi
+          # Create 'python' symlink if it doesn't exist (for tools expecting 'python')
+          if ! which python > /dev/null 2>&1; then
+              sudo ln -sf $(which python3) /usr/local/bin/python
+          fi
+
+      - name: Install CMake
+        run: |
+          if which cmake > /dev/null 2>&1; then
+              echo "cmake executable exists"
+              cmake --version
+          else
+              brew install cmake
+          fi
+
+      - name: Install ccache
+        run: brew install ccache
+
+      - name: Configure ccache
+        uses: ./.github/actions/xahau-configure-ccache
+        with:
+          max_size: 2G
+          hash_dir: true
+          compiler_check: content
+
+      - name: Check environment
+        run: |
+          echo "PATH:"
+          echo "${PATH}" | tr ':' '\n'
+          which python && python --version || echo "Python not found"
+          which conan && conan --version || echo "Conan not found"
+          which cmake && cmake --version || echo "CMake not found"
+          clang --version
+          ccache --version
+          echo "---- Full Environment ----"
+          env
+
+      - name: Configure Conan
+        run: |
+          conan profile new default --detect || true # Ignore error if profile exists
+          conan profile update settings.compiler.cppstd=20 default
+
+      - name: Install dependencies
+        uses: ./.github/actions/xahau-ga-dependencies
+        with:
+          configuration: ${{ matrix.configuration }}
+          build_dir: ${{ env.build_dir }}
+          compiler-id: clang
+          cache_version: ${{ env.CACHE_VERSION }}
+          main_branch: ${{ env.MAIN_BRANCH_NAME }}
+
+      - name: Build
+        uses: ./.github/actions/xahau-ga-build
+        with:
+          generator: ${{ matrix.generator }}
+          configuration: ${{ matrix.configuration }}
+          build_dir: ${{ env.build_dir }}
+          compiler-id: clang
+          cache_version: ${{ env.CACHE_VERSION }}
+          main_branch: ${{ env.MAIN_BRANCH_NAME }}
+
+      - name: Test
+        run: |
+          ${{ env.build_dir }}/rippled --unittest --unittest-jobs $(nproc)

.github/workflows/xahau-ga-nix.yml

@@ -0,0 +1,123 @@
+name: Nix - GA Runner
+
+on:
+  push:
+    branches: ["dev", "candidate", "release"]
+  pull_request:
+    branches: ["dev", "candidate", "release", "jshooks"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build-job:
+    runs-on: ubuntu-latest
+    outputs:
+      artifact_name: ${{ steps.set-artifact-name.outputs.artifact_name }}
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [gcc]
+        configuration: [Debug]
+        include:
+          - compiler: gcc
+            cc: gcc-11
+            cxx: g++-11
+            compiler_id: gcc-11
+    env:
+      build_dir: .build
+      # Bump this number to invalidate all caches globally.
+      CACHE_VERSION: 1
+      MAIN_BRANCH_NAME: dev
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y ninja-build ${{ matrix.cc }} ${{ matrix.cxx }} ccache
+          # Install specific Conan version needed
+          pip install --upgrade "conan<2"
+
+      - name: Configure ccache
+        uses: ./.github/actions/xahau-configure-ccache
+        with:
+          max_size: 2G
+          hash_dir: true
+          compiler_check: content
+
+      - name: Configure Conan
+        run: |
+          conan profile new default --detect || true # Ignore error if profile exists
+          conan profile update settings.compiler.cppstd=20 default
+          conan profile update settings.compiler=${{ matrix.compiler }} default
+          conan profile update settings.compiler.libcxx=libstdc++11 default
+          conan profile update env.CC=/usr/bin/${{ matrix.cc }} default
+          conan profile update env.CXX=/usr/bin/${{ matrix.cxx }} default
+          conan profile update conf.tools.build:compiler_executables='{"c": "/usr/bin/${{ matrix.cc }}", "cpp": "/usr/bin/${{ matrix.cxx }}"}' default
+
+          # Set correct compiler version based on matrix.compiler
+          if [ "${{ matrix.compiler }}" = "gcc" ]; then
+            conan profile update settings.compiler.version=11 default
+          elif [ "${{ matrix.compiler }}" = "clang" ]; then
+            conan profile update settings.compiler.version=14 default
+          fi
+          # Display profile for verification
+          conan profile show default
+
+      - name: Check environment
+        run: |
+          echo "PATH:"
+          echo "${PATH}" | tr ':' '\n'
+          which conan && conan --version || echo "Conan not found"
+          which cmake && cmake --version || echo "CMake not found"
+          which ${{ matrix.cc }} && ${{ matrix.cc }} --version || echo "${{ matrix.cc }} not found"
+          which ${{ matrix.cxx }} && ${{ matrix.cxx }} --version || echo "${{ matrix.cxx }} not found"
+          which ccache && ccache --version || echo "ccache not found"
+          echo "---- Full Environment ----"
+          env
+
+      - name: Install dependencies
+        uses: ./.github/actions/xahau-ga-dependencies
+        with:
+          configuration: ${{ matrix.configuration }}
+          build_dir: ${{ env.build_dir }}
+          compiler-id: ${{ matrix.compiler_id }}
+          cache_version: ${{ env.CACHE_VERSION }}
+          main_branch: ${{ env.MAIN_BRANCH_NAME }}
+
+      - name: Build
+        uses: ./.github/actions/xahau-ga-build
+        with:
+          generator: Ninja
+          configuration: ${{ matrix.configuration }}
+          build_dir: ${{ env.build_dir }}
+          cc: ${{ matrix.cc }}
+          cxx: ${{ matrix.cxx }}
+          compiler-id: ${{ matrix.compiler_id }}
+          cache_version: ${{ env.CACHE_VERSION }}
+          main_branch: ${{ env.MAIN_BRANCH_NAME }}
+
+      - name: Set artifact name
+        id: set-artifact-name
+        run: |
+          ARTIFACT_NAME="build-output-nix-${{ github.run_id }}-${{ matrix.compiler }}-${{ matrix.configuration }}"
+          echo "artifact_name=${ARTIFACT_NAME}" >> "$GITHUB_OUTPUT"
+          echo "Using artifact name: ${ARTIFACT_NAME}"
+
+      - name: Debug build directory
+        run: |
+          echo "Checking build directory contents: ${{ env.build_dir }}"
+          ls -la ${{ env.build_dir }} || echo "Build directory not found or empty"
+
+      - name: Run tests
+        run: |
+          # Ensure the binary exists before trying to run
+          if [ -f "${{ env.build_dir }}/rippled" ]; then
+            ${{ env.build_dir }}/rippled --unittest --unittest-jobs $(nproc)
+          else
+             echo "Error: rippled executable not found in ${{ env.build_dir }}"
+             exit 1
+          fi

.github/workflows/xahau-sh-build-in-docker.yml

@@ -0,0 +1,85 @@
+name: Release - SH Runner
+
+on:
+  push:
+    branches: [ "dev", "candidate", "release"]
+  pull_request:
+    branches: [ "dev", "candidate", "release"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  DEBUG_CONTAINERS: 1
+  REMOVE_CONTAINERS: 0
+
+jobs:
+  build-and-test:
+    runs-on: [self-hosted, vanity]
+    steps:
+      - name: Prepare workspace
+        run: |
+          SAFE_BRANCH=$(echo "${{ github.ref_name }}" | sed -e 's/[^a-zA-Z0-9._-]/-/g')
+          CHECKOUT_PATH="${SAFE_BRANCH}-${{ github.sha }}"
+          echo "CHECKOUT_PATH=${CHECKOUT_PATH}" >> $GITHUB_ENV
+          mkdir -p "$CHECKOUT_PATH"
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          path: ${{ env.CHECKOUT_PATH }}
+          clean: true
+          fetch-depth: 2
+
+      - name: Set Cleanup Script Path
+        run: |
+          echo "JOB_CLEANUP_SCRIPT=$(mktemp)" >> $GITHUB_ENV
+
+      - name: Build using Docker
+        working-directory: ${{ env.CHECKOUT_PATH }}
+        run: /bin/bash release-builder.sh
+
+      - name: Stop Container (Cleanup after build)
+        if: always()
+        working-directory: ${{ env.CHECKOUT_PATH }}
+        run: |
+          echo "Running cleanup script: $JOB_CLEANUP_SCRIPT"
+          /bin/bash -e -x "$JOB_CLEANUP_SCRIPT"
+          CLEANUP_EXIT_CODE=$?
+
+          if [[ "$CLEANUP_EXIT_CODE" -eq 0 ]]; then
+            echo "Cleanup script succeeded."
+            rm -f "$JOB_CLEANUP_SCRIPT"
+            echo "Cleanup script removed."
+          else
+            echo "⚠️ Cleanup script failed! Keeping for debugging: $JOB_CLEANUP_SCRIPT"
+          fi
+
+          if [[ "${DEBUG_CONTAINERS}" == "1" ]]; then
+            echo "🔍 Checking for leftover containers..."
+            BUILD_CONTAINERS=$(docker ps --format '{{.Names}}' | grep '^xahaud_cached_builder' || echo "")
+            CONTAINER_NAME="xahaud_cached_builder_${{ github.workflow }}-${{ github.ref_name }}"
+            if [[ -n "$BUILD_CONTAINERS" && "${REMOVE_CONTAINERS}" == "1" ]]; then
+              echo "⚠️ WARNING: Some build containers are still running"
+              echo "$BUILD_CONTAINERS"
+              echo "Attempting to stop build containers.."
+              echo "Stopping container: $CONTAINER_NAME"
+              docker stop "$CONTAINER_NAME" || echo "Failed to stop container: $CONTAINER_NAME"
+              echo "Removing container: $CONTAINER_NAME"
+              docker rm -f "$CONTAINER_NAME" || echo "Failed to remove container: $CONTAINER_NAME"
+              echo "✅ Build container stopped and removed"
+            else
+              echo "✅ No build containers found"
+            fi
+          fi
+
+      - name: Run unit tests
+        working-directory: ${{ env.CHECKOUT_PATH }}
+        run: /bin/bash docker-unit-tests.sh
+
+      - name: Cleanup workspace
+        if: always()
+        run: |
+          echo "Cleaning workspace for ${CHECKOUT_PATH}"
+          rm -rf "${{ github.workspace }}/${CHECKOUT_PATH}"

.gitignore

@@ -114,3 +114,7 @@ pkg_out
 pkg
 CMakeUserPresets.json
 bld.rippled/
+
+# binary
+qjsc
+generated

.vscode/settings.json

@@ -3,7 +3,7 @@
   "C_Cpp.clang_format_path": ".clang-format",
   "C_Cpp.clang_format_fallbackStyle": "{ ColumnLimit: 0 }",
   "[cpp]":{
-    "editor.wordBasedSuggestions": false,
+    "editor.wordBasedSuggestions": "off",
     "editor.suggest.insertMode": "replace",
     "editor.semanticHighlighting.enabled": true,
     "editor.tabSize": 4,

BUILD.md

@@ -0,0 +1,442 @@
+> These instructions assume you have a C++ development environment ready
+> with Git, Python, Conan, CMake, and a C++ compiler. For help setting one up
+> on Linux, macOS, or Windows, see [our guide](./docs/build/environment.md).
+>
+> These instructions also assume a basic familiarity with Conan and CMake.
+> If you are unfamiliar with Conan,
+> you can read our [crash course](./docs/build/conan.md)
+> or the official [Getting Started][3] walkthrough.
+
+## Branches
+
+For a stable release, choose the `master` branch or one of the [tagged
+releases](https://github.com/ripple/rippled/releases).
+
+```
+git checkout master
+```
+
+For the latest release candidate, choose the `release` branch.
+
+```
+git checkout release
+```
+
+For the latest set of untested features, or to contribute, choose the `develop`
+branch.
+
+```
+git checkout develop
+```
+
+
+## Minimum Requirements
+
+- [Python 3.7](https://www.python.org/downloads/)
+- [Conan 1.55](https://conan.io/downloads.html)
+- [CMake 3.16](https://cmake.org/download/)
+
+`rippled` is written in the C++20 dialect and includes the `<concepts>` header.
+The [minimum compiler versions][2] required are:
+
+| Compiler    | Version |
+|-------------|---------|
+| GCC         | 10      |
+| Clang       | 13      |
+| Apple Clang | 13.1.6  |
+| MSVC        | 19.23   |
+
+We don't recommend Windows for `rippled` production at this time. As of
+January 2023, Ubuntu has the highest level of quality assurance, testing,
+and support.
+
+Windows developers should use Visual Studio 2019. `rippled` isn't
+compatible with [Boost](https://www.boost.org/) 1.78 or 1.79, and Conan
+can't build earlier Boost versions.
+
+**Note:** 32-bit Windows development isn't supported.
+
+
+## Steps
+
+
+### Set Up Conan
+
+1. (Optional) If you've never used Conan, use autodetect to set up a default profile.
+
+   ```
+   conan profile new default --detect
+   ```
+
+2. Update the compiler settings.
+
+   ```
+   conan profile update settings.compiler.cppstd=20 default
+   ```
+
+   Linux developers will commonly have a default Conan [profile][] that compiles
+   with GCC and links with libstdc++.
+   If you are linking with libstdc++ (see profile setting `compiler.libcxx`),
+   then you will need to choose the `libstdc++11` ABI.
+
+   ```
+   conan profile update settings.compiler.libcxx=libstdc++11 default
+   ```
+
+   On Windows, you should use the x64 native build tools.
+   An easy way to do that is to run the shortcut "x64 Native Tools Command
+   Prompt" for the version of Visual Studio that you have installed.
+
+   Windows developers must also build `rippled` and its dependencies for the x64
+   architecture.
+
+   ```
+   conan profile update settings.arch=x86_64 default
+   ```
+
+3. (Optional) If you have multiple compilers installed on your platform,
+   make sure that Conan and CMake select the one you want to use.
+   This setting will set the correct variables (`CMAKE_<LANG>_COMPILER`)
+   in the generated CMake toolchain file.
+
+   ```
+   conan profile update 'conf.tools.build:compiler_executables={"c": "<path>", "cpp": "<path>"}' default
+   ```
+
+   It should choose the compiler for dependencies as well,
+   but not all of them have a Conan recipe that respects this setting (yet).
+   For the rest, you can set these environment variables:
+
+   ```
+   conan profile update env.CC=<path> default
+   conan profile update env.CXX=<path> default
+   ```
+
+4. Export our [Conan recipe for Snappy](./external/snappy).
+   It doesn't explicitly link the C++ standard library,
+   which allows you to statically link it with GCC, if you want.
+
+   ```
+   conan export external/snappy snappy/1.1.9@
+   ```
+
+5. Export our [Conan recipe for SOCI](./external/soci).
+   It patches their CMake to correctly import its dependencies.
+
+   ```
+   conan export external/soci soci/4.0.3@
+   ```
+
+### Build and Test
+
+1. Create a build directory and move into it.
+
+   ```
+   mkdir .build
+   cd .build
+   ```
+
+   You can use any directory name. Conan treats your working directory as an
+   install folder and generates files with implementation details.
+   You don't need to worry about these files, but make sure to change
+   your working directory to your build directory before calling Conan.
+
+   **Note:** You can specify a directory for the installation files by adding
+   the `install-folder` or `-if` option to every `conan install` command
+   in the next step.
+
+2. Generate CMake files for every configuration you want to build. 
+
+    ```
+    conan install .. --output-folder . --build missing --settings build_type=Release
+    conan install .. --output-folder . --build missing --settings build_type=Debug
+    ```
+
+    For a single-configuration generator, e.g. `Unix Makefiles` or `Ninja`,
+    you only need to run this command once.
+    For a multi-configuration generator, e.g. `Visual Studio`, you may want to
+    run it more than once.
+
+    Each of these commands should also have a different `build_type` setting.
+    A second command with the same `build_type` setting will overwrite the files
+    generated by the first. You can pass the build type on the command line with
+    `--settings build_type=$BUILD_TYPE` or in the profile itself,
+    under the section `[settings]` with the key `build_type`.
+    
+    If you are using a Microsoft Visual C++ compiler,
+    then you will need to ensure consistency between the `build_type` setting
+    and the `compiler.runtime` setting.
+    
+    When `build_type` is `Release`, `compiler.runtime` should be `MT`.
+    
+    When `build_type` is `Debug`, `compiler.runtime` should be `MTd`.
+
+    ```
+    conan install .. --output-folder . --build missing --settings build_type=Release --settings compiler.runtime=MT
+    conan install .. --output-folder . --build missing --settings build_type=Debug --settings compiler.runtime=MTd
+    ```
+
+3. Configure CMake and pass the toolchain file generated by Conan, located at
+   `$OUTPUT_FOLDER/build/generators/conan_toolchain.cmake`.
+
+    Single-config generators:
+    
+    ```
+    cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release ..
+    ```
+
+    Pass the CMake variable [`CMAKE_BUILD_TYPE`][build_type]
+    and make sure it matches the `build_type` setting you chose in the previous
+    step.
+
+    Multi-config gnerators:
+
+    ```
+    cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake ..
+    ```
+
+    **Note:** You can pass build options for `rippled` in this step.
+
+4. Build `rippled`.
+
+   For a single-configuration generator, it will build whatever configuration
+   you passed for `CMAKE_BUILD_TYPE`. For a multi-configuration generator,
+   you must pass the option `--config` to select the build configuration. 
+
+   Single-config generators:
+
+   ```
+   cmake --build .
+   ```
+
+   Multi-config generators:
+    
+   ```
+   cmake --build . --config Release
+   cmake --build . --config Debug
+   ```
+
+5. Test rippled.
+
+   Single-config generators:
+
+   ```
+   ./rippled --unittest
+   ```
+
+   Multi-config generators:
+
+   ```
+   ./Release/rippled --unittest
+   ./Debug/rippled --unittest
+   ```
+
+   The location of `rippled` in your build directory depends on your CMake
+   generator. Pass `--help` to see the rest of the command line options.
+
+
+## Options
+
+| Option | Default Value | Description |
+| --- | ---| ---|
+| `assert` | OFF | Enable assertions.
+| `reporting` | OFF | Build the reporting mode feature. |
+| `tests` | ON | Build tests. |
+| `unity` | ON | Configure a unity build. |
+| `san` | N/A | Enable a sanitizer with Clang. Choices are `thread` and `address`. |
+
+[Unity builds][5] may be faster for the first build
+(at the cost of much more memory) since they concatenate sources into fewer
+translation units. Non-unity builds may be faster for incremental builds,
+and can be helpful for detecting `#include` omissions.
+
+
+## Troubleshooting
+
+
+### Conan
+
+If you have trouble building dependencies after changing Conan settings,
+try removing the Conan cache.
+
+```
+rm -rf ~/.conan/data
+```
+
+
+### no std::result_of
+
+If your compiler version is recent enough to have removed `std::result_of` as
+part of C++20, e.g. Apple Clang 15.0, then you might need to add a preprocessor
+definition to your build.
+
+```
+conan profile update 'options.boost:extra_b2_flags="define=BOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
+conan profile update 'env.CFLAGS="-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
+conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
+conan profile update 'conf.tools.build:cflags+=["-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"]' default
+conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"]' default
+```
+
+
+### recompile with -fPIC
+
+If you get a linker error suggesting that you recompile Boost with
+position-independent code, such as:
+
+```
+/usr/bin/ld.gold: error: /home/username/.conan/data/boost/1.77.0/_/_/package/.../lib/libboost_container.a(alloc_lib.o):
+  requires unsupported dynamic reloc 11; recompile with -fPIC
+```
+
+Conan most likely downloaded a bad binary distribution of the dependency.
+This seems to be a [bug][1] in Conan just for Boost 1.77.0 compiled with GCC
+for Linux. The solution is to build the dependency locally by passing
+`--build boost` when calling `conan install`.
+
+```
+/usr/bin/ld.gold: error: /home/username/.conan/data/boost/1.77.0/_/_/package/dc8aedd23a0f0a773a5fcdcfe1ae3e89c4205978/lib/libboost_container.a(alloc_lib.o): requires unsupported dynamic reloc 11; recompile with -fPIC
+```
+
+
+## Add a Dependency
+
+If you want to experiment with a new package, follow these steps:
+
+1. Search for the package on [Conan Center](https://conan.io/center/).
+2. Modify [`conanfile.py`](./conanfile.py):
+    - Add a version of the package to the `requires` property.
+    - Change any default options for the package by adding them to the
+    `default_options` property (with syntax `'$package:$option': $value`).
+3. Modify [`CMakeLists.txt`](./CMakeLists.txt):
+    - Add a call to `find_package($package REQUIRED)`.
+    - Link a library from the package to the target `ripple_libs`
+    (search for the existing call to `target_link_libraries(ripple_libs INTERFACE ...)`).
+4. Start coding! Don't forget to include whatever headers you need from the package.
+
+
+## A crash course in CMake and Conan
+
+To better understand how to use Conan,
+we should first understand _why_ we use Conan,
+and to understand that,
+we need to understand how we use CMake.
+
+
+### CMake
+
+Technically, you don't need CMake to build this project.
+You could manually compile every translation unit into an object file,
+using the right compiler options,
+and then manually link all those objects together,
+using the right linker options.
+However, that is very tedious and error-prone,
+which is why we lean on tools like CMake.
+
+We have written CMake configuration files
+([`CMakeLists.txt`](./CMakeLists.txt) and friends)
+for this project so that CMake can be used to correctly compile and link
+all of the translation units in it.
+Or rather, CMake will generate files for a separate build system
+(e.g. Make, Ninja, Visual Studio, Xcode, etc.)
+that compile and link all of the translation units.
+Even then, CMake has parameters, some of which are platform-specific.
+In CMake's parlance, parameters are specially-named **variables** like
+[`CMAKE_BUILD_TYPE`][build_type] or
+[`CMAKE_MSVC_RUNTIME_LIBRARY`][runtime].
+Parameters include:
+
+- what build system to generate files for
+- where to find the compiler and linker
+- where to find dependencies, e.g. libraries and headers
+- how to link dependencies, e.g. any special compiler or linker flags that
+    need to be used with them, including preprocessor definitions
+- how to compile translation units, e.g. with optimizations, debug symbols,
+    position-independent code, etc.
+- on Windows, which runtime library to link with
+
+For some of these parameters, like the build system and compiler,
+CMake goes through a complicated search process to choose default values.
+For others, like the dependencies,
+_we_ had written in the CMake configuration files of this project
+our own complicated process to choose defaults.
+For most developers, things "just worked"... until they didn't, and then
+you were left trying to debug one of these complicated processes, instead of
+choosing and manually passing the parameter values yourself.
+
+You can pass every parameter to CMake on the command line,
+but writing out these parameters every time we want to configure CMake is
+a pain.
+Most humans prefer to put them into a configuration file, once, that
+CMake can read every time it is configured.
+For CMake, that file is a [toolchain file][toolchain].
+
+
+### Conan
+
+These next few paragraphs on Conan are going to read much like the ones above
+for CMake.
+
+Technically, you don't need Conan to build this project.
+You could manually download, configure, build, and install all of the
+dependencies yourself, and then pass all of the parameters necessary for
+CMake to link to those dependencies.
+To guarantee ABI compatibility, you must be sure to use the same set of
+compiler and linker options for all dependencies _and_ this project.
+However, that is very tedious and error-prone, which is why we lean on tools
+like Conan.
+
+We have written a Conan configuration file ([`conanfile.py`](./conanfile.py))
+so that Conan can be used to correctly download, configure, build, and install
+all of the dependencies for this project,
+using a single set of compiler and linker options for all of them.
+It generates files that contain almost all of the parameters that CMake
+expects.
+Those files include:
+
+- A single toolchain file.
+- For every dependency, a CMake [package configuration file][pcf],
+    [package version file][pvf], and for every build type, a package
+    targets file.
+    Together, these files implement version checking and define `IMPORTED`
+    targets for the dependencies.
+
+The toolchain file itself amends the search path
+([`CMAKE_PREFIX_PATH`][prefix_path]) so that [`find_package()`][find_package]
+will [discover][search] the generated package configuration files.
+
+**Nearly all we must do to properly configure CMake is pass the toolchain
+file.**
+What CMake parameters are left out?
+You'll still need to pick a build system generator,
+and if you choose a single-configuration generator,
+you'll need to pass the `CMAKE_BUILD_TYPE`,
+which should match the `build_type` setting you gave to Conan.
+
+Even then, Conan has parameters, some of which are platform-specific.
+In Conan's parlance, parameters are either settings or options.
+**Settings** are shared by all packages, e.g. the build type.
+**Options** are specific to a given package, e.g. whether to build and link
+OpenSSL as a shared library.
+
+For settings, Conan goes through a complicated search process to choose
+defaults.
+For options, each package recipe defines its own defaults.
+
+You can pass every parameter to Conan on the command line,
+but it is more convenient to put them in a [profile][profile].
+**All we must do to properly configure Conan is edit and pass the profile.**
+
+
+[1]: https://github.com/conan-io/conan-center-index/issues/13168
+[5]: https://en.wikipedia.org/wiki/Unity_build
+[build_type]: https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
+[runtime]: https://cmake.org/cmake/help/latest/variable/CMAKE_MSVC_RUNTIME_LIBRARY.html
+[toolchain]: https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html
+[pcf]: https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html#package-configuration-file
+[pvf]: https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html#package-version-file
+[find_package]: https://cmake.org/cmake/help/latest/command/find_package.html
+[search]: https://cmake.org/cmake/help/latest/command/find_package.html#search-procedure
+[prefix_path]: https://cmake.org/cmake/help/latest/variable/CMAKE_PREFIX_PATH.html
+[profile]: https://docs.conan.io/en/latest/reference/profiles.html
+

Builds/CMake/RippledCore.cmake

@@ -23,6 +23,11 @@ else()
   message(STATUS "ACL not found, continuing without ACL support")
 endif()
 
+add_library(libxrpl INTERFACE)
+target_link_libraries(libxrpl INTERFACE xrpl_core)
+add_library(xrpl::libxrpl ALIAS libxrpl)
+
+
 #[===============================[
     beast/legacy FILES:
     TODO: review these sources for removal or replacement
@@ -144,10 +149,11 @@ target_link_libraries (xrpl_core
   PUBLIC
     OpenSSL::Crypto
     Ripple::boost
-    NIH::WasmEdge
+    wasmedge::wasmedge
+    NIH::quickjs
     Ripple::syslibs
-    NIH::secp256k1
-    NIH::ed25519-donna
+    secp256k1::secp256k1
+    ed25519::ed25519
     date::date
     Ripple::opts)
 #[=================================[
@@ -324,6 +330,11 @@ if (tests)
       src/ripple/beast/unit_test/detail/const_container.hpp
     DESTINATION include/ripple/beast/unit_test/detail)
 endif () #tests
+#[===================================================================[
+   JS Hooks integration 
+#]===================================================================]
+include(Builds/CMake/jshooks/JSHooks.cmake)
+
 #[===================================================================[
    rippled executable
 #]===================================================================]
@@ -392,6 +403,7 @@ target_sources (rippled PRIVATE
   src/ripple/app/misc/NegativeUNLVote.cpp
   src/ripple/app/misc/NetworkOPs.cpp
   src/ripple/app/misc/SHAMapStoreImp.cpp
+  src/ripple/app/misc/StateAccounting.cpp
   src/ripple/app/misc/detail/impl/WorkSSL.cpp
   src/ripple/app/misc/impl/AccountTxPaging.cpp
   src/ripple/app/misc/impl/AmendmentTable.cpp
@@ -433,13 +445,18 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/CancelOffer.cpp
   src/ripple/app/tx/impl/CashCheck.cpp
   src/ripple/app/tx/impl/Change.cpp
+  src/ripple/app/tx/impl/ClaimReward.cpp
+  src/ripple/app/tx/impl/Clawback.cpp
   src/ripple/app/tx/impl/CreateCheck.cpp
   src/ripple/app/tx/impl/CreateOffer.cpp
   src/ripple/app/tx/impl/CreateTicket.cpp
   src/ripple/app/tx/impl/DeleteAccount.cpp
   src/ripple/app/tx/impl/DepositPreauth.cpp
   src/ripple/app/tx/impl/Escrow.cpp
+  src/ripple/app/tx/impl/GenesisMint.cpp
+  src/ripple/app/tx/impl/Import.cpp
   src/ripple/app/tx/impl/InvariantCheck.cpp
+  src/ripple/app/tx/impl/Invoke.cpp
   src/ripple/app/tx/impl/NFTokenAcceptOffer.cpp
   src/ripple/app/tx/impl/NFTokenBurn.cpp
   src/ripple/app/tx/impl/NFTokenCancelOffer.cpp
@@ -448,13 +465,11 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/OfferStream.cpp
   src/ripple/app/tx/impl/PayChan.cpp
   src/ripple/app/tx/impl/Payment.cpp
+  src/ripple/app/tx/impl/Remit.cpp
   src/ripple/app/tx/impl/SetAccount.cpp
-  src/ripple/app/tx/impl/SetRegularKey.cpp
   src/ripple/app/tx/impl/SetHook.cpp
-  src/ripple/app/tx/impl/ClaimReward.cpp
-  src/ripple/app/tx/impl/GenesisMint.cpp
-  src/ripple/app/tx/impl/Import.cpp
-  src/ripple/app/tx/impl/Invoke.cpp
+  src/ripple/app/tx/impl/SetRemarks.cpp
+  src/ripple/app/tx/impl/SetRegularKey.cpp
   src/ripple/app/tx/impl/SetSignerList.cpp
   src/ripple/app/tx/impl/SetTrust.cpp
   src/ripple/app/tx/impl/SignerEntries.cpp
@@ -537,7 +552,9 @@ target_sources (rippled PRIVATE
        subdir: nodestore
   #]===============================]
   src/ripple/nodestore/backend/CassandraFactory.cpp
+  src/ripple/nodestore/backend/RWDBFactory.cpp
   src/ripple/nodestore/backend/MemoryFactory.cpp
+  src/ripple/nodestore/backend/FlatmapFactory.cpp
   src/ripple/nodestore/backend/NuDBFactory.cpp
   src/ripple/nodestore/backend/NullFactory.cpp
   src/ripple/nodestore/backend/RocksDBFactory.cpp
@@ -602,6 +619,7 @@ target_sources (rippled PRIVATE
   src/ripple/rpc/handlers/BlackList.cpp
   src/ripple/rpc/handlers/BookOffers.cpp
   src/ripple/rpc/handlers/CanDelete.cpp
+  src/ripple/rpc/handlers/Catalogue.cpp
   src/ripple/rpc/handlers/Connect.cpp
   src/ripple/rpc/handlers/ConsensusInfo.cpp
   src/ripple/rpc/handlers/CrawlShards.cpp
@@ -657,6 +675,7 @@ target_sources (rippled PRIVATE
   src/ripple/rpc/handlers/ValidatorListSites.cpp
   src/ripple/rpc/handlers/Validators.cpp
   src/ripple/rpc/handlers/WalletPropose.cpp
+  src/ripple/rpc/handlers/Catalogue.cpp
   src/ripple/rpc/impl/DeliveredAmount.cpp
   src/ripple/rpc/impl/Handler.cpp
   src/ripple/rpc/impl/LegacyPathFind.cpp
@@ -668,6 +687,9 @@ target_sources (rippled PRIVATE
   src/ripple/rpc/impl/ShardVerificationScheduler.cpp
   src/ripple/rpc/impl/Status.cpp
   src/ripple/rpc/impl/TransactionSign.cpp
+  src/ripple/rpc/impl/NFTokenID.cpp
+  src/ripple/rpc/impl/NFTokenOfferID.cpp
+  src/ripple/rpc/impl/NFTSyntheticSerializer.cpp
   #[===============================[
      main sources:
        subdir: perflog
@@ -706,6 +728,7 @@ if (tests)
     src/test/app/BaseFee_test.cpp
     src/test/app/Check_test.cpp
     src/test/app/ClaimReward_test.cpp
+    src/test/app/Clawback_test.cpp
     src/test/app/CrossingLimits_test.cpp
     src/test/app/DeliverMin_test.cpp
     src/test/app/DepositAuth_test.cpp
@@ -736,17 +759,23 @@ if (tests)
     src/test/app/Path_test.cpp
     src/test/app/PayChan_test.cpp
     src/test/app/PayStrand_test.cpp
+    src/test/app/PreviousTxn_test.cpp
     src/test/app/PseudoTx_test.cpp
     src/test/app/RCLCensorshipDetector_test.cpp
     src/test/app/RCLValidations_test.cpp
     src/test/app/Regression_test.cpp
+    src/test/app/Remit_test.cpp
     src/test/app/SHAMapStore_test.cpp
     src/test/app/SetAuth_test.cpp
+    src/test/app/SetHook_test.cpp
+    src/test/app/SetHookTSH_test.cpp
     src/test/app/SetRegularKey_test.cpp
+    src/test/app/SetRemarks_test.cpp
     src/test/app/SetTrust_test.cpp
     src/test/app/Taker_test.cpp
     src/test/app/TheoreticalQuality_test.cpp
     src/test/app/Ticket_test.cpp
+    src/test/app/Touch_test.cpp
     src/test/app/Transaction_ordering_test.cpp
     src/test/app/TrustAndBalance_test.cpp
     src/test/app/TxQ_test.cpp
@@ -755,6 +784,7 @@ if (tests)
     src/test/app/ValidatorList_test.cpp
     src/test/app/ValidatorSite_test.cpp
     src/test/app/SetHook_test.cpp
+    src/test/app/SetJSHook_test.cpp
     src/test/app/SetHookTSH_test.cpp
     src/test/app/Wildcard_test.cpp
     src/test/app/XahauGenesis_test.cpp
@@ -889,10 +919,13 @@ if (tests)
     src/test/jtx/impl/rate.cpp
     src/test/jtx/impl/regkey.cpp
     src/test/jtx/impl/reward.cpp
+    src/test/jtx/impl/remarks.cpp
+    src/test/jtx/impl/remit.cpp
     src/test/jtx/impl/sendmax.cpp
     src/test/jtx/impl/seq.cpp
     src/test/jtx/impl/sig.cpp
     src/test/jtx/impl/tag.cpp
+    src/test/jtx/impl/TestHelpers.cpp
     src/test/jtx/impl/ticket.cpp
     src/test/jtx/impl/token.cpp
     src/test/jtx/impl/trust.cpp
@@ -980,10 +1013,12 @@ if (tests)
     src/test/rpc/AccountLinesRPC_test.cpp
     src/test/rpc/AccountObjects_test.cpp
     src/test/rpc/AccountOffers_test.cpp
+    src/test/rpc/AccountNamespace_test.cpp
     src/test/rpc/AccountSet_test.cpp
     src/test/rpc/AccountTx_test.cpp
     src/test/rpc/AmendmentBlocked_test.cpp
     src/test/rpc/Book_test.cpp
+    src/test/rpc/Catalogue_test.cpp
     src/test/rpc/DepositAuthorized_test.cpp
     src/test/rpc/DeliveredAmount_test.cpp
     src/test/rpc/Feature_test.cpp
@@ -1037,6 +1072,11 @@ if (tests)
     src/test/unit_test/multi_runner.cpp)
 endif () #tests
 
+# Add JS hooks support to rippled when tests are enabled
+if (tests)
+  target_add_jshooks(rippled)
+endif () #tests
+
 target_link_libraries (rippled
   Ripple::boost
   Ripple::opts

Builds/CMake/RippledDocs.cmake

@@ -1,6 +1,13 @@
 #[===================================================================[
    docs target (optional)
 #]===================================================================]
+
+# Early return if the `docs` directory is missing,
+# e.g. when we are building a Conan package.
+if(NOT EXISTS docs)
+  return()
+endif()
+
 if (tests)
   find_package (Doxygen)
   if (NOT TARGET Doxygen::doxygen)

Builds/CMake/RippledInstall.cmake

@@ -4,7 +4,7 @@
 
 install (
   TARGETS
-    ed25519-donna
+    quickjs
     common
     opts
     ripple_syslibs
@@ -16,17 +16,6 @@ install (
   RUNTIME DESTINATION bin
   INCLUDES DESTINATION include)
 
-if(${INSTALL_SECP256K1})
-install (
-  TARGETS
-    secp256k1
-  EXPORT RippleExports
-  LIBRARY DESTINATION lib
-  ARCHIVE DESTINATION lib
-  RUNTIME DESTINATION bin
-  INCLUDES DESTINATION include)
-endif()
-
 install (EXPORT RippleExports
   FILE RippleTargets.cmake
   NAMESPACE Ripple::

Builds/CMake/RippledMultiConfig.cmake

@@ -14,7 +14,7 @@ if (is_multiconfig)
   file(GLOB md_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} CONFIGURE_DEPENDS
     *.md)
   LIST(APPEND all_sources ${md_files})
-  foreach (_target secp256k1 ed25519-donna pbufs xrpl_core rippled)
+  foreach (_target secp256k1::secp256k1 ed25519::ed25519 pbufs xrpl_core rippled)
     get_target_property (_type ${_target} TYPE)
     if(_type STREQUAL "INTERFACE_LIBRARY")
       continue()

Builds/CMake/conan/Boost.cmake

@@ -0,0 +1,52 @@
+find_package(Boost 1.83 REQUIRED
+  COMPONENTS
+    chrono
+    container
+    context
+    coroutine
+    date_time
+    filesystem
+    program_options
+    regex
+    system
+    thread
+)
+
+add_library(ripple_boost INTERFACE)
+add_library(Ripple::boost ALIAS ripple_boost)
+if(XCODE)
+  target_include_directories(ripple_boost BEFORE INTERFACE ${Boost_INCLUDE_DIRS})
+  target_compile_options(ripple_boost INTERFACE --system-header-prefix="boost/")
+else()
+  target_include_directories(ripple_boost SYSTEM BEFORE INTERFACE ${Boost_INCLUDE_DIRS})
+endif()
+
+target_link_libraries(ripple_boost
+  INTERFACE
+    Boost::boost
+    Boost::chrono
+    Boost::container
+    Boost::coroutine
+    Boost::date_time
+    Boost::filesystem
+    Boost::program_options
+    Boost::regex
+    Boost::system
+    Boost::iostreams
+    Boost::thread)
+if(Boost_COMPILER)
+  target_link_libraries(ripple_boost INTERFACE Boost::disable_autolinking)
+endif()
+if(san AND is_clang)
+  # TODO: gcc does not support -fsanitize-blacklist...can we do something else
+  # for gcc ?
+  if(NOT Boost_INCLUDE_DIRS AND TARGET Boost::headers)
+    get_target_property(Boost_INCLUDE_DIRS Boost::headers INTERFACE_INCLUDE_DIRECTORIES)
+  endif()
+  message(STATUS "Adding [${Boost_INCLUDE_DIRS}] to sanitizer blacklist")
+  file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt "src:${Boost_INCLUDE_DIRS}/*")
+  target_compile_options(opts
+    INTERFACE
+      # ignore boost headers for sanitizing
+      -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt)
+endif()

Builds/CMake/conan/Protobuf.cmake

@@ -0,0 +1,22 @@
+find_package(Protobuf 3.8)
+
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/proto_gen)
+set(ccbd ${CMAKE_CURRENT_BINARY_DIR})
+set(CMAKE_CURRENT_BINARY_DIR ${CMAKE_BINARY_DIR}/proto_gen)
+protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS src/ripple/proto/ripple.proto)
+set(CMAKE_CURRENT_BINARY_DIR ${ccbd})
+
+add_library(pbufs STATIC ${PROTO_SRCS} ${PROTO_HDRS})
+target_include_directories(pbufs SYSTEM PUBLIC
+  ${CMAKE_BINARY_DIR}/proto_gen
+  ${CMAKE_BINARY_DIR}/proto_gen/src/ripple/proto
+)
+target_link_libraries(pbufs protobuf::libprotobuf)
+target_compile_options(pbufs
+  PUBLIC
+    $<$<BOOL:${XCODE}>:
+      --system-header-prefix="google/protobuf"
+      -Wno-deprecated-dynamic-exception-spec
+    >
+)
+add_library(Ripple::pbufs ALIAS pbufs)

Builds/CMake/conan/gRPC.cmake

@@ -0,0 +1,62 @@
+find_package(gRPC 1.23)
+
+#[=================================[
+   generate protobuf sources for
+   grpc defs and bundle into a
+   static lib
+#]=================================]
+set(GRPC_GEN_DIR "${CMAKE_BINARY_DIR}/proto_gen_grpc")
+file(MAKE_DIRECTORY ${GRPC_GEN_DIR})
+set(GRPC_PROTO_SRCS)
+set(GRPC_PROTO_HDRS)
+set(GRPC_PROTO_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/src/ripple/proto/org")
+file(GLOB_RECURSE GRPC_DEFINITION_FILES LIST_DIRECTORIES false "${GRPC_PROTO_ROOT}/*.proto")
+foreach(file ${GRPC_DEFINITION_FILES})
+  get_filename_component(_abs_file ${file} ABSOLUTE)
+  get_filename_component(_abs_dir ${_abs_file} DIRECTORY)
+  get_filename_component(_basename ${file} NAME_WE)
+  get_filename_component(_proto_inc ${GRPC_PROTO_ROOT} DIRECTORY) # updir one level
+  file(RELATIVE_PATH _rel_root_file ${_proto_inc} ${_abs_file})
+  get_filename_component(_rel_root_dir ${_rel_root_file} DIRECTORY)
+  file(RELATIVE_PATH _rel_dir ${CMAKE_CURRENT_SOURCE_DIR} ${_abs_dir})
+
+  set(src_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.cc")
+  set(src_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.cc")
+  set(hdr_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.h")
+  set(hdr_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.h")
+  add_custom_command(
+    OUTPUT ${src_1} ${src_2} ${hdr_1} ${hdr_2}
+    COMMAND protobuf::protoc
+    ARGS --grpc_out=${GRPC_GEN_DIR}
+         --cpp_out=${GRPC_GEN_DIR}
+         --plugin=protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
+         -I ${_proto_inc} -I ${_rel_dir}
+         ${_abs_file}
+    DEPENDS ${_abs_file} protobuf::protoc gRPC::grpc_cpp_plugin
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Running gRPC C++ protocol buffer compiler on ${file}"
+    VERBATIM)
+    set_source_files_properties(${src_1} ${src_2} ${hdr_1} ${hdr_2} PROPERTIES GENERATED TRUE)
+    list(APPEND GRPC_PROTO_SRCS ${src_1} ${src_2})
+    list(APPEND GRPC_PROTO_HDRS ${hdr_1} ${hdr_2})
+endforeach()
+
+add_library(grpc_pbufs STATIC ${GRPC_PROTO_SRCS} ${GRPC_PROTO_HDRS})
+#target_include_directories(grpc_pbufs PRIVATE src)
+target_include_directories(grpc_pbufs SYSTEM PUBLIC ${GRPC_GEN_DIR})
+target_link_libraries(grpc_pbufs
+  "gRPC::grpc++"
+  # libgrpc is missing references.
+  absl::random_random
+)
+target_compile_options(grpc_pbufs
+  PRIVATE
+    $<$<BOOL:${MSVC}>:-wd4065>
+    $<$<NOT:$<BOOL:${MSVC}>>:-Wno-deprecated-declarations>
+  PUBLIC
+    $<$<BOOL:${MSVC}>:-wd4996>
+    $<$<BOOL:${XCODE}>:
+      --system-header-prefix="google/protobuf"
+      -Wno-deprecated-dynamic-exception-spec
+    >)
+add_library(Ripple::grpc_pbufs ALIAS grpc_pbufs)

Builds/CMake/deps/Boost.cmake

@@ -1,14 +1,16 @@
 #[===================================================================[
    NIH dep: boost
 #]===================================================================]
-
 if((NOT DEFINED BOOST_ROOT) AND(DEFINED ENV{BOOST_ROOT}))
   set(BOOST_ROOT $ENV{BOOST_ROOT})
 endif()
+if((NOT DEFINED BOOST_LIBRARYDIR) AND(DEFINED ENV{BOOST_LIBRARYDIR}))
+  set(BOOST_LIBRARYDIR $ENV{BOOST_LIBRARYDIR})
+endif()
 file(TO_CMAKE_PATH "${BOOST_ROOT}" BOOST_ROOT)
 if(WIN32 OR CYGWIN)
   # Workaround for MSVC having two boost versions - x86 and x64 on same PC in stage folders
-  if(DEFINED BOOST_ROOT)
+  if((NOT DEFINED BOOST_LIBRARYDIR) AND (DEFINED BOOST_ROOT))
     if(IS_DIRECTORY ${BOOST_ROOT}/stage64/lib)
       set(BOOST_LIBRARYDIR ${BOOST_ROOT}/stage64/lib)
     elseif(IS_DIRECTORY ${BOOST_ROOT}/stage/lib)
@@ -44,7 +46,7 @@ else()
 endif()
 # TBD:
 # Boost_USE_DEBUG_RUNTIME:  When ON, uses Boost libraries linked against the
-find_package(Boost 1.70 REQUIRED
+find_package(Boost 1.86 REQUIRED
   COMPONENTS
     chrono
     container
@@ -55,6 +57,7 @@ find_package(Boost 1.70 REQUIRED
     program_options
     regex
     system
+    iostreams
     thread)
 
 add_library(ripple_boost INTERFACE)
@@ -74,6 +77,7 @@ target_link_libraries(ripple_boost
     Boost::coroutine
     Boost::date_time
     Boost::filesystem
+    Boost::iostreams
     Boost::program_options
     Boost::regex
     Boost::system

Builds/CMake/deps/FindBoost.cmake

@@ -248,6 +248,7 @@ include(FindPackageHandleStandardArgs)
 # Save project's policies
 cmake_policy(PUSH)
 cmake_policy(SET CMP0057 NEW) # if IN_LIST
+#cmake_policy(SET CMP0144 NEW)
 
 #-------------------------------------------------------------------------------
 # Before we go searching, check whether a boost cmake package is available, unless
@@ -969,7 +970,24 @@ function(_Boost_COMPONENT_DEPENDENCIES component _ret)
       set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic)
       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
     endif()
-    if(NOT Boost_VERSION_STRING VERSION_LESS 1.77.0)
+    
+    # Special handling for Boost 1.86.0 and higher
+    if(NOT Boost_VERSION_STRING VERSION_LESS 1.86.0)
+      # Explicitly set these for Boost 1.86
+      set(_Boost_IOSTREAMS_DEPENDENCIES "")  # No dependencies for iostreams in 1.86
+      
+      # Debug output to help diagnose the issue
+      if(Boost_DEBUG)
+        message(STATUS "Using special dependency settings for Boost 1.86.0+")
+        message(STATUS "Component: ${component}, uppercomponent: ${uppercomponent}")
+        message(STATUS "Boost_VERSION_STRING: ${Boost_VERSION_STRING}")
+        message(STATUS "BOOST_ROOT: $ENV{BOOST_ROOT}")
+        message(STATUS "BOOST_LIBRARYDIR: $ENV{BOOST_LIBRARYDIR}")
+      endif()
+    endif()
+    
+    # Only show warning for versions beyond what we've defined
+    if(NOT Boost_VERSION_STRING VERSION_LESS 1.87.0)
       message(WARNING "New Boost version may have incorrect or missing dependencies and imported targets")
     endif()
   endif()
@@ -1879,6 +1897,18 @@ foreach(COMPONENT ${Boost_FIND_COMPONENTS})
     list(INSERT _boost_LIBRARY_SEARCH_DIRS_RELEASE 0 ${Boost_LIBRARY_DIR_DEBUG})
   endif()
 
+  if(NOT Boost_VERSION_STRING VERSION_LESS 1.86.0)
+    if(BOOST_LIBRARYDIR AND EXISTS "${BOOST_LIBRARYDIR}")
+      # Clear existing search paths and use only BOOST_LIBRARYDIR 
+      set(_boost_LIBRARY_SEARCH_DIRS_RELEASE "${BOOST_LIBRARYDIR}" NO_DEFAULT_PATH)
+      set(_boost_LIBRARY_SEARCH_DIRS_DEBUG "${BOOST_LIBRARYDIR}" NO_DEFAULT_PATH)
+        
+      if(Boost_DEBUG)
+        message(STATUS "Boost 1.86: Setting library search dirs to BOOST_LIBRARYDIR: ${BOOST_LIBRARYDIR}")
+      endif()
+    endif()
+  endif()
+
   # Avoid passing backslashes to _Boost_FIND_LIBRARY due to macro re-parsing.
   string(REPLACE "\\" "/" _boost_LIBRARY_SEARCH_DIRS_tmp "${_boost_LIBRARY_SEARCH_DIRS_RELEASE}")
 

Builds/CMake/deps/Rocksdb.cmake

@@ -80,6 +80,7 @@ if (local_rocksdb)
       -DCMAKE_DEBUG_POSTFIX=_d
       $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
       -DBUILD_SHARED_LIBS=OFF
+      -DROCKSDB_BUILD_SHARED=OFF
       -DCMAKE_POSITION_INDEPENDENT_CODE=ON
       -DWITH_JEMALLOC=$<IF:$<BOOL:${jemalloc}>,ON,OFF>
       -DWITH_SNAPPY=ON

Builds/CMake/deps/WasmEdge.cmake

@@ -81,4 +81,4 @@ if(XAR_LIBRARY)
 else()
   message(WARNING "xar library not found... (only important for mac builds)")
 endif()
-add_library (NIH::WasmEdge ALIAS wasmedge)
+add_library (wasmedge::wasmedge ALIAS wasmedge)

Builds/CMake/deps/gRPC.cmake

@@ -74,7 +74,11 @@ else ()
       if (NOT _location)
         message (FATAL_ERROR "using pkg-config for grpc, can't find c-ares")
       endif ()
-      add_library (c-ares::cares ${_static} IMPORTED GLOBAL)
+      if(${_location} MATCHES "\\.a$")
+        add_library(c-ares::cares STATIC IMPORTED GLOBAL)
+      else()
+        add_library(c-ares::cares SHARED IMPORTED GLOBAL)
+      endif()      
       set_target_properties (c-ares::cares PROPERTIES
         IMPORTED_LOCATION ${_location}
         INTERFACE_INCLUDE_DIRECTORIES "${${_prefix}_INCLUDE_DIRS}"
@@ -204,6 +208,7 @@ else ()
       CMAKE_ARGS
         -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
         -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_CXX_STANDARD=17
         $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
         $<$<BOOL:${CMAKE_TOOLCHAIN_FILE}>:-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}>
         $<$<BOOL:${VCPKG_TARGET_TRIPLET}>:-DVCPKG_TARGET_TRIPLET=${VCPKG_TARGET_TRIPLET}>

Builds/CMake/deps/quickjs.cmake

@@ -0,0 +1,52 @@
+# QuickJS source files
+set(QUICKJS_SOURCES
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libutf.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/qsort_r.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/tutf8e.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/vector.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/char-utils.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/buffer-utils.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/utils.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/ringbuffer.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libregexp.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libregexp.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libunicode.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/cutils.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs-libc.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libbf.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs-textcode.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs-internal.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/debug.c
+)
+
+# QuickJS include directories
+set(QUICKJS_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs)
+
+# RHTODO: Fix this to be dynamic
+set(QUICKJS_VERSION "2023-01-01")
+
+# QuickJS compile definitions
+set(QUICKJS_COMPILE_DEFINITIONS
+    _GNU_SOURCE
+    CONFIG_VERSION="${QUICKJS_VERSION}"
+    CONFIG_BIGNUM
+)
+
+# Create static library
+add_library(quickjs STATIC ${QUICKJS_SOURCES})
+target_include_directories(quickjs
+  PUBLIC
+    $<BUILD_INTERFACE:${QUICKJS_INCLUDE_DIRS}>
+    $<INSTALL_INTERFACE:include/quickjs>
+)
+target_compile_definitions(quickjs PUBLIC ${QUICKJS_COMPILE_DEFINITIONS})
+
+add_library(NIH::quickjs ALIAS quickjs)
+target_link_libraries(ripple_libs INTERFACE NIH::quickjs)
+
+install(
+    FILES
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/*.h
+    DESTINATION include/quickjs
+)

Builds/CMake/jshooks/JSHooks.cmake

@@ -0,0 +1,102 @@
+# JSHooks.cmake Generate JS hook headers for tests
+
+# Find Python3
+find_package(Python3 REQUIRED COMPONENTS Interpreter)
+
+# Set paths
+set(JSHOOK_SOURCE_DIR ${CMAKE_SOURCE_DIR}/src/test/app)
+set(JSHOOK_BUILD_DIR ${CMAKE_BINARY_DIR}/jshooks/generated)
+set(JSHOOK_CACHE_DIR ${CMAKE_BINARY_DIR}/jshooks/cache)
+set(JSHOOK_SCRIPT_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+# Create directories
+file(MAKE_DIRECTORY ${JSHOOK_BUILD_DIR})
+file(MAKE_DIRECTORY ${JSHOOK_CACHE_DIR})
+
+# Download and build qjsc if not provided
+if(NOT DEFINED QJSC_BINARY OR QJSC_BINARY STREQUAL "")
+  # Check if qjsc exists locally first
+  set(LOCAL_QJSC_PATH ${JSHOOK_SOURCE_DIR}/qjsc)
+  if(EXISTS ${LOCAL_QJSC_PATH})
+    set(QJSC_BINARY ${LOCAL_QJSC_PATH})
+  else()
+    # Use FetchContent to download and build quickjslite
+    include(FetchContent)
+    
+    FetchContent_Declare(
+      quickjslite
+      GIT_REPOSITORY https://github.com/RichardAH/quickjslite.git
+      GIT_TAG        863bf70645dcf21e960af2f1540f40029d09498e
+    )
+    
+    FetchContent_MakeAvailable(quickjslite)
+    
+    # Build qjsc using make
+    set(QUICKJS_SOURCE_DIR ${quickjslite_SOURCE_DIR})
+    set(QUICKJS_BINARY_DIR ${quickjslite_BINARY_DIR})
+    set(QJSC_BINARY ${QUICKJS_SOURCE_DIR}/qjsc)
+    
+    # Custom target to build qjsc
+    include(ProcessorCount)
+    ProcessorCount(N)
+    if(NOT N EQUAL 0)
+      set(MAKE_JOBS -j${N})
+    else()
+      set(MAKE_JOBS "")
+    endif()
+    
+    add_custom_command(
+      OUTPUT ${QJSC_BINARY}
+      COMMAND ${CMAKE_COMMAND} -E chdir ${QUICKJS_SOURCE_DIR} make ${MAKE_JOBS} qjsc
+      DEPENDS ${QUICKJS_SOURCE_DIR}/Makefile
+      COMMENT "Building qjsc from quickjslite (using ${N} jobs)..."
+      VERBATIM
+    )
+    
+    # Create a target for qjsc dependency
+    add_custom_target(build_qjsc DEPENDS ${QJSC_BINARY})
+  endif()
+endif()
+
+# Set up dependencies for qjsc
+if(TARGET build_qjsc)
+  set(QJSC_DEPENDENCY build_qjsc)
+else()
+  set(QJSC_DEPENDENCY "")
+endif()
+
+# Custom command to generate headers
+add_custom_command(
+  OUTPUT ${JSHOOK_SOURCE_DIR}/SetJSHook_wasm.h ${JSHOOK_BUILD_DIR}/.timestamp
+  COMMAND
+    ${CMAKE_COMMAND} -E env QJSC_BINARY=${QJSC_BINARY} ${Python3_EXECUTABLE}
+    ${JSHOOK_SCRIPT_DIR}/build_test_jshooks.py --source
+    ${JSHOOK_SOURCE_DIR}/SetJSHook_test.cpp --master
+    ${JSHOOK_SOURCE_DIR}/SetJSHook_wasm.h --output-dir ${JSHOOK_BUILD_DIR}
+    --cache-dir ${JSHOOK_CACHE_DIR} --log-level info
+  COMMAND ${CMAKE_COMMAND} -E touch ${JSHOOK_BUILD_DIR}/.timestamp
+  DEPENDS ${JSHOOK_SOURCE_DIR}/SetJSHook_test.cpp
+          ${JSHOOK_SCRIPT_DIR}/build_test_jshooks.py
+          ${QJSC_BINARY}
+  WORKING_DIRECTORY ${JSHOOK_SOURCE_DIR}
+  COMMENT "Generating JS hook headers..."
+  VERBATIM)
+
+# Custom target
+add_custom_target(generate_js_hooks ALL
+                  DEPENDS ${JSHOOK_SOURCE_DIR}/SetJSHook_wasm.h)
+
+# Add qjsc dependency if needed
+if(QJSC_DEPENDENCY)
+  add_dependencies(generate_js_hooks ${QJSC_DEPENDENCY})
+endif()
+
+# Function to add JS hook support to a target
+function(target_add_jshooks TARGET)
+  target_include_directories(${TARGET} PRIVATE ${CMAKE_BINARY_DIR}/jshooks)
+  add_dependencies(${TARGET} generate_js_hooks)
+endfunction()
+
+# Export variables for use by consumers
+set(JSHOOK_GENERATED_DIR ${JSHOOK_BUILD_DIR})
+set(JSHOOK_MASTER_HEADER ${JSHOOK_SOURCE_DIR}/SetJSHook_wasm.h)

Builds/CMake/jshooks/build_test_jshooks.py

@@ -0,0 +1,380 @@
+#!/usr/bin/env python3
+
+import argparse
+import hashlib
+import logging
+import os
+import re
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+
+def get_qjsc_hash(qjsc_path):
+    """Generate a hash of the qjsc binary to include in the cache key."""
+    try:
+        with open(qjsc_path, "rb") as f:
+            return hashlib.sha256(f.read()).hexdigest()[
+                :16
+            ]  # Use first 16 chars of hash for brevity
+    except Exception as e:
+        logging.warning(f"Could not hash qjsc binary: {e}")
+        return "unknown"
+
+
+def find_qjsc_binary():
+    """Find qjsc binary in expected locations."""
+    # Check environment variable first
+    if "QJSC_BINARY" in os.environ:
+        qjsc_path = os.environ["QJSC_BINARY"]
+        if os.path.exists(qjsc_path) and os.access(qjsc_path, os.X_OK):
+            return qjsc_path
+        else:
+            logging.error(f"QJSC_BINARY points to invalid path: {qjsc_path}")
+            sys.exit(1)
+
+    # Check current directory
+    qjsc_path = "./qjsc"
+    if os.path.exists(qjsc_path) and os.access(qjsc_path, os.X_OK):
+        return qjsc_path
+
+    # Not found
+    logging.error(
+        "qjsc not found in current directory.\n"
+        "This requires the custom quickjslite build from:\n"
+        "https://github.com/RichardAH/quickjslite\n"
+        "Build it and place in src/test/app/ or set QJSC_BINARY environment variable"
+    )
+    sys.exit(1)
+
+
+def convert_js_to_carray(js_file, js_content, qjsc_path):
+    """
+    Convert a JavaScript file to a C array using qjsc.
+    Extracts just the hex bytes from the qjsc output.
+    """
+    try:
+        # Run qjsc to compile the JavaScript file to C code
+        result = subprocess.run(
+            [qjsc_path, "-c", "-o", "/dev/stdout", js_file],
+            capture_output=True,
+            check=True,
+        )
+
+        # Check if we have any output
+        if not result.stdout:
+            logging.error(f"Error: qjsc produced no output for {js_file}")
+            sys.exit(1)
+
+        # Convert to text and extract just the hex values
+        output_text = result.stdout.decode("utf-8", errors="replace")
+
+        # Extract hexadecimal values from the array definition
+        # Looking for patterns like 0x43, 0x0c, etc.
+        hex_values = re.findall(r"0x[0-9A-Fa-f]{2}", output_text)
+
+        # Format them as 0xXXU for the C array
+        c_array = ", ".join([f"{hex_val}U" for hex_val in hex_values])
+
+        return c_array
+
+    except subprocess.CalledProcessError as e:
+        logging.error(f"Error executing qjsc: {e}, content: {js_content}")
+        if e.stderr:
+            logging.error(f"stderr: {e.stderr.decode('utf-8', errors='replace')}")
+        sys.exit(1)
+
+
+def extract_hook_description(js_content, start_line=None):
+    """Extract description from // @hook comment at start of JS content."""
+    lines = js_content.split("\n")
+    for line in lines:
+        line = line.strip()
+        if line.startswith("// @hook "):
+            return line[9:]  # Remove '// @hook ' prefix
+        elif line and not line.startswith("//"):
+            break  # Stop at first non-comment line
+    
+    # If no @hook comment found, return line number info
+    if start_line is not None:
+        return f"MISSING @hook (line {start_line})"
+    return None
+
+
+def generate_content_hash(content):
+    """Generate 8-character hash for content."""
+    return hashlib.sha256(content.encode("utf-8")).hexdigest()[:8]
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate JS hook headers with individual .inc files"
+    )
+    parser.add_argument(
+        "--source",
+        default="SetJSHook_test.cpp",
+        help="Source file containing JS hooks",
+    )
+    parser.add_argument(
+        "--master",
+        default="SetJSHook_wasm.h",
+        help="Master header file to generate",
+    )
+    parser.add_argument(
+        "--output-dir",
+        required=True,
+        help="Directory for generated .inc files",
+    )
+    parser.add_argument(
+        "--cache-dir",
+        help="Directory for compilation cache (optional)",
+    )
+    parser.add_argument(
+        "--xahaud-root",
+        help="Xahaud root directory (if not specified, will try to auto-detect)",
+    )
+    parser.add_argument(
+        "--log-level",
+        default="error",
+        choices=["debug", "info", "warning", "error", "critical"],
+        help="Set logging level (default: error)",
+    )
+
+    args = parser.parse_args()
+
+    # Configure logging
+    numeric_level = getattr(logging, args.log_level.upper(), None)
+    logging.basicConfig(
+        level=numeric_level, format="[jshooks] %(levelname)s: %(message)s"
+    )
+
+    # Set working directory if xahaud_root is provided
+    if args.xahaud_root:
+        working_dir = os.path.join(args.xahaud_root, "src/test/app")
+        if os.path.exists(working_dir):
+            os.chdir(working_dir)
+            logging.info(f"Changed working directory to: {working_dir}")
+        else:
+            logging.error(f"Working directory does not exist: {working_dir}")
+            sys.exit(1)
+
+    # Find qjsc binary
+    qjsc_path = find_qjsc_binary()
+    logging.info(f"Using qjsc: {qjsc_path}")
+
+    # Create output directories
+    Path(args.output_dir).mkdir(parents=True, exist_ok=True)
+    if args.cache_dir:
+        Path(args.cache_dir).mkdir(parents=True, exist_ok=True)
+
+    # Get hash of qjsc binary for cache key
+    qjsc_hash = get_qjsc_hash(qjsc_path)
+
+    # Make paths relative for logging
+    relative_source = f"src/test/app/{os.path.basename(args.source)}"
+    relative_master = f"src/test/app/{os.path.basename(args.master)}"
+    logging.info(f"Processing {relative_source} to generate {relative_master}...")
+
+    # Check if input file exists
+    if not os.path.exists(args.source):
+        logging.error(f"Error: Input file '{args.source}' not found.")
+        sys.exit(1)
+
+    # Read input file content
+    with open(args.source, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    content_with_form_feeds = content.replace("\n", "\f")
+
+    # Get hooks using regex that matches the original bash script's grep command
+    pattern = r'R"\[test\.hook\](.*?)\[test\.hook\]"'
+    hook_matches = list(re.finditer(pattern, content_with_form_feeds, re.DOTALL))
+
+    if not hook_matches:
+        logging.warning("Warning: No test hooks found in the input file.")
+        # Create empty master header
+        with open(args.master, "w") as f:
+            f.write(
+                f"""// Generated by build_test_jshooks.py - DO COMMIT THIS FILE
+// Last updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+// 
+// This file provides a registry of all JS test hooks.
+// Individual compiled hooks are in build/jshooks/generated/
+
+#ifndef SETHOOK_JSWASM_INCLUDED
+#define SETHOOK_JSWASM_INCLUDED
+
+#include <map>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+namespace ripple {{
+namespace test {{
+
+// Map of all JS test hooks - populated at compile time
+std::map<std::string, std::vector<uint8_t>> jswasm = {{
+    // No hooks found
+}};
+
+}} // namespace test
+}} // namespace ripple
+
+#endif
+"""
+            )
+        sys.exit(0)
+
+    # Process the matches and calculate line numbers
+    processed_matches = []
+    hook_line_ranges = []
+
+    for match in hook_matches:
+        # Calculate start and end line numbers
+        start_line = content_with_form_feeds[: match.start()].count("\f") + 1
+        end_line = content_with_form_feeds[: match.end()].count("\f") + 1
+        hook_line_ranges.append((start_line, end_line))
+
+        # Extract the content and process it
+        raw_content = match.group(1)
+        # Remove the opening tag
+        processed = re.sub(r"^\(", "", raw_content)
+        # Remove the closing tag and any trailing whitespace/form feeds
+        processed = re.sub(r"\)[\f \t]*$", "/*end*/", processed)
+        processed_matches.append(processed)
+
+    # Generate individual .inc files and collect include statements
+    include_statements = []
+
+    counter = 0
+    for hook_content in processed_matches:
+        logging.debug(f"Processing hook {counter}...")
+
+        # Clean content and convert back to newlines
+        clean_content = (
+            hook_content[:-7] if hook_content.endswith("/*end*/") else hook_content
+        )
+        clean_content = clean_content.replace("\f", "\n")
+
+        # Check if this is a WebAssembly module
+        wat_count = len(re.findall(r"\(module", hook_content))
+        if wat_count > 0:
+            logging.error(f"Error: WebAssembly text format detected in hook {counter}")
+            sys.exit(1)
+
+        # Generate hash for this hook
+        content_hash = generate_content_hash(clean_content)
+        inc_filename = f"test.hook.{content_hash}.inc"
+        inc_path = os.path.join(args.output_dir, inc_filename)
+
+        # Extract description
+        start_line, end_line = hook_line_ranges[counter]
+        description = extract_hook_description(clean_content, start_line)
+        comment = f"  // {description}" if description else ""
+
+        # Add to include statements
+        include_statements.append(f'    #include "generated/{inc_filename}"{comment}')
+
+        # Check cache
+        cache_file = None
+        if args.cache_dir:
+            cache_content_hash = hashlib.sha256(
+                f"{qjsc_hash}:{clean_content}".encode("utf-8")
+            ).hexdigest()
+            cache_file = os.path.join(
+                args.cache_dir, f"hook-{cache_content_hash}.c_array"
+            )
+
+        # Get or generate C array
+        if args.cache_dir and cache_file and os.path.exists(cache_file):
+            logging.debug(f"Using cached version for hook {counter}")
+            with open(cache_file, "r") as cache:
+                c_array = cache.read()
+        else:
+            logging.debug(f"Compiling hook {counter}...")
+            # Generate JS file
+            js_content = clean_content + "\n"
+            js_file = os.path.join(args.output_dir, f"temp-{counter}-gen.js")
+            with open(js_file, "w", encoding="utf-8") as f:
+                f.write(js_content)
+
+            try:
+                c_array = convert_js_to_carray(js_file, js_content, qjsc_path)
+
+                # Cache the result
+                if args.cache_dir and cache_file:
+                    with open(cache_file, "w") as cache:
+                        cache.write(c_array)
+
+                # Clean up temp file
+                os.remove(js_file)
+            except Exception as e:
+                logging.error(f"Compilation error for hook {counter}: {e}")
+                sys.exit(1)
+
+        # Generate .inc file with actual line range
+        start_line, end_line = hook_line_ranges[counter]
+        # Make source path relative to repo root
+        relative_source = f"src/test/app/{os.path.basename(args.source)}"
+        with open(inc_path, "w") as f:
+            f.write(
+                f"""// Auto-generated - DO NOT EDIT
+// Source: {relative_source}:{start_line} ({start_line}:{end_line})
+// Hash: {content_hash}
+
+{{R"[test.hook]({clean_content})[test.hook]", {{
+{c_array}
+}}}},
+"""
+            )
+
+        counter += 1
+
+    # Generate master header
+    with open(args.master, "w") as f:
+        f.write(
+            f"""// Generated by build_test_jshooks.py - DO COMMIT THIS FILE
+// Last updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+// 
+// This file provides a registry of all JS test hooks.
+// Individual compiled hooks are in build/jshooks/generated/
+
+#ifndef SETHOOK_JSWASM_INCLUDED
+#define SETHOOK_JSWASM_INCLUDED
+
+#include <map>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+namespace ripple {{
+namespace test {{
+
+// Map of all JS test hooks - populated at compile time
+std::map<std::string, std::vector<uint8_t>> jswasm = {{
+{chr(10).join(include_statements)}
+}};
+
+}} // namespace test
+}} // namespace ripple
+
+#endif
+"""
+        )
+
+    # Format the output file using clang-format
+    logging.info("Formatting master header...")
+    try:
+        subprocess.run(["clang-format", "-i", args.master], check=True)
+        logging.info(f"Successfully generated {relative_master} with {counter} hooks")
+    except subprocess.CalledProcessError:
+        logging.warning(
+            "Warning: clang-format failed, output might not be properly formatted"
+        )
+    except FileNotFoundError:
+        logging.warning("Warning: clang-format not found, output will not be formatted")
+
+
+if __name__ == "__main__":
+    main()

Builds/levelization/results/loops.txt

@@ -52,6 +52,9 @@ Loop: ripple.overlay ripple.rpc
 Loop: test.app test.jtx
   test.app > test.jtx
 
+Loop: test.app test.rpc
+  test.rpc ~= test.app
+
 Loop: test.jtx test.toplevel
   test.toplevel > test.jtx
 

Builds/levelization/results/ordering.txt

@@ -90,7 +90,6 @@ test.app > ripple.overlay
 test.app > ripple.protocol
 test.app > ripple.resource
 test.app > ripple.rpc
-test.app > test.rpc
 test.app > test.toplevel
 test.app > test.unit_test
 test.basics > ripple.basics

CMakeLists.txt

@@ -1,14 +1,24 @@
 cmake_minimum_required (VERSION 3.16)
-
-if (POLICY CMP0074)
-  cmake_policy(SET CMP0074 NEW)
-endif ()
-
-project (rippled)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
+if(POLICY CMP0074)
+  cmake_policy(SET CMP0074 NEW)
+endif()
+if(POLICY CMP0077)
+  cmake_policy(SET CMP0077 NEW)
+endif()
+
+# Fix "unrecognized escape" issues when passing CMAKE_MODULE_PATH on Windows.
+file(TO_CMAKE_PATH "${CMAKE_MODULE_PATH}" CMAKE_MODULE_PATH)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake")
+
+if(POLICY CMP0144)
+  cmake_policy(SET CMP0144 NEW)
+endif()
+
+project (rippled)
 set(Boost_NO_BOOST_CMAKE ON)
 
 # make GIT_COMMIT_HASH define available to all sources
@@ -23,14 +33,27 @@ if(Git_FOUND)
     endif()
 endif() #git
 
-if (thread_safety_analysis)
+if(thread_safety_analysis)
   add_compile_options(-Wthread-safety -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS -DRIPPLE_ENABLE_THREAD_SAFETY_ANNOTATIONS)
   add_compile_options("-stdlib=libc++")
   add_link_options("-stdlib=libc++")
 endif()
 
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake")
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/deps")
+option(USE_CONAN "Use Conan package manager for dependencies" OFF)
+# Then, auto-detect if conan_toolchain.cmake is being used
+if(CMAKE_TOOLCHAIN_FILE)
+  # Check if the toolchain file path contains "conan_toolchain"
+  if(CMAKE_TOOLCHAIN_FILE MATCHES "conan_toolchain")
+    set(USE_CONAN ON CACHE BOOL "Using Conan detected from toolchain file" FORCE)
+    message(STATUS "Conan toolchain detected: ${CMAKE_TOOLCHAIN_FILE}")
+    message(STATUS "Building with Conan dependencies")
+  endif()
+endif()
+
+if (NOT USE_CONAN)
+  list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake")
+  list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/deps")
+endif()
 
 include (CheckCXXCompilerFlag)
 include (FetchContent)
@@ -44,7 +67,9 @@ endif ()
 include(RippledSanity)
 include(RippledVersion)
 include(RippledSettings)
-include(RippledNIH)
+if (NOT USE_CONAN)
+  include(RippledNIH)
+endif()
 # this check has to remain in the top-level cmake
 # because of the early return statement
 if (packages_only)
@@ -57,24 +82,87 @@ include(RippledCompiler)
 include(RippledInterface)
 
 ###
+if (NOT USE_CONAN)
+  add_subdirectory(src/secp256k1)
+  add_subdirectory(src/ed25519-donna)
+  include(deps/Boost)
+  include(deps/OpenSSL)
+  # include(deps/Secp256k1)
+  # include(deps/Ed25519-donna)
+  include(deps/Lz4)
+  include(deps/Libarchive)
+  include(deps/Sqlite)
+  include(deps/Soci)
+  include(deps/Snappy)
+  include(deps/Rocksdb)
+  include(deps/Nudb)
+  include(deps/date)
+  include(deps/Protobuf)
+  include(deps/gRPC)
+  include(deps/cassandra)
+  include(deps/Postgres)
+  include(deps/WasmEdge)
+else()
+  include(conan/Boost)
+  find_package(OpenSSL 1.1.1 REQUIRED)
+  set_target_properties(OpenSSL::SSL PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2
+  )
+  add_subdirectory(src/secp256k1)
+  add_subdirectory(src/ed25519-donna)
+  find_package(lz4 REQUIRED)
+  # Target names with :: are not allowed in a generator expression.
+  # We need to pull the include directories and imported location properties
+  # from separate targets.
+  find_package(LibArchive REQUIRED)
+  find_package(SOCI REQUIRED)
+  find_package(SQLite3 REQUIRED)
+  find_package(Snappy REQUIRED)
+  find_package(wasmedge REQUIRED)
+  option(rocksdb "Enable RocksDB" ON)
+  if(rocksdb)
+    find_package(RocksDB REQUIRED)
+    set_target_properties(RocksDB::rocksdb PROPERTIES
+      INTERFACE_COMPILE_DEFINITIONS RIPPLE_ROCKSDB_AVAILABLE=1
+    )
+    target_link_libraries(ripple_libs INTERFACE RocksDB::rocksdb)
+  endif()
+  find_package(nudb REQUIRED)
+  find_package(date REQUIRED)
+  include(conan/Protobuf)
+  include(conan/gRPC)
+    if(TARGET nudb::core)
+    set(nudb nudb::core)
+  elseif(TARGET NuDB::nudb)
+    set(nudb NuDB::nudb)
+  else()
+    message(FATAL_ERROR "unknown nudb target")
+  endif()
+  target_link_libraries(ripple_libs INTERFACE ${nudb})
 
-include(deps/Boost)
-include(deps/OpenSSL)
-include(deps/Secp256k1)
-include(deps/Ed25519-donna)
-include(deps/Lz4)
-include(deps/Libarchive)
-include(deps/Sqlite)
-include(deps/Soci)
-include(deps/Snappy)
-include(deps/Rocksdb)
-include(deps/Nudb)
-include(deps/date)
-include(deps/Protobuf)
-include(deps/gRPC)
-include(deps/cassandra)
-include(deps/Postgres)
-include(deps/WasmEdge)
+  if(reporting)
+    find_package(cassandra-cpp-driver REQUIRED)
+    find_package(PostgreSQL REQUIRED)
+    target_link_libraries(ripple_libs INTERFACE
+      cassandra-cpp-driver::cassandra-cpp-driver
+      PostgreSQL::PostgreSQL
+    )
+  endif()
+  target_link_libraries(ripple_libs INTERFACE
+    ed25519::ed25519
+    LibArchive::LibArchive
+    lz4::lz4
+    OpenSSL::Crypto
+    OpenSSL::SSL
+    Ripple::grpc_pbufs
+    Ripple::pbufs
+    secp256k1::secp256k1
+    soci::soci
+    SQLite::SQLite3
+  )
+endif()
+
+include(deps/quickjs)
 
 ###
 

README.md

@@ -1,4 +1,4 @@
-# Xahau
+# Xahau 
 
 **Note:** Throughout this README, references to "we" or "our" pertain to the community and contributors involved in the Xahau network. It does not imply a legal entity or a specific collection of individuals.
 
@@ -67,5 +67,5 @@ git-subtree. See those directories' README files for more details.
   - [explorer.xahau.network](https://explorer.xahau.network)
 - **Testnet & Faucet**: Test applications and obtain test XAH at [xahau-test.net](https://xahau-test.net) and use the testnet explorer at [explorer.xahau.network](https://explorer.xahau.network).
 - **Supporting Wallets**: A list of wallets that support XAH and Xahau-based assets.
-  - [Xumm](https://xumm.app)
-  - [Crossmark](https://crossmark.io)
+  - [Xaman](https://xaman.app)
+  - [Crossmark](https://crossmark.io)

RELEASENOTES.md

@@ -8,6 +8,130 @@ This document contains the release notes for `rippled`, the reference server imp
 Have new ideas? Need help with setting up your node? [Please open an issue here](https://github.com/xrplf/rippled/issues/new/choose).
 
 
+# Introducing XRP Ledger version 1.11.0
+
+Version 1.11.0 of `rippled`, the reference server implementation of the XRP Ledger protocol, is now available.
+
+This release reduces memory usage, introduces the `fixNFTokenRemint` amendment, and adds new features and bug fixes. For example, the new NetworkID field in transactions helps to prevent replay attacks with side-chains.
+
+[Sign Up for Future Release Announcements](https://groups.google.com/g/ripple-server)
+
+<!-- BREAK -->
+
+## Action Required
+
+The `fixNFTokenRemint` amendment is now open for voting according to the XRP Ledger's [amendment process](https://xrpl.org/amendments.html), which enables protocol changes following two weeks of >80% support from trusted validators.
+
+If you operate an XRP Ledger server, upgrade to version 1.11.0 by July 5 to ensure service continuity. The exact time that protocol changes take effect depends on the voting decisions of the decentralized network.
+
+
+## Install / Upgrade
+
+On supported platforms, see the [instructions on installing or updating `rippled`](https://xrpl.org/install-rippled.html).
+
+
+## What's Changed
+
+### New Features and Improvements
+
+* Allow port numbers be be specified using a either a colon or a space by @RichardAH in https://github.com/XRPLF/rippled/pull/4328
+* Eliminate memory allocation from critical path: by @nbougalis in https://github.com/XRPLF/rippled/pull/4353
+* Make it easy for projects to depend on libxrpl by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4449
+* Add the ability to mark amendments as obsolete by @ximinez in https://github.com/XRPLF/rippled/pull/4291
+* Always create the FeeSettings object in genesis ledger by @ximinez in https://github.com/XRPLF/rippled/pull/4319
+* Log exception messages in several locations by @drlongle in https://github.com/XRPLF/rippled/pull/4400
+* Parse flags in account_info method by @drlongle in https://github.com/XRPLF/rippled/pull/4459
+* Add NFTokenPages to account_objects RPC by @RichardAH in https://github.com/XRPLF/rippled/pull/4352
+* add jss fields used by clio `nft_info` by @ledhed2222 in https://github.com/XRPLF/rippled/pull/4320
+* Introduce a slab-based memory allocator and optimize SHAMapItem by @nbougalis in https://github.com/XRPLF/rippled/pull/4218
+* Add NetworkID field to transactions to help prevent replay attacks on and from side-chains by @RichardAH in https://github.com/XRPLF/rippled/pull/4370
+* If present, set quorum based on command line. by @mtrippled in https://github.com/XRPLF/rippled/pull/4489
+* API does not accept seed or public key for account by @drlongle in https://github.com/XRPLF/rippled/pull/4404
+* Add `nftoken_id`, `nftoken_ids` and `offer_id` meta fields into NFT `Tx` responses by @shawnxie999 in https://github.com/XRPLF/rippled/pull/4447
+
+### Bug Fixes
+
+* fix(gateway_balances): handle overflow exception by @RichardAH in https://github.com/XRPLF/rippled/pull/4355
+* fix(ValidatorSite): handle rare null pointer dereference in timeout by @ximinez in https://github.com/XRPLF/rippled/pull/4420
+* RPC commands understand markers derived from all ledger object types by @ximinez in https://github.com/XRPLF/rippled/pull/4361
+* `fixNFTokenRemint`: prevent NFT re-mint: by @shawnxie999 in https://github.com/XRPLF/rippled/pull/4406
+* Fix a case where ripple::Expected returned a json array, not a value by @scottschurr in https://github.com/XRPLF/rippled/pull/4401
+* fix: Ledger data returns an empty list (instead of null) when all entries are filtered out by @drlongle in https://github.com/XRPLF/rippled/pull/4398
+* Fix unit test ripple.app.LedgerData by @drlongle in https://github.com/XRPLF/rippled/pull/4484
+* Fix the fix for std::result_of by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4496
+* Fix errors for Clang 16 by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4501
+* Ensure that switchover vars are initialized before use: by @seelabs in https://github.com/XRPLF/rippled/pull/4527
+* Move faulty assert by @ximinez in https://github.com/XRPLF/rippled/pull/4533
+* Fix unaligned load and stores: (#4528) by @seelabs in https://github.com/XRPLF/rippled/pull/4531
+* fix node size estimation by @dangell7 in https://github.com/XRPLF/rippled/pull/4536
+* fix: remove redundant moves by @ckeshava in https://github.com/XRPLF/rippled/pull/4565
+
+### Code Cleanup and Testing
+
+* Replace compare() with the three-way comparison operator in base_uint, Issue and Book by @drlongle in https://github.com/XRPLF/rippled/pull/4411
+* Rectify the import paths of boost::function_output_iterator by @ckeshava in https://github.com/XRPLF/rippled/pull/4293
+* Expand Linux test matrix by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4454
+* Add patched recipe for SOCI by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4510
+* Switch to self-hosted runners for macOS by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4511
+* [TRIVIAL] Add missing includes by @seelabs in https://github.com/XRPLF/rippled/pull/4555
+
+### Docs
+
+* Refactor build instructions by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4381
+* Add install instructions for package managers by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4472
+* Fix typo by @solmsted in https://github.com/XRPLF/rippled/pull/4508
+* Update environment.md by @sappenin in https://github.com/XRPLF/rippled/pull/4498
+* Update BUILD.md by @oeggert in https://github.com/XRPLF/rippled/pull/4514
+* Trivial: add comments for NFToken-related invariants by @scottschurr in https://github.com/XRPLF/rippled/pull/4558
+
+## New Contributors
+* @drlongle made their first contribution in https://github.com/XRPLF/rippled/pull/4411
+* @ckeshava made their first contribution in https://github.com/XRPLF/rippled/pull/4293
+* @solmsted made their first contribution in https://github.com/XRPLF/rippled/pull/4508
+* @sappenin made their first contribution in https://github.com/XRPLF/rippled/pull/4498
+* @oeggert made their first contribution in https://github.com/XRPLF/rippled/pull/4514
+
+**Full Changelog**: https://github.com/XRPLF/rippled/compare/1.10.1...1.11.0
+
+
+### GitHub
+
+The public source code repository for `rippled` is hosted on GitHub at <https://github.com/XRPLF/rippled>.
+
+We welcome all contributions and invite everyone to join the community of XRP Ledger developers to help build the Internet of Value.
+
+### Credits
+
+The following people contributed directly to this release:
+- Alloy Networks <45832257+alloynetworks@users.noreply.github.com>
+- Brandon Wilson <brandon@coil.com>
+- Chenna Keshava B S <21219765+ckeshava@users.noreply.github.com>
+- David Fuelling <sappenin@gmail.com>
+- Denis Angell <dangell@transia.co>
+- Ed Hennis <ed@ripple.com>
+- Elliot Lee <github.public@intelliot.com>
+- John Freeman <jfreeman08@gmail.com>
+- Mark Travis <mtrippled@users.noreply.github.com>
+- Nik Bougalis <nikb@bougalis.net>
+- RichardAH <richard.holland@starstone.co.nz>
+- Scott Determan <scott.determan@yahoo.com>
+- Scott Schurr <scott@ripple.com>
+- Shawn Xie <35279399+shawnxie999@users.noreply.github.com>
+- drlongle <drlongle@gmail.com>
+- ledhed2222 <ledhed2222@users.noreply.github.com>
+- oeggert <117319296+oeggert@users.noreply.github.com>
+- solmsted <steven.olm@gmail.com>
+
+
+Bug Bounties and Responsible Disclosures:
+We welcome reviews of the rippled code and urge researchers to
+responsibly disclose any issues they may find.
+
+To report a bug, please send a detailed report to:
+
+    bugs@xrpl.org
+
+
 # Introducing XRP Ledger version 1.10.1
 
 Version 1.10.1 of `rippled`, the reference server implementation of the XRP Ledger protocol, is now available. This release restores packages for Ubuntu 18.04.

SECURITY.md

@@ -61,13 +61,12 @@ For these complaints or reports, please [contact our support team](mailto:bugs@x
 
 ### The following type of security problems are excluded
 
-- (D)DOS attacks
-- Error messages or error pages without sensitive data
-- Tests & sample data as publicly available in our repositories at Github
-- Common issues like browser header warnings or DNS configuration, identified by vulnerability scans
-- Vulnerability scan reports for software we publicly use
-- Security issues related to outdated OS's, browsers or plugins
-- Reports for security problems that we have been notified of before
+1. **In scope**. Only bugs in software under the scope of the program qualify. Currently, that means `xahaud` and `xahau-lib`.
+2. **Relevant**. A security issue, posing a danger to user funds, privacy or the operation of the Xahau Ledger.
+3. **Original and previously unknown**. Bugs that are already known and discussed in public do not qualify. Previously reported bugs, even if publicly unknown, are not eligible.
+4. **Specific**. We welcome general security advice or recommendations, but we cannot pay bounties for that.
+5. **Fixable**. There has to be something we can do to permanently fix the problem. Note that bugs in other people’s software may still qualify in some cases. For example, if you find a bug in a library that we use which can compromise the security of software that is in scope and we can get it fixed, you may qualify for a bounty.
+6. **Unused**. If you use the exploit to attack the Xahau Ledger, you do not qualify for a bounty. If you report a vulnerability used in an ongoing or past attack and there is specific, concrete evidence that suggests you are the attacker we reserve the right not to pay a bounty.
 
 Please note: Reports that are lacking any proof (such as screenshots or other data), detailed information or details on how to reproduce any unexpected result will be investigated but will not be eligible for any reward.
 

build-core.sh

@@ -1,4 +1,11 @@
-#!/bin/bash
+#!/bin/bash -u
+# We use set -e and bash with -u to bail on first non zero exit code of any
+# processes launched or upon any unbound variable.
+# We use set -x to print commands before running them to help with
+# debugging.
+set -ex
+
+set -e
 
 echo "START INSIDE CONTAINER - CORE"
 
@@ -23,12 +30,12 @@ fi
 perl -i -pe "s/^(\\s*)-DBUILD_SHARED_LIBS=OFF/\\1-DBUILD_SHARED_LIBS=OFF\\n\\1-DROCKSDB_BUILD_SHARED=OFF/g" Builds/CMake/deps/Rocksdb.cmake &&
 mv Builds/CMake/deps/WasmEdge.cmake Builds/CMake/deps/WasmEdge.old &&
 echo "find_package(LLVM REQUIRED CONFIG)
-message(STATUS \"Found LLVM ${LLVM_PACKAGE_VERSION}\")
+message(STATUS \"Found LLVM \${LLVM_PACKAGE_VERSION}\")
 message(STATUS \"Using LLVMConfig.cmake in: \${LLVM_DIR}\")
 add_library (wasmedge STATIC IMPORTED GLOBAL)
 set_target_properties(wasmedge PROPERTIES IMPORTED_LOCATION \${WasmEdge_LIB})
 target_link_libraries (ripple_libs INTERFACE wasmedge)
-add_library (NIH::WasmEdge ALIAS wasmedge)
+add_library (wasmedge::wasmedge ALIAS wasmedge)
 message(\"WasmEdge DONE\")
 " > Builds/CMake/deps/WasmEdge.cmake &&
 git checkout src/ripple/protocol/impl/BuildInfo.cpp &&

build-full.sh

@@ -1,4 +1,11 @@
-#!/bin/bash
+#!/bin/bash -u
+# We use set -e and bash with -u to bail on first non zero exit code of any
+# processes launched or upon any unbound variable.
+# We use set -x to print commands before running them to help with
+# debugging.
+set -ex
+
+set -e
 
 echo "START INSIDE CONTAINER - FULL"
 
@@ -9,8 +16,17 @@ echo "-- GITHUB_RUN_NUMBER: $4"
 
 umask 0000;
 
+echo "Fixing CentOS 7 EOL"
+
+sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
+sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
+yum clean all
+yum-config-manager --disable centos-sclo-sclo
+
+####
+
 cd /io;
-mkdir src/certs;
+mkdir -p src/certs;
 curl --silent -k https://raw.githubusercontent.com/RichardAH/rippled-release-builder/main/ca-bundle/certbundle.h -o src/certs/certbundle.h;
 if [ "`grep certbundle.h src/ripple/net/impl/RegisterSSLCerts.cpp | wc -l`" -eq "0" ]
 then
@@ -57,8 +73,8 @@ then
     #endif/g" src/ripple/net/impl/RegisterSSLCerts.cpp &&
     sed -i "s/#include <ripple\/net\/RegisterSSLCerts.h>/\0\n#include <certs\/certbundle.h>/g" src/ripple/net/impl/RegisterSSLCerts.cpp
 fi
-mkdir .nih_c;
-mkdir .nih_toolchain;
+mkdir -p .nih_c;
+mkdir -p .nih_toolchain;
 cd .nih_toolchain &&
 yum install -y wget lz4 lz4-devel git llvm13-static.x86_64 llvm13-devel.x86_64 devtoolset-10-binutils zlib-static ncurses-static -y \
   devtoolset-7-gcc-c++ \
@@ -81,11 +97,11 @@ echo "-- Install Cmake 3.23.1 --" &&
 pwd &&
 ( wget -nc -q https://github.com/Kitware/CMake/releases/download/v3.23.1/cmake-3.23.1-linux-x86_64.tar.gz; echo "" ) &&
 tar -xzf cmake-3.23.1-linux-x86_64.tar.gz -C /hbb/ &&
-echo "-- Install Boost 1.75.0 --" &&
+echo "-- Install Boost 1.86.0 --" &&
 pwd &&
-( wget -nc -q https://boostorg.jfrog.io/artifactory/main/release/1.75.0/source/boost_1_75_0.tar.gz; echo "" ) &&
-tar -xzf boost_1_75_0.tar.gz &&
-cd boost_1_75_0 && ./bootstrap.sh && ./b2  link=static -j$3 && ./b2 install &&
+( wget -nc -q https://archives.boost.io/release/1.86.0/source/boost_1_86_0.tar.gz; echo "" ) &&
+tar -xzf boost_1_86_0.tar.gz &&
+cd boost_1_86_0 && ./bootstrap.sh && ./b2  link=static -j$3 && ./b2 install &&
 cd ../ &&
 echo "-- Install Protobuf 3.20.0 --" &&
 pwd &&
@@ -106,7 +122,7 @@ tar -xf libunwind-13.0.1.src.tar.xz &&
 cp -r libunwind-13.0.1.src/include libunwind-13.0.1.src/src lld-13.0.1.src/ &&
 cd lld-13.0.1.src &&
 rm -rf build CMakeCache.txt &&
-mkdir build &&
+mkdir -p build &&
 cd build &&
 cmake .. -DLLVM_LIBRARY_DIR=/usr/lib64/llvm13/lib/ -DCMAKE_INSTALL_PREFIX=/usr/lib64/llvm13/ -DCMAKE_BUILD_TYPE=Release &&
 make -j$3 install &&
@@ -116,11 +132,11 @@ cd ../../ &&
 echo "-- Build WasmEdge --" &&
 ( wget -nc -q https://github.com/WasmEdge/WasmEdge/archive/refs/tags/0.11.2.zip; unzip -o 0.11.2.zip; ) &&
 cd WasmEdge-0.11.2 &&
-( mkdir build; echo "" ) &&
+( mkdir -p build; echo "" ) &&
 cd build &&
-export BOOST_ROOT="/usr/local/src/boost_1_75_0" &&
+export BOOST_ROOT="/usr/local/src/boost_1_86_0" &&
 export Boost_LIBRARY_DIRS="/usr/local/lib" &&
-export BOOST_INCLUDEDIR="/usr/local/src/boost_1_75_0" &&
+export BOOST_INCLUDEDIR="/usr/local/src/boost_1_86_0" &&
 export PATH=`echo $PATH | sed -E "s/devtoolset-7/devtoolset-9/g"` &&
 cmake .. \
     -DCMAKE_BUILD_TYPE=Release \

cfg/genesis.json

@@ -62,7 +62,8 @@
           "3C43D9A973AA4443EF3FC38E42DD306160FBFFDAB901CD8BAA15D09F2597EB87",
           "0285B7E5E08E1A8E4C15636F0591D87F73CB6A7B6452A932AD72BBC8E5D1CBE3",
           "6E739F4F8B07BED29FC9FF440DA3C301CD14A180DF45819F658FEC2F7DE31427",
-          "36799EA497B1369B170805C078AEFE6188345F9B3E324C21E9CA3FF574E3C3D6"
+          "36799EA497B1369B170805C078AEFE6188345F9B3E324C21E9CA3FF574E3C3D6",
+          "DD4F86291F142A20761B32B4D0CE4291F86CA33F0B46F0D04171482FBA52E536"
         ],
         "Flags": 0,
         "LedgerEntryType": "Amendments",

cfg/rippled-example.cfg

@@ -1056,7 +1056,18 @@
 #       Cassandra is an alternative backend to be used only with Reporting Mode.
 #       See the Reporting Mode section for more details about Reporting Mode.
 #
-#   Required keys for NuDB and RocksDB:
+#   type = RWDB
+#
+#       RWDB is a high-performance memory store written by XRPL-Labs and optimized
+#       for xahaud. RWDB is NOT persistent and the data will be lost on restart.
+#       RWDB is recommended for Validator and Peer nodes that are not required to 
+#       store history.
+#
+#       RWDB maintains its high speed regardless of the amount of history
+#       stored. Online delete should NOT be used instead RWDB will use the 
+#       ledger_history config value to determine how many ledgers to keep in memory.
+#
+#   Required keys for NuDB, RWDB and RocksDB:
 #
 #       path                Location to store the database
 #
@@ -1112,7 +1123,8 @@
 #       online_delete       Minimum value of 256. Enable automatic purging
 #                           of older ledger information. Maintain at least this
 #                           number of ledger records online. Must be greater
-#                           than or equal to ledger_history.
+#                           than or equal to ledger_history. If using RWDB 
+#                           this value is ignored.
 #
 #       These keys modify the behavior of online_delete, and thus are only
 #       relevant if online_delete is defined and non-zero:

cfg/rippled-standalone.cfg

@@ -1,4 +1,4 @@
-# standalone: ./rippled -a --ledgerfile config/genesis.json --conf config/rippled-standalone.cfg
+# standalone: ./rippled -a --ledgerfile cfg/genesis.json --conf cfg/rippled-standalone.cfg
 [server]
 port_rpc_admin_local
 port_ws_public
@@ -144,4 +144,13 @@ D686F2538F410C9D0D856788E98E3579595DAF7B38D38887F81ECAC934B06040 HooksUpdate1
 86E83A7D2ECE3AD5FA87AB2195AE015C950469ABF0B72EAACED318F74886AE90 CryptoConditionsSuite
 3C43D9A973AA4443EF3FC38E42DD306160FBFFDAB901CD8BAA15D09F2597EB87 NonFungibleTokensV1
 0285B7E5E08E1A8E4C15636F0591D87F73CB6A7B6452A932AD72BBC8E5D1CBE3 fixNFTokenDirV1
-36799EA497B1369B170805C078AEFE6188345F9B3E324C21E9CA3FF574E3C3D6 fixNFTokenNegOffer
+36799EA497B1369B170805C078AEFE6188345F9B3E324C21E9CA3FF574E3C3D6 fixNFTokenNegOffer
+4C499D17719BB365B69010A436B64FD1A82AAB199FC1CEB06962EBD01059FB09 fixXahauV1
+215181D23BF5C173314B5FDB9C872C92DE6CC918483727DE037C0C13E7E6EE9D fixXahauV2
+0D8BF22FF7570D58598D1EF19EBB6E142AD46E59A223FD3816262FBB69345BEA Remit
+7CA0426E7F411D39BB014E57CD9E08F61DE1750F0D41FCD428D9FB80BB7596B0 ZeroB2M
+4B8466415FAB32FFA89D9DCBE166A42340115771DF611A7160F8D7439C87ECD8 fixNSDelete
+EDB4EE4C524E16BDD91D9A529332DED08DCAAA51CC6DC897ACFA1A0ED131C5B6 fix240819
+8063140E9260799D6716756B891CEC3E7006C4E4F277AB84670663A88F94B9C4 fixPageCap
+88693F108C3CD8A967F3F4253A32DEF5E35F9406ACD2A11B88B11D90865763A9 fix240911
+DD4F86291F142A20761B32B4D0CE4291F86CA33F0B46F0D04171482FBA52E536 JsHooks

conanfile.py

@@ -0,0 +1,155 @@
+from conan import ConanFile
+from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
+import re
+
+class Xrpl(ConanFile):
+    name = 'xrpl'
+
+    license = 'ISC'
+    author = 'John Freeman <jfreeman@ripple.com>'
+    url = 'https://github.com/xrplf/rippled'
+    description = 'The XRP Ledger'
+    settings = 'os', 'compiler', 'build_type', 'arch'
+    options = {
+        'assertions': [True, False],
+        'coverage': [True, False],
+        'fPIC': [True, False],
+        'jemalloc': [True, False],
+        'reporting': [True, False],
+        'rocksdb': [True, False],
+        'shared': [True, False],
+        'static': [True, False],
+        'tests': [True, False],
+        'unity': [True, False],
+    }
+
+    requires = [
+        'boost/1.86.0',
+        'date/3.0.1',
+        'libarchive/3.6.0',
+        'lz4/1.9.3',
+        'grpc/1.50.1',
+        'nudb/2.0.8',
+        'openssl/1.1.1u',
+        'protobuf/3.21.9',
+        'snappy/1.1.10',
+        'soci/4.0.3',
+        'sqlite3/3.42.0',
+        'zlib/1.2.13',
+        'wasmedge/0.11.2',
+    ]
+
+    default_options = {
+        'assertions': False,
+        'coverage': False,
+        'fPIC': True,
+        'jemalloc': False,
+        'reporting': False,
+        'rocksdb': True,
+        'shared': False,
+        'static': True,
+        'tests': True,
+        'unity': False,
+
+        'cassandra-cpp-driver:shared': False,
+        'date:header_only': True,
+        'grpc:shared': False,
+        'grpc:secure': True,
+        'libarchive:shared': False,
+        'libarchive:with_acl': False,
+        'libarchive:with_bzip2': False,
+        'libarchive:with_cng': False,
+        'libarchive:with_expat': False,
+        'libarchive:with_iconv': False,
+        'libarchive:with_libxml2': False,
+        'libarchive:with_lz4': True,
+        'libarchive:with_lzma': False,
+        'libarchive:with_lzo': False,
+        'libarchive:with_nettle': False,
+        'libarchive:with_openssl': False,
+        'libarchive:with_pcreposix': False,
+        'libarchive:with_xattr': False,
+        'libarchive:with_zlib': False,
+        'libpq:shared': False,
+        'lz4:shared': False,
+        'openssl:shared': False,
+        'protobuf:shared': False,
+        'protobuf:with_zlib': True,
+        'rocksdb:enable_sse': False,
+        'rocksdb:lite': False,
+        'rocksdb:shared': False,
+        'rocksdb:use_rtti': True,
+        'rocksdb:with_jemalloc': False,
+        'rocksdb:with_lz4': True,
+        'rocksdb:with_snappy': True,
+        'snappy:shared': False,
+        'soci:shared': False,
+        'soci:with_sqlite3': True,
+        'soci:with_boost': True,
+    }
+
+    def set_version(self):
+        path = f'{self.recipe_folder}/src/ripple/protocol/impl/BuildInfo.cpp'
+        regex = r'versionString\s?=\s?\"(.*)\"'
+        with open(path, 'r') as file:
+            matches = (re.search(regex, line) for line in file)
+            match = next(m for m in matches if m)
+            self.version = match.group(1)
+
+    def configure(self):
+        if self.settings.compiler == 'apple-clang':
+            self.options['boost'].visibility = 'global'
+
+    def requirements(self):
+        if self.options.jemalloc:
+            self.requires('jemalloc/5.2.1')
+        if self.options.reporting:
+            self.requires('cassandra-cpp-driver/2.15.3')
+            self.requires('libpq/13.6')
+        if self.options.rocksdb:
+            self.requires('rocksdb/6.27.3')
+
+    exports_sources = (
+        'CMakeLists.txt', 'Builds/*', 'bin/getRippledInfo', 'src/*', 'cfg/*'
+    )
+
+    def layout(self):
+        cmake_layout(self)
+        # Fix this setting to follow the default introduced in Conan 1.48
+        # to align with our build instructions.
+        self.folders.generators = 'build/generators'
+
+    generators = 'CMakeDeps'
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables['tests'] = self.options.tests
+        tc.variables['assert'] = self.options.assertions
+        tc.variables['coverage'] = self.options.coverage
+        tc.variables['jemalloc'] = self.options.jemalloc
+        tc.variables['reporting'] = self.options.reporting
+        tc.variables['rocksdb'] = self.options.rocksdb
+        tc.variables['BUILD_SHARED_LIBS'] = self.options.shared
+        tc.variables['static'] = self.options.static
+        tc.variables['unity'] = self.options.unity
+        tc.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.verbose = True
+        cmake.configure()
+        cmake.build()
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.verbose = True
+        cmake.install()
+
+    def package_info(self):
+        libxrpl = self.cpp_info.components['libxrpl']
+        libxrpl.libs = [
+            'libxrpl_core.a',
+            'libed25519.a',
+            'libsecp256k1.a',
+        ]
+        libxrpl.includedirs = ['include']
+        libxrpl.requires = ['boost::boost']

docker-unit-tests.sh

@@ -1,4 +1,11 @@
-#!/bin/bash
+#!/bin/bash -x
 
-docker run --rm -i -v $(pwd):/io ubuntu sh -c '/io/release-build/xahaud -u'
+BUILD_CORES=$(echo "scale=0 ; `nproc` / 1.337" | bc)
 
+if [[ "$GITHUB_REPOSITORY" == "" ]]; then
+  #Default
+  BUILD_CORES=8
+fi
+
+echo "Mounting $(pwd)/io in ubuntu and running unit tests"
+docker run --rm -i -v $(pwd):/io -e BUILD_CORES=$BUILD_CORES ubuntu sh -c '/io/release-build/xahaud --unittest-jobs $BUILD_CORES -u'

docs/build/environment.md

@@ -0,0 +1,84 @@
+Our [build instructions][BUILD.md] assume you have a C++ development
+environment complete with Git, Python, Conan, CMake, and a C++ compiler.
+This document exists to help readers set one up on any of the Big Three
+platforms: Linux, macOS, or Windows.
+
+[BUILD.md]: ../../BUILD.md
+
+
+## Linux
+
+Package ecosystems vary across Linux distributions,
+so there is no one set of instructions that will work for every Linux user.
+These instructions are written for Ubuntu 22.04.
+They are largely copied from the [script][1] used to configure our Docker
+container for continuous integration.
+That script handles many more responsibilities.
+These instructions are just the bare minimum to build one configuration of
+rippled.
+You can check that codebase for other Linux distributions and versions.
+If you cannot find yours there,
+then we hope that these instructions can at least guide you in the right
+direction.
+
+```
+apt update
+apt install --yes curl git libssl-dev python3.10-dev python3-pip make g++-11
+
+curl --location --remote-name \
+  "https://github.com/Kitware/CMake/releases/download/v3.25.1/cmake-3.25.1.tar.gz"
+tar -xzf cmake-3.25.1.tar.gz
+rm cmake-3.25.1.tar.gz
+cd cmake-3.25.1
+./bootstrap --parallel=$(nproc)
+make --jobs $(nproc)
+make install
+cd ..
+
+pip3 install 'conan<2'
+```
+
+[1]: https://github.com/thejohnfreeman/rippled-docker/blob/master/ubuntu-22.04/install.sh
+
+
+## macOS
+
+Open a Terminal and enter the below command to bring up a dialog to install
+the command line developer tools.
+Once it is finished, this command should return a version greater than the
+minimum required (see [BUILD.md][]).
+
+```
+clang --version
+```
+
+The command line developer tools should include Git too:
+
+```
+git --version
+```
+
+Install [Homebrew][],
+use it to install [pyenv][],
+use it to install Python,
+and use it to install Conan:
+
+[Homebrew]: https://brew.sh/
+[pyenv]: https://github.com/pyenv/pyenv
+
+```
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+brew update
+brew install xz
+brew install pyenv
+pyenv install 3.10-dev
+pyenv global 3.10-dev
+eval "$(pyenv init -)"
+pip install 'conan<2'
+```
+
+Install CMake with Homebrew too:
+
+```
+brew install cmake
+```

docs/build/install.md

@@ -0,0 +1,159 @@
+This document contains instructions for installing rippled.
+The APT package manager is common on Debian-based Linux distributions like
+Ubuntu,
+while the YUM package manager is common on Red Hat-based Linux distributions
+like CentOS.
+Installing from source is an option for all platforms,
+and the only supported option for installing custom builds.
+
+
+## From source
+
+From a source build, you can install rippled and libxrpl using CMake's
+`--install` mode:
+
+```
+cmake --install . --prefix /opt/local
+```
+
+The default [prefix][1] is typically `/usr/local` on Linux and macOS and
+`C:/Program Files/rippled` on Windows.
+
+[1]: https://cmake.org/cmake/help/latest/variable/CMAKE_INSTALL_PREFIX.html
+
+
+## With the APT package manager
+
+1. Update repositories:
+
+        sudo apt update -y
+
+2. Install utilities:
+
+        sudo apt install -y apt-transport-https ca-certificates wget gnupg
+
+3. Add Ripple's package-signing GPG key to your list of trusted keys:
+
+        sudo mkdir /usr/local/share/keyrings/
+        wget -q -O - "https://repos.ripple.com/repos/api/gpg/key/public" | gpg --dearmor > ripple-key.gpg
+        sudo mv ripple-key.gpg /usr/local/share/keyrings
+
+
+4. Check the fingerprint of the newly-added key:
+
+        gpg /usr/local/share/keyrings/ripple-key.gpg
+
+    The output should include an entry for Ripple such as the following:
+
+        gpg: WARNING: no command supplied.  Trying to guess what you mean ...
+        pub   rsa3072 2019-02-14 [SC] [expires: 2026-02-17]
+            C0010EC205B35A3310DC90DE395F97FFCCAFD9A2
+        uid           TechOps Team at Ripple <techops+rippled@ripple.com>
+        sub   rsa3072 2019-02-14 [E] [expires: 2026-02-17]
+
+
+    In particular, make sure that the fingerprint matches. (In the above example, the fingerprint is on the third line, starting with `C001`.)
+
+4. Add the appropriate Ripple repository for your operating system version:
+
+        echo "deb [signed-by=/usr/local/share/keyrings/ripple-key.gpg] https://repos.ripple.com/repos/rippled-deb focal stable" | \
+            sudo tee -a /etc/apt/sources.list.d/ripple.list
+
+    The above example is appropriate for **Ubuntu 20.04 Focal Fossa**. For other operating systems, replace the word `focal` with one of the following:
+
+    - `jammy` for **Ubuntu 22.04 Jammy Jellyfish**
+    - `bionic` for **Ubuntu 18.04 Bionic Beaver**
+    - `bullseye` for **Debian 11 Bullseye**
+    - `buster` for **Debian 10 Buster**
+
+    If you want access to development or pre-release versions of `rippled`, use one of the following instead of `stable`:
+
+    - `unstable` - Pre-release builds ([`release` branch](https://github.com/ripple/rippled/tree/release))
+    - `nightly` - Experimental/development builds ([`develop` branch](https://github.com/ripple/rippled/tree/develop))
+
+    **Warning:** Unstable and nightly builds may be broken at any time. Do not use these builds for production servers.
+
+5. Fetch the Ripple repository.
+
+        sudo apt -y update
+
+6. Install the `rippled` software package:
+
+        sudo apt -y install rippled
+
+7. Check the status of the `rippled` service:
+
+        systemctl status rippled.service
+
+    The `rippled` service should start automatically. If not, you can start it manually:
+
+        sudo systemctl start rippled.service
+
+8. Optional: allow `rippled` to bind to privileged ports.
+
+    This allows you to serve incoming API requests on port 80 or 443. (If you want to do so, you must also update the config file's port settings.)
+
+        sudo setcap 'cap_net_bind_service=+ep' /opt/ripple/bin/rippled
+
+
+## With the YUM package manager
+
+1. Install the Ripple RPM repository:
+
+    Choose the appropriate RPM repository for the stability of releases you want:
+
+    - `stable` for the latest production release (`master` branch)
+    - `unstable` for pre-release builds (`release` branch)
+    - `nightly` for experimental/development builds (`develop` branch)
+
+    *Stable*
+
+        cat << REPOFILE | sudo tee /etc/yum.repos.d/ripple.repo
+        [ripple-stable]
+        name=XRP Ledger Packages
+        enabled=1
+        gpgcheck=0
+        repo_gpgcheck=1
+        baseurl=https://repos.ripple.com/repos/rippled-rpm/stable/
+        gpgkey=https://repos.ripple.com/repos/rippled-rpm/stable/repodata/repomd.xml.key
+        REPOFILE
+
+    *Unstable*
+
+        cat << REPOFILE | sudo tee /etc/yum.repos.d/ripple.repo
+        [ripple-unstable]
+        name=XRP Ledger Packages
+        enabled=1
+        gpgcheck=0
+        repo_gpgcheck=1
+        baseurl=https://repos.ripple.com/repos/rippled-rpm/unstable/
+        gpgkey=https://repos.ripple.com/repos/rippled-rpm/unstable/repodata/repomd.xml.key
+        REPOFILE
+
+    *Nightly*
+
+        cat << REPOFILE | sudo tee /etc/yum.repos.d/ripple.repo
+        [ripple-nightly]
+        name=XRP Ledger Packages
+        enabled=1
+        gpgcheck=0
+        repo_gpgcheck=1
+        baseurl=https://repos.ripple.com/repos/rippled-rpm/nightly/
+        gpgkey=https://repos.ripple.com/repos/rippled-rpm/nightly/repodata/repomd.xml.key
+        REPOFILE
+
+2. Fetch the latest repo updates:
+
+        sudo yum -y update
+
+3. Install the new `rippled` package:
+
+        sudo yum install -y rippled
+
+4. Configure the `rippled` service to start on boot:
+
+        sudo systemctl enable rippled.service
+
+5. Start the `rippled` service:
+
+        sudo systemctl start rippled.service

external/rocksdb/conanfile.py

@@ -0,0 +1,193 @@
+import os
+import shutil
+from conans import ConanFile, CMake
+from conan.tools import microsoft as ms
+
+class RocksDB(ConanFile):
+    name = 'rocksdb'
+    version = '6.27.3'
+
+    license = ('GPL-2.0-only', 'Apache-2.0')
+    url = 'https://github.com/conan-io/conan-center-index'
+    description = 'A library that provides an embeddable, persistent key-value store for fast storage'
+    topics = ('rocksdb', 'database', 'leveldb', 'facebook', 'key-value')
+
+    settings = 'os', 'compiler', 'build_type', 'arch'
+    options = {
+        'enable_sse': [False, 'sse42', 'avx2'],
+        'fPIC': [True, False],
+        'lite': [True, False],
+        'shared': [True, False],
+        'use_rtti': [True, False],
+        'with_gflags': [True, False],
+        'with_jemalloc': [True, False],
+        'with_lz4': [True, False],
+        'with_snappy': [True, False],
+        'with_tbb': [True, False],
+        'with_zlib': [True, False],
+        'with_zstd': [True, False],
+    }
+    default_options = {
+        'enable_sse': False,
+        'fPIC': True,
+        'lite': False,
+        'shared': False,
+        'use_rtti': False,
+        'with_gflags': False,
+        'with_jemalloc': False,
+        'with_lz4': False,
+        'with_snappy': False,
+        'with_tbb': False,
+        'with_zlib': False,
+        'with_zstd': False,
+    }
+
+    def requirements(self):
+        if self.options.with_gflags:
+            self.requires('gflags/2.2.2')
+        if self.options.with_jemalloc:
+            self.requires('jemalloc/5.2.1')
+        if self.options.with_lz4:
+            self.requires('lz4/1.9.3')
+        if self.options.with_snappy:
+            self.requires('snappy/1.1.9')
+        if self.options.with_tbb:
+            self.requires('onetbb/2020.3')
+        if self.options.with_zlib:
+            self.requires('zlib/1.2.11')
+        if self.options.with_zstd:
+            self.requires('zstd/1.5.2')
+
+    def config_options(self):
+        if self.settings.os == 'Windows':
+            del self.options.fPIC
+
+    def configure(self):
+        if self.options.shared:
+            del self.options.fPIC
+
+    generators = 'cmake', 'cmake_find_package'
+
+    scm = {
+        'type': 'git',
+        'url': 'https://github.com/facebook/rocksdb.git',
+        'revision': 'v6.27.3',
+    }
+
+    exports_sources = 'thirdparty.inc'
+    # For out-of-source build.
+    no_copy_source = True
+
+    _cmake = None
+
+    def _configure_cmake(self):
+        if self._cmake:
+            return
+
+        self._cmake = CMake(self)
+
+        self._cmake.definitions['CMAKE_POSITION_INDEPENDENT_CODE'] = True
+
+        self._cmake.definitions['DISABLE_STALL_NOTIF'] = False
+        self._cmake.definitions['FAIL_ON_WARNINGS'] = False
+        self._cmake.definitions['OPTDBG'] = True
+        self._cmake.definitions['WITH_TESTS'] = False
+        self._cmake.definitions['WITH_TOOLS'] = False
+
+        self._cmake.definitions['WITH_GFLAGS'] = self.options.with_gflags
+        self._cmake.definitions['WITH_JEMALLOC'] = self.options.with_jemalloc
+        self._cmake.definitions['WITH_LZ4'] = self.options.with_lz4
+        self._cmake.definitions['WITH_SNAPPY'] = self.options.with_snappy
+        self._cmake.definitions['WITH_TBB'] = self.options.with_tbb
+        self._cmake.definitions['WITH_ZLIB'] = self.options.with_zlib
+        self._cmake.definitions['WITH_ZSTD'] = self.options.with_zstd
+
+        self._cmake.definitions['USE_RTTI'] = self.options.use_rtti
+        self._cmake.definitions['ROCKSDB_LITE'] = self.options.lite
+        self._cmake.definitions['ROCKSDB_INSTALL_ON_WINDOWS'] = (
+            self.settings.os == 'Windows'
+        )
+
+        if not self.options.enable_sse:
+            self._cmake.definitions['PORTABLE'] = True
+            self._cmake.definitions['FORCE_SSE42'] = False
+        elif self.options.enable_sse == 'sse42':
+            self._cmake.definitions['PORTABLE'] = True
+            self._cmake.definitions['FORCE_SSE42'] = True
+        elif self.options.enable_sse == 'avx2':
+            self._cmake.definitions['PORTABLE'] = False
+            self._cmake.definitions['FORCE_SSE42'] = False
+
+        self._cmake.definitions['WITH_ASAN'] = False
+        self._cmake.definitions['WITH_BZ2'] = False
+        self._cmake.definitions['WITH_JNI'] = False
+        self._cmake.definitions['WITH_LIBRADOS'] = False
+        if ms.is_msvc(self):
+            self._cmake.definitions['WITH_MD_LIBRARY'] = (
+                ms.msvc_runtime_flag(self).startswith('MD')
+            )
+            self._cmake.definitions['WITH_RUNTIME_DEBUG'] = (
+                ms.msvc_runtime_flag(self).endswith('d')
+            )
+        self._cmake.definitions['WITH_NUMA'] = False
+        self._cmake.definitions['WITH_TSAN'] = False
+        self._cmake.definitions['WITH_UBSAN'] = False
+        self._cmake.definitions['WITH_WINDOWS_UTF8_FILENAMES'] = False
+        self._cmake.definitions['WITH_XPRESS'] = False
+        self._cmake.definitions['WITH_FALLOCATE'] = True
+
+
+    def build(self):
+        if ms.is_msvc(self):
+            file = os.path.join(
+                self.recipe_folder, '..', 'export_source', 'thirdparty.inc'
+            )
+            shutil.copy(file, self.build_folder)
+        self._configure_cmake()
+        self._cmake.configure()
+        self._cmake.build()
+
+    def package(self):
+        self._configure_cmake()
+        self._cmake.install()
+
+    def package_info(self):
+        self.cpp_info.filenames['cmake_find_package'] = 'RocksDB'
+        self.cpp_info.filenames['cmake_find_package_multi'] = 'RocksDB'
+        self.cpp_info.set_property('cmake_file_name', 'RocksDB')
+
+        self.cpp_info.names['cmake_find_package'] = 'RocksDB'
+        self.cpp_info.names['cmake_find_package_multi'] = 'RocksDB'
+
+        self.cpp_info.components['librocksdb'].names['cmake_find_package'] = 'rocksdb'
+        self.cpp_info.components['librocksdb'].names['cmake_find_package_multi'] = 'rocksdb'
+        self.cpp_info.components['librocksdb'].set_property(
+            'cmake_target_name', 'RocksDB::rocksdb'
+        )
+
+        self.cpp_info.components['librocksdb'].libs = ['rocksdb']
+
+        if self.settings.os == "Windows":
+            self.cpp_info.components["librocksdb"].system_libs = ["shlwapi", "rpcrt4"]
+            if self.options.shared:
+                self.cpp_info.components["librocksdb"].defines = ["ROCKSDB_DLL"]
+        elif self.settings.os in ["Linux", "FreeBSD"]:
+            self.cpp_info.components["librocksdb"].system_libs = ["pthread", "m"]
+
+        if self.options.lite:
+            self.cpp_info.components["librocksdb"].defines.append("ROCKSDB_LITE")
+
+        if self.options.with_gflags:
+            self.cpp_info.components["librocksdb"].requires.append("gflags::gflags")
+        if self.options.with_jemalloc:
+            self.cpp_info.components["librocksdb"].requires.append("jemalloc::jemalloc")
+        if self.options.with_lz4:
+            self.cpp_info.components["librocksdb"].requires.append("lz4::lz4")
+        if self.options.with_snappy:
+            self.cpp_info.components["librocksdb"].requires.append("snappy::snappy")
+        if self.options.with_tbb:
+            self.cpp_info.components["librocksdb"].requires.append("onetbb::onetbb")
+        if self.options.with_zlib:
+            self.cpp_info.components["librocksdb"].requires.append("zlib::zlib")
+        if self.options.with_zstd:
+            self.cpp_info.components["librocksdb"].requires.append("zstd::zstd")

external/rocksdb/thirdparty.inc

@@ -0,0 +1,62 @@
+if(WITH_GFLAGS)
+  # Config with namespace available since gflags 2.2.2
+  find_package(gflags REQUIRED)
+  set(GFLAGS_LIB gflags::gflags)
+  list(APPEND THIRDPARTY_LIBS ${GFLAGS_LIB})
+  add_definitions(-DGFLAGS=1)
+endif()
+
+if(WITH_SNAPPY)
+  find_package(Snappy REQUIRED)
+  add_definitions(-DSNAPPY)
+  list(APPEND THIRDPARTY_LIBS Snappy::snappy)
+endif()
+
+if(WITH_LZ4)
+  find_package(lz4 REQUIRED)
+  add_definitions(-DLZ4)
+  list(APPEND THIRDPARTY_LIBS lz4::lz4)
+endif()
+
+if(WITH_ZLIB)
+  find_package(ZLIB REQUIRED)
+  add_definitions(-DZLIB)
+  list(APPEND THIRDPARTY_LIBS ZLIB::ZLIB)
+endif()
+
+option(WITH_BZ2 "build with bzip2" OFF)
+if(WITH_BZ2)
+  find_package(BZip2 REQUIRED)
+  add_definitions(-DBZIP2)
+  list(APPEND THIRDPARTY_LIBS BZip2::BZip2)
+endif()
+
+if(WITH_ZSTD)
+  find_package(zstd REQUIRED)
+  add_definitions(-DZSTD)
+  list(APPEND THIRDPARTY_LIBS zstd::zstd)
+endif()
+
+# ================================================== XPRESS ==================================================
+# This makes use of built-in Windows API, no additional includes, links to a system lib
+
+if(WITH_XPRESS)
+  message(STATUS "XPRESS is enabled")
+  add_definitions(-DXPRESS)
+  # We are using the implementation provided by the system
+  list(APPEND SYSTEM_LIBS Cabinet.lib)
+else()
+  message(STATUS "XPRESS is disabled")
+endif()
+
+# ================================================== JEMALLOC ==================================================
+if(WITH_JEMALLOC)
+  message(STATUS "JEMALLOC library is enabled")
+  add_definitions(-DROCKSDB_JEMALLOC -DJEMALLOC_EXPORT= -DJEMALLOC_NO_RENAME)
+  list(APPEND THIRDPARTY_LIBS jemalloc::jemalloc)
+  set(ARTIFACT_SUFFIX "_je")
+
+else ()
+  set(ARTIFACT_SUFFIX "")
+  message(STATUS "JEMALLOC library is disabled")
+endif ()

external/snappy/conandata.yml

@@ -0,0 +1,40 @@
+sources:
+  "1.1.10":
+    url: "https://github.com/google/snappy/archive/1.1.10.tar.gz"
+    sha256: "49d831bffcc5f3d01482340fe5af59852ca2fe76c3e05df0e67203ebbe0f1d90"
+  "1.1.9":
+    url: "https://github.com/google/snappy/archive/1.1.9.tar.gz"
+    sha256: "75c1fbb3d618dd3a0483bff0e26d0a92b495bbe5059c8b4f1c962b478b6e06e7"
+  "1.1.8":
+    url: "https://github.com/google/snappy/archive/1.1.8.tar.gz"
+    sha256: "16b677f07832a612b0836178db7f374e414f94657c138e6993cbfc5dcc58651f"
+  "1.1.7":
+    url: "https://github.com/google/snappy/archive/1.1.7.tar.gz"
+    sha256: "3dfa02e873ff51a11ee02b9ca391807f0c8ea0529a4924afa645fbf97163f9d4"
+patches:
+  "1.1.10":
+    - patch_file: "patches/1.1.10-0001-fix-inlining-failure.patch"
+      patch_description: "disable inlining for compilation error"
+      patch_type: "portability"
+    - patch_file: "patches/1.1.9-0002-no-Werror.patch"
+      patch_description: "disable 'warning as error' options"
+      patch_type: "portability"
+    - patch_file: "patches/1.1.10-0003-fix-clobber-list-older-llvm.patch"
+      patch_description: "disable inline asm on apple-clang"
+      patch_type: "portability"
+    - patch_file: "patches/1.1.9-0004-rtti-by-default.patch"
+      patch_description: "remove 'disable rtti'"
+      patch_type: "conan"
+  "1.1.9":
+    - patch_file: "patches/1.1.9-0001-fix-inlining-failure.patch"
+      patch_description: "disable inlining for compilation error"
+      patch_type: "portability"
+    - patch_file: "patches/1.1.9-0002-no-Werror.patch"
+      patch_description: "disable 'warning as error' options"
+      patch_type: "portability"
+    - patch_file: "patches/1.1.9-0003-fix-clobber-list-older-llvm.patch"
+      patch_description: "disable inline asm on apple-clang"
+      patch_type: "portability"
+    - patch_file: "patches/1.1.9-0004-rtti-by-default.patch"
+      patch_description: "remove 'disable rtti'"
+      patch_type: "conan"

external/snappy/conanfile.py

@@ -0,0 +1,89 @@
+from conan import ConanFile
+from conan.tools.build import check_min_cppstd
+from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
+from conan.tools.files import apply_conandata_patches, copy, export_conandata_patches, get, rmdir
+from conan.tools.scm import Version
+import os
+
+required_conan_version = ">=1.54.0"
+
+
+class SnappyConan(ConanFile):
+    name = "snappy"
+    description = "A fast compressor/decompressor"
+    topics = ("google", "compressor", "decompressor")
+    url = "https://github.com/conan-io/conan-center-index"
+    homepage = "https://github.com/google/snappy"
+    license = "BSD-3-Clause"
+
+    package_type = "library"
+    settings = "os", "arch", "compiler", "build_type"
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False],
+    }
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+    }
+
+    def export_sources(self):
+        export_conandata_patches(self)
+
+    def config_options(self):
+        if self.settings.os == 'Windows':
+            del self.options.fPIC
+
+    def configure(self):
+        if self.options.shared:
+            self.options.rm_safe("fPIC")
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+
+    def validate(self):
+        if self.settings.compiler.get_safe("cppstd"):
+            check_min_cppstd(self, 11)
+
+    def source(self):
+        get(self, **self.conan_data["sources"][self.version], strip_root=True)
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["SNAPPY_BUILD_TESTS"] = False
+        if Version(self.version) >= "1.1.8":
+            tc.variables["SNAPPY_FUZZING_BUILD"] = False
+            tc.variables["SNAPPY_REQUIRE_AVX"] = False
+            tc.variables["SNAPPY_REQUIRE_AVX2"] = False
+            tc.variables["SNAPPY_INSTALL"] = True
+        if Version(self.version) >= "1.1.9":
+            tc.variables["SNAPPY_BUILD_BENCHMARKS"] = False
+        tc.generate()
+
+    def build(self):
+        apply_conandata_patches(self)
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def package(self):
+        copy(self, "COPYING", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
+        cmake = CMake(self)
+        cmake.install()
+        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
+
+    def package_info(self):
+        self.cpp_info.set_property("cmake_file_name", "Snappy")
+        self.cpp_info.set_property("cmake_target_name", "Snappy::snappy")
+        # TODO: back to global scope in conan v2 once cmake_find_package* generators removed
+        self.cpp_info.components["snappylib"].libs = ["snappy"]
+        if not self.options.shared:
+            if self.settings.os in ["Linux", "FreeBSD"]:
+                self.cpp_info.components["snappylib"].system_libs.append("m")
+
+        # TODO: to remove in conan v2 once cmake_find_package* generators removed
+        self.cpp_info.names["cmake_find_package"] = "Snappy"
+        self.cpp_info.names["cmake_find_package_multi"] = "Snappy"
+        self.cpp_info.components["snappylib"].names["cmake_find_package"] = "snappy"
+        self.cpp_info.components["snappylib"].names["cmake_find_package_multi"] = "snappy"
+        self.cpp_info.components["snappylib"].set_property("cmake_target_name", "Snappy::snappy")

external/snappy/patches/1.1.10-0001-fix-inlining-failure.patch

@@ -0,0 +1,13 @@
+diff --git a/snappy-stubs-internal.h b/snappy-stubs-internal.h
+index 1548ed7..3b4a9f3 100644
+--- a/snappy-stubs-internal.h
++++ b/snappy-stubs-internal.h
+@@ -100,7 +100,7 @@
+ 
+ // Inlining hints.
+ #if HAVE_ATTRIBUTE_ALWAYS_INLINE
+-#define SNAPPY_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
++#define SNAPPY_ATTRIBUTE_ALWAYS_INLINE
+ #else
+ #define SNAPPY_ATTRIBUTE_ALWAYS_INLINE
+ #endif  // HAVE_ATTRIBUTE_ALWAYS_INLINE

external/snappy/patches/1.1.10-0003-fix-clobber-list-older-llvm.patch

@@ -0,0 +1,13 @@
+diff --git a/snappy.cc b/snappy.cc
+index d414718..e4efb59 100644
+--- a/snappy.cc
++++ b/snappy.cc
+@@ -1132,7 +1132,7 @@ inline size_t AdvanceToNextTagX86Optimized(const uint8_t** ip_p, size_t* tag) {
+   size_t literal_len = *tag >> 2;
+   size_t tag_type = *tag;
+   bool is_literal;
+-#if defined(__GCC_ASM_FLAG_OUTPUTS__) && defined(__x86_64__)
++#if defined(__GCC_ASM_FLAG_OUTPUTS__) && defined(__x86_64__) && ( (!defined(__clang__) && !defined(__APPLE__)) || (!defined(__APPLE__) && defined(__clang__) && (__clang_major__ >= 9)) || (defined(__APPLE__) && defined(__clang__) && (__clang_major__ > 11)) )
+   // TODO clang misses the fact that the (c & 3) already correctly
+   // sets the zero flag.
+   asm("and $3, %k[tag_type]\n\t"

external/snappy/patches/1.1.9-0001-fix-inlining-failure.patch

@@ -0,0 +1,14 @@
+Fixes the following error:
+error: inlining failed in call to ‘always_inline’ ‘size_t snappy::AdvanceToNextTag(const uint8_t**, size_t*)’: function body can be overwritten at link time
+
+--- snappy-stubs-internal.h
++++ snappy-stubs-internal.h
+@@ -100,7 +100,7 @@
+ 
+ // Inlining hints.
+ #ifdef HAVE_ATTRIBUTE_ALWAYS_INLINE
+-#define SNAPPY_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
++#define SNAPPY_ATTRIBUTE_ALWAYS_INLINE
+ #else
+ #define SNAPPY_ATTRIBUTE_ALWAYS_INLINE
+ #endif

external/snappy/patches/1.1.9-0002-no-Werror.patch

@@ -0,0 +1,12 @@
+--- CMakeLists.txt
++++ CMakeLists.txt
+@@ -69,7 +69,7 @@
+-  # Use -Werror for clang only.
++if(0)
+   if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+     if(NOT CMAKE_CXX_FLAGS MATCHES "-Werror")
+       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+     endif(NOT CMAKE_CXX_FLAGS MATCHES "-Werror")
+   endif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+-
++endif()

external/snappy/patches/1.1.9-0003-fix-clobber-list-older-llvm.patch

@@ -0,0 +1,12 @@
+asm clobbers do not work for clang < 9 and apple-clang < 11 (found by SpaceIm)
+--- snappy.cc
++++ snappy.cc
+@@ -1026,7 +1026,7 @@
+   size_t literal_len = *tag >> 2;
+   size_t tag_type = *tag;
+   bool is_literal;
+-#if defined(__GNUC__) && defined(__x86_64__)
++#if defined(__GNUC__) && defined(__x86_64__) && ( (!defined(__clang__) && !defined(__APPLE__)) || (!defined(__APPLE__) && defined(__clang__) && (__clang_major__ >= 9)) || (defined(__APPLE__) && defined(__clang__) && (__clang_major__ > 11)) )
+   // TODO clang misses the fact that the (c & 3) already correctly
+   // sets the zero flag.
+   asm("and $3, %k[tag_type]\n\t"

external/snappy/patches/1.1.9-0004-rtti-by-default.patch

@@ -0,0 +1,20 @@
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -53,8 +53,6 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+   add_definitions(-D_HAS_EXCEPTIONS=0)
+ 
+   # Disable RTTI.
+-  string(REGEX REPLACE "/GR" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GR-")
+ else(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+   # Use -Wall for clang and gcc.
+   if(NOT CMAKE_CXX_FLAGS MATCHES "-Wall")
+@@ -78,8 +76,6 @@ endif()
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
+ 
+   # Disable RTTI.
+-  string(REGEX REPLACE "-frtti" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
+ endif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+ 
+ # BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to make

external/soci/conandata.yml

@@ -0,0 +1,12 @@
+sources:
+  "4.0.3":
+    url: "https://github.com/SOCI/soci/archive/v4.0.3.tar.gz"
+    sha256: "4b1ff9c8545c5d802fbe06ee6cd2886630e5c03bf740e269bb625b45cf934928"
+patches:
+  "4.0.3":
+    - patch_file: "patches/0001-Remove-hardcoded-INSTALL_NAME_DIR-for-relocatable-li.patch"
+      patch_description: "Generate relocatable libraries on MacOS"
+      patch_type: "portability"
+    - patch_file: "patches/0002-Fix-soci_backend.patch"
+      patch_description: "Fix variable names for dependencies"
+      patch_type: "conan"

external/soci/conanfile.py

@@ -0,0 +1,212 @@
+from conan import ConanFile
+from conan.tools.build import check_min_cppstd
+from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
+from conan.tools.files import apply_conandata_patches, copy, export_conandata_patches, get, rmdir
+from conan.tools.microsoft import is_msvc
+from conan.tools.scm import Version
+from conan.errors import ConanInvalidConfiguration
+import os
+
+required_conan_version = ">=1.55.0"
+
+
+class SociConan(ConanFile):
+    name = "soci"
+    homepage = "https://github.com/SOCI/soci"
+    url = "https://github.com/conan-io/conan-center-index"
+    description = "The C++ Database Access Library "
+    topics = ("mysql", "odbc", "postgresql", "sqlite3")
+    license = "BSL-1.0"
+
+    settings = "os", "arch", "compiler", "build_type"
+    options = {
+        "shared":           [True, False],
+        "fPIC":             [True, False],
+        "empty":            [True, False],
+        "with_sqlite3":     [True, False],
+        "with_db2":         [True, False],
+        "with_odbc":        [True, False],
+        "with_oracle":      [True, False],
+        "with_firebird":    [True, False],
+        "with_mysql":       [True, False],
+        "with_postgresql":  [True, False],
+        "with_boost":       [True, False],
+    }
+    default_options = {
+        "shared":           False,
+        "fPIC":             True,
+        "empty":            False,
+        "with_sqlite3":     False,
+        "with_db2":         False,
+        "with_odbc":        False,
+        "with_oracle":      False,
+        "with_firebird":    False,
+        "with_mysql":       False,
+        "with_postgresql":  False,
+        "with_boost":       False,
+    }
+
+    def export_sources(self):
+        export_conandata_patches(self)
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            self.options.rm_safe("fPIC")
+
+    def configure(self):
+        if self.options.shared:
+            self.options.rm_safe("fPIC")
+
+    def requirements(self):
+        if self.options.with_sqlite3:
+            self.requires("sqlite3/3.41.1")
+        if self.options.with_odbc and self.settings.os != "Windows":
+            self.requires("odbc/2.3.11")
+        if self.options.with_mysql:
+            self.requires("libmysqlclient/8.0.31")
+        if self.options.with_postgresql:
+            self.requires("libpq/14.7")
+        if self.options.with_boost:
+            self.requires("boost/1.81.0")
+
+    @property
+    def _minimum_compilers_version(self):
+        return {
+            "Visual Studio": "14",
+            "gcc": "4.8",
+            "clang": "3.8",
+            "apple-clang": "8.0"
+        }
+
+    def validate(self):
+        if self.settings.compiler.get_safe("cppstd"):
+            check_min_cppstd(self, 11)
+
+        compiler = str(self.settings.compiler)
+        compiler_version = Version(self.settings.compiler.version.value)
+        if compiler not in self._minimum_compilers_version:
+            self.output.warning("{} recipe lacks information about the {} compiler support.".format(self.name, self.settings.compiler))
+        elif compiler_version < self._minimum_compilers_version[compiler]:
+            raise ConanInvalidConfiguration("{} requires a {} version >= {}".format(self.name, compiler, compiler_version))
+
+        prefix  = "Dependencies for"
+        message = "not configured in this conan package."
+        if self.options.with_db2:
+            # self.requires("db2/0.0.0") # TODO add support for db2
+            raise ConanInvalidConfiguration("{} DB2 {} ".format(prefix, message))
+        if self.options.with_oracle:
+            # self.requires("oracle_db/0.0.0") # TODO add support for oracle
+            raise ConanInvalidConfiguration("{} ORACLE {} ".format(prefix, message))
+        if self.options.with_firebird:
+            # self.requires("firebird/0.0.0") # TODO add support for firebird
+            raise ConanInvalidConfiguration("{} firebird {} ".format(prefix, message))
+
+    def source(self):
+        get(self, **self.conan_data["sources"][self.version], strip_root=True)
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+
+        tc.variables["SOCI_SHARED"] = self.options.shared
+        tc.variables["SOCI_STATIC"] = not self.options.shared
+        tc.variables["SOCI_TESTS"] = False
+        tc.variables["SOCI_CXX11"] = True
+        tc.variables["SOCI_EMPTY"] = self.options.empty
+        tc.variables["WITH_SQLITE3"] = self.options.with_sqlite3
+        tc.variables["WITH_DB2"] = self.options.with_db2
+        tc.variables["WITH_ODBC"] = self.options.with_odbc
+        tc.variables["WITH_ORACLE"] = self.options.with_oracle
+        tc.variables["WITH_FIREBIRD"] = self.options.with_firebird
+        tc.variables["WITH_MYSQL"] = self.options.with_mysql
+        tc.variables["WITH_POSTGRESQL"] = self.options.with_postgresql
+        tc.variables["WITH_BOOST"] = self.options.with_boost
+        tc.generate()
+
+        deps = CMakeDeps(self)
+        deps.generate()
+
+    def build(self):
+        apply_conandata_patches(self)
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def package(self):
+        copy(self, "LICENSE_1_0.txt", dst=os.path.join(self.package_folder, "licenses"), src=self.source_folder)
+
+        cmake = CMake(self)
+        cmake.install()
+
+        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
+
+    def package_info(self):
+        self.cpp_info.set_property("cmake_file_name", "SOCI")
+
+        target_suffix = "" if self.options.shared else "_static"
+        lib_prefix = "lib" if is_msvc(self) and not self.options.shared else ""
+        version = Version(self.version)
+        lib_suffix = "_{}_{}".format(version.major, version.minor) if self.settings.os == "Windows" else ""
+
+        # soci_core
+        self.cpp_info.components["soci_core"].set_property("cmake_target_name", "SOCI::soci_core{}".format(target_suffix))
+        self.cpp_info.components["soci_core"].libs = ["{}soci_core{}".format(lib_prefix, lib_suffix)]
+        if self.options.with_boost:
+            self.cpp_info.components["soci_core"].requires.append("boost::boost")
+
+        # soci_empty
+        if self.options.empty:
+            self.cpp_info.components["soci_empty"].set_property("cmake_target_name", "SOCI::soci_empty{}".format(target_suffix))
+            self.cpp_info.components["soci_empty"].libs = ["{}soci_empty{}".format(lib_prefix, lib_suffix)]
+            self.cpp_info.components["soci_empty"].requires = ["soci_core"]
+
+        # soci_sqlite3
+        if self.options.with_sqlite3:
+            self.cpp_info.components["soci_sqlite3"].set_property("cmake_target_name", "SOCI::soci_sqlite3{}".format(target_suffix))
+            self.cpp_info.components["soci_sqlite3"].libs = ["{}soci_sqlite3{}".format(lib_prefix, lib_suffix)]
+            self.cpp_info.components["soci_sqlite3"].requires = ["soci_core", "sqlite3::sqlite3"]
+
+        # soci_odbc
+        if self.options.with_odbc:
+            self.cpp_info.components["soci_odbc"].set_property("cmake_target_name", "SOCI::soci_odbc{}".format(target_suffix))
+            self.cpp_info.components["soci_odbc"].libs = ["{}soci_odbc{}".format(lib_prefix, lib_suffix)]
+            self.cpp_info.components["soci_odbc"].requires = ["soci_core"]
+            if self.settings.os == "Windows":
+                self.cpp_info.components["soci_odbc"].system_libs.append("odbc32")
+            else:
+                self.cpp_info.components["soci_odbc"].requires.append("odbc::odbc")
+
+        # soci_mysql
+        if self.options.with_mysql:
+            self.cpp_info.components["soci_mysql"].set_property("cmake_target_name", "SOCI::soci_mysql{}".format(target_suffix))
+            self.cpp_info.components["soci_mysql"].libs = ["{}soci_mysql{}".format(lib_prefix, lib_suffix)]
+            self.cpp_info.components["soci_mysql"].requires = ["soci_core", "libmysqlclient::libmysqlclient"]
+
+        # soci_postgresql
+        if self.options.with_postgresql:
+            self.cpp_info.components["soci_postgresql"].set_property("cmake_target_name", "SOCI::soci_postgresql{}".format(target_suffix))
+            self.cpp_info.components["soci_postgresql"].libs = ["{}soci_postgresql{}".format(lib_prefix, lib_suffix)]
+            self.cpp_info.components["soci_postgresql"].requires = ["soci_core", "libpq::libpq"]
+
+        # TODO: to remove in conan v2 once cmake_find_package* generators removed
+        self.cpp_info.names["cmake_find_package"] = "SOCI"
+        self.cpp_info.names["cmake_find_package_multi"] = "SOCI"
+        self.cpp_info.components["soci_core"].names["cmake_find_package"] = "soci_core{}".format(target_suffix)
+        self.cpp_info.components["soci_core"].names["cmake_find_package_multi"] = "soci_core{}".format(target_suffix)
+        if self.options.empty:
+            self.cpp_info.components["soci_empty"].names["cmake_find_package"] = "soci_empty{}".format(target_suffix)
+            self.cpp_info.components["soci_empty"].names["cmake_find_package_multi"] = "soci_empty{}".format(target_suffix)
+        if self.options.with_sqlite3:
+            self.cpp_info.components["soci_sqlite3"].names["cmake_find_package"] = "soci_sqlite3{}".format(target_suffix)
+            self.cpp_info.components["soci_sqlite3"].names["cmake_find_package_multi"] = "soci_sqlite3{}".format(target_suffix)
+        if self.options.with_odbc:
+            self.cpp_info.components["soci_odbc"].names["cmake_find_package"] = "soci_odbc{}".format(target_suffix)
+            self.cpp_info.components["soci_odbc"].names["cmake_find_package_multi"] = "soci_odbc{}".format(target_suffix)
+        if self.options.with_mysql:
+            self.cpp_info.components["soci_mysql"].names["cmake_find_package"] = "soci_mysql{}".format(target_suffix)
+            self.cpp_info.components["soci_mysql"].names["cmake_find_package_multi"] = "soci_mysql{}".format(target_suffix)
+        if self.options.with_postgresql:
+            self.cpp_info.components["soci_postgresql"].names["cmake_find_package"] = "soci_postgresql{}".format(target_suffix)
+            self.cpp_info.components["soci_postgresql"].names["cmake_find_package_multi"] = "soci_postgresql{}".format(target_suffix)

external/soci/patches/0001-Remove-hardcoded-INSTALL_NAME_DIR-for-relocatable-li.patch

@@ -0,0 +1,39 @@
+From d491bf7b5040d314ffd0c6310ba01f78ff44c85e Mon Sep 17 00:00:00 2001
+From: Rasmus Thomsen <rasmus.thomsen@dampsoft.de>
+Date: Fri, 14 Apr 2023 09:16:29 +0200
+Subject: [PATCH] Remove hardcoded INSTALL_NAME_DIR for relocatable libraries
+ on MacOS
+
+---
+ cmake/SociBackend.cmake | 2 +-
+ src/core/CMakeLists.txt | 1 -
+ 2 files changed, 1 insertion(+), 2 deletions(-)
+
+diff --git a/cmake/SociBackend.cmake b/cmake/SociBackend.cmake
+index 5d4ef0df..39fe1f77 100644
+--- a/cmake/SociBackend.cmake
++++ b/cmake/SociBackend.cmake
+@@ -171,7 +171,7 @@ macro(soci_backend NAME)
+           set_target_properties(${THIS_BACKEND_TARGET}
+             PROPERTIES
+             SOVERSION ${${PROJECT_NAME}_SOVERSION}
+-            INSTALL_NAME_DIR ${CMAKE_INSTALL_PREFIX}/lib)
++          )
+ 
+           if(APPLE)
+             set_target_properties(${THIS_BACKEND_TARGET}
+diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
+index 3e7deeae..f9eae564 100644
+--- a/src/core/CMakeLists.txt
++++ b/src/core/CMakeLists.txt
+@@ -59,7 +59,6 @@ if (SOCI_SHARED)
+       PROPERTIES
+       VERSION ${SOCI_VERSION}
+       SOVERSION ${SOCI_SOVERSION}
+-      INSTALL_NAME_DIR ${CMAKE_INSTALL_PREFIX}/lib
+       CLEAN_DIRECT_OUTPUT 1)
+   endif()
+ 
+-- 
+2.25.1
+

external/soci/patches/0002-Fix-soci_backend.patch

@@ -0,0 +1,24 @@
+diff --git a/cmake/SociBackend.cmake b/cmake/SociBackend.cmake
+index 0a664667..3fa2ed95 100644
+--- a/cmake/SociBackend.cmake
++++ b/cmake/SociBackend.cmake
+@@ -31,14 +31,13 @@ macro(soci_backend_deps_found NAME DEPS SUCCESS)
+     if(NOT DEPEND_FOUND)
+       list(APPEND DEPS_NOT_FOUND ${dep})
+     else()
+-      string(TOUPPER "${dep}" DEPU)
+-      if( ${DEPU}_INCLUDE_DIR )
+-        list(APPEND DEPS_INCLUDE_DIRS ${${DEPU}_INCLUDE_DIR})
++      if( ${dep}_INCLUDE_DIR )
++        list(APPEND DEPS_INCLUDE_DIRS ${${dep}_INCLUDE_DIR})
+       endif()
+-      if( ${DEPU}_INCLUDE_DIRS )
+-        list(APPEND DEPS_INCLUDE_DIRS ${${DEPU}_INCLUDE_DIRS})
++      if( ${dep}_INCLUDE_DIRS )
++        list(APPEND DEPS_INCLUDE_DIRS ${${dep}_INCLUDE_DIRS})
+       endif()
+-      list(APPEND DEPS_LIBRARIES ${${DEPU}_LIBRARIES})
++      list(APPEND DEPS_LIBRARIES ${${dep}_LIBRARIES})
+     endif()
+   endforeach()
+ 

external/wasmedge/conandata.yml

@@ -0,0 +1,194 @@
+sources:
+  "0.13.5":
+    Windows:
+      "x86_64":
+        Visual Studio:
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.13.5/WasmEdge-0.13.5-windows.zip"
+            sha256: "db533289ba26ec557b5193593c9ed03db75be3bc7aa737e2caa5b56b8eef888a"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.13.5/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    Linux:
+      "x86_64":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.13.5/WasmEdge-0.13.5-manylinux2014_x86_64.tar.gz"
+            sha256: "3686e0226871bf17b62ec57e1c15778c2947834b90af0dfad14f2e0202bf9284"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.13.5/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+      "armv8":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.13.5/WasmEdge-0.13.5-manylinux2014_aarch64.tar.gz"
+            sha256: "472de88e0257c539c120b33fdd1805e1e95063121acc2df1d5626e4676b93529"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.11.1/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    Macos:
+      "x86_64":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.13.5/WasmEdge-0.13.5-darwin_x86_64.tar.gz"
+            sha256: "b7fdfaf59805951241f47690917b501ddfa06d9b6f7e0262e44e784efe4a7b33"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.13.5/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+      "armv8":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.13.5/WasmEdge-0.13.5-darwin_arm64.tar.gz"
+            sha256: "acc93721210294ced0887352f360e42e46dcc05332e6dd78c1452fb3a35d5255"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.13.5/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    Android:
+      "armv8":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.13.5/WasmEdge-0.13.5-android_aarch64.tar.gz"
+            sha256: "59a0d68a0c7368b51cc65cb5a44a68037d79fd449883ef42792178d57c8784a8"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.13.5/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+  "0.11.2":
+    Windows:
+      "x86_64":
+        Visual Studio:
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.11.2/WasmEdge-0.11.2-windows.zip"
+            sha256: "ca49b98c0cf5f187e08c3ba71afc8d71365fde696f10b4219379a4a4d1a91e6d"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.11.2/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    Linux:
+      "x86_64":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.11.2/WasmEdge-0.11.2-manylinux2014_x86_64.tar.gz"
+            sha256: "784bf1eb25928e2cf02aa88e9372388fad682b4a188485da3cd9162caeedf143"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.11.2/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+      "armv8":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.11.2/WasmEdge-0.11.2-manylinux2014_aarch64.tar.gz"
+            sha256: "a2766a4c1edbaea298a30e5431a4e795003a10d8398a933d923f23d4eb4fa5d1"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.11.1/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    Macos:
+      "x86_64":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.11.2/WasmEdge-0.11.2-darwin_x86_64.tar.gz"
+            sha256: "aedec53f29b1e0b657e46e67dba3e2f32a2924f4d9136e60073ea1aba3073e70"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.11.2/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+      "armv8":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.11.2/WasmEdge-0.11.2-darwin_arm64.tar.gz"
+            sha256: "fe391df90e1eee69cf1e976f5ddf60c20f29b651710aaa4fc03e2ab4fe52c0d3"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.11.2/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    Android:
+      "armv8":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.11.2/WasmEdge-0.11.2-android_aarch64.tar.gz"
+            sha256: "69e308f5927c753b2bb5639569d10219b60598174d8b304bdf310093fd7b2464"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.11.2/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+  "0.11.1":
+    Windows:
+      "x86_64":
+        Visual Studio:
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.11.1/WasmEdge-0.11.1-windows.zip"
+            sha256: "c86f6384555a0484a5dd81faba5636bba78f5e3d6eaf627d880e34843f9e24bf"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.11.1/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    Linux:
+      "x86_64":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.11.1/WasmEdge-0.11.1-manylinux2014_x86_64.tar.gz"
+            sha256: "76ce4ea0eb86adfa52c73f6c6b44383626d94990e0923cae8b1e6f060ef2bf5b"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.11.1/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+      "armv8":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.11.1/WasmEdge-0.11.1-manylinux2014_aarch64.tar.gz"
+            sha256: "cb9ea32932360463991cfda80e09879b2cf6c69737f12f3f2b371cd0af4e9ce8"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.11.1/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    Macos:
+      "x86_64":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.11.1/WasmEdge-0.11.1-darwin_x86_64.tar.gz"
+            sha256: "56df2b00669c25b8143ea2c17370256cd6a33f3b316d3b47857dd38d603cb69a"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.11.1/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+      "armv8":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.11.1/WasmEdge-0.11.1-darwin_arm64.tar.gz"
+            sha256: "82f7da1a7a36ec1923fb045193784dd090a03109e84da042af97297205a71f08"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.11.1/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    Android:
+      "armv8":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.11.1/WasmEdge-0.11.1-android_aarch64.tar.gz"
+            sha256: "af8694e93bf72ac5506450d4caebccc340fbba254dca3d58ec0712e96ec9dedd"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.11.1/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+  "0.10.0":
+    Windows:
+      "x86_64":
+        Visual Studio:
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.10.0/WasmEdge-0.10.0-windows.zip"
+            sha256: "63b8a02cced52a723aa283dba02bbe887656256ecca69bb0fff17872c0fb5ebc"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.10.0/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    Linux:
+      "x86_64":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.10.0/WasmEdge-0.10.0-manylinux2014_x86_64.tar.gz"
+            sha256: "4c1ffca9fd8cbdeb8f0951ddaffbbefe81ae123d5b80f61e80ea8d9b56853cde"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.10.0/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+      "armv8":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.10.0/WasmEdge-0.10.0-manylinux2014_aarch64.tar.gz"
+            sha256: "c000bf96d0a73a1d360659246c0806c2ce78620b6f78c1147fbf9e2be0280bd9"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.10.0/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+  "0.9.1":
+    Windows:
+      "x86_64":
+        Visual Studio:
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.9.1/WasmEdge-0.9.1-windows.zip"
+            sha256: "68240d8aee23d44db5cc252d8c1cf5d0c77ab709a122af2747a4b836ba461671"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.9.1/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    Linux:
+      "x86_64":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.9.1/WasmEdge-0.9.1-manylinux2014_x86_64.tar.gz"
+            sha256: "bcb6fe3d6e30db0d0aa267ec3bd9b7248f8c8c387620cef4049d682d293c8371"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.9.1/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+      "armv8":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.9.1/WasmEdge-0.9.1-manylinux2014_aarch64.tar.gz"
+            sha256: "515bcac3520cd546d9d14372b7930ab48b43f1c5dc258a9f61a82b22c0107eef"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.9.1/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+  "0.9.0":
+    Windows:
+      "x86_64":
+        Visual Studio:
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.9.0/WasmEdge-0.9.0-windows.zip"
+            sha256: "f81bfea4cf09053510e3e74c16c1ee010fc93def8a7e78744443b950f0011c3b"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.9.0/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    Linux:
+      "x86_64":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.9.0/WasmEdge-0.9.0-manylinux2014_x86_64.tar.gz"
+            sha256: "27847f15e4294e707486458e857d7cb11806481bb67a26f076a717a1446827ed"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.9.0/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+      "armv8":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.9.0/WasmEdge-0.9.0-manylinux2014_aarch64.tar.gz"
+            sha256: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.9.0/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    Macos:
+      "armv8":
+        "gcc":
+          - url: "https://github.com/WasmEdge/WasmEdge/releases/download/0.9.0/WasmEdge-0.9.0-darwin_arm64.tar.gz"
+            sha256: "236a407a646f746ab78a1d0a39fa4e85fe28eae219b1635ba49f908d7944686d"
+          - url: "https://raw.githubusercontent.com/WasmEdge/WasmEdge/0.9.0/LICENSE"
+            sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"

external/wasmedge/conanfile.py

@@ -0,0 +1,92 @@
+from conan import ConanFile
+from conan.tools.files import get, copy, download
+from conan.tools.scm import Version
+from conan.errors import ConanInvalidConfiguration
+
+import os
+
+required_conan_version = ">=1.53.0"
+
+class WasmedgeConan(ConanFile):
+    name = "wasmedge"
+    description = ("WasmEdge is a lightweight, high-performance, and extensible WebAssembly runtime"
+                "for cloud native, edge, and decentralized applications."
+                "It powers serverless apps, embedded functions, microservices, smart contracts, and IoT devices.")
+    license = "Apache-2.0"
+    url = "https://github.com/conan-io/conan-center-index"
+    homepage = "https://github.com/WasmEdge/WasmEdge/"
+    topics = ("webassembly", "wasm", "wasi", "emscripten")
+    package_type = "shared-library"
+    settings = "os", "arch", "compiler", "build_type"
+
+    @property
+    def _compiler_alias(self):
+        return {
+            "Visual Studio": "Visual Studio",
+            # "Visual Studio": "msvc",
+            "msvc": "msvc",
+        }.get(str(self.info.settings.compiler), "gcc")
+
+    def configure(self):
+        self.settings.compiler.rm_safe("libcxx")
+        self.settings.compiler.rm_safe("cppstd")
+
+    def validate(self):
+        try:
+            self.conan_data["sources"][self.version][str(self.settings.os)][str(self.settings.arch)][self._compiler_alias]
+        except KeyError:
+            raise ConanInvalidConfiguration("Binaries for this combination of version/os/arch/compiler are not available")
+
+    def package_id(self):
+        del self.info.settings.compiler.version
+        self.info.settings.compiler = self._compiler_alias
+
+    def build(self):
+        # This is packaging binaries so the download needs to be in build
+        get(self, **self.conan_data["sources"][self.version][str(self.settings.os)][str(self.settings.arch)][self._compiler_alias][0],
+            destination=self.source_folder, strip_root=True)
+        download(self, filename="LICENSE",
+                 **self.conan_data["sources"][self.version][str(self.settings.os)][str(self.settings.arch)][self._compiler_alias][1])
+
+    def package(self):
+        copy(self, pattern="*.h", dst=os.path.join(self.package_folder, "include"), src=os.path.join(self.source_folder, "include"), keep_path=True)
+        copy(self, pattern="*.inc", dst=os.path.join(self.package_folder, "include"), src=os.path.join(self.source_folder, "include"), keep_path=True)
+
+        srclibdir = os.path.join(self.source_folder, "lib64" if self.settings.os == "Linux" else "lib")
+        srcbindir = os.path.join(self.source_folder, "bin")
+        dstlibdir = os.path.join(self.package_folder, "lib")
+        dstbindir = os.path.join(self.package_folder, "bin")
+        if Version(self.version) >= "0.11.1":
+            copy(self, pattern="wasmedge.lib", src=srclibdir, dst=dstlibdir, keep_path=False)
+            copy(self, pattern="wasmedge.dll", src=srcbindir, dst=dstbindir, keep_path=False)
+            copy(self, pattern="libwasmedge.so*", src=srclibdir, dst=dstlibdir, keep_path=False)
+            copy(self, pattern="libwasmedge*.dylib", src=srclibdir,  dst=dstlibdir, keep_path=False)
+        else:
+            copy(self, pattern="wasmedge_c.lib", src=srclibdir, dst=dstlibdir, keep_path=False)
+            copy(self, pattern="wasmedge_c.dll", src=srcbindir, dst=dstbindir, keep_path=False)
+            copy(self, pattern="libwasmedge_c.so*", src=srclibdir, dst=dstlibdir, keep_path=False)
+            copy(self, pattern="libwasmedge_c*.dylib", src=srclibdir,  dst=dstlibdir, keep_path=False)
+
+        copy(self, pattern="wasmedge*", src=srcbindir, dst=dstbindir, keep_path=False)
+        copy(self, pattern="LICENSE", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"), keep_path=False)
+
+    def package_info(self):
+        if Version(self.version) >= "0.11.1":
+            self.cpp_info.libs = ["wasmedge"]
+        else:
+            self.cpp_info.libs = ["wasmedge_c"]
+
+        bindir = os.path.join(self.package_folder, "bin")
+        self.output.info("Appending PATH environment variable: {}".format(bindir))
+        self.env_info.PATH.append(bindir)
+
+        if self.settings.os == "Windows":
+            self.cpp_info.system_libs.append("ws2_32")
+            self.cpp_info.system_libs.append("wsock32")
+            self.cpp_info.system_libs.append("shlwapi")
+
+        if self.settings.os in ["Linux", "FreeBSD"]:
+            self.cpp_info.system_libs.append("m")
+            self.cpp_info.system_libs.append("dl")
+            self.cpp_info.system_libs.append("rt")
+            self.cpp_info.system_libs.append("pthread")

hook/generate_sfcodes.sh

@@ -0,0 +1,29 @@
+#/bin/bash
+RIPPLED_ROOT="../src/ripple"
+echo '// For documentation please see: https://xrpl-hooks.readme.io/reference/'
+echo '// Generated using generate_sfcodes.sh'
+cat $RIPPLED_ROOT/protocol/impl/SField.cpp | grep -E '^CONSTRUCT_' |
+    sed 's/UINT16,/1,/g' |
+    sed 's/UINT32,/2,/g' |
+    sed 's/UINT64,/3,/g' |
+    sed 's/HASH128,/4,/g' |
+    sed 's/HASH256,/5,/g' |
+    sed 's/UINT128,/4,/g' |
+    sed 's/UINT256,/5,/g' |
+    sed 's/AMOUNT,/6,/g' |
+    sed 's/VL,/7,/g' |
+    sed 's/ACCOUNT,/8,/g' |
+    sed 's/OBJECT,/14,/g' |
+    sed 's/ARRAY,/15,/g' |
+    sed 's/UINT8,/16,/g' |
+    sed 's/HASH160,/17,/g' |
+    sed 's/UINT160,/17,/g' |
+    sed 's/PATHSET,/18,/g' |
+    sed 's/VECTOR256,/19,/g' |
+    sed 's/UINT96,/20,/g' |
+    sed 's/UINT192,/21,/g' |
+    sed 's/UINT384,/22,/g' |
+    sed 's/UINT512,/23,/g' |
+    grep -Eo '"([^"]+)", *([0-9]+), *([0-9]+)' |
+    sed 's/"//g' | sed 's/ *//g' | sed 's/,/ /g' |
+    awk '{print ("#define sf"$1" (("$2"U << 16U) + "$3"U)")}'

hook/genesis/govern.c

@@ -637,43 +637,55 @@ int64_t hook(uint32_t r)
             {
                 previous_member[0] = 'V';
 
-                for (int i = 1; GUARD(32), i < 32; ++i)
+                for (int tbl = 1; GUARD(2), tbl <= 2; ++tbl)
                 {
-                    previous_member[1] = i < 2 ? 'R' : i < 12 ? 'H' : 'S';
-                    previous_member[2] = 
-                        i == 0 ? 'R' :
-                        i == 1 ? 'D' :
-                        i < 12 ? i - 2 :
-                        i - 12;
-
-                    uint8_t vote_key[32];
-                    if (state(SBUF(vote_key), SBUF(previous_member)) == 32)
+                    for (int i = 0; GUARD(66), i < 32; ++i)
                     {
-                        uint8_t vote_count = 0;
+                        previous_member[1] = i < 2 ? 'R' : i < 12 ? 'H' : 'S';
+                        previous_member[2] = 
+                            i == 0 ? 'R' :
+                            i == 1 ? 'D' :
+                            i < 12 ? i - 2 :
+                            i - 12;
+                        previous_member[3] = tbl;
 
-                        // find and decrement the vote counter
-                        vote_key[0] = 'C';
-                        vote_key[1] = previous_member[1];
-                        vote_key[2] = previous_member[2];
-                        if (state(&vote_count, 1, SBUF(vote_key)) == 1)
+                        uint8_t vote_key[32] = {};
+                        uint8_t ts = 
+                            previous_member[1] == 'H' ? 32 :      // hook topics are a 32 byte hook hash
+                            previous_member[1] == 'S' ? 20 :      // account topics are a 20 byte account ID
+                            8;                        // reward topics are an 8 byte le xfl
+                        
+                        uint8_t padding = 32 - ts;
+
+                        if (state(vote_key + padding, ts, SBUF(previous_member)) == ts)
                         {
-                            // if we're down to 1 vote then delete state
-                            if (vote_count <= 1)
-                            {
-                                ASSERT(state_set(0,0, SBUF(vote_key)) == 0);
-                                trace_num(SBUF("Decrement vote count deleted"), vote_count);
-                            }
-                            else    // otherwise decrement
-                            {
-                                vote_count--;
-                                ASSERT(state_set(&vote_count, 1, SBUF(vote_key)) == 1);
-                                trace_num(SBUF("Decrement vote count to"), vote_count);
-                            }
-                        }
+                            uint8_t vote_count = 0;
 
-                        // delete the vote entry
-                        ASSERT(state_set(0,0, SBUF(previous_member)) == 0);
-                        trace(SBUF("Vote entry deleted"), vote_key, 32, 1);
+                            // find and decrement the vote counter
+                            vote_key[0] = 'C';
+                            vote_key[1] = previous_member[1];
+                            vote_key[2] = previous_member[2];
+                            vote_key[3] = tbl;
+                            if (state(&vote_count, 1, SBUF(vote_key)) == 1)
+                            {
+                                // if we're down to 1 vote then delete state
+                                if (vote_count <= 1)
+                                {
+                                    ASSERT(state_set(0,0, SBUF(vote_key)) == 0);
+                                    trace_num(SBUF("Decrement vote count deleted"), vote_count);
+                                }
+                                else    // otherwise decrement
+                                {
+                                    vote_count--;
+                                    ASSERT(state_set(&vote_count, 1, SBUF(vote_key)) == 1);
+                                    trace_num(SBUF("Decrement vote count to"), vote_count);
+                                }
+                            }
+
+                            // delete the vote entry
+                            ASSERT(state_set(0,0, SBUF(previous_member)) == 0);
+                            trace(SBUF("Vote entry deleted"), vote_key, 32, 1);
+                        }
                     }
                 }
 

hook/macro.h

@@ -1,5 +1,5 @@
 /**
- * These are helper macros for writing hooks, all of them are optional as is including hookmacro.h at all
+ * These are helper macros for writing hooks, all of them are optional as is including macro.h at all
  */
 
 #include <stdint.h>
@@ -9,13 +9,32 @@
 #ifndef HOOKMACROS_INCLUDED
 #define HOOKMACROS_INCLUDED 1
 
-
 #ifdef NDEBUG
 #define DEBUG 0
 #else
 #define DEBUG 1
 #endif
 
+#define DONEEMPTY()\
+    accept(0,0,__LINE__)
+
+#define DONEMSG(msg)\
+    accept(msg, sizeof(msg),__LINE__)
+
+#define DONE(x)\
+    accept(SVAR(x),(uint32_t)__LINE__);
+
+#define ASSERT(x)\
+{\
+    if (!(x))\
+        rollback(0,0,__LINE__);\
+}
+
+#define NOPE(x)\
+{\
+    return rollback((x), sizeof(x), __LINE__);\
+}
+
 #define TRACEVAR(v) if (DEBUG) trace_num((uint32_t)(#v), (uint32_t)(sizeof(#v) - 1), (int64_t)v);
 #define TRACEHEX(v) if (DEBUG) trace((uint32_t)(#v), (uint32_t)(sizeof(#v) - 1), (uint32_t)(v), (uint32_t)(sizeof(v)), 1);
 #define TRACEXFL(v) if (DEBUG) trace_float((uint32_t)(#v), (uint32_t)(sizeof(#v) - 1), (int64_t)v);
@@ -26,6 +45,7 @@
 #define GUARDM(maxiter, n) _g(( (1ULL << 31U) + (__LINE__ << 16) + n), (maxiter)+1)
 
 #define SBUF(str) (uint32_t)(str), sizeof(str)
+#define SVAR(x) &x, sizeof(x)
 
 #define REQUIRE(cond, str)\
 {\
@@ -138,6 +158,17 @@ int out_len = 0;\
         *(((uint64_t*)(buf1)) + 2) == *(((uint64_t*)(buf2)) + 2) &&\
         *(((uint64_t*)(buf1)) + 3) == *(((uint64_t*)(buf2)) + 3))
 
+#define BUFFER_EQUAL_64(buf1, buf2) \
+    ( \
+        (*((uint64_t*)(buf1) + 0) == *((uint64_t*)(buf2) + 0)) && \
+        (*((uint64_t*)(buf1) + 1) == *((uint64_t*)(buf2) + 1)) && \
+        (*((uint64_t*)(buf1) + 2) == *((uint64_t*)(buf2) + 2)) && \
+        (*((uint64_t*)(buf1) + 3) == *((uint64_t*)(buf2) + 3)) && \
+        (*((uint64_t*)(buf1) + 4) == *((uint64_t*)(buf2) + 4)) && \
+        (*((uint64_t*)(buf1) + 5) == *((uint64_t*)(buf2) + 5)) && \
+        (*((uint64_t*)(buf1) + 6) == *((uint64_t*)(buf2) + 6)) && \
+        (*((uint64_t*)(buf1) + 7) == *((uint64_t*)(buf2) + 7)) \
+    )
 
 // when using this macro buf1len may be dynamic but buf2len must be static
 // provide n >= 1 to indicate how many times the macro will be hit on the line of code
@@ -185,6 +216,18 @@ int out_len = 0;\
 #define BUFFER_EQUAL(output, buf1, buf2, compare_len)\
     BUFFER_EQUAL_GUARD(output, buf1, compare_len, buf2, compare_len, 1)
 
+
+#define UINT8_TO_BUF(buf_raw, i)\
+{\
+    unsigned char* buf = (unsigned char*)buf_raw;\
+    buf[0] = (((uint8_t)i) >> 0) & 0xFFUL;\
+    if (i < 0) buf[0] |= 0x80U;\
+}
+
+#define UINT8_FROM_BUF(buf)\
+    (((uint8_t)((buf)[0]) <<  0))
+
+
 #define UINT16_TO_BUF(buf_raw, i)\
 {\
     unsigned char* buf = (unsigned char*)buf_raw;\
@@ -205,7 +248,6 @@ int out_len = 0;\
     buf[3] = (((uint64_t)i) >>  0) & 0xFFUL;\
 }
 
-
 #define UINT32_FROM_BUF(buf)\
     (((uint64_t)((buf)[0]) << 24) +\
      ((uint64_t)((buf)[1]) << 16) +\
@@ -225,7 +267,6 @@ int out_len = 0;\
     buf[7] = (((uint64_t)i) >>  0) & 0xFFUL;\
 }
 
-
 #define UINT64_FROM_BUF(buf)\
     (((uint64_t)((buf)[0]) << 56) +\
      ((uint64_t)((buf)[1]) << 48) +\
@@ -236,17 +277,6 @@ int out_len = 0;\
      ((uint64_t)((buf)[6]) <<  8) +\
      ((uint64_t)((buf)[7]) <<  0))
 
-
-#define INT64_FROM_BUF(buf)\
-   ((((uint64_t)((buf)[0] & 0x7FU) << 56) +\
-     ((uint64_t)((buf)[1]) << 48) +\
-     ((uint64_t)((buf)[2]) << 40) +\
-     ((uint64_t)((buf)[3]) << 32) +\
-     ((uint64_t)((buf)[4]) << 24) +\
-     ((uint64_t)((buf)[5]) << 16) +\
-     ((uint64_t)((buf)[6]) <<  8) +\
-     ((uint64_t)((buf)[7]) <<  0)) * (buf[0] & 0x80U ? -1 : 1))
-
 #define INT64_TO_BUF(buf_raw, i)\
 {\
     unsigned char* buf = (unsigned char*)buf_raw;\
@@ -261,6 +291,65 @@ int out_len = 0;\
     if (i < 0) buf[0] |= 0x80U;\
 }
 
+#define INT64_FROM_BUF(buf)\
+   ((((uint64_t)((buf)[0] & 0x7FU) << 56) +\
+     ((uint64_t)((buf)[1]) << 48) +\
+     ((uint64_t)((buf)[2]) << 40) +\
+     ((uint64_t)((buf)[3]) << 32) +\
+     ((uint64_t)((buf)[4]) << 24) +\
+     ((uint64_t)((buf)[5]) << 16) +\
+     ((uint64_t)((buf)[6]) <<  8) +\
+     ((uint64_t)((buf)[7]) <<  0)) * (buf[0] & 0x80U ? -1 : 1))
+
+
+#define BYTES20_TO_BUF(buf_raw, i)\
+{\
+    unsigned char* buf = (unsigned char*)buf_raw;\
+    *(uint64_t*)(buf + 0) = *(uint64_t*)(i +  0);\
+    *(uint64_t*)(buf + 8) = *(uint64_t*)(i +  8);\
+    *(uint32_t*)(buf + 16) = *(uint32_t*)(i + 16);\
+}
+
+#define BYTES20_FROM_BUF(buf_raw, i)\
+{\
+    const unsigned char* buf = (const unsigned char*)buf_raw;\
+    *(uint64_t*)(i +  0) = *(const uint64_t*)(buf + 0);\
+    *(uint64_t*)(i +  8) = *(const uint64_t*)(buf + 8);\
+    *(uint32_t*)(i + 16) = *(const uint32_t*)(buf + 16);\
+}
+
+#define BYTES32_TO_BUF(buf_raw, i)\
+{\
+    unsigned char* buf = (unsigned char*)buf_raw;\
+    *(uint64_t*)(buf + 0) = *(uint64_t*)(i +  0);\
+    *(uint64_t*)(buf + 8) = *(uint64_t*)(i +  8);\
+    *(uint64_t*)(buf + 16) = *(uint64_t*)(i + 16);\
+    *(uint64_t*)(buf + 24) = *(uint64_t*)(i + 24);\
+}
+
+#define BYTES32_FROM_BUF(buf_raw, i)\
+{\
+    const unsigned char* buf = (const unsigned char*)buf_raw;\
+    *(uint64_t*)(i +  0) = *(const uint64_t*)(buf + 0);\
+    *(uint64_t*)(i +  8) = *(const uint64_t*)(buf + 8);\
+    *(uint64_t*)(i + 16) = *(const uint64_t*)(buf + 16);\
+    *(uint64_t*)(i + 24) = *(const uint64_t*)(buf + 24);\
+}
+
+#define FLIP_ENDIAN_32(n) ((uint32_t) (((n & 0xFFU) << 24U) | \
+                                   ((n & 0xFF00U) << 8U) | \
+                                 ((n & 0xFF0000U) >> 8U) | \
+                                ((n & 0xFF000000U) >> 24U)))
+
+#define FLIP_ENDIAN_64(n) ((uint64_t)(((n & 0xFFULL) << 56ULL) |             \
+                                      ((n & 0xFF00ULL) << 40ULL) |           \
+                                      ((n & 0xFF0000ULL) << 24ULL) |         \
+                                      ((n & 0xFF000000ULL) << 8ULL) |        \
+                                      ((n & 0xFF00000000ULL) >> 8ULL) |      \
+                                      ((n & 0xFF0000000000ULL) >> 24ULL) |   \
+                                      ((n & 0xFF000000000000ULL) >> 40ULL) | \
+                                      ((n & 0xFF00000000000000ULL) >> 56ULL)))
+
 #define tfCANONICAL 0x80000000UL
 
 #define atACCOUNT 1U
@@ -287,350 +376,6 @@ int out_len = 0;\
 #define amRIPPLEESCROW 17U
 #define amDELIVEREDAMOUNT 18U
 
-/**
- * RH NOTE -- PAY ATTENTION
- *
- * ALL 'ENCODE' MACROS INCREMENT BUF_OUT
- * THIS IS TO MAKE CHAINING EASY
- * BUF_OUT IS A SACRIFICIAL POINTER
- *
- * 'ENCODE' MACROS WITH CONSTANTS HAVE
- * ALIASING TO ASSIST YOU WITH ORDER
- * _TYPECODE_FIELDCODE_ENCODE_MACRO
- * TO PRODUCE A SERIALIZED OBJECT
- * IN CANONICAL FORMAT YOU MUST ORDER
- * FIRST BY TYPE CODE THEN BY FIELD CODE
- *
- * ALL 'PREPARE' MACROS PRESERVE POINTERS
- *
- **/
-
-
-#define ENCODE_TL_SIZE 49
-#define ENCODE_TL(buf_out, tlamt, amount_type)\
-{\
-        uint8_t uat = amount_type; \
-        buf_out[0] = 0x60U +(uat & 0x0FU ); \
-        for (int i = 1; GUARDM(48, 1), i < 49; ++i)\
-            buf_out[i] = tlamt[i-1];\
-        buf_out += ENCODE_TL_SIZE;\
-}
-#define _06_XX_ENCODE_TL(buf_out, drops, amount_type )\
-    ENCODE_TL(buf_out, drops, amount_type );
-#define ENCODE_TL_AMOUNT(buf_out, drops )\
-    ENCODE_TL(buf_out, drops, amAMOUNT );
-#define _06_01_ENCODE_TL_AMOUNT(buf_out, drops )\
-    ENCODE_TL_AMOUNT(buf_out, drops );
-
-
-// Encode drops to serialization format
-// consumes 9 bytes
-#define ENCODE_DROPS_SIZE 9
-#define ENCODE_DROPS(buf_out, drops, amount_type ) \
-    {\
-        uint8_t uat = amount_type; \
-        uint64_t udrops = drops; \
-        buf_out[0] = 0x60U +(uat & 0x0FU ); \
-        buf_out[1] = 0b01000000 + (( udrops >> 56 ) & 0b00111111 ); \
-        buf_out[2] = (udrops >> 48) & 0xFFU; \
-        buf_out[3] = (udrops >> 40) & 0xFFU; \
-        buf_out[4] = (udrops >> 32) & 0xFFU; \
-        buf_out[5] = (udrops >> 24) & 0xFFU; \
-        buf_out[6] = (udrops >> 16) & 0xFFU; \
-        buf_out[7] = (udrops >>  8) & 0xFFU; \
-        buf_out[8] = (udrops >>  0) & 0xFFU; \
-        buf_out += ENCODE_DROPS_SIZE; \
-    }
-
-#define _06_XX_ENCODE_DROPS(buf_out, drops, amount_type )\
-    ENCODE_DROPS(buf_out, drops, amount_type );
-
-#define ENCODE_DROPS_AMOUNT(buf_out, drops )\
-    ENCODE_DROPS(buf_out, drops, amAMOUNT );
-#define _06_01_ENCODE_DROPS_AMOUNT(buf_out, drops )\
-    ENCODE_DROPS_AMOUNT(buf_out, drops );
-
-#define ENCODE_DROPS_FEE(buf_out, drops )\
-    ENCODE_DROPS(buf_out, drops, amFEE );
-#define _06_08_ENCODE_DROPS_FEE(buf_out, drops )\
-    ENCODE_DROPS_FEE(buf_out, drops );
-
-#define ENCODE_TT_SIZE 3
-#define ENCODE_TT(buf_out, tt )\
-    {\
-        uint8_t utt = tt;\
-        buf_out[0] = 0x12U;\
-        buf_out[1] =(utt >> 8 ) & 0xFFU;\
-        buf_out[2] =(utt >> 0 ) & 0xFFU;\
-        buf_out += ENCODE_TT_SIZE; \
-    }
-#define _01_02_ENCODE_TT(buf_out, tt)\
-    ENCODE_TT(buf_out, tt);
-
-
-#define ENCODE_ACCOUNT_SIZE 22
-#define ENCODE_ACCOUNT(buf_out, account_id, account_type)\
-    {\
-        uint8_t uat = account_type;\
-        buf_out[0] = 0x80U + uat;\
-        buf_out[1] = 0x14U;\
-        *(uint64_t*)(buf_out +  2) = *(uint64_t*)(account_id +  0);\
-        *(uint64_t*)(buf_out + 10) = *(uint64_t*)(account_id +  8);\
-        *(uint32_t*)(buf_out + 18) = *(uint32_t*)(account_id + 16);\
-        buf_out += ENCODE_ACCOUNT_SIZE;\
-    }
-#define _08_XX_ENCODE_ACCOUNT(buf_out, account_id, account_type)\
-    ENCODE_ACCOUNT(buf_out, account_id, account_type);
-
-#define ENCODE_ACCOUNT_SRC_SIZE 22
-#define ENCODE_ACCOUNT_SRC(buf_out, account_id)\
-    ENCODE_ACCOUNT(buf_out, account_id, atACCOUNT);
-#define _08_01_ENCODE_ACCOUNT_SRC(buf_out, account_id)\
-    ENCODE_ACCOUNT_SRC(buf_out, account_id);
-
-#define ENCODE_ACCOUNT_DST_SIZE 22
-#define ENCODE_ACCOUNT_DST(buf_out, account_id)\
-    ENCODE_ACCOUNT(buf_out, account_id, atDESTINATION);
-#define _08_03_ENCODE_ACCOUNT_DST(buf_out, account_id)\
-    ENCODE_ACCOUNT_DST(buf_out, account_id);
-
-#define ENCODE_ACCOUNT_OWNER_SIZE 22
-#define ENCODE_ACCOUNT_OWNER(buf_out, account_id) \
-    ENCODE_ACCOUNT(buf_out, account_id, atOWNER);
-#define _08_02_ENCODE_ACCOUNT_OWNER(buf_out, account_id) \
-    ENCODE_ACCOUNT_OWNER(buf_out, account_id);
-
-#define ENCODE_UINT32_COMMON_SIZE 5U
-#define ENCODE_UINT32_COMMON(buf_out, i, field)\
-    {\
-        uint32_t ui = i; \
-        uint8_t uf = field; \
-        buf_out[0] = 0x20U +(uf & 0x0FU); \
-        buf_out[1] =(ui >> 24 ) & 0xFFU; \
-        buf_out[2] =(ui >> 16 ) & 0xFFU; \
-        buf_out[3] =(ui >>  8 ) & 0xFFU; \
-        buf_out[4] =(ui >>  0 ) & 0xFFU; \
-        buf_out += ENCODE_UINT32_COMMON_SIZE; \
-    }
-#define _02_XX_ENCODE_UINT32_COMMON(buf_out, i, field)\
-    ENCODE_UINT32_COMMON(buf_out, i, field)\
-
-#define ENCODE_UINT32_UNCOMMON_SIZE 6U
-#define ENCODE_UINT32_UNCOMMON(buf_out, i, field)\
-    {\
-        uint32_t ui = i; \
-        uint8_t uf = field; \
-        buf_out[0] = 0x20U; \
-        buf_out[1] = uf; \
-        buf_out[2] =(ui >> 24 ) & 0xFFU; \
-        buf_out[3] =(ui >> 16 ) & 0xFFU; \
-        buf_out[4] =(ui >>  8 ) & 0xFFU; \
-        buf_out[5] =(ui >>  0 ) & 0xFFU; \
-        buf_out += ENCODE_UINT32_UNCOMMON_SIZE; \
-    }
-#define _02_XX_ENCODE_UINT32_UNCOMMON(buf_out, i, field)\
-    ENCODE_UINT32_UNCOMMON(buf_out, i, field)\
-
-#define ENCODE_LLS_SIZE 6U
-#define ENCODE_LLS(buf_out, lls )\
-    ENCODE_UINT32_UNCOMMON(buf_out, lls, 0x1B );
-#define _02_27_ENCODE_LLS(buf_out, lls )\
-    ENCODE_LLS(buf_out, lls );
-
-#define ENCODE_FLS_SIZE 6U
-#define ENCODE_FLS(buf_out, fls )\
-    ENCODE_UINT32_UNCOMMON(buf_out, fls, 0x1A );
-#define _02_26_ENCODE_FLS(buf_out, fls )\
-    ENCODE_FLS(buf_out, fls );
-
-#define ENCODE_TAG_SRC_SIZE 5
-#define ENCODE_TAG_SRC(buf_out, tag )\
-    ENCODE_UINT32_COMMON(buf_out, tag, 0x3U );
-#define _02_03_ENCODE_TAG_SRC(buf_out, tag )\
-    ENCODE_TAG_SRC(buf_out, tag );
-
-#define ENCODE_TAG_DST_SIZE 5
-#define ENCODE_TAG_DST(buf_out, tag )\
-    ENCODE_UINT32_COMMON(buf_out, tag, 0xEU );
-#define _02_14_ENCODE_TAG_DST(buf_out, tag )\
-    ENCODE_TAG_DST(buf_out, tag );
-
-#define ENCODE_SEQUENCE_SIZE 5
-#define ENCODE_SEQUENCE(buf_out, sequence )\
-    ENCODE_UINT32_COMMON(buf_out, sequence, 0x4U );
-#define _02_04_ENCODE_SEQUENCE(buf_out, sequence )\
-    ENCODE_SEQUENCE(buf_out, sequence );
-
-#define ENCODE_FLAGS_SIZE 5
-#define ENCODE_FLAGS(buf_out, tag )\
-    ENCODE_UINT32_COMMON(buf_out, tag, 0x2U );
-#define _02_02_ENCODE_FLAGS(buf_out, tag )\
-    ENCODE_FLAGS(buf_out, tag );
-
-#define ENCODE_SIGNING_PUBKEY_SIZE 35
-#define ENCODE_SIGNING_PUBKEY(buf_out, pkey )\
-    {\
-        buf_out[0] = 0x73U;\
-        buf_out[1] = 0x21U;\
-        *(uint64_t*)(buf_out +  2) = *(uint64_t*)(pkey +  0);\
-        *(uint64_t*)(buf_out + 10) = *(uint64_t*)(pkey +  8);\
-        *(uint64_t*)(buf_out + 18) = *(uint64_t*)(pkey + 16);\
-        *(uint64_t*)(buf_out + 26) = *(uint64_t*)(pkey + 24);\
-        buf[34] = pkey[32];\
-        buf_out += ENCODE_SIGNING_PUBKEY_SIZE;\
-    }
-
-#define _07_03_ENCODE_SIGNING_PUBKEY(buf_out, pkey )\
-    ENCODE_SIGNING_PUBKEY(buf_out, pkey );
-
-#define ENCODE_SIGNING_PUBKEY_NULL_SIZE 2
-#define ENCODE_SIGNING_PUBKEY_NULL(buf_out )\
-    {\
-        *buf_out++ = 0x73U;\
-        *buf_out++ = 0x00U;\
-    }
-
-#define _07_03_ENCODE_SIGNING_PUBKEY_NULL(buf_out )\
-    ENCODE_SIGNING_PUBKEY_NULL(buf_out );
-
-
-#define _0E_0E_ENCODE_HOOKOBJ(buf_out, hhash)\
-{\
-        uint8_t* hook0 = (hhash);\
-        *buf_out++ = 0xEEU;   /* hook obj start */ \
-        if (hook0 == 0) /* noop */\
-        {\
-            /* do nothing */ \
-        }\
-        else\
-        {\
-            *buf_out++ = 0x22U; /* flags = override */\
-            *buf_out++ = 0x00U;\
-            *buf_out++ = 0x00U;\
-            *buf_out++ = 0x00U;\
-            *buf_out++ = 0x01U;\
-            if (hook0 == 0xFFFFFFFFUL) /* delete operation */ \
-            {\
-                *buf_out++ = 0x7BU; /* empty createcode */ \
-                *buf_out++ = 0x00U;\
-            }\
-            else\
-            {\
-                *buf_out++ = 0x50U; /* HookHash */\
-                *buf_out++ = 0x1FU;\
-                uint64_t* d = (uint64_t*)buf_out;\
-                uint64_t* s = (uint64_t*)hook0;\
-                *d++ = *s++;\
-                *d++ = *s++;\
-                *d++ = *s++;\
-                *d++ = *s++;\
-                buf_out+=32;\
-            }\
-        }\
-        *buf_out++ = 0xE1U;\
-}
-
-#define PREPARE_HOOKSET(buf_out_master, maxlen, h, sizeout)\
-    {\
-        uint8_t* buf_out = (buf_out_master);                                            \
-        uint8_t acc[20];                                                                \
-        uint32_t cls = (uint32_t)ledger_seq();                                          \
-        hook_account(SBUF(acc));                                                        \
-        _01_02_ENCODE_TT                   (buf_out, ttHOOK_SET                     );  \
-        _02_02_ENCODE_FLAGS                (buf_out, tfCANONICAL                    );  \
-        _02_04_ENCODE_SEQUENCE             (buf_out, 0                              );  \
-        _02_26_ENCODE_FLS                  (buf_out, cls + 1                        );  \
-        _02_27_ENCODE_LLS                  (buf_out, cls + 5                        );  \
-        uint8_t* fee_ptr = buf_out;                                                     \
-        _06_08_ENCODE_DROPS_FEE            (buf_out, 0                              );  \
-        _07_03_ENCODE_SIGNING_PUBKEY_NULL  (buf_out                                 );  \
-        _08_01_ENCODE_ACCOUNT_SRC          (buf_out, acc                            );  \
-        uint32_t remaining_size = (maxlen) - (buf_out - (buf_out_master));              \
-        int64_t edlen = etxn_details((uint32_t)buf_out, remaining_size);                \
-        buf_out += edlen;                                                               \
-        *buf_out++ = 0xFBU;   /* hook array start */                                    \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[0]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[1]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[2]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[3]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[4]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[5]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[6]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[7]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[8]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[9]);                           \
-        *buf_out++ = 0xF1U;  /* hook array end */                                       \
-        sizeout = (buf_out - (buf_out_master));                                         \
-        int64_t fee = etxn_fee_base(buf_out_master, sizeout);                           \
-        _06_08_ENCODE_DROPS_FEE            (fee_ptr, fee                            );  \
-    }
-
-#ifdef HAS_CALLBACK
-#define PREPARE_PAYMENT_SIMPLE_SIZE 270U
-#else
-#define PREPARE_PAYMENT_SIMPLE_SIZE 248U
-#endif
-
-#define PREPARE_PAYMENT_SIMPLE(buf_out_master, drops_amount_raw, to_address, dest_tag_raw, src_tag_raw)\
-    {\
-        uint8_t* buf_out = buf_out_master;\
-        uint8_t acc[20];\
-        uint64_t drops_amount = (drops_amount_raw);\
-        uint32_t dest_tag = (dest_tag_raw);\
-        uint32_t src_tag = (src_tag_raw);\
-        uint32_t cls = (uint32_t)ledger_seq();\
-        hook_account(SBUF(acc));\
-        _01_02_ENCODE_TT                   (buf_out, ttPAYMENT                      );      /* uint16  | size   3 */ \
-        _02_02_ENCODE_FLAGS                (buf_out, tfCANONICAL                    );      /* uint32  | size   5 */ \
-        _02_03_ENCODE_TAG_SRC              (buf_out, src_tag                        );      /* uint32  | size   5 */ \
-        _02_04_ENCODE_SEQUENCE             (buf_out, 0                              );      /* uint32  | size   5 */ \
-        _02_14_ENCODE_TAG_DST              (buf_out, dest_tag                       );      /* uint32  | size   5 */ \
-        _02_26_ENCODE_FLS                  (buf_out, cls + 1                        );      /* uint32  | size   6 */ \
-        _02_27_ENCODE_LLS                  (buf_out, cls + 5                        );      /* uint32  | size   6 */ \
-        _06_01_ENCODE_DROPS_AMOUNT         (buf_out, drops_amount                   );      /* amount  | size   9 */ \
-        uint8_t* fee_ptr = buf_out;\
-        _06_08_ENCODE_DROPS_FEE            (buf_out, 0                              );      /* amount  | size   9 */ \
-        _07_03_ENCODE_SIGNING_PUBKEY_NULL  (buf_out                                 );      /* pk      | size  35 */ \
-        _08_01_ENCODE_ACCOUNT_SRC          (buf_out, acc                            );      /* account | size  22 */ \
-        _08_03_ENCODE_ACCOUNT_DST          (buf_out, to_address                     );      /* account | size  22 */ \
-        int64_t edlen = etxn_details((uint32_t)buf_out, PREPARE_PAYMENT_SIMPLE_SIZE);       /* emitdet | size 1?? */ \
-        int64_t fee = etxn_fee_base(buf_out_master, PREPARE_PAYMENT_SIMPLE_SIZE);                                    \ 
-        _06_08_ENCODE_DROPS_FEE            (fee_ptr, fee                            );                               \
-    }
-
-#ifdef HAS_CALLBACK
-#define PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE 309
-#else
-#define PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE 287
-#endif
-#define PREPARE_PAYMENT_SIMPLE_TRUSTLINE(buf_out_master, tlamt, to_address, dest_tag_raw, src_tag_raw)\
-    {\
-        uint8_t* buf_out = buf_out_master;\
-        uint8_t acc[20];\
-        uint32_t dest_tag = (dest_tag_raw);\
-        uint32_t src_tag = (src_tag_raw);\
-        uint32_t cls = (uint32_t)ledger_seq();\
-        hook_account(SBUF(acc));\
-        _01_02_ENCODE_TT                   (buf_out, ttPAYMENT                      );      /* uint16  | size   3 */ \
-        _02_02_ENCODE_FLAGS                (buf_out, tfCANONICAL                    );      /* uint32  | size   5 */ \
-        _02_03_ENCODE_TAG_SRC              (buf_out, src_tag                        );      /* uint32  | size   5 */ \
-        _02_04_ENCODE_SEQUENCE             (buf_out, 0                              );      /* uint32  | size   5 */ \
-        _02_14_ENCODE_TAG_DST              (buf_out, dest_tag                       );      /* uint32  | size   5 */ \
-        _02_26_ENCODE_FLS                  (buf_out, cls + 1                        );      /* uint32  | size   6 */ \
-        _02_27_ENCODE_LLS                  (buf_out, cls + 5                        );      /* uint32  | size   6 */ \
-        _06_01_ENCODE_TL_AMOUNT            (buf_out, tlamt                          );      /* amount  | size  48 */ \
-        uint8_t* fee_ptr = buf_out;\
-        _06_08_ENCODE_DROPS_FEE            (buf_out, 0                              );      /* amount  | size   9 */ \
-        _07_03_ENCODE_SIGNING_PUBKEY_NULL  (buf_out                                 );      /* pk      | size  35 */ \
-        _08_01_ENCODE_ACCOUNT_SRC          (buf_out, acc                            );      /* account | size  22 */ \
-        _08_03_ENCODE_ACCOUNT_DST          (buf_out, to_address                     );      /* account | size  22 */ \
-        etxn_details((uint32_t)buf_out, PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE);             /* emitdet | size 1?? */  \
-        int64_t fee = etxn_fee_base(buf_out_master, PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE);                          \ 
-        _06_08_ENCODE_DROPS_FEE            (fee_ptr, fee                            );                               \
-    }
-
-
-
 #endif
 
 

hook/sfcodes.h

@@ -60,7 +60,10 @@
 #define sfBurnedNFTokens ((2U << 16U) + 44U)
 #define sfHookStateCount ((2U << 16U) + 45U)
 #define sfEmitGeneration ((2U << 16U) + 46U)
-#define sfLockCount ((2U << 16U) + 47U)
+#define sfLockCount ((2U << 16U) + 49U)
+#define sfFirstNFTokenSequence ((2U << 16U) + 50U)
+#define sfXahauActivationLgrSeq ((2U << 16U) + 96U)
+#define sfImportSequence ((2U << 16U) + 97U)
 #define sfRewardTime ((2U << 16U) + 98U)
 #define sfRewardLgrFirst ((2U << 16U) + 99U)
 #define sfRewardLgrLast ((2U << 16U) + 100U)
@@ -80,12 +83,15 @@
 #define sfHookInstructionCount ((3U << 16U) + 17U)
 #define sfHookReturnCode ((3U << 16U) + 18U)
 #define sfReferenceCount ((3U << 16U) + 19U)
+#define sfTouchCount ((3U << 16U) + 97U)
+#define sfAccountIndex ((3U << 16U) + 98U)
+#define sfAccountCount ((3U << 16U) + 99U)
 #define sfRewardAccumulator ((3U << 16U) + 100U)
 #define sfEmailHash ((4U << 16U) + 1U)
-#define sfTakerPaysCurrency ((10U << 16U) + 1U)
-#define sfTakerPaysIssuer ((10U << 16U) + 2U)
-#define sfTakerGetsCurrency ((10U << 16U) + 3U)
-#define sfTakerGetsIssuer ((10U << 16U) + 4U)
+#define sfTakerPaysCurrency ((17U << 16U) + 1U)
+#define sfTakerPaysIssuer ((17U << 16U) + 2U)
+#define sfTakerGetsCurrency ((17U << 16U) + 3U)
+#define sfTakerGetsIssuer ((17U << 16U) + 4U)
 #define sfLedgerHash ((5U << 16U) + 1U)
 #define sfParentHash ((5U << 16U) + 2U)
 #define sfTransactionHash ((5U << 16U) + 3U)
@@ -120,6 +126,9 @@
 #define sfOfferID ((5U << 16U) + 34U)
 #define sfEscrowID ((5U << 16U) + 35U)
 #define sfURITokenID ((5U << 16U) + 36U)
+#define sfGovernanceFlags ((5U << 16U) + 99U)
+#define sfGovernanceMarks ((5U << 16U) + 98U)
+#define sfEmittedTxnID ((5U << 16U) + 97U)
 #define sfAmount ((6U << 16U) + 1U)
 #define sfBalance ((6U << 16U) + 2U)
 #define sfLimitAmount ((6U << 16U) + 3U)
@@ -136,6 +145,9 @@
 #define sfNFTokenBrokerFee ((6U << 16U) + 19U)
 #define sfHookCallbackFee ((6U << 16U) + 20U)
 #define sfLockedBalance ((6U << 16U) + 21U)
+#define sfBaseFeeDrops ((6U << 16U) + 22U)
+#define sfReserveBaseDrops ((6U << 16U) + 23U)
+#define sfReserveIncrementDrops ((6U << 16U) + 24U)
 #define sfPublicKey ((7U << 16U) + 1U)
 #define sfMessageKey ((7U << 16U) + 2U)
 #define sfSigningPubKey ((7U << 16U) + 3U)
@@ -171,11 +183,13 @@
 #define sfNFTokenMinter ((8U << 16U) + 9U)
 #define sfEmitCallback ((8U << 16U) + 10U)
 #define sfHookAccount ((8U << 16U) + 16U)
+#define sfInform ((8U << 16U) + 99U)
 #define sfIndexes ((19U << 16U) + 1U)
 #define sfHashes ((19U << 16U) + 2U)
 #define sfAmendments ((19U << 16U) + 3U)
 #define sfNFTokenOffers ((19U << 16U) + 4U)
 #define sfHookNamespaces ((19U << 16U) + 5U)
+#define sfURITokenIDs ((19U << 16U) + 99U)
 #define sfPaths ((18U << 16U) + 1U)
 #define sfTransactionMetaData ((14U << 16U) + 2U)
 #define sfCreatedNode ((14U << 16U) + 3U)
@@ -198,6 +212,12 @@
 #define sfHookDefinition ((14U << 16U) + 22U)
 #define sfHookParameter ((14U << 16U) + 23U)
 #define sfHookGrant ((14U << 16U) + 24U)
+#define sfGenesisMint ((14U << 16U) + 96U)
+#define sfActiveValidator ((14U << 16U) + 95U)
+#define sfImportVLKey ((14U << 16U) + 94U)
+#define sfHookEmission ((14U << 16U) + 93U)
+#define sfMintURIToken ((14U << 16U) + 92U)
+#define sfAmountEntry ((14U << 16U) + 91U)
 #define sfSigners ((15U << 16U) + 3U)
 #define sfSignerEntries ((15U << 16U) + 4U)
 #define sfTemplate ((15U << 16U) + 5U)
@@ -212,4 +232,8 @@
 #define sfHookExecutions ((15U << 16U) + 18U)
 #define sfHookParameters ((15U << 16U) + 19U)
 #define sfHookGrants ((15U << 16U) + 20U)
+#define sfGenesisMints ((15U << 16U) + 96U)
 #define sfActiveValidators ((15U << 16U) + 95U)
+#define sfImportVLKeys ((15U << 16U) + 94U)
+#define sfHookEmissions ((15U << 16U) + 93U)
+#define sfAmounts ((15U << 16U) + 92U)

hook/tts.h

@@ -31,6 +31,7 @@
 #define ttURITOKEN_BUY 47
 #define ttURITOKEN_CREATE_SELL_OFFER 48
 #define ttURITOKEN_CANCEL_SELL_OFFER 49
+#define ttREMIT 95
 #define ttGENESIS_MINT 96
 #define ttIMPORT 97
 #define ttCLAIM_REWARD 98

release-builder.sh

@@ -1,4 +1,9 @@
-#!/bin/bash
+#!/bin/bash -u
+# We use set -e and bash with -u to bail on first non zero exit code of any
+# processes launched or upon any unbound variable.
+# We use set -x to print commands before running them to help with
+# debugging.
+set -ex
 
 echo "START BUILDING (HOST)"
 
@@ -12,10 +17,18 @@ if [[ "$GITHUB_REPOSITORY" == "" ]]; then
   BUILD_CORES=8
 fi
 
+# Ensure still works outside of GH Actions by setting these to /dev/null
+# GA will run this script and then delete it at the end of the job
+JOB_CLEANUP_SCRIPT=${JOB_CLEANUP_SCRIPT:-/dev/null}
+NORMALIZED_WORKFLOW=$(echo "$GITHUB_WORKFLOW" | tr -c 'a-zA-Z0-9' '-')
+NORMALIZED_REF=$(echo "$GITHUB_REF" | tr -c 'a-zA-Z0-9' '-')
+CONTAINER_NAME="xahaud_cached_builder_${NORMALIZED_WORKFLOW}-${NORMALIZED_REF}"
+
 echo "-- BUILD CORES:       $BUILD_CORES"
 echo "-- GITHUB_REPOSITORY: $GITHUB_REPOSITORY"
 echo "-- GITHUB_SHA:        $GITHUB_SHA"
 echo "-- GITHUB_RUN_NUMBER: $GITHUB_RUN_NUMBER"
+echo "-- CONTAINER_NAME:    $CONTAINER_NAME"
 
 which docker 2> /dev/null 2> /dev/null
 if [ "$?" -eq "1" ]
@@ -31,13 +44,14 @@ then
   exit 1
 fi
 
-STATIC_CONTAINER=$(docker ps -a | grep xahaud_cached_builder |wc -l)
+STATIC_CONTAINER=$(docker ps -a | grep $CONTAINER_NAME |wc -l)
 
-if [[ "$STATIC_CONTAINER" -gt "0" && "$GITHUB_REPOSITORY" != "" ]]; then
+# if [[ "$STATIC_CONTAINER" -gt "0" && "$GITHUB_REPOSITORY" != "" ]]; then
+if false; then
   echo "Static container, execute in static container to have max. cache"
-  docker start xahaud_cached_builder
-  docker exec -i xahaud_cached_builder /hbb_exe/activate-exec bash -x /io/build-core.sh "$GITHUB_REPOSITORY" "$GITHUB_SHA" "$BUILD_CORES" "$GITHUB_RUN_NUMBER"
-  docker stop xahaud_cached_builder
+  docker start $CONTAINER_NAME
+  docker exec -i $CONTAINER_NAME /hbb_exe/activate-exec bash -x /io/build-core.sh "$GITHUB_REPOSITORY" "$GITHUB_SHA" "$BUILD_CORES" "$GITHUB_RUN_NUMBER"
+  docker stop $CONTAINER_NAME
 else
   echo "No static container, build on temp container"
   rm -rf release-build;
@@ -50,10 +64,12 @@ else
   else
     # GH Action, runner
     echo "GH Action, runner, clean & re-create create persistent container"
-    docker rm -f xahaud_cached_builder
-    docker run -di --user 0:$(id -g) --name xahaud_cached_builder -v /data/builds:/data/builds -v `pwd`:/io --network host ghcr.io/foobarwidget/holy-build-box-x64 /hbb_exe/activate-exec bash
-    docker exec -i xahaud_cached_builder /hbb_exe/activate-exec bash -x /io/build-full.sh "$GITHUB_REPOSITORY" "$GITHUB_SHA" "$BUILD_CORES" "$GITHUB_RUN_NUMBER"
-    docker stop xahaud_cached_builder
+    docker rm -f $CONTAINER_NAME
+    echo "echo 'Stopping container: $CONTAINER_NAME'" >> "$JOB_CLEANUP_SCRIPT"
+    echo "docker stop --time=15 \"$CONTAINER_NAME\" || echo 'Failed to stop container or container not running'" >> "$JOB_CLEANUP_SCRIPT"
+    docker run -di --user 0:$(id -g) --name $CONTAINER_NAME -v /data/builds:/data/builds -v `pwd`:/io --network host ghcr.io/foobarwidget/holy-build-box-x64 /hbb_exe/activate-exec bash
+    docker exec -i $CONTAINER_NAME /hbb_exe/activate-exec bash -x /io/build-full.sh "$GITHUB_REPOSITORY" "$GITHUB_SHA" "$BUILD_CORES" "$GITHUB_RUN_NUMBER"
+    docker stop $CONTAINER_NAME
   fi
 fi
 

src/ed25519-donna/CMakeLists.txt

@@ -0,0 +1,48 @@
+cmake_minimum_required(VERSION 3.11)
+
+project(ed25519
+  LANGUAGES C
+)
+
+if(PROJECT_NAME STREQUAL CMAKE_PROJECT_NAME)
+  set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/output/$<CONFIG>/lib")
+endif()
+
+if(NOT TARGET OpenSSL::SSL)
+  find_package(OpenSSL)
+endif()
+
+add_library(ed25519 STATIC
+  ed25519.c
+)
+add_library(ed25519::ed25519 ALIAS ed25519)
+target_link_libraries(ed25519 PUBLIC OpenSSL::SSL)
+
+include(GNUInstallDirs)
+
+#[=========================================================[
+   NOTE for macos:
+   https://github.com/floodyberry/ed25519-donna/issues/29
+   our source for ed25519-donna-portable.h has been
+   patched to workaround this.
+#]=========================================================]
+target_include_directories(ed25519 PUBLIC
+  $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+)
+
+install(
+  TARGETS ed25519
+  EXPORT ${PROJECT_NAME}-exports
+  ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+)
+install(
+  EXPORT ${PROJECT_NAME}-exports
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
+  FILE ${PROJECT_NAME}-targets.cmake
+  NAMESPACE ${PROJECT_NAME}::
+)
+install(
+  FILES ed25519.h
+  DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+)

src/magic/magic_enum.h

@@ -5,11 +5,11 @@
 // | |  | | (_| | (_| | | (__  | |____| | | | |_| | | | | | | | |____|_|   |_|
 // |_|  |_|\__,_|\__, |_|\___| |______|_| |_|\__,_|_| |_| |_|  \_____|
 //                __/ | https://github.com/Neargye/magic_enum
-//               |___/  version 0.9.3
+//               |___/  version 0.9.5
 //
 // Licensed under the MIT License <http://opensource.org/licenses/MIT>.
 // SPDX-License-Identifier: MIT
-// Copyright (c) 2019 - 2023 Daniil Goncharov <neargye@gmail.com>.
+// Copyright (c) 2019 - 2024 Daniil Goncharov <neargye@gmail.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
@@ -34,7 +34,7 @@
 
 #define MAGIC_ENUM_VERSION_MAJOR 0
 #define MAGIC_ENUM_VERSION_MINOR 9
-#define MAGIC_ENUM_VERSION_PATCH 3
+#define MAGIC_ENUM_VERSION_PATCH 5
 
 #include <array>
 #include <cstddef>
@@ -60,7 +60,7 @@
 
 #if defined(MAGIC_ENUM_NO_ASSERT)
 #  define MAGIC_ENUM_ASSERT(...) static_cast<void>(0)
-#else
+#elif !defined(MAGIC_ENUM_ASSERT)
 #  include <cassert>
 #  define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__))
 #endif
@@ -69,9 +69,11 @@
 #  pragma clang diagnostic push
 #  pragma clang diagnostic ignored "-Wunknown-warning-option"
 #  pragma clang diagnostic ignored "-Wenum-constexpr-conversion"
+#  pragma clang diagnostic ignored "-Wuseless-cast" // suppresses 'static_cast<char_type>('\0')' for char_type = char (common on Linux).
 #elif defined(__GNUC__)
 #  pragma GCC diagnostic push
 #  pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // May be used uninitialized 'return {};'.
+#  pragma GCC diagnostic ignored "-Wuseless-cast" // suppresses 'static_cast<char_type>('\0')' for char_type = char (common on Linux).
 #elif defined(_MSC_VER)
 #  pragma warning(push)
 #  pragma warning(disable : 26495) // Variable 'static_str<N>::chars_' is uninitialized.
@@ -164,14 +166,11 @@ namespace customize {
 // If need another range for specific enum type, add specialization enum_range for necessary enum type.
 template <typename E>
 struct enum_range {
-  static_assert(std::is_enum_v<E>, "magic_enum::customize::enum_range requires enum type.");
   static constexpr int min = MAGIC_ENUM_RANGE_MIN;
   static constexpr int max = MAGIC_ENUM_RANGE_MAX;
-  static_assert(max > min, "magic_enum::customize::enum_range requires max > min.");
 };
 
 static_assert(MAGIC_ENUM_RANGE_MAX > MAGIC_ENUM_RANGE_MIN, "MAGIC_ENUM_RANGE_MAX must be greater than MAGIC_ENUM_RANGE_MIN.");
-static_assert((MAGIC_ENUM_RANGE_MAX - MAGIC_ENUM_RANGE_MIN) < (std::numeric_limits<std::uint16_t>::max)(), "MAGIC_ENUM_RANGE must be less than UINT16_MAX.");
 
 namespace detail {
 
@@ -216,9 +215,9 @@ namespace detail {
 template <typename T>
 struct supported
 #if defined(MAGIC_ENUM_SUPPORTED) && MAGIC_ENUM_SUPPORTED || defined(MAGIC_ENUM_NO_CHECK_SUPPORT)
-    : std::true_type {};
+  : std::true_type {};
 #else
-    : std::false_type {};
+  : std::false_type {};
 #endif
 
 template <auto V, typename E = std::decay_t<decltype(V)>, std::enable_if_t<std::is_enum_v<E>, int> = 0>
@@ -423,10 +422,20 @@ constexpr auto n() noexcept {
     constexpr auto name_ptr = MAGIC_ENUM_GET_TYPE_NAME_BUILTIN(E);
     constexpr auto name = name_ptr ? str_view{name_ptr, std::char_traits<char>::length(name_ptr)} : str_view{};
 #elif defined(__clang__)
-    auto name = str_view{__PRETTY_FUNCTION__ + 34, sizeof(__PRETTY_FUNCTION__) - 36};
+    str_view name;
+    if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) {
+      static_assert(always_false_v<E>, "magic_enum::detail::n requires __PRETTY_FUNCTION__.");
+      return str_view{};
+    } else {
+      name.size_ = sizeof(__PRETTY_FUNCTION__) - 36;
+      name.str_ = __PRETTY_FUNCTION__ + 34;
+    }
 #elif defined(__GNUC__)
     auto name = str_view{__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1};
-    if (name.str_[name.size_ - 1] == ']') {
+    if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) {
+      static_assert(always_false_v<E>, "magic_enum::detail::n requires __PRETTY_FUNCTION__.");
+      return str_view{};
+    } else if (name.str_[name.size_ - 1] == ']') {
       name.size_ -= 50;
       name.str_ += 49;
     } else {
@@ -489,7 +498,14 @@ constexpr auto n() noexcept {
     constexpr auto name_ptr = MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V);
     auto name = name_ptr ? str_view{name_ptr, std::char_traits<char>::length(name_ptr)} : str_view{};
 #elif defined(__clang__)
-    auto name = str_view{__PRETTY_FUNCTION__ + 34, sizeof(__PRETTY_FUNCTION__) - 36};
+    str_view name;
+    if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) {
+      static_assert(always_false_v<decltype(V)>, "magic_enum::detail::n requires __PRETTY_FUNCTION__.");
+      return str_view{};
+    } else {
+      name.size_ = sizeof(__PRETTY_FUNCTION__) - 36;
+      name.str_ = __PRETTY_FUNCTION__ + 34;
+    }
     if (name.size_ > 22 && name.str_[0] == '(' && name.str_[1] == 'a' && name.str_[10] == ' ' && name.str_[22] == ':') {
       name.size_ -= 23;
       name.str_ += 23;
@@ -499,7 +515,10 @@ constexpr auto n() noexcept {
     }
 #elif defined(__GNUC__)
     auto name = str_view{__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1};
-    if (name.str_[name.size_ - 1] == ']') {
+    if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) {
+      static_assert(always_false_v<decltype(V)>, "magic_enum::detail::n requires __PRETTY_FUNCTION__.");
+      return str_view{};
+    } else if (name.str_[name.size_ - 1] == ']') {
       name.size_ -= 55;
       name.str_ += 54;
     } else {
@@ -698,7 +717,7 @@ constexpr void valid_count(bool* valid, std::size_t& count) noexcept {
     }                                                       \
   }
 
-  MAGIC_ENUM_FOR_EACH_256(MAGIC_ENUM_V);
+  MAGIC_ENUM_FOR_EACH_256(MAGIC_ENUM_V)
 
   if constexpr ((I + 256) < Size) {
     valid_count<E, S, Size, Min, I + 256>(valid, count);
@@ -750,7 +769,6 @@ constexpr auto values() noexcept {
   constexpr auto max = reflected_max<E, S>();
   constexpr auto range_size = max - min + 1;
   static_assert(range_size > 0, "magic_enum::enum_range requires valid size.");
-  static_assert(range_size < (std::numeric_limits<std::uint16_t>::max)(), "magic_enum::enum_range requires valid size.");
 
   return values<E, S, range_size, min>();
 }
@@ -807,7 +825,8 @@ inline constexpr auto max_v = (count_v<E, S> > 0) ? static_cast<U>(values_v<E, S
 
 template <typename E, enum_subtype S, std::size_t... I>
 constexpr auto names(std::index_sequence<I...>) noexcept {
-  return std::array<string_view, sizeof...(I)>{{enum_name_v<E, values_v<E, S>[I]>...}};
+  constexpr auto names = std::array<string_view, sizeof...(I)>{{enum_name_v<E, values_v<E, S>[I]>...}};
+  return names;
 }
 
 template <typename E, enum_subtype S>
@@ -818,7 +837,8 @@ using names_t = decltype((names_v<D, S>));
 
 template <typename E, enum_subtype S, std::size_t... I>
 constexpr auto entries(std::index_sequence<I...>) noexcept {
-  return std::array<std::pair<E, string_view>, sizeof...(I)>{{{values_v<E, S>[I], enum_name_v<E, values_v<E, S>[I]>}...}};
+  constexpr auto entries = std::array<std::pair<E, string_view>, sizeof...(I)>{{{values_v<E, S>[I], enum_name_v<E, values_v<E, S>[I]>}...}};
+  return entries;
 }
 
 template <typename E, enum_subtype S>
@@ -845,17 +865,16 @@ constexpr bool is_sparse() noexcept {
 template <typename E, enum_subtype S = subtype_v<E>>
 inline constexpr bool is_sparse_v = is_sparse<E, S>();
 
-template <typename E, enum_subtype S, typename U = std::underlying_type_t<E>>
-constexpr U values_ors() noexcept {
-  static_assert(S == enum_subtype::flags, "magic_enum::detail::values_ors requires valid subtype.");
+template <typename E, enum_subtype S>
+struct is_reflected
+#if defined(MAGIC_ENUM_NO_CHECK_REFLECTED_ENUM)
+  : std::true_type {};
+#else
+  : std::bool_constant<std::is_enum_v<E> && (count_v<E, S> != 0)> {};
+#endif
 
-  auto ors = U{0};
-  for (std::size_t i = 0; i < count_v<E, S>; ++i) {
-    ors |= static_cast<U>(values_v<E, S>[i]);
-  }
-
-  return ors;
-}
+template <typename E, enum_subtype S>
+inline constexpr bool is_reflected_v = is_reflected<std::decay_t<E>, S>{};
 
 template <bool, typename R>
 struct enable_if_enum {};
@@ -1156,6 +1175,7 @@ template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 [[nodiscard]] constexpr auto enum_value(std::size_t index) noexcept -> detail::enable_if_t<E, std::decay_t<E>> {
   using D = std::decay_t<E>;
+  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
   if constexpr (detail::is_sparse_v<D, S>) {
     return MAGIC_ENUM_ASSERT(index < detail::count_v<D, S>), detail::values_v<D, S>[index];
@@ -1170,6 +1190,7 @@ template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 template <typename E, std::size_t I, detail::enum_subtype S = detail::subtype_v<E>>
 [[nodiscard]] constexpr auto enum_value() noexcept -> detail::enable_if_t<E, std::decay_t<E>> {
   using D = std::decay_t<E>;
+  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
   static_assert(I < detail::count_v<D, S>, "magic_enum::enum_value out of range.");
 
   return enum_value<D, S>(I);
@@ -1178,7 +1199,10 @@ template <typename E, std::size_t I, detail::enum_subtype S = detail::subtype_v<
 // Returns std::array with enum values, sorted by enum value.
 template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 [[nodiscard]] constexpr auto enum_values() noexcept -> detail::enable_if_t<E, detail::values_t<E, S>> {
-  return detail::values_v<std::decay_t<E>, S>;
+  using D = std::decay_t<E>;
+  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
+
+  return detail::values_v<D, S>;
 }
 
 // Returns integer value from enum value.
@@ -1199,11 +1223,9 @@ template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 [[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t<E, optional<std::size_t>> {
   using D = std::decay_t<E>;
   using U = underlying_type_t<D>;
+  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
-  if constexpr (detail::count_v<D, S> == 0) {
-    static_cast<void>(value);
-    return {}; // Empty enum.
-  } else if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
+  if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
 #if defined(MAGIC_ENUM_ENABLE_HASH)
     return detail::constexpr_switch<&detail::values_v<D, S>, detail::case_call_t::index>(
         [](std::size_t i) { return optional<std::size_t>{i}; },
@@ -1231,14 +1253,17 @@ template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 template <detail::enum_subtype S, typename E>
 [[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t<E, optional<std::size_t>> {
   using D = std::decay_t<E>;
+  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
   return enum_index<D, S>(value);
 }
 
 // Obtains index in enum values from static storage enum variable.
 template <auto V, detail::enum_subtype S = detail::subtype_v<std::decay_t<decltype(V)>>>
-[[nodiscard]] constexpr auto enum_index() noexcept -> detail::enable_if_t<decltype(V), std::size_t> {
-  constexpr auto index = enum_index<std::decay_t<decltype(V)>, S>(V);
+[[nodiscard]] constexpr auto enum_index() noexcept -> detail::enable_if_t<decltype(V), std::size_t> {\
+  using D = std::decay_t<decltype(V)>;
+  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
+  constexpr auto index = enum_index<D, S>(V);
   static_assert(index, "magic_enum::enum_index enum value does not have a index.");
 
   return *index;
@@ -1259,6 +1284,7 @@ template <auto V>
 template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 [[nodiscard]] constexpr auto enum_name(E value) noexcept -> detail::enable_if_t<E, string_view> {
   using D = std::decay_t<E>;
+  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
   if (const auto i = enum_index<D, S>(value)) {
     return detail::names_v<D, S>[*i];
@@ -1271,6 +1297,7 @@ template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 template <detail::enum_subtype S, typename E>
 [[nodiscard]] constexpr auto enum_name(E value) -> detail::enable_if_t<E, string_view> {
   using D = std::decay_t<E>;
+  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
   return enum_name<D, S>(value);
 }
@@ -1278,13 +1305,19 @@ template <detail::enum_subtype S, typename E>
 // Returns std::array with names, sorted by enum value.
 template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 [[nodiscard]] constexpr auto enum_names() noexcept -> detail::enable_if_t<E, detail::names_t<E, S>> {
-  return detail::names_v<std::decay_t<E>, S>;
+  using D = std::decay_t<E>;
+  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
+
+  return detail::names_v<D, S>;
 }
 
 // Returns std::array with pairs (value, name), sorted by enum value.
 template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 [[nodiscard]] constexpr auto enum_entries() noexcept -> detail::enable_if_t<E, detail::entries_t<E, S>> {
-  return detail::entries_v<std::decay_t<E>, S>;
+  using D = std::decay_t<E>;
+  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
+
+  return detail::entries_v<D, S>;
 }
 
 // Allows you to write magic_enum::enum_cast<foo>("bar", magic_enum::case_insensitive);
@@ -1295,31 +1328,27 @@ inline constexpr auto case_insensitive = detail::case_insensitive<>{};
 template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 [[nodiscard]] constexpr auto enum_cast(underlying_type_t<E> value) noexcept -> detail::enable_if_t<E, optional<std::decay_t<E>>> {
   using D = std::decay_t<E>;
+  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
-  if constexpr (detail::count_v<D, S> == 0) {
-    static_cast<void>(value);
-    return {}; // Empty enum.
-  } else {
-    if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
+  if constexpr (detail::is_sparse_v<D, S> || (S == detail::enum_subtype::flags)) {
 #if defined(MAGIC_ENUM_ENABLE_HASH)
-      return detail::constexpr_switch<&detail::values_v<D, S>, detail::case_call_t::value>(
-          [](D v) { return optional<D>{v}; },
-          static_cast<D>(value),
-          detail::default_result_type_lambda<optional<D>>);
+    return detail::constexpr_switch<&detail::values_v<D, S>, detail::case_call_t::value>(
+        [](D v) { return optional<D>{v}; },
+        static_cast<D>(value),
+        detail::default_result_type_lambda<optional<D>>);
 #else
-      for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
-        if (value == static_cast<underlying_type_t<D>>(enum_value<D, S>(i))) {
-          return static_cast<D>(value);
-        }
-      }
-      return {}; // Invalid value or out of range.
-#endif
-    } else {
-      if (value >= detail::min_v<D, S> && value <= detail::max_v<D, S>) {
+    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
+      if (value == static_cast<underlying_type_t<D>>(enum_value<D, S>(i))) {
         return static_cast<D>(value);
       }
-      return {}; // Invalid value or out of range.
     }
+    return {}; // Invalid value or out of range.
+#endif
+  } else {
+    if (value >= detail::min_v<D, S> && value <= detail::max_v<D, S>) {
+      return static_cast<D>(value);
+    }
+    return {}; // Invalid value or out of range.
   }
 }
 
@@ -1328,26 +1357,23 @@ template <typename E, detail::enum_subtype S = detail::subtype_v<E>>
 template <typename E, detail::enum_subtype S = detail::subtype_v<E>, typename BinaryPredicate = std::equal_to<>>
 [[nodiscard]] constexpr auto enum_cast(string_view value, [[maybe_unused]] BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable<BinaryPredicate>()) -> detail::enable_if_t<E, optional<std::decay_t<E>>, BinaryPredicate> {
   using D = std::decay_t<E>;
+  static_assert(detail::is_reflected_v<D, S>, "magic_enum requires enum implementation and valid max and min.");
 
-  if constexpr (detail::count_v<D, S> == 0) {
-    static_cast<void>(value);
-    return {}; // Empty enum.
 #if defined(MAGIC_ENUM_ENABLE_HASH)
-    } else if constexpr (detail::is_default_predicate<BinaryPredicate>()) {
-      return detail::constexpr_switch<&detail::names_v<D, S>, detail::case_call_t::index>(
-          [](std::size_t i) { return optional<D>{detail::values_v<D, S>[i]}; },
-          value,
-          detail::default_result_type_lambda<optional<D>>,
-          [&p](string_view lhs, string_view rhs) { return detail::cmp_equal(lhs, rhs, p); });
-#endif
-    } else {
-    for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
-      if (detail::cmp_equal(value, detail::names_v<D, S>[i], p)) {
-        return enum_value<D, S>(i);
-      }
-    }
-    return {}; // Invalid value or out of range.
+  if constexpr (detail::is_default_predicate<BinaryPredicate>()) {
+    return detail::constexpr_switch<&detail::names_v<D, S>, detail::case_call_t::index>(
+        [](std::size_t i) { return optional<D>{detail::values_v<D, S>[i]}; },
+        value,
+        detail::default_result_type_lambda<optional<D>>,
+        [&p](string_view lhs, string_view rhs) { return detail::cmp_equal(lhs, rhs, p); });
   }
+#endif
+  for (std::size_t i = 0; i < detail::count_v<D, S>; ++i) {
+    if (detail::cmp_equal(value, detail::names_v<D, S>[i], p)) {
+      return enum_value<D, S>(i);
+    }
+  }
+  return {}; // Invalid value or out of range.
 }
 
 // Checks whether enum contains value with such value.

src/quickjs/buffer-utils.c

@@ -0,0 +1,820 @@
+#include "defines.h"
+#include "char-utils.h"
+#include "buffer-utils.h"
+#include "utils.h"
+#ifdef _WIN32
+#include <windows.h>
+#elif defined(HAVE_TERMIOS_H)
+#include <termios.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#endif
+#include "debug.h"
+
+/**
+ * \addtogroup buffer-utils
+ * @{
+ */
+size_t
+ansi_length(const char* str, size_t len) {
+  size_t i, n = 0, p;
+  for(i = 0; i < len;) {
+    if(str[i] == 0x1b && (p = ansi_skip(&str[i], len - i)) > 0) {
+      i += p;
+      continue;
+    }
+    n++;
+    i++;
+  }
+  return n;
+}
+
+size_t
+ansi_skip(const char* str, size_t len) {
+  size_t pos = 0;
+  if(str[pos] == 0x1b) {
+    if(++pos < len && str[pos] == '[') {
+      while(++pos < len)
+        if(is_alphanumeric_char(str[pos]))
+          break;
+      if(++pos < len && str[pos] == '~')
+        ++pos;
+      return pos;
+    }
+  }
+  return 0;
+}
+
+size_t
+ansi_truncate(const char* str, size_t len, size_t limit) {
+  size_t i, n = 0, p;
+  for(i = 0; i < len;) {
+    if((p = ansi_skip(&str[i], len - i)) > 0) {
+      i += p;
+      continue;
+    }
+    n += is_escape_char(str[i]) ? 2 : 1;
+
+    i++;
+    if(n > limit)
+      break;
+  }
+  return i;
+}
+
+int64_t
+array_search(void* a, size_t m, size_t elsz, void* needle) {
+  char* ptr = a;
+  int64_t n, ret;
+  n = m / elsz;
+  for(ret = 0; ret < n; ret++) {
+    if(!memcmp(ptr, needle, elsz))
+      return ret;
+
+    ptr += elsz;
+  }
+  return -1;
+}
+
+char*
+str_escape(const char* s) {
+  DynBuf dbuf;
+  dbuf_init2(&dbuf, 0, 0);
+  dbuf_put_escaped(&dbuf, s, strlen(s));
+  dbuf_0(&dbuf);
+  return (char*)dbuf.buf;
+}
+
+char*
+byte_escape(const void* s, size_t n) {
+  DynBuf dbuf;
+  dbuf_init2(&dbuf, 0, 0);
+  dbuf_put_escaped(&dbuf, s, n);
+  dbuf_0(&dbuf);
+  return (char*)dbuf.buf;
+}
+
+size_t
+byte_findb(const void* haystack, size_t hlen, const void* what, size_t wlen) {
+  size_t i, last;
+  const char* s = (const char*)haystack;
+  if(hlen < wlen)
+    return hlen;
+  last = hlen - wlen;
+  for(i = 0; i <= last; i++) {
+    if(byte_equal(s, wlen, what))
+      return i;
+    s++;
+  }
+  return hlen;
+}
+
+size_t
+byte_finds(const void* haystack, size_t hlen, const char* what) {
+  return byte_findb(haystack, hlen, what, strlen(what));
+}
+
+size_t
+byte_equal(const void* s, size_t n, const void* t) {
+  return memcmp(s, t, n) == 0;
+}
+
+void
+byte_copy(void* out, size_t len, const void* in) {
+  char* s = (char*)out;
+  const char* t = (const char*)in;
+  size_t i;
+  for(i = 0; i < len; ++i)
+    s[i] = t[i];
+}
+
+void
+byte_copyr(void* out, size_t len, const void* in) {
+  char* s = (char*)out + len;
+  const char* t = (const char*)in;
+  const char* u = t + len;
+
+  for(;;) {
+    if(t >= u)
+      break;
+    --u;
+    --s;
+    *s = *u;
+  }
+}
+
+size_t
+byte_rchrs(const char* in, size_t len, const char needles[], size_t nn) {
+  const char *s = in, *end = in + len, *found = 0;
+  size_t i;
+  for(; s < end; s++) {
+    for(i = 0; i < nn; ++i) {
+      if(*s == needles[i])
+        found = s;
+    }
+  }
+  return (size_t)((found ? found : s) - in);
+}
+
+char*
+dbuf_at_n(const DynBuf* db, size_t i, size_t* n, char sep) {
+  size_t p, l = 0;
+  for(p = 0; p < db->size; ++p) {
+    if(l == i) {
+      *n = byte_chr((const char*)&db->buf[p], db->size - p, sep);
+      return (char*)&db->buf[p];
+    }
+    if(db->buf[p] == sep)
+      ++l;
+  }
+  *n = 0;
+  return 0;
+}
+
+const char*
+dbuf_last_line(DynBuf* db, size_t* len) {
+  size_t i;
+
+  if((i = byte_rchr(db->buf, db->size, '\n')) < db->size)
+    i++;
+  else
+    i = 0;
+
+  if(len)
+    *len = db->size - i;
+
+  return (const char*)&db->buf[i];
+}
+
+int
+dbuf_prepend(DynBuf* s, const uint8_t* data, size_t len) {
+  int ret;
+  if(!(ret = dbuf_reserve_start(s, len)))
+    memcpy(s->buf, data, len);
+
+  return 0;
+}
+
+void
+dbuf_put_colorstr(DynBuf* db, const char* str, const char* color, int with_color) {
+  if(with_color)
+    dbuf_putstr(db, color);
+
+  dbuf_putstr(db, str);
+  if(with_color)
+    dbuf_putstr(db, COLOR_NONE);
+}
+
+void
+dbuf_put_escaped_pred(DynBuf* db, const char* str, size_t len, int (*pred)(int)) {
+  size_t i = 0, j;
+  char c;
+
+  while(i < len) {
+    if((j = predicate_find(&str[i], len - i, pred))) {
+      dbuf_append(db, (const uint8_t*)&str[i], j);
+      i += j;
+    }
+
+    if(i == len)
+      break;
+
+    dbuf_putc(db, '\\');
+
+    if(str[i] == 0x1b) {
+      dbuf_append(db, (const uint8_t*)"x1b", 3);
+    } else {
+      int r = pred(str[i]);
+
+      dbuf_putc(db, (r > 1 && r <= 127) ? r : (c = escape_char_letter(str[i])) ? c : str[i]);
+
+      if(r == 'u' || r == 'x')
+        dbuf_printf(db, r == 'u' ? "%04x" : "%02x", str[i]);
+    }
+
+    i++;
+  }
+}
+
+const uint8_t escape_url_tab[256] = {
+    '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%',  '%', '%', '%',
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   '%',
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
+    '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%',  '%', '%', '%',
+};
+
+const uint8_t escape_noquote_tab[256] = {
+    'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
+    'x', 'x', 'x', 'x', 0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u',  'u',  'u',  'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+};
+
+const uint8_t escape_singlequote_tab[256] = {
+    'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
+    'x', 'x', 'x', 'x', 0,   0,   0,   0,   0,    0,    0,    0x27, 0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u',  'u',  'u',  'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+};
+
+const uint8_t escape_doublequote_tab[256] = {
+    'x', 'x', 'x', 'x', 'x', 'x', 'x',  'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
+
+    'x', 'x', 'x', 'x', 0,   0,   0x22, 0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,    0,   0x5c, 0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u', 'u',  'u',  'u',  'u',  'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+};
+
+const uint8_t escape_backquote_tab[256] = {
+    'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 0x62, 0x74, 0,   0x76, 0x66, 0,   'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
+    'x', 'x', 'x', 'x', 0,   0,   0,   0,   0x24, 0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,    0,   0,    0x60, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u',  'u', 'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+};
+
+void
+dbuf_put_escaped_table(DynBuf* db, const char* str, size_t len, const uint8_t table[256]) {
+  size_t i = 0, clen;
+  int32_t c;
+  const uint8_t *pos, *end, *next;
+
+  for(pos = (const uint8_t*)str, end = pos + len; pos < end; pos = next) {
+    uint8_t r, ch;
+
+    if((c = unicode_from_utf8(pos, end - pos, &next)) < 0)
+      break;
+    clen = next - pos;
+    ch = c;
+    r = (clen >= 2 || c > 0xff) ? 'u' : table[c];
+
+    if(r == 'u' && clen > 1 && (c & 0xffffff00) == 0) {
+      r = 'x';
+      // ch = c >> 8;
+    }
+
+    if(r == '%') {
+      static const char hexdigits[] = "0123456789ABCDEF";
+
+      dbuf_putc(db, '%');
+      dbuf_putc(db, hexdigits[c >> 4]);
+      dbuf_putc(db, hexdigits[c & 0xf]);
+    } else if(c == 0x1b) {
+      dbuf_putstr(db, "\\x1b");
+    } else if(r == 'u') {
+      dbuf_printf(db, c > 0xffff ? "\\u{%X}" : "\\u%04x", c);
+    } else if(r == 'x') {
+      dbuf_printf(db, "\\x%02x", ch);
+    } else if(r) {
+      dbuf_putc(db, '\\');
+      dbuf_putc(db, (r > 1 && r <= 127) ? r : (c = escape_char_letter(ch)) ? c : ch);
+    } else {
+      dbuf_put(db, pos, next - pos);
+    }
+
+    i++;
+  }
+}
+
+void
+dbuf_put_unescaped_pred(DynBuf* db, const char* str, size_t len, int (*pred)(const char*, size_t*)) {
+  size_t i = 0, j;
+  // char c;
+
+  while(i < len) {
+    int r = 0;
+    if((j = byte_chr(&str[i], len - i, '\\'))) {
+      dbuf_append(db, (const uint8_t*)&str[i], j);
+      i += j;
+    }
+    if(i == len)
+      break;
+    size_t n = 1;
+
+    if(pred) {
+      r = pred(&str[i + 1], &n);
+
+      if(!r && n == 1)
+        dbuf_putc(db, '\\');
+    }
+
+    if(r >= 0)
+      dbuf_putc(db, /*n > 1 ||*/ r ? /*(r > 1 && r < 256) ?*/ r : str[i]);
+    i += n;
+  }
+}
+
+static inline int
+hexdigit(char c) {
+  if(c >= '0' && c <= '9')
+    return c - '0';
+
+  if(c >= 'a' && c <= 'f')
+    c -= 32;
+
+  if(c >= 'A' && c <= 'F')
+    return c - 'A' + 10;
+
+  return -1;
+}
+
+void
+dbuf_put_unescaped_table(DynBuf* db, const char* str, size_t len, const uint8_t table[256]) {
+  size_t i = 0, j;
+  char escape_char = table == escape_url_tab ? '%' : '\\';
+
+  while(i < len) {
+    if((j = byte_chr(&str[i], len - i, escape_char))) {
+      dbuf_append(db, (const uint8_t*)&str[i], j);
+      i += j;
+    }
+
+    if(i == len)
+      break;
+
+    if(escape_char == '%') {
+      int hi = hexdigit(str[i + 1]), lo = hexdigit(str[i + 2]);
+      uint8_t c = (hi << 4) | (lo & 0xf);
+      dbuf_putc(db, c);
+
+      i += 2;
+
+    } else {
+      ++i;
+
+      uint8_t c;
+
+      switch(str[i]) {
+        case 'b': c = '\b'; break;
+        case 't': c = '\t'; break;
+        case 'n': c = '\n'; break;
+        case 'v': c = '\v'; break;
+        case 'f': c = '\f'; break;
+        case 'r': c = '\r'; break;
+        default: c = str[i]; break;
+      }
+
+      uint8_t r = table[c];
+
+      if(!(r && r != 'x' && r != 'u')) {
+        dbuf_putc(db, '\\');
+        dbuf_putc(db, c);
+      } else {
+        dbuf_putc(db, str[i] == r ? c : r);
+      }
+    }
+
+    ++i;
+  }
+}
+
+void
+dbuf_put_escaped(DynBuf* db, const char* str, size_t len) {
+  return dbuf_put_escaped_table(db, str, len, escape_noquote_tab);
+}
+
+void
+dbuf_put_value(DynBuf* db, JSContext* ctx, JSValueConst value) {
+  const char* str;
+  size_t len;
+  str = JS_ToCStringLen(ctx, &len, value);
+  dbuf_append(db, str, len);
+  JS_FreeCString(ctx, str);
+}
+
+void
+dbuf_put_uint32(DynBuf* db, uint32_t num) {
+  char buf[FMT_ULONG];
+  dbuf_put(db, (const uint8_t*)buf, fmt_ulong(buf, num));
+}
+
+void
+dbuf_put_atom(DynBuf* db, JSContext* ctx, JSAtom atom) {
+  const char* str;
+  str = JS_AtomToCString(ctx, atom);
+  dbuf_putstr(db, str);
+  JS_FreeCString(ctx, str);
+}
+
+int
+dbuf_reserve_start(DynBuf* s, size_t len) {
+  if(unlikely((s->size + len) > s->allocated_size)) {
+    if(dbuf_realloc(s, s->size + len))
+      return -1;
+  }
+  if(s->size > 0)
+    memcpy(s->buf + len, s->buf, s->size);
+
+  s->size += len;
+  return 0;
+}
+
+uint8_t*
+dbuf_reserve(DynBuf* s, size_t len) {
+  if(unlikely((s->size + len) > s->allocated_size))
+    if(dbuf_realloc(s, s->size + len))
+      return 0;
+
+  return &s->buf[s->size];
+}
+
+size_t
+dbuf_token_pop(DynBuf* db, char delim) {
+  size_t n, p, len;
+  len = db->size;
+  for(n = db->size; n > 0;) {
+    if((p = byte_rchr(db->buf, n, delim)) == n) {
+      db->size = 0;
+      break;
+    }
+    if(p > 0 && db->buf[p - 1] == '\\') {
+      n = p - 1;
+      continue;
+    }
+    db->size = p;
+    break;
+  }
+  return len - db->size;
+}
+
+size_t
+dbuf_token_push(DynBuf* db, const char* str, size_t len, char delim) {
+  size_t pos;
+  if(db->size)
+    dbuf_putc(db, delim);
+
+  pos = db->size;
+  dbuf_put_escaped_pred(db, str, len, is_dot_char);
+  return db->size - pos;
+}
+
+JSValue
+dbuf_tostring_free(DynBuf* s, JSContext* ctx) {
+  JSValue r;
+  r = JS_NewStringLen(ctx, s->buf ? (const char*)s->buf : "", s->buf ? s->size : 0);
+  dbuf_free(s);
+  return r;
+}
+
+ssize_t
+dbuf_load(DynBuf* s, const char* filename) {
+  FILE* fp;
+  size_t nbytes = 0;
+  if((fp = fopen(filename, "rb"))) {
+    char buf[4096];
+    size_t r;
+    while(!feof(fp)) {
+      if((r = fread(buf, 1, sizeof(buf), fp)) == 0) {
+        fclose(fp);
+        return -1;
+      }
+      dbuf_put(s, (uint8_t const*)buf, r);
+      nbytes += r;
+    }
+    fclose(fp);
+  }
+  return nbytes;
+}
+
+int
+dbuf_vprintf(DynBuf* s, const char* fmt, va_list ap) {
+
+  s->size += vsnprintf((char*)(s->buf + s->size), s->allocated_size - s->size, fmt, ap);
+
+  return 0;
+}
+
+InputBuffer
+js_input_buffer(JSContext* ctx, JSValueConst value) {
+  InputBuffer ret = {{{0, 0}}, 0, &input_buffer_free_default, JS_UNDEFINED, {0, INT64_MAX}};
+
+  if(js_is_typedarray(ctx, value)) {
+    ret.value = offset_typedarray(&ret.range, value, ctx);
+  } else if(js_is_arraybuffer(ctx, value) || js_is_sharedarraybuffer(ctx, value)) {
+    ret.value = JS_DupValue(ctx, value);
+  }
+
+  if(js_is_arraybuffer(ctx, ret.value) || js_is_sharedarraybuffer(ctx, ret.value)) {
+    block_arraybuffer(&ret.block, ret.value, ctx);
+  } else {
+    JS_ThrowTypeError(ctx, "Invalid type (%s) for input buffer", js_value_typestr(ctx, ret.value));
+    JS_FreeValue(ctx, ret.value);
+    ret.value = JS_EXCEPTION;
+  }
+
+  return ret;
+}
+
+#undef free
+
+InputBuffer
+js_input_chars(JSContext* ctx, JSValueConst value) {
+  InputBuffer ret = {{{0, 0}}, 0, &input_buffer_free_default, JS_UNDEFINED, OFFSET_INIT()};
+
+  if(JS_IsString(value)) {
+    ret.data = (uint8_t*)JS_ToCStringLen(ctx, &ret.size, value);
+    ret.value = JS_DupValue(ctx, value);
+    ret.free = &input_buffer_free_default;
+  } else {
+    ret = js_input_buffer(ctx, value);
+  }
+
+  return ret;
+}
+
+InputBuffer
+js_input_args(JSContext* ctx, int argc, JSValueConst argv[]) {
+  InputBuffer input = js_input_chars(ctx, argv[0]);
+
+  if(argc > 1)
+    js_offset_length(ctx, input.size, argc - 1, argv + 1, &input.range);
+
+  return input;
+}
+
+InputBuffer
+js_output_args(JSContext* ctx, int argc, JSValueConst argv[]) {
+  InputBuffer output = js_input_buffer(ctx, argv[0]);
+
+  if(argc > 1)
+    js_offset_length(ctx, output.size, argc - 1, argv + 1, &output.range);
+
+  return output;
+}
+
+BOOL
+input_buffer_valid(const InputBuffer* in) {
+  return !JS_IsException(in->value);
+}
+
+InputBuffer
+input_buffer_clone(const InputBuffer* in, JSContext* ctx) {
+  InputBuffer ret = js_input_buffer(ctx, in->value);
+
+  ret.pos = in->pos;
+  ret.size = in->size;
+  ret.free = in->free;
+
+  return ret;
+}
+
+void
+input_buffer_dump(const InputBuffer* in, DynBuf* db) {
+  dbuf_printf(db, "(InputBuffer){ .data = %p, .size = %lu, .pos = %lu, .free = %p }", in->data, (unsigned long)in->size, (unsigned long)in->pos, in->free);
+}
+
+void
+input_buffer_free(InputBuffer* in, JSContext* ctx) {
+  if(in->data) {
+    in->free(ctx, (const char*)in->data, in->value);
+    in->data = 0;
+    in->size = 0;
+    in->pos = 0;
+    in->value = JS_UNDEFINED;
+  }
+}
+
+const uint8_t*
+input_buffer_peek(InputBuffer* in, size_t* lenp) {
+  input_buffer_peekc(in, lenp);
+  return input_buffer_data(in) + in->pos;
+}
+
+const uint8_t*
+input_buffer_get(InputBuffer* in, size_t* lenp) {
+  const uint8_t* ret = input_buffer_peek(in, lenp);
+
+  in->pos += *lenp;
+
+  return ret;
+}
+
+const char*
+input_buffer_currentline(InputBuffer* in, size_t* len) {
+  size_t i;
+
+  if((i = byte_rchr(input_buffer_data(in), in->pos, '\n')) < in->pos)
+    i++;
+
+  if(len)
+    *len = in->pos - i;
+
+  return (const char*)&input_buffer_data(in)[i];
+}
+
+size_t
+input_buffer_column(InputBuffer* in, size_t* len) {
+  size_t i;
+
+  if((i = byte_rchr(input_buffer_data(in), in->pos, '\n')) < in->pos)
+    i++;
+
+  return in->pos - i;
+}
+
+int
+js_offset_length(JSContext* ctx, int64_t size, int argc, JSValueConst argv[], OffsetLength* off_len_p) {
+  int ret = 0;
+  int64_t off = 0, len = size;
+
+  if(argc >= 1 && JS_IsNumber(argv[0])) {
+    if(!JS_ToInt64(ctx, &off, argv[0]))
+      ret = 1;
+
+    if(argc >= 2 && JS_IsNumber(argv[1]))
+      if(!JS_ToInt64(ctx, &len, argv[1]))
+        ret = 2;
+
+    if(size && off != size)
+      off = ((off % size) + size) % size;
+
+    if(len >= 0)
+      len = MIN_NUM(len, size - off);
+    else
+      len = size - off;
+
+    if(off_len_p) {
+      off_len_p->offset = off;
+      off_len_p->length = len;
+    }
+  }
+
+  return ret;
+}
+
+int
+js_index_range(JSContext* ctx, int64_t size, int argc, JSValueConst argv[], IndexRange* idx_rng_p) {
+  int ret = 0;
+  int64_t start = 0, end = size;
+
+  if(argc >= 1 && JS_IsNumber(argv[0])) {
+    if(!JS_ToInt64(ctx, &start, argv[0]))
+      ret = 1;
+
+    if(argc >= 2 && JS_IsNumber(argv[1]))
+      if(!JS_ToInt64(ctx, &end, argv[1]))
+        ret = 2;
+
+    if(size > 0) {
+      start = ((start % size) + size) % size;
+      end = ((end % size) + size) % size;
+    }
+
+    if(end > size)
+      end = size;
+
+    if(idx_rng_p) {
+      idx_rng_p->start = start;
+      idx_rng_p->end = end;
+    }
+  }
+
+  return ret;
+}
+
+int
+screen_size(int size[2]) {
+#ifdef _WIN32
+  CONSOLE_SCREEN_BUFFER_INFO csbi;
+
+  GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
+  size[0] = csbi.srWindow.Right - csbi.srWindow.Left + 1;
+  size[1] = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
+  return 0;
+
+#elif defined(HAVE_TERMIOS_H)
+  {
+    struct winsize w = {.ws_col = -1, .ws_row = -1};
+
+    if(isatty(STDIN_FILENO))
+      ioctl(STDIN_FILENO, TIOCGWINSZ, &w);
+    else if(isatty(STDOUT_FILENO))
+      ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
+    else if(isatty(STDERR_FILENO))
+      ioctl(STDERR_FILENO, TIOCGWINSZ, &w);
+
+    size[0] = w.ws_col;
+    size[1] = w.ws_row;
+    return 0;
+  }
+#else
+  size[0] = 80;
+  size[1] = 25;
+  return 0;
+#endif
+  return -1;
+}
+
+#undef js_realloc_rt
+void
+js_dbuf_allocator(JSContext* ctx, DynBuf* s) {
+  dbuf_init2(s, JS_GetRuntime(ctx), (DynBufReallocFunc*)js_realloc_rt);
+}
+
+inline int
+input_buffer_peekc(InputBuffer* in, size_t* lenp) {
+  const uint8_t *pos, *end, *next;
+  int cp;
+  pos = input_buffer_data(in) + in->pos;
+  end = input_buffer_data(in) + input_buffer_length(in);
+  cp = unicode_from_utf8(pos, end - pos, &next);
+
+  *lenp = next - pos;
+
+  return cp;
+}
+
+inline int
+input_buffer_putc(InputBuffer* in, unsigned int c, JSContext* ctx) {
+  int len;
+
+  if(in->pos + UTF8_CHAR_LEN_MAX > in->size)
+    if(block_realloc(&in->block, in->pos + UTF8_CHAR_LEN_MAX, ctx))
+      return -1;
+
+  len = unicode_to_utf8(&in->data[in->pos], c);
+
+  in->pos += len;
+
+  return len;
+}
+
+size_t
+dbuf_bitflags(DynBuf* db, uint32_t bits, const char* const names[]) {
+  size_t i, n = 0;
+  for(i = 0; i < sizeof(bits) * 8; i++) {
+    if(bits & (1 << i)) {
+      size_t len = strlen(names[i]);
+      if(n) {
+        n++;
+        dbuf_putstr(db, "|");
+      }
+      dbuf_append(db, names[i], len);
+      n += len;
+    }
+  }
+  return n;
+}
+
+/**
+ * @}
+ */

src/quickjs/buffer-utils.h

@@ -0,0 +1,348 @@
+#ifndef BUFFER_UTILS_H
+#define BUFFER_UTILS_H
+
+#include <quickjs.h>
+#include <cutils.h>
+#include <stdarg.h>
+
+#include "char-utils.h"
+
+/**
+ * \defgroup buffer-utils buffer-utils: Buffer Utilities
+ * @{
+ */
+int64_t array_search(void* a, size_t m, size_t elsz, void* needle);
+#define array_contains(a, m, elsz, needle) (array_search((a), (m), (elsz), (needle)) != -1)
+
+size_t ansi_length(const char*, size_t);
+size_t ansi_skip(const char*, size_t);
+size_t ansi_truncate(const char*, size_t, size_t limit);
+int64_t array_search(void*, size_t, size_t elsz, void* needle);
+char* str_escape(const char*);
+
+char* byte_escape(const void*, size_t);
+size_t byte_findb(const void*, size_t, const void* what, size_t wlen);
+size_t byte_finds(const void*, size_t, const char* what);
+size_t byte_equal(const void* s, size_t n, const void* t);
+void byte_copy(void* out, size_t len, const void* in);
+void byte_copyr(void* out, size_t len, const void* in);
+size_t byte_rchrs(const char* in, size_t len, const char needles[], size_t nn);
+
+#define DBUF_INIT_0() \
+  (DynBuf) { 0, 0, 0, 0, 0, 0 }
+#define DBUF_INIT_CTX(ctx) \
+  (DynBuf) { 0, 0, 0, 0, (DynBufReallocFunc*)js_realloc_rt, JS_GetRuntime(ctx) }
+
+extern const uint8_t escape_url_tab[256], escape_noquote_tab[256], escape_singlequote_tab[256], escape_doublequote_tab[256], escape_backquote_tab[256];
+
+char* dbuf_at_n(const DynBuf*, size_t, size_t* n, char sep);
+const char* dbuf_last_line(DynBuf*, size_t*);
+int dbuf_prepend(DynBuf*, const uint8_t*, size_t len);
+void dbuf_put_colorstr(DynBuf*, const char*, const char* color, int with_color);
+void dbuf_put_escaped_pred(DynBuf*, const char*, size_t len, int (*pred)(int));
+void dbuf_put_escaped_table(DynBuf*, const char*, size_t len, const uint8_t table[256]);
+void dbuf_put_unescaped_table(DynBuf* db, const char* str, size_t len, const uint8_t table[256]);
+void dbuf_put_unescaped_pred(DynBuf*, const char*, size_t len, int (*pred)());
+void dbuf_put_escaped(DynBuf*, const char*, size_t len);
+void dbuf_put_value(DynBuf*, JSContext*, JSValue value);
+void dbuf_put_uint32(DynBuf* db, uint32_t num);
+void dbuf_put_atom(DynBuf* db, JSContext* ctx, JSAtom atom);
+int dbuf_reserve_start(DynBuf*, size_t);
+uint8_t* dbuf_reserve(DynBuf*, size_t);
+size_t dbuf_token_pop(DynBuf*, char);
+size_t dbuf_token_push(DynBuf*, const char*, size_t len, char delim);
+JSValue dbuf_tostring_free(DynBuf*, JSContext*);
+ssize_t dbuf_load(DynBuf*, const char*);
+int dbuf_vprintf(DynBuf*, const char*, va_list);
+
+int screen_size(int size[2]);
+
+static inline int
+dbuf_putm(DynBuf* db, ...) {
+  int r = 0;
+  va_list a;
+  const char* s;
+  va_start(a, db);
+  while((s = va_arg(a, char*)))
+    if(dbuf_putstr(db, s))
+      return -1;
+  va_end(a);
+  return r;
+}
+
+#define dbuf_append(d, x, n) dbuf_put((d), (const uint8_t*)(x), (n))
+
+static inline size_t
+dbuf_count(DynBuf* db, int ch) {
+  return byte_count(db->buf, db->size, ch);
+}
+
+static inline void
+dbuf_0(DynBuf* db) {
+  dbuf_putc(db, '\0');
+  db->size--;
+}
+
+static inline void
+dbuf_zero(DynBuf* db) {
+  dbuf_realloc(db, 0);
+  db->size = 0;
+}
+
+size_t dbuf_bitflags(DynBuf* db, uint32_t bits, const char* const names[]);
+
+#define js_dbuf_init(ctx, buf) dbuf_init2((buf), (ctx), (realloc_func*)&utils_js_realloc)
+#define js_dbuf_init_rt(rt, buf) dbuf_init2((buf), (rt), (realloc_func*)&utils_js_realloc_rt)
+
+void js_dbuf_allocator(JSContext* ctx, DynBuf* s);
+
+typedef struct {
+  uint8_t* base;
+  size_t size;
+} MemoryBlock;
+
+static inline void
+block_init(MemoryBlock* mb) {
+  mb->base = 0;
+  mb->size = 0;
+}
+
+/* clang-format off */
+static inline void* block_data(const MemoryBlock* mb) { return mb->base; }
+static inline size_t block_length(const MemoryBlock* mb) { return mb->size; }
+static inline void* block_begin(const MemoryBlock* mb) { return mb->base; }
+static inline void* block_end(const MemoryBlock* mb) { return mb->base + mb->size; }
+/* clang-format on */
+
+static inline BOOL
+block_arraybuffer(MemoryBlock* mb, JSValueConst ab, JSContext* ctx) {
+  mb->base = JS_GetArrayBuffer(ctx, &mb->size, ab);
+  return mb->base != 0;
+}
+
+typedef struct {
+  uint8_t *start, *end;
+} PointerRange;
+
+static inline void
+range_init(PointerRange* pr) {
+  pr->end = pr->start = 0;
+}
+
+static inline PointerRange
+range_from(const MemoryBlock* mb) {
+  return (PointerRange){mb->base, mb->base + mb->size};
+}
+
+typedef struct {
+  int64_t start, end;
+} IndexRange;
+
+typedef struct {
+  int64_t offset, length;
+} OffsetLength;
+
+#define OFFSET_INIT() \
+  (OffsetLength) { 0, INT64_MAX }
+
+static inline void
+offset_init(OffsetLength* ol) {
+  ol->offset = 0;
+  ol->length = INT64_MAX;
+}
+
+static inline BOOL
+offset_is_default(const OffsetLength* ol) {
+  return ol->offset == 0 && ol->length == INT64_MAX;
+}
+
+static inline void*
+offset_data(const OffsetLength* ol, const void* x) {
+  return (uint8_t*)x + ol->offset;
+}
+
+static inline size_t
+offset_size(const OffsetLength* ol, size_t n) {
+  if(ol->length == -1)
+    return (signed long)n - ol->offset;
+  return MIN_NUM(ol->length, (signed long)n - ol->offset);
+}
+
+static inline MemoryBlock
+offset_block(const OffsetLength* ol, const void* x, size_t n) {
+  return (MemoryBlock){offset_data(ol, x), offset_size(ol, n)};
+}
+
+static inline PointerRange
+offset_range(const OffsetLength* ol, const void* x, size_t n) {
+  MemoryBlock mb = offset_block(ol, x, n);
+  return range_from(&mb);
+}
+
+static inline OffsetLength
+offset_slice(const OffsetLength ol, int64_t start, int64_t end) {
+  if(start < 0)
+    start = ol.length + (start % ol.length);
+  else if(start > ol.length)
+    start = ol.length;
+  if(end < 0)
+    end = ol.length + (end % ol.length);
+  else if(end > ol.length)
+    end = ol.length;
+
+  return (OffsetLength){start, end - start};
+}
+
+static inline OffsetLength
+offset_offset(const OffsetLength* ol, const OffsetLength* by) {
+  OffsetLength ret;
+  ret.offset = ol->offset + by->offset;
+  ret.length = MIN_NUM(by->length, ol->length - by->offset);
+  return ret;
+}
+
+static inline OffsetLength
+offset_from_indexrange(const IndexRange* ir) {
+  OffsetLength ret;
+  ret.offset = ir->start;
+  ret.length = ir->end - ir->start;
+  return ret;
+}
+
+static inline JSValue
+offset_typedarray(OffsetLength* ol, JSValueConst array, JSContext* ctx) {
+  JSValue ret;
+  size_t offset, length;
+
+  ret = JS_GetTypedArrayBuffer(ctx, array, &offset, &length, NULL);
+
+  if(!JS_IsException(ret)) {
+    ol->offset = offset;
+    ol->length = length;
+  }
+
+  return ret;
+}
+
+static inline IndexRange
+indexrange_from_offset(const OffsetLength* ol) {
+  IndexRange ret;
+  ret.start = ol->offset;
+  ret.end = ol->offset + ol->length;
+  return ret;
+}
+
+static inline MemoryBlock
+block_range(const MemoryBlock* mb, const OffsetLength* range) {
+  MemoryBlock ret;
+  ret.base = mb->base + range->offset;
+  ret.size = MIN_NUM((size_t)range->length, mb->size - range->offset);
+  return ret;
+}
+
+static inline int
+block_realloc(MemoryBlock* mb, size_t new_size, JSContext* ctx) {
+  if((mb->base = js_realloc(ctx, mb->base, new_size))) {
+    mb->size = new_size;
+    return 0;
+  }
+  return -1;
+}
+
+typedef struct InputBuffer {
+  union {
+    MemoryBlock block;
+    struct {
+      uint8_t* data;
+      size_t size;
+    };
+  };
+  size_t pos;
+  void (*free)(JSContext*, const char*, JSValue);
+  JSValue value;
+  OffsetLength range;
+} InputBuffer;
+
+static inline void
+input_buffer_free_default(JSContext* ctx, const char* str, JSValue val) {
+  if(JS_IsString(val))
+    JS_FreeCString(ctx, str);
+
+  if(!JS_IsUndefined(val))
+    JS_FreeValue(ctx, val);
+}
+
+InputBuffer js_input_buffer(JSContext* ctx, JSValueConst value);
+InputBuffer js_input_chars(JSContext* ctx, JSValueConst value);
+InputBuffer js_input_args(JSContext* ctx, int argc, JSValueConst argv[]);
+InputBuffer js_output_args(JSContext* ctx, int argc, JSValueConst argv[]);
+
+InputBuffer input_buffer_clone(const InputBuffer* in, JSContext* ctx);
+BOOL input_buffer_valid(const InputBuffer* in);
+void input_buffer_dump(const InputBuffer* in, DynBuf* db);
+void input_buffer_free(InputBuffer* in, JSContext* ctx);
+
+static inline uint8_t*
+input_buffer_data(const InputBuffer* in) {
+  return offset_data(&in->range, in->data);
+}
+
+static inline size_t
+input_buffer_length(const InputBuffer* in) {
+  return offset_size(&in->range, in->size);
+}
+
+static inline MemoryBlock
+input_buffer_block(InputBuffer* in) {
+  return (MemoryBlock){input_buffer_data(in), input_buffer_length(in)};
+}
+
+static inline MemoryBlock*
+input_buffer_blockptr(InputBuffer* in) {
+  return &in->block;
+}
+
+const uint8_t* input_buffer_get(InputBuffer* in, size_t* lenp);
+const uint8_t* input_buffer_peek(InputBuffer* in, size_t* lenp);
+const char* input_buffer_currentline(InputBuffer*, size_t* len);
+size_t input_buffer_column(InputBuffer*, size_t* len);
+
+int input_buffer_peekc(InputBuffer* in, size_t* lenp);
+int input_buffer_putc(InputBuffer*, unsigned int, JSContext*);
+
+static inline int
+input_buffer_getc(InputBuffer* in) {
+  size_t n;
+  int ret;
+  ret = input_buffer_peekc(in, &n);
+  in->pos += n;
+  return ret;
+}
+
+static inline void*
+input_buffer_begin(const InputBuffer* in) {
+  return input_buffer_data(in);
+}
+
+static inline void*
+input_buffer_end(const InputBuffer* in) {
+  return input_buffer_data(in) + input_buffer_length(in);
+}
+
+static inline BOOL
+input_buffer_eof(const InputBuffer* in) {
+  return in->pos == input_buffer_length(in);
+}
+
+static inline size_t
+input_buffer_remain(const InputBuffer* in) {
+  return input_buffer_length(in) - in->pos;
+}
+
+int js_offset_length(JSContext*, int64_t size, int argc, JSValueConst argv[], OffsetLength* off_len_p);
+int js_index_range(JSContext*, int64_t size, int argc, JSValueConst argv[], IndexRange* idx_rng_p);
+
+/**
+ * @}
+ */
+#endif /* defined(BUFFER_UTILS) */

src/quickjs/char-utils.c

@@ -0,0 +1,578 @@
+#include "char-utils.h"
+#include "libutf.h"
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__)
+#include <winnls.h>
+#include <windows.h>
+#include <wchar.h>
+#endif
+
+/**
+ * \addtogroup char-utils
+ * @{
+ */
+size_t
+token_length(const char* str, size_t len, char delim) {
+  const char *s, *e;
+  size_t pos;
+
+  for(s = str, e = s + len; s < e; s += pos + 1) {
+    pos = byte_chr(s, e - s, delim);
+
+    if(s + pos == e)
+      break;
+
+    if(pos == 0 || s[pos - 1] != '\\') {
+      s += pos;
+      break;
+    }
+  }
+
+  return s - str;
+}
+
+size_t
+fmt_ulong(char* dest, uint32_t i) {
+  uint32_t len, tmp, len2;
+
+  for(len = 1, tmp = i; tmp > 9; ++len)
+    tmp /= 10;
+
+  if(dest)
+    for(tmp = i, dest += len, len2 = len + 1; --len2; tmp /= 10)
+      *--dest = (char)((tmp % 10) + '0');
+
+  return len;
+}
+
+size_t
+fmt_longlong(char* dest, int64_t i) {
+  if(i < 0) {
+    if(dest)
+      *dest++ = '-';
+    return fmt_ulonglong(dest, (uint64_t)-i) + 1;
+  }
+
+  return fmt_ulonglong(dest, (uint64_t)i);
+}
+
+size_t
+fmt_ulonglong(char* dest, uint64_t i) {
+  size_t len;
+  uint64_t tmp, len2;
+
+  for(len = 1, tmp = i; tmp > 9ll; ++len)
+    tmp /= 10ll;
+
+  if(dest)
+    for(tmp = i, dest += len, len2 = len + 1; --len2; tmp /= 10ll)
+      *--dest = (tmp % 10ll) + '0';
+
+  return len;
+}
+
+#define tohex(c) (char)((c) >= 10 ? (c)-10 + 'a' : (c) + '0')
+
+size_t
+fmt_xlonglong(char* dest, uint64_t i) {
+  uint64_t len, tmp;
+
+  for(len = 1, tmp = i; tmp > 15ll; ++len)
+    tmp >>= 4ll;
+
+  if(dest)
+    for(tmp = i, dest += len;;) {
+      *--dest = tohex(tmp & 15ll);
+
+      if(!(tmp >>= 4ll))
+        break;
+    }
+
+  return len;
+}
+
+size_t
+fmt_xlonglong0(char* dest, uint64_t num, size_t n) {
+  size_t i = 0, len;
+
+  if((len = fmt_xlonglong(NULL, num)) < n) {
+    len = n - len;
+
+    while(i < len)
+      dest[i++] = '0';
+  }
+
+  i += fmt_xlonglong(&dest[i], num);
+  return i;
+}
+
+size_t
+fmt_8long(char* dest, uint32_t i) {
+  uint32_t len, tmp;
+
+  /* first count the number of bytes needed */
+  for(len = 1, tmp = i; tmp > 7; ++len)
+    tmp >>= 3;
+
+  if(dest)
+    for(tmp = i, dest += len;;) {
+      *--dest = (char)((tmp & 7) + '0');
+
+      if(!(tmp >>= 3))
+        break;
+    }
+
+  return len;
+}
+
+#define tohex(c) (char)((c) >= 10 ? (c)-10 + 'a' : (c) + '0')
+
+size_t
+fmt_xlong(char* dest, uint32_t i) {
+  uint32_t len, tmp;
+
+  /* first count the number of bytes needed */
+  for(len = 1, tmp = i; tmp > 15; ++len)
+    tmp >>= 4;
+
+  if(dest)
+    for(tmp = i, dest += len;;) {
+      *--dest = tohex(tmp & 15);
+
+      if(!(tmp >>= 4))
+        break;
+    }
+
+  return len;
+}
+
+size_t
+fmt_xlong0(char* dest, uint32_t num, size_t n) {
+  size_t i = 0, len;
+
+  if((len = fmt_xlong(NULL, num)) < n) {
+    len = n - len;
+
+    while(i < len)
+      dest[i++] = '0';
+  }
+
+  i += fmt_xlong(&dest[i], num);
+  return i;
+}
+
+size_t
+scan_ushort(const char* src, uint16_t* dest) {
+  const char* cur;
+  uint16_t l;
+
+  for(cur = src, l = 0; *cur >= '0' && *cur <= '9'; ++cur) {
+    uint32_t tmp = l * 10ul + *cur - '0';
+
+    if((uint16_t)tmp != tmp)
+      break;
+
+    l = tmp;
+  }
+
+  if(cur > src)
+    *dest = l;
+
+  return (size_t)(cur - src);
+}
+
+size_t
+scan_uint(const char* src, uint32_t* dest) {
+  uint64_t u64;
+  size_t r = scan_ulonglong(src, &u64);
+  *dest = u64;
+  return r;
+}
+
+size_t
+scan_int(const char* src, int32_t* dest) {
+  int64_t i64;
+  size_t r = scan_longlong(src, &i64);
+  *dest = i64;
+  return r;
+}
+
+#ifndef MAXLONG
+#define MAXLONG (((uint32_t)-1) >> 1)
+#endif
+
+size_t
+scan_longlong(const char* src, int64_t* dest) {
+  size_t i, o;
+  uint64_t l;
+  char c = src[0];
+  unsigned int neg = c == '-';
+  o = c == '-' || c == '+';
+
+  if((i = scan_ulonglong(src + o, &l))) {
+    if(i > 0ll && l > MAXLONG + neg) {
+      l /= 10ll;
+      --i;
+    }
+
+    if(i + o)
+      *dest = (int64_t)(c == '-' ? -l : l);
+
+    return i + o;
+  }
+
+  return 0;
+}
+
+size_t
+scan_ulonglong(const char* src, uint64_t* dest) {
+  const char* tmp = src;
+  uint64_t l = 0;
+  unsigned char c;
+
+  while((c = (unsigned char)(*tmp - '0')) < 10) {
+    uint64_t n;
+    n = l << 3ll;
+
+    if((n >> 3ll) != l)
+      break;
+
+    if(n + (l << 1ll) < n)
+      break;
+
+    n += l << 1ll;
+
+    if(n + c < n)
+      break;
+
+    l = n + c;
+    ++tmp;
+  }
+
+  if(tmp - src)
+    *dest = l;
+
+  return (size_t)(tmp - src);
+}
+
+size_t
+scan_xlonglong(const char* src, uint64_t* dest) {
+  const char* tmp = src;
+  int64_t l = 0;
+  unsigned char c;
+
+  while((c = scan_fromhex(*tmp)) < 16) {
+    l = (l << 4) + c;
+    ++tmp;
+  }
+
+  *dest = l;
+  return tmp - src;
+}
+
+size_t
+scan_8longn(const char* src, size_t n, uint32_t* dest) {
+  const char* tmp = src;
+  uint32_t l = 0;
+  unsigned char c;
+
+  while(n-- > 0 && (c = (unsigned char)(*tmp - '0')) < 8) {
+    if(l >> (sizeof(l) * 8 - 3))
+      break;
+
+    l = l * 8 + c;
+    ++tmp;
+  }
+
+  *dest = l;
+  return (size_t)(tmp - src);
+}
+
+size_t
+scan_whitenskip(const char* s, size_t limit) {
+  const char *t, *u;
+
+  for(t = s, u = t + limit; t < u; ++t)
+    if(!is_whitespace_char(*t))
+      break;
+
+  return (size_t)(t - s);
+}
+
+size_t
+scan_nonwhitenskip(const char* s, size_t limit) {
+  const char *t, *u;
+
+  for(t = s, u = t + limit; t < u; ++t)
+    if(is_whitespace_char(*t))
+      break;
+
+  return (size_t)(t - s);
+}
+
+size_t
+scan_line(const char* s, size_t limit) {
+  const char *t, *u;
+
+  for(t = s, u = s + limit; t < u; ++t)
+    if(*t == '\n' || *t == '\r')
+      break;
+
+  return (size_t)(t - s);
+}
+
+size_t
+scan_lineskip(const char* s, size_t limit) {
+  const char *t, *u;
+
+  for(t = s, u = s + limit; t < u; ++t)
+    if(*t == '\n') {
+      ++t;
+      break;
+    }
+
+  return (size_t)(t - s);
+}
+
+size_t
+scan_lineskip_escaped(const char* s, size_t limit) {
+  const char *t, *u;
+
+  for(t = s, u = s + limit; t < u; ++t) {
+    if(*t == '\\') {
+      ++t;
+      continue;
+    }
+    if(*t == '\n') {
+      ++t;
+      break;
+    }
+  }
+
+  return (size_t)(t - s);
+}
+
+size_t
+scan_eolskip(const char* s, size_t limit) {
+  size_t n = 0;
+
+  if(n + 1 < limit && s[0] == '\r' && s[1] == '\n')
+    n += 2;
+  else if(n < limit && s[0] == '\n')
+    n += 1;
+
+  return n;
+}
+
+size_t
+utf8_strlen(const void* in, size_t len) {
+  const uint8_t *pos, *end, *next;
+  size_t i = 0;
+
+  for(pos = (const uint8_t*)in, end = pos + len; pos < end; pos = next, ++i)
+    unicode_from_utf8(pos, end - pos, &next);
+
+  return i;
+}
+
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__)
+wchar_t*
+utf8_towcs(const char* s) {
+  int len = (int)strlen(s);
+  int n = MultiByteToWideChar(CP_UTF8, 0, s, len, NULL, 0);
+  wchar_t* ret;
+
+  if((ret = (wchar_t*)malloc((n + 1) * sizeof(wchar_t)))) {
+    MultiByteToWideChar(CP_UTF8, 0, s, len, ret, n);
+    ret[n] = L'\0';
+  }
+
+  return ret;
+}
+
+char*
+utf8_fromwcs(const wchar_t* wstr) {
+  int len = (int)wcslen(wstr);
+  int n = WideCharToMultiByte(CP_UTF8, 0, wstr, len, NULL, 0, NULL, NULL);
+  char* ret;
+
+  if((ret = malloc((n + 1)))) {
+    WideCharToMultiByte(CP_UTF8, 0, wstr, len, ret, n, NULL, NULL);
+    ret[n] = '\0';
+  }
+
+  return ret;
+}
+#endif
+
+BOOL
+utf16_multiword(const void* in) {
+  const uint16_t* p16 = in;
+  LibutfC16Type type = libutf_c16_type(p16[0]);
+
+  return !((LIBUTF_UTF16_NOT_SURROGATE == type) || (LIBUTF_UTF16_SURROGATE_HIGH != type || LIBUTF_UTF16_SURROGATE_LOW != libutf_c16_type(p16[1])));
+}
+
+int
+case_lowerc(int c) {
+  if(c >= 'A' && c <= 'Z')
+    c += 'a' - 'A';
+
+  return c;
+}
+
+int
+case_starts(const char* a, const char* b) {
+  const char *s, *t;
+
+  for(s = a, t = b;; ++s, ++t) {
+    unsigned char x, y;
+
+    if(!*t)
+      return 1;
+
+    x = case_lowerc(*s);
+    y = case_lowerc(*t);
+
+    if(x != y)
+      break;
+
+    if(!x)
+      break;
+  }
+
+  return 0;
+}
+
+int
+case_diffb(const void* S, size_t len, const void* T) {
+  unsigned char x, y;
+  const char *s, *t;
+
+  for(s = (const char*)S, t = (const char*)T; len > 0;) {
+    --len;
+    x = case_lowerc(*s);
+    y = case_lowerc(*t);
+
+    ++s;
+    ++t;
+
+    if(x != y)
+      return ((int)(unsigned int)x) - ((int)(unsigned int)y);
+  }
+
+  return 0;
+}
+
+size_t
+case_findb(const void* haystack, size_t hlen, const void* what, size_t wlen) {
+  size_t i, last;
+  const char* s = haystack;
+
+  if(hlen < wlen)
+    return hlen;
+
+  last = hlen - wlen;
+
+  for(i = 0; i <= last; i++, s++)
+    if(!case_diffb(s, wlen, what))
+      return i;
+
+  return hlen;
+}
+
+size_t
+case_finds(const void* haystack, const char* what) {
+  return case_findb(haystack, strlen(haystack), what, strlen(what));
+}
+
+ssize_t
+write_file(const char* file, const void* buf, size_t len) {
+  FILE* f;
+  ssize_t ret = -1;
+
+  if((f = fopen(file, "w+")))
+    switch(fwrite(buf, len, 1, f)) {
+      case 1: {
+        ret = len;
+        break;
+      }
+    }
+
+  fflush(f);
+  ret = ftell(f);
+  fclose(f);
+
+  return ret;
+}
+
+ssize_t
+puts_file(const char* file, const char* s) {
+  return write_file(file, s, strlen(s));
+}
+
+size_t
+u64toa(char* x, uint64_t num, int base) {
+  size_t len = 0;
+  uint64_t n = num;
+
+  do {
+    n /= base;
+    len++;
+    x++;
+  } while(n != 0);
+
+  *x-- = '\0';
+
+  do {
+    char c = num % base;
+    num /= base;
+
+    if(c >= 10)
+      c += 'a' - '0' - 10;
+    *x-- = c + '0';
+  } while(num != 0);
+
+  return len;
+}
+
+size_t
+i64toa(char* x, int64_t num, int base) {
+  size_t pos = 0, len;
+
+  if(num < 0) {
+    x[pos++] = '-';
+    num = -num;
+  }
+
+  len = u64toa(&x[pos], num, base);
+
+  return pos + len;
+}
+
+size_t
+str_findb(const char* s1, const char* x, size_t n) {
+  const char* b;
+  size_t i, j, len = strlen(s1);
+
+  if(len >= n) {
+    size_t end = len - n + 1;
+
+    for(i = 0; i < end; i++) {
+      b = &s1[i];
+
+      for(j = 0; x[j] == b[j];)
+        if(++j == n)
+          return i;
+    }
+  }
+
+  return len;
+}
+
+size_t
+str_find(const void* s, const void* what) {
+  return str_findb(s, what, strlen(what));
+}
+/**
+ * @}
+ */

src/quickjs/char-utils.h

@@ -0,0 +1,441 @@
+#ifndef CHAR_UTILS_H
+#define CHAR_UTILS_H
+
+#include <cutils.h>
+#include <string.h>
+#include "debug.h"
+
+/**
+ * \defgroup char-utils char-utils: Character Utilities
+ * @{
+ */
+#define is_control_char(c) ((c) == '\a' || (c) == '\b' || (c) == '\t' || (c) == '\n' || (c) == '\v' || (c) == '\f' || (c) == '\r')
+#define is_alphanumeric_char(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
+
+#define is_digit_char(c) ((c) >= '0' && (c) <= '9')
+#define is_print_char(c) ((c) >= ' ' && (c) <= '\x7f')
+#define is_newline_char(c) ((c) == '\n')
+#define is_identifier_char(c) (is_alphanumeric_char(c) || is_digit_char(c) || (c) == '$' || (c) == '_')
+#define is_whitespace_char(c) ((c) == ' ' || (c) == '\t' || (c) == '\v' || (c) == '\n' || (c) == '\r')
+
+#define str_equal(s, t) (!strcmp((s), (t)))
+
+static inline int
+escape_char_pred(int c) {
+  static const unsigned char table[256] = {
+      'x', 'x', 'x', 'x', 'x', 'x',  'x', 'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
+      'x', 'x', 'x', 0,   0,   0,    0,   0,   0,    0,    0x27, 0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0x5c, 0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    'x',  0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  };
+
+  return table[(unsigned char)c];
+}
+
+static inline int
+unescape_char_pred(int c) {
+  switch(c) {
+    case 'b': return 8;
+    case 'f': return 12;
+    case 'n': return 10;
+    case 'r': return 13;
+    case 't': return 9;
+    case 'v': return 11;
+    case '\'': return 39;
+    case '\\': return 92;
+  }
+
+  return 0;
+}
+
+static inline int
+is_escape_char(int c) {
+  return is_control_char(c) || c == '\\' || c == '\'' || c == 0x1b || c == 0;
+}
+
+static inline int
+is_backslash_char(int c) {
+  return c == '\\';
+}
+
+//#define is_dot_char(c) ((c) == '.')0
+//#define is_backslash_char(c) ((c) == '\\')
+
+static inline int
+is_dot_char(int c) {
+  return c == '.';
+}
+
+static inline int
+is_identifier(const char* str) {
+  if(!((*str >= 'A' && *str <= 'Z') || (*str >= 'a' && *str <= 'z') || *str == '$' || *str == '_'))
+    return 0;
+
+  while(*++str)
+    if(!is_identifier_char(*str))
+      return 0;
+
+  return 1;
+}
+
+static inline int
+is_integer(const char* str) {
+  if(*str == '-')
+    ++str;
+
+  if(!(*str >= '1' && *str <= '9') && !(*str == '0' && str[1] == '\0'))
+    return 0;
+
+  while(*++str)
+    if(!is_digit_char(*str))
+      return 0;
+
+  return 1;
+}
+
+static inline size_t
+byte_count(const void* s, size_t n, char c) {
+  const uint8_t* t;
+  uint8_t ch = (uint8_t)c;
+  size_t count;
+
+  for(t = (uint8_t*)s, count = 0; n; ++t, --n)
+    if(*t == ch)
+      ++count;
+
+  return count;
+}
+
+static inline size_t
+byte_chr(const void* str, size_t len, char c) {
+  const char* s = memchr(str, c, len);
+
+  if(s)
+    return s - (const char*)str;
+
+  return len;
+}
+
+static inline size_t
+byte_rchr(const void* haystack, size_t len, char needle) {
+  const char *s, *t;
+
+  for(s = (const char*)haystack, t = s + len;;) {
+    --t;
+
+    if(s > t)
+      break;
+
+    if(*t == needle)
+      return (size_t)(t - s);
+  }
+
+  return len;
+}
+
+/*size_t
+byte_rchr(const void* str, size_t len, char c) {
+  const char* s = memrchr(str, c, len);
+  if(s)
+    return s - (const char*)str;
+  return len;
+}*/
+
+static inline size_t
+byte_chrs(const void* str, size_t len, const char needle[], size_t nl) {
+  const char *s, *t;
+
+  for(s = str, t = s + len; s != t; s++)
+    if(byte_chr(needle, nl, *s) < nl)
+      break;
+
+  return s - (const char*)str;
+}
+
+static inline int
+byte_diff(const void* a, size_t len, const void* b) {
+  size_t i;
+
+  for(i = 0; i < len; ++i) {
+    int r = ((unsigned char*)a)[i] - ((unsigned char*)b)[i];
+
+    if(r)
+      return r;
+  }
+
+  return 0;
+}
+
+static inline int
+byte_diff2(const char* a, size_t alen, const char* b, size_t blen) {
+
+  if(alen < blen)
+    return -b[alen];
+
+  if(blen < alen)
+    return a[blen];
+
+  return byte_diff(a, alen, b);
+}
+
+static inline size_t
+str_chr(const char* in, char needle) {
+  const char *t, c = needle;
+
+  for(t = in; *t; ++t)
+    if(*t == c)
+      break;
+
+  return (size_t)(t - in);
+}
+
+static inline size_t
+str_chrs(const char* in, const char needles[], size_t nn) {
+  const char* t;
+  size_t i;
+
+  for(t = in; *t; ++t)
+    for(i = 0; i < nn; i++)
+      if(*t == needles[i])
+        return (size_t)(t - in);
+
+  return (size_t)(t - in);
+}
+
+static inline size_t
+str_rchr(const char* s, char needle) {
+  const char *in, *found = 0;
+
+  for(in = s; *in; ++in)
+    if(*in == needle)
+      found = in;
+
+  return (size_t)((found ? found : in) - s);
+}
+
+static inline size_t
+str_rchrs(const char* in, const char needles[], size_t nn) {
+  const char *s, *found = 0;
+  size_t i;
+
+  for(s = in; *s; ++s)
+    for(i = 0; i < nn; ++i)
+      if(*s == needles[i])
+        found = s;
+
+  return (size_t)((found ? found : s) - in);
+}
+
+static inline int
+str_endb(const char* a, const char* x, size_t n) {
+  size_t alen = strlen(a);
+  a += alen - n;
+
+  return alen >= n && !memcmp(a, x, n);
+}
+
+/* str_ends returns 1 if the b is a suffix of a, 0 otherwise */
+static inline int
+str_ends(const char* a, const char* b) {
+  return str_endb(a, b, strlen(b));
+}
+
+static inline int
+str_startb(const char* a, const char* x, size_t len) {
+  size_t i;
+
+  for(i = 0;; i++) {
+    if(i == len)
+      return 1;
+    if(a[i] != x[i])
+      break;
+  }
+
+  return 0;
+}
+
+static inline int
+str_start(const char* a, const char* b) {
+  return str_startb(a, b, strlen(b));
+}
+
+#define str_contains(s, needle) (!!strchr((s), (needle)))
+
+char* str_escape(const char*);
+
+static inline size_t
+str_count(const char* s, char c) {
+  size_t i, count = 0;
+
+  for(i = 0; s[i]; i++)
+    if(s[i] == c)
+      ++count;
+
+  return count;
+}
+
+static inline size_t
+str_copy(char* out, const char* in) {
+  char* s;
+
+  for(s = out; (*s = *in); ++s)
+    ++in;
+
+  return (size_t)(s - out);
+}
+
+static inline size_t
+str_copyn(char* out, const char* in, size_t n) {
+  char* s;
+
+  for(s = out; n-- && (*s = *in); ++s)
+    ++in;
+
+  *s = '\0';
+  return (size_t)(s - out);
+}
+
+static inline char*
+str_ndup(const char* s, size_t n) {
+  char* r = malloc(n + 1);
+
+  if(r == NULL)
+    return NULL;
+
+  memcpy(r, s, n);
+  r[n] = '\0';
+  return r;
+}
+
+size_t str_findb(const char*, const char*, size_t);
+size_t str_find(const void*, const void*);
+
+static inline size_t
+predicate_find(const char* str, size_t len, int (*pred)(int32_t)) {
+  size_t pos;
+
+  for(pos = 0; pos < len; pos++)
+    if(pred(str[pos]))
+      break;
+
+  return pos;
+}
+
+static inline size_t
+lookup_find(const char* str, size_t len, const char table[256]) {
+  size_t pos;
+
+  for(pos = 0; pos < len; pos++)
+    if(table[(unsigned char)str[pos]])
+      break;
+
+  return pos;
+}
+
+static inline char
+escape_char_letter(char c) {
+  switch(c) {
+    case '\0': return '0';
+    case '\a': return 'a';
+    case '\b': return 'b';
+    case '\t': return 't';
+    case '\n': return 'n';
+    case '\v': return 'v';
+    case '\f': return 'f';
+    case '\r': return 'r';
+    case '\\': return '\\';
+    case '\'': return '\'';
+  }
+
+  return 0;
+}
+
+#define FMT_LONG 41  /* enough space to hold -2^127 in decimal, plus \0 */
+#define FMT_ULONG 40 /* enough space to hold 2^128 - 1 in decimal, plus \0 */
+#define FMT_8LONG 44 /* enough space to hold 2^128 - 1 in octal, plus \0 */
+#define FMT_XLONG 33 /* enough space to hold 2^128 - 1 in hexadecimal, plus \0 */
+
+size_t token_length(const char*, size_t, char delim);
+size_t fmt_ulong(char*, uint32_t);
+size_t scan_ushort(const char*, uint16_t*);
+size_t fmt_longlong(char*, int64_t);
+size_t fmt_ulonglong(char*, uint64_t);
+size_t fmt_xlonglong(char*, uint64_t);
+size_t fmt_xlonglong0(char*, uint64_t, size_t);
+size_t fmt_8long(char* dest, uint32_t i);
+size_t fmt_xlong(char* dest, uint32_t num);
+size_t fmt_xlong0(char* dest, uint32_t num, size_t n);
+size_t scan_longlong(const char*, int64_t*);
+size_t scan_int(const char*, int32_t*);
+size_t scan_uint(const char*, uint32_t*);
+size_t scan_ulonglong(const char*, uint64_t*);
+size_t scan_xlonglong(const char*, uint64_t*);
+size_t scan_8longn(const char*, size_t, uint32_t* dest);
+size_t scan_whitenskip(const char*, size_t);
+size_t scan_nonwhitenskip(const char*, size_t);
+size_t scan_line(const char*, size_t);
+size_t scan_lineskip(const char*, size_t);
+size_t scan_lineskip_escaped(const char*, size_t);
+size_t scan_eolskip(const char*, size_t);
+size_t utf8_strlen(const void*, size_t);
+wchar_t* utf8_towcs(const char*);
+char* utf8_fromwcs(const wchar_t*);
+BOOL utf16_multiword(const void*);
+int case_lowerc(int);
+int case_starts(const char*, const char*);
+int case_diffb(const void*, size_t, const void* T);
+size_t case_findb(const void*, size_t, const void* what, size_t wlen);
+size_t case_finds(const void*, const char*);
+
+static inline int
+scan_fromhex(unsigned char c) {
+  c -= '0';
+
+  if(c <= 9)
+    return c;
+
+  c &= ~0x20;
+  c -= 'A' - '0';
+
+  if(c < 6)
+    return c + 10;
+
+  return -1;
+}
+
+static inline size_t
+scan_8long(const char* src, uint32_t* dest) {
+  return scan_8longn(src, (size_t)-1, dest);
+}
+
+static inline size_t
+utf8_charlen(const char* in, size_t len) {
+  const uint8_t* next = (const void*)in;
+  int r = unicode_from_utf8((const uint8_t*)in, len, &next);
+  return r == -1 ? 0 : next - (const uint8_t*)in;
+}
+
+static inline int
+utf8_charcode(const char* in, size_t len) {
+  const uint8_t* next = (const void*)in;
+  int r = unicode_from_utf8((const uint8_t*)in, len, &next);
+  return next > in ? r : -1;
+}
+
+BOOL utf16_multiword(const void*);
+
+ssize_t write_file(const char* file, const void* buf, size_t len);
+ssize_t puts_file(const char* file, const char* s);
+
+size_t u64toa(char*, uint64_t num, int base);
+size_t i64toa(char*, int64_t num, int base);
+
+/**
+ * @}
+ */
+#endif /* defined(CHAR_UTILS_H) */

src/quickjs/cutils.c

@@ -0,0 +1,631 @@
+/*
+ * C utilities
+ *
+ * Copyright (c) 2017 Fabrice Bellard
+ * Copyright (c) 2018 Charlie Gordon
+ *
+ * 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 <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include "cutils.h"
+
+void pstrcpy(char *buf, int buf_size, const char *str)
+{
+    int c;
+    char *q = buf;
+
+    if (buf_size <= 0)
+        return;
+
+    for(;;) {
+        c = *str++;
+        if (c == 0 || q >= buf + buf_size - 1)
+            break;
+        *q++ = c;
+    }
+    *q = '\0';
+}
+
+/* strcat and truncate. */
+char *pstrcat(char *buf, int buf_size, const char *s)
+{
+    int len;
+    len = strlen(buf);
+    if (len < buf_size)
+        pstrcpy(buf + len, buf_size - len, s);
+    return buf;
+}
+
+int strstart(const char *str, const char *val, const char **ptr)
+{
+    const char *p, *q;
+    p = str;
+    q = val;
+    while (*q != '\0') {
+        if (*p != *q)
+            return 0;
+        p++;
+        q++;
+    }
+    if (ptr)
+        *ptr = p;
+    return 1;
+}
+
+int has_suffix(const char *str, const char *suffix)
+{
+    size_t len = strlen(str);
+    size_t slen = strlen(suffix);
+    return (len >= slen && !memcmp(str + len - slen, suffix, slen));
+}
+
+/* Dynamic buffer package */
+
+static void *dbuf_default_realloc(void *opaque, void *ptr, size_t size)
+{
+    return realloc(ptr, size);
+}
+
+void dbuf_init2(DynBuf *s, void *opaque, DynBufReallocFunc *realloc_func)
+{
+    memset(s, 0, sizeof(*s));
+    if (!realloc_func)
+        realloc_func = dbuf_default_realloc;
+    s->opaque = opaque;
+    s->realloc_func = realloc_func;
+}
+
+void dbuf_init(DynBuf *s)
+{
+    dbuf_init2(s, NULL, NULL);
+}
+
+/* return < 0 if error */
+int dbuf_realloc(DynBuf *s, size_t new_size)
+{
+    size_t size;
+    uint8_t *new_buf;
+    if (new_size > s->allocated_size) {
+        if (s->error)
+            return -1;
+        size = s->allocated_size * 3 / 2;
+        if (size > new_size)
+            new_size = size;
+        new_buf = s->realloc_func(s->opaque, s->buf, new_size);
+        if (!new_buf) {
+            s->error = TRUE;
+            return -1;
+        }
+        s->buf = new_buf;
+        s->allocated_size = new_size;
+    }
+    return 0;
+}
+
+int dbuf_write(DynBuf *s, size_t offset, const uint8_t *data, size_t len)
+{
+    size_t end;
+    end = offset + len;
+    if (dbuf_realloc(s, end))
+        return -1;
+    memcpy(s->buf + offset, data, len);
+    if (end > s->size)
+        s->size = end;
+    return 0;
+}
+
+int dbuf_put(DynBuf *s, const uint8_t *data, size_t len)
+{
+    if (unlikely((s->size + len) > s->allocated_size)) {
+        if (dbuf_realloc(s, s->size + len))
+            return -1;
+    }
+    memcpy_no_ub(s->buf + s->size, data, len);
+    s->size += len;
+    return 0;
+}
+
+int dbuf_put_self(DynBuf *s, size_t offset, size_t len)
+{
+    if (unlikely((s->size + len) > s->allocated_size)) {
+        if (dbuf_realloc(s, s->size + len))
+            return -1;
+    }
+    memcpy(s->buf + s->size, s->buf + offset, len);
+    s->size += len;
+    return 0;
+}
+
+int dbuf_putc(DynBuf *s, uint8_t c)
+{
+    return dbuf_put(s, &c, 1);
+}
+
+int dbuf_putstr(DynBuf *s, const char *str)
+{
+    return dbuf_put(s, (const uint8_t *)str, strlen(str));
+}
+
+int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
+                                                      const char *fmt, ...)
+{
+    va_list ap;
+    char buf[128];
+    int len;
+
+    va_start(ap, fmt);
+    len = vsnprintf(buf, sizeof(buf), fmt, ap);
+    va_end(ap);
+    if (len < sizeof(buf)) {
+        /* fast case */
+        return dbuf_put(s, (uint8_t *)buf, len);
+    } else {
+        if (dbuf_realloc(s, s->size + len + 1))
+            return -1;
+        va_start(ap, fmt);
+        vsnprintf((char *)(s->buf + s->size), s->allocated_size - s->size,
+                  fmt, ap);
+        va_end(ap);
+        s->size += len;
+    }
+    return 0;
+}
+
+void dbuf_free(DynBuf *s)
+{
+    /* we test s->buf as a fail safe to avoid crashing if dbuf_free()
+       is called twice */
+    if (s->buf) {
+        s->realloc_func(s->opaque, s->buf, 0);
+    }
+    memset(s, 0, sizeof(*s));
+}
+
+/* Note: at most 31 bits are encoded. At most UTF8_CHAR_LEN_MAX bytes
+   are output. */
+int unicode_to_utf8(uint8_t *buf, unsigned int c)
+{
+    uint8_t *q = buf;
+
+    if (c < 0x80) {
+        *q++ = c;
+    } else {
+        if (c < 0x800) {
+            *q++ = (c >> 6) | 0xc0;
+        } else {
+            if (c < 0x10000) {
+                *q++ = (c >> 12) | 0xe0;
+            } else {
+                if (c < 0x00200000) {
+                    *q++ = (c >> 18) | 0xf0;
+                } else {
+                    if (c < 0x04000000) {
+                        *q++ = (c >> 24) | 0xf8;
+                    } else if (c < 0x80000000) {
+                        *q++ = (c >> 30) | 0xfc;
+                        *q++ = ((c >> 24) & 0x3f) | 0x80;
+                    } else {
+                        return 0;
+                    }
+                    *q++ = ((c >> 18) & 0x3f) | 0x80;
+                }
+                *q++ = ((c >> 12) & 0x3f) | 0x80;
+            }
+            *q++ = ((c >> 6) & 0x3f) | 0x80;
+        }
+        *q++ = (c & 0x3f) | 0x80;
+    }
+    return q - buf;
+}
+
+static const unsigned int utf8_min_code[5] = {
+    0x80, 0x800, 0x10000, 0x00200000, 0x04000000,
+};
+
+static const unsigned char utf8_first_code_mask[5] = {
+    0x1f, 0xf, 0x7, 0x3, 0x1,
+};
+
+/* return -1 if error. *pp is not updated in this case. max_len must
+   be >= 1. The maximum length for a UTF8 byte sequence is 6 bytes. */
+int unicode_from_utf8(const uint8_t *p, int max_len, const uint8_t **pp)
+{
+    int l, c, b, i;
+
+    c = *p++;
+    if (c < 0x80) {
+        *pp = p;
+        return c;
+    }
+    switch(c) {
+    case 0xc0: case 0xc1: case 0xc2: case 0xc3:
+    case 0xc4: case 0xc5: case 0xc6: case 0xc7:
+    case 0xc8: case 0xc9: case 0xca: case 0xcb:
+    case 0xcc: case 0xcd: case 0xce: case 0xcf:
+    case 0xd0: case 0xd1: case 0xd2: case 0xd3:
+    case 0xd4: case 0xd5: case 0xd6: case 0xd7:
+    case 0xd8: case 0xd9: case 0xda: case 0xdb:
+    case 0xdc: case 0xdd: case 0xde: case 0xdf:
+        l = 1;
+        break;
+    case 0xe0: case 0xe1: case 0xe2: case 0xe3:
+    case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+    case 0xe8: case 0xe9: case 0xea: case 0xeb:
+    case 0xec: case 0xed: case 0xee: case 0xef:
+        l = 2;
+        break;
+    case 0xf0: case 0xf1: case 0xf2: case 0xf3:
+    case 0xf4: case 0xf5: case 0xf6: case 0xf7:
+        l = 3;
+        break;
+    case 0xf8: case 0xf9: case 0xfa: case 0xfb:
+        l = 4;
+        break;
+    case 0xfc: case 0xfd:
+        l = 5;
+        break;
+    default:
+        return -1;
+    }
+    /* check that we have enough characters */
+    if (l > (max_len - 1))
+        return -1;
+    c &= utf8_first_code_mask[l - 1];
+    for(i = 0; i < l; i++) {
+        b = *p++;
+        if (b < 0x80 || b >= 0xc0)
+            return -1;
+        c = (c << 6) | (b & 0x3f);
+    }
+    if (c < utf8_min_code[l - 1])
+        return -1;
+    *pp = p;
+    return c;
+}
+
+#if 0
+
+#if defined(EMSCRIPTEN) || defined(__ANDROID__)
+
+static void *rqsort_arg;
+static int (*rqsort_cmp)(const void *, const void *, void *);
+
+static int rqsort_cmp2(const void *p1, const void *p2)
+{
+    return rqsort_cmp(p1, p2, rqsort_arg);
+}
+
+/* not reentrant, but not needed with emscripten */
+void rqsort(void *base, size_t nmemb, size_t size,
+            int (*cmp)(const void *, const void *, void *),
+            void *arg)
+{
+    rqsort_arg = arg;
+    rqsort_cmp = cmp;
+    qsort(base, nmemb, size, rqsort_cmp2);
+}
+
+#endif
+
+#else
+
+typedef void (*exchange_f)(void *a, void *b, size_t size);
+typedef int (*cmp_f)(const void *, const void *, void *opaque);
+
+static void exchange_bytes(void *a, void *b, size_t size) {
+    uint8_t *ap = (uint8_t *)a;
+    uint8_t *bp = (uint8_t *)b;
+
+    while (size-- != 0) {
+        uint8_t t = *ap;
+        *ap++ = *bp;
+        *bp++ = t;
+    }
+}
+
+static void exchange_one_byte(void *a, void *b, size_t size) {
+    uint8_t *ap = (uint8_t *)a;
+    uint8_t *bp = (uint8_t *)b;
+    uint8_t t = *ap;
+    *ap = *bp;
+    *bp = t;
+}
+
+static void exchange_int16s(void *a, void *b, size_t size) {
+    uint16_t *ap = (uint16_t *)a;
+    uint16_t *bp = (uint16_t *)b;
+
+    for (size /= sizeof(uint16_t); size-- != 0;) {
+        uint16_t t = *ap;
+        *ap++ = *bp;
+        *bp++ = t;
+    }
+}
+
+static void exchange_one_int16(void *a, void *b, size_t size) {
+    uint16_t *ap = (uint16_t *)a;
+    uint16_t *bp = (uint16_t *)b;
+    uint16_t t = *ap;
+    *ap = *bp;
+    *bp = t;
+}
+
+static void exchange_int32s(void *a, void *b, size_t size) {
+    uint32_t *ap = (uint32_t *)a;
+    uint32_t *bp = (uint32_t *)b;
+
+    for (size /= sizeof(uint32_t); size-- != 0;) {
+        uint32_t t = *ap;
+        *ap++ = *bp;
+        *bp++ = t;
+    }
+}
+
+static void exchange_one_int32(void *a, void *b, size_t size) {
+    uint32_t *ap = (uint32_t *)a;
+    uint32_t *bp = (uint32_t *)b;
+    uint32_t t = *ap;
+    *ap = *bp;
+    *bp = t;
+}
+
+static void exchange_int64s(void *a, void *b, size_t size) {
+    uint64_t *ap = (uint64_t *)a;
+    uint64_t *bp = (uint64_t *)b;
+
+    for (size /= sizeof(uint64_t); size-- != 0;) {
+        uint64_t t = *ap;
+        *ap++ = *bp;
+        *bp++ = t;
+    }
+}
+
+static void exchange_one_int64(void *a, void *b, size_t size) {
+    uint64_t *ap = (uint64_t *)a;
+    uint64_t *bp = (uint64_t *)b;
+    uint64_t t = *ap;
+    *ap = *bp;
+    *bp = t;
+}
+
+static void exchange_int128s(void *a, void *b, size_t size) {
+    uint64_t *ap = (uint64_t *)a;
+    uint64_t *bp = (uint64_t *)b;
+
+    for (size /= sizeof(uint64_t) * 2; size-- != 0; ap += 2, bp += 2) {
+        uint64_t t = ap[0];
+        uint64_t u = ap[1];
+        ap[0] = bp[0];
+        ap[1] = bp[1];
+        bp[0] = t;
+        bp[1] = u;
+    }
+}
+
+static void exchange_one_int128(void *a, void *b, size_t size) {
+    uint64_t *ap = (uint64_t *)a;
+    uint64_t *bp = (uint64_t *)b;
+    uint64_t t = ap[0];
+    uint64_t u = ap[1];
+    ap[0] = bp[0];
+    ap[1] = bp[1];
+    bp[0] = t;
+    bp[1] = u;
+}
+
+static inline exchange_f exchange_func(const void *base, size_t size) {
+    switch (((uintptr_t)base | (uintptr_t)size) & 15) {
+    case 0:
+        if (size == sizeof(uint64_t) * 2)
+            return exchange_one_int128;
+        else
+            return exchange_int128s;
+    case 8:
+        if (size == sizeof(uint64_t))
+            return exchange_one_int64;
+        else
+            return exchange_int64s;
+    case 4:
+    case 12:
+        if (size == sizeof(uint32_t))
+            return exchange_one_int32;
+        else
+            return exchange_int32s;
+    case 2:
+    case 6:
+    case 10:
+    case 14:
+        if (size == sizeof(uint16_t))
+            return exchange_one_int16;
+        else
+            return exchange_int16s;
+    default:
+        if (size == 1)
+            return exchange_one_byte;
+        else
+            return exchange_bytes;
+    }
+}
+
+static void heapsortx(void *base, size_t nmemb, size_t size, cmp_f cmp, void *opaque)
+{
+    uint8_t *basep = (uint8_t *)base;
+    size_t i, n, c, r;
+    exchange_f swap = exchange_func(base, size);
+
+    if (nmemb > 1) {
+        i = (nmemb / 2) * size;
+        n = nmemb * size;
+
+        while (i > 0) {
+            i -= size;
+            for (r = i; (c = r * 2 + size) < n; r = c) {
+                if (c < n - size && cmp(basep + c, basep + c + size, opaque) <= 0)
+                    c += size;
+                if (cmp(basep + r, basep + c, opaque) > 0)
+                    break;
+                swap(basep + r, basep + c, size);
+            }
+        }
+        for (i = n - size; i > 0; i -= size) {
+            swap(basep, basep + i, size);
+
+            for (r = 0; (c = r * 2 + size) < i; r = c) {
+                if (c < i - size && cmp(basep + c, basep + c + size, opaque) <= 0)
+                    c += size;
+                if (cmp(basep + r, basep + c, opaque) > 0)
+                    break;
+                swap(basep + r, basep + c, size);
+            }
+        }
+    }
+}
+
+static inline void *med3(void *a, void *b, void *c, cmp_f cmp, void *opaque)
+{
+    return cmp(a, b, opaque) < 0 ?
+        (cmp(b, c, opaque) < 0 ? b : (cmp(a, c, opaque) < 0 ? c : a )) :
+        (cmp(b, c, opaque) > 0 ? b : (cmp(a, c, opaque) < 0 ? a : c ));
+}
+
+/* pointer based version with local stack and insertion sort threshhold */
+void rqsort(void *base, size_t nmemb, size_t size, cmp_f cmp, void *opaque)
+{
+    struct { uint8_t *base; size_t count; int depth; } stack[50], *sp = stack;
+    uint8_t *ptr, *pi, *pj, *plt, *pgt, *top, *m;
+    size_t m4, i, lt, gt, span, span2;
+    int c, depth;
+    exchange_f swap = exchange_func(base, size);
+    exchange_f swap_block = exchange_func(base, size | 128);
+
+    if (nmemb < 2 || size <= 0)
+        return;
+
+    sp->base = (uint8_t *)base;
+    sp->count = nmemb;
+    sp->depth = 0;
+    sp++;
+
+    while (sp > stack) {
+        sp--;
+        ptr = sp->base;
+        nmemb = sp->count;
+        depth = sp->depth;
+
+        while (nmemb > 6) {
+            if (++depth > 50) {
+                /* depth check to ensure worst case logarithmic time */
+                heapsortx(ptr, nmemb, size, cmp, opaque);
+                nmemb = 0;
+                break;
+            }
+            /* select median of 3 from 1/4, 1/2, 3/4 positions */
+            /* should use median of 5 or 9? */
+            m4 = (nmemb >> 2) * size;
+            m = med3(ptr + m4, ptr + 2 * m4, ptr + 3 * m4, cmp, opaque);
+            swap(ptr, m, size);  /* move the pivot to the start or the array */
+            i = lt = 1;
+            pi = plt = ptr + size;
+            gt = nmemb;
+            pj = pgt = top = ptr + nmemb * size;
+            for (;;) {
+                while (pi < pj && (c = cmp(ptr, pi, opaque)) >= 0) {
+                    if (c == 0) {
+                        swap(plt, pi, size);
+                        lt++;
+                        plt += size;
+                    }
+                    i++;
+                    pi += size;
+                }
+                while (pi < (pj -= size) && (c = cmp(ptr, pj, opaque)) <= 0) {
+                    if (c == 0) {
+                        gt--;
+                        pgt -= size;
+                        swap(pgt, pj, size);
+                    }
+                }
+                if (pi >= pj)
+                    break;
+                swap(pi, pj, size);
+                i++;
+                pi += size;
+            }
+            /* array has 4 parts:
+             * from 0 to lt excluded: elements identical to pivot
+             * from lt to pi excluded: elements smaller than pivot
+             * from pi to gt excluded: elements greater than pivot
+             * from gt to n excluded: elements identical to pivot
+             */
+            /* move elements identical to pivot in the middle of the array: */
+            /* swap values in ranges [0..lt[ and [i-lt..i[
+               swapping the smallest span between lt and i-lt is sufficient
+             */
+            span = plt - ptr;
+            span2 = pi - plt;
+            lt = i - lt;
+            if (span > span2)
+                span = span2;
+            swap_block(ptr, pi - span, span);
+            /* swap values in ranges [gt..top[ and [i..top-(top-gt)[
+               swapping the smallest span between top-gt and gt-i is sufficient
+             */
+            span = top - pgt;
+            span2 = pgt - pi;
+            pgt = top - span2;
+            gt = nmemb - (gt - i);
+            if (span > span2)
+                span = span2;
+            swap_block(pi, top - span, span);
+
+            /* now array has 3 parts:
+             * from 0 to lt excluded: elements smaller than pivot
+             * from lt to gt excluded: elements identical to pivot
+             * from gt to n excluded: elements greater than pivot
+             */
+            /* stack the larger segment and keep processing the smaller one
+               to minimize stack use for pathological distributions */
+            if (lt > nmemb - gt) {
+                sp->base = ptr;
+                sp->count = lt;
+                sp->depth = depth;
+                sp++;
+                ptr = pgt;
+                nmemb -= gt;
+            } else {
+                sp->base = pgt;
+                sp->count = nmemb - gt;
+                sp->depth = depth;
+                sp++;
+                nmemb = lt;
+            }
+        }
+        /* Use insertion sort for small fragments */
+        for (pi = ptr + size, top = ptr + nmemb * size; pi < top; pi += size) {
+            for (pj = pi; pj > ptr && cmp(pj - size, pj, opaque) > 0; pj -= size)
+                swap(pj, pj - size, size);
+        }
+    }
+}
+
+#endif

src/quickjs/cutils.h

@@ -0,0 +1,341 @@
+/*
+ * C utilities
+ *
+ * Copyright (c) 2017 Fabrice Bellard
+ * Copyright (c) 2018 Charlie Gordon
+ *
+ * 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.
+ */
+#ifndef CUTILS_H
+#define CUTILS_H
+
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#define likely(x)       __builtin_expect(!!(x), 1)
+#define unlikely(x)     __builtin_expect(!!(x), 0)
+#define force_inline inline __attribute__((always_inline))
+#define no_inline __attribute__((noinline))
+#define __maybe_unused __attribute__((unused))
+
+#define xglue(x, y) x ## y
+#define glue(x, y) xglue(x, y)
+#define stringify(s)    tostring(s)
+#define tostring(s)     #s
+
+#ifndef offsetof
+#define offsetof(type, field) ((size_t) &((type *)0)->field)
+#endif
+#ifndef countof
+#define countof(x) (sizeof(x) / sizeof((x)[0]))
+#endif
+#ifndef container_of
+/* return the pointer of type 'type *' containing 'ptr' as field 'member' */
+#define container_of(ptr, type, member) ((type *)((uint8_t *)(ptr) - offsetof(type, member)))
+#endif
+
+typedef int BOOL;
+
+#ifndef FALSE
+enum {
+    FALSE = 0,
+    TRUE = 1,
+};
+#endif
+
+void pstrcpy(char *buf, int buf_size, const char *str);
+char *pstrcat(char *buf, int buf_size, const char *s);
+int strstart(const char *str, const char *val, const char **ptr);
+int has_suffix(const char *str, const char *suffix);
+
+/* Prevent UB when n == 0 and (src == NULL or dest == NULL) */
+static inline void memcpy_no_ub(void *dest, const void *src, size_t n) {
+    if (n)
+        memcpy(dest, src, n);
+}
+
+static inline int max_int(int a, int b)
+{
+    if (a > b)
+        return a;
+    else
+        return b;
+}
+
+static inline int min_int(int a, int b)
+{
+    if (a < b)
+        return a;
+    else
+        return b;
+}
+
+static inline uint32_t max_uint32(uint32_t a, uint32_t b)
+{
+    if (a > b)
+        return a;
+    else
+        return b;
+}
+
+static inline uint32_t min_uint32(uint32_t a, uint32_t b)
+{
+    if (a < b)
+        return a;
+    else
+        return b;
+}
+
+static inline int64_t max_int64(int64_t a, int64_t b)
+{
+    if (a > b)
+        return a;
+    else
+        return b;
+}
+
+static inline int64_t min_int64(int64_t a, int64_t b)
+{
+    if (a < b)
+        return a;
+    else
+        return b;
+}
+
+/* WARNING: undefined if a = 0 */
+static inline int clz32(unsigned int a)
+{
+    return __builtin_clz(a);
+}
+
+/* WARNING: undefined if a = 0 */
+static inline int clz64(uint64_t a)
+{
+    return __builtin_clzll(a);
+}
+
+/* WARNING: undefined if a = 0 */
+static inline int ctz32(unsigned int a)
+{
+    return __builtin_ctz(a);
+}
+
+/* WARNING: undefined if a = 0 */
+static inline int ctz64(uint64_t a)
+{
+    return __builtin_ctzll(a);
+}
+
+struct __attribute__((packed)) packed_u64 {
+    uint64_t v;
+};
+
+struct __attribute__((packed)) packed_u32 {
+    uint32_t v;
+};
+
+struct __attribute__((packed)) packed_u16 {
+    uint16_t v;
+};
+
+static inline uint64_t get_u64(const uint8_t *tab)
+{
+    return ((const struct packed_u64 *)tab)->v;
+}
+
+static inline int64_t get_i64(const uint8_t *tab)
+{
+    return (int64_t)((const struct packed_u64 *)tab)->v;
+}
+
+static inline void put_u64(uint8_t *tab, uint64_t val)
+{
+    ((struct packed_u64 *)tab)->v = val;
+}
+
+static inline uint32_t get_u32(const uint8_t *tab)
+{
+    return ((const struct packed_u32 *)tab)->v;
+}
+
+static inline int32_t get_i32(const uint8_t *tab)
+{
+    return (int32_t)((const struct packed_u32 *)tab)->v;
+}
+
+static inline void put_u32(uint8_t *tab, uint32_t val)
+{
+    ((struct packed_u32 *)tab)->v = val;
+}
+
+static inline uint32_t get_u16(const uint8_t *tab)
+{
+    return ((const struct packed_u16 *)tab)->v;
+}
+
+static inline int32_t get_i16(const uint8_t *tab)
+{
+    return (int16_t)((const struct packed_u16 *)tab)->v;
+}
+
+static inline void put_u16(uint8_t *tab, uint16_t val)
+{
+    ((struct packed_u16 *)tab)->v = val;
+}
+
+static inline uint32_t get_u8(const uint8_t *tab)
+{
+    return *tab;
+}
+
+static inline int32_t get_i8(const uint8_t *tab)
+{
+    return (int8_t)*tab;
+}
+
+static inline void put_u8(uint8_t *tab, uint8_t val)
+{
+    *tab = val;
+}
+
+#ifndef bswap16
+static inline uint16_t bswap16(uint16_t x)
+{
+    return (x >> 8) | (x << 8);
+}
+#endif
+
+#ifndef bswap32
+static inline uint32_t bswap32(uint32_t v)
+{
+    return ((v & 0xff000000) >> 24) | ((v & 0x00ff0000) >>  8) |
+        ((v & 0x0000ff00) <<  8) | ((v & 0x000000ff) << 24);
+}
+#endif
+
+#ifndef bswap64
+static inline uint64_t bswap64(uint64_t v)
+{
+    return ((v & ((uint64_t)0xff << (7 * 8))) >> (7 * 8)) |
+        ((v & ((uint64_t)0xff << (6 * 8))) >> (5 * 8)) |
+        ((v & ((uint64_t)0xff << (5 * 8))) >> (3 * 8)) |
+        ((v & ((uint64_t)0xff << (4 * 8))) >> (1 * 8)) |
+        ((v & ((uint64_t)0xff << (3 * 8))) << (1 * 8)) |
+        ((v & ((uint64_t)0xff << (2 * 8))) << (3 * 8)) |
+        ((v & ((uint64_t)0xff << (1 * 8))) << (5 * 8)) |
+        ((v & ((uint64_t)0xff << (0 * 8))) << (7 * 8));
+}
+#endif
+
+/* XXX: should take an extra argument to pass slack information to the caller */
+typedef void *DynBufReallocFunc(void *opaque, void *ptr, size_t size);
+
+typedef struct DynBuf {
+    uint8_t *buf;
+    size_t size;
+    size_t allocated_size;
+    BOOL error; /* true if a memory allocation error occurred */
+    DynBufReallocFunc *realloc_func;
+    void *opaque; /* for realloc_func */
+} DynBuf;
+
+void dbuf_init(DynBuf *s);
+void dbuf_init2(DynBuf *s, void *opaque, DynBufReallocFunc *realloc_func);
+int dbuf_realloc(DynBuf *s, size_t new_size);
+int dbuf_write(DynBuf *s, size_t offset, const uint8_t *data, size_t len);
+int dbuf_put(DynBuf *s, const uint8_t *data, size_t len);
+int dbuf_put_self(DynBuf *s, size_t offset, size_t len);
+int dbuf_putc(DynBuf *s, uint8_t c);
+int dbuf_putstr(DynBuf *s, const char *str);
+static inline int dbuf_put_u16(DynBuf *s, uint16_t val)
+{
+    return dbuf_put(s, (uint8_t *)&val, 2);
+}
+static inline int dbuf_put_u32(DynBuf *s, uint32_t val)
+{
+    return dbuf_put(s, (uint8_t *)&val, 4);
+}
+static inline int dbuf_put_u64(DynBuf *s, uint64_t val)
+{
+    return dbuf_put(s, (uint8_t *)&val, 8);
+}
+int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
+                                                      const char *fmt, ...);
+void dbuf_free(DynBuf *s);
+static inline BOOL dbuf_error(DynBuf *s) {
+    return s->error;
+}
+static inline void dbuf_set_error(DynBuf *s)
+{
+    s->error = TRUE;
+}
+
+#define UTF8_CHAR_LEN_MAX 6
+
+int unicode_to_utf8(uint8_t *buf, unsigned int c);
+int unicode_from_utf8(const uint8_t *p, int max_len, const uint8_t **pp);
+
+static inline BOOL is_surrogate(uint32_t c)
+{
+    return (c >> 11) == (0xD800 >> 11); // 0xD800-0xDFFF
+}
+
+static inline BOOL is_hi_surrogate(uint32_t c)
+{
+    return (c >> 10) == (0xD800 >> 10); // 0xD800-0xDBFF
+}
+
+static inline BOOL is_lo_surrogate(uint32_t c)
+{
+    return (c >> 10) == (0xDC00 >> 10); // 0xDC00-0xDFFF
+}
+
+static inline uint32_t get_hi_surrogate(uint32_t c)
+{
+    return (c >> 10) - (0x10000 >> 10) + 0xD800;
+}
+
+static inline uint32_t get_lo_surrogate(uint32_t c)
+{
+    return (c & 0x3FF) | 0xDC00;
+}
+
+static inline uint32_t from_surrogate(uint32_t hi, uint32_t lo)
+{
+    return 0x10000 + 0x400 * (hi - 0xD800) + (lo - 0xDC00);
+}
+
+static inline int from_hex(int c)
+{
+    if (c >= '0' && c <= '9')
+        return c - '0';
+    else if (c >= 'A' && c <= 'F')
+        return c - 'A' + 10;
+    else if (c >= 'a' && c <= 'f')
+        return c - 'a' + 10;
+    else
+        return -1;
+}
+
+void rqsort(void *base, size_t nmemb, size_t size,
+            int (*cmp)(const void *, const void *, void *),
+            void *arg);
+
+#endif  /* CUTILS_H */

src/quickjs/debug.c

@@ -0,0 +1,483 @@
+#define _IN_DEBUG_C 1
+#include "debug.h"
+#include <quickjs.h>
+#include <list.h>
+#include <cutils.h>
+#include <assert.h>
+#include "defines.h"
+#include <string.h>
+#include <stdlib.h>
+
+/**
+ * \addtogroup debug
+ * @{
+ */
+struct alloc_block {
+  struct list_head link;
+  const char* file;
+  int line;
+  size_t size;
+};
+
+#define ALLOC_BLOCK_SIZE sizeof(struct alloc_block)
+#define ALLOC_BLOCK(p) (((struct alloc_block*)(p)) - 1)
+#define ALLOC_PTR struct alloc_block*
+
+#undef malloc
+#undef calloc
+#undef realloc
+#undef strdup
+#undef free
+#undef js_malloc
+#undef js_mallocz
+#undef js_realloc
+#undef js_strdup
+#undef js_strndup
+#undef js_free
+#undef js_malloc_usable_size
+#undef js_malloc_rt
+#undef js_mallocz_rt
+#undef js_realloc_rt
+#undef js_free_rt
+#undef js_malloc_usable_size_rt
+
+thread_local struct list_head alloc_block_list = {0, 0};
+
+static inline void
+add_to_list(struct list_head* el, struct list_head* head) {
+  if(alloc_block_list.prev == 0 && alloc_block_list.next == 0)
+    init_list_head(&alloc_block_list);
+
+  list_add_tail(el, head);
+}
+
+int64_t
+check_pointer(void* p) {
+  ALLOC_PTR ptr = ALLOC_BLOCK(p);
+  struct list_head* link;
+  int64_t ret = 0;
+  list_for_each(link, &alloc_block_list) {
+    if(link == &ptr->link)
+      return ret;
+    ret++;
+  }
+  // assert(0);
+  return -1;
+}
+
+void*
+debug_malloc(size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if((ptr = malloc(n + ALLOC_BLOCK_SIZE))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_calloc(size_t m, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  m *= n;
+  n = 1;
+
+  if((ptr = calloc(m + ALLOC_BLOCK_SIZE, 1))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_realloc(void* p, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if(p) {
+
+    check_pointer(p);
+
+    ptr = ALLOC_BLOCK(p);
+    list_del(&ptr->link);
+
+    if(n == 0) {
+      free(ptr);
+      return 0;
+    }
+
+    ptr = realloc(ptr, n + ALLOC_BLOCK_SIZE);
+  } else {
+    ptr = malloc(n + ALLOC_BLOCK_SIZE);
+  }
+
+  if(ptr) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_strdup(const char* s, const char* file, int line) {
+  ALLOC_PTR ptr;
+  size_t len = strlen(s);
+
+  if((ptr = malloc(len + 1 + ALLOC_BLOCK_SIZE))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = len + 1;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+
+    memcpy(&ptr[1], s, len + 1);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void
+debug_free(void* p, const char* file, int line) {
+  ALLOC_PTR ptr = ALLOC_BLOCK(p);
+
+  list_del(&ptr->link);
+
+  memset(ptr, 0xff, ALLOC_BLOCK_SIZE);
+
+  free(ptr);
+}
+
+void*
+debug_js_malloc(JSContext* ctx, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if((ptr = js_malloc(ctx, n + ALLOC_BLOCK_SIZE))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_js_mallocz(JSContext* ctx, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if((ptr = js_mallocz(ctx, n + ALLOC_BLOCK_SIZE))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_js_realloc(JSContext* ctx, void* p, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if(p) {
+
+    check_pointer(p);
+
+    ptr = ALLOC_BLOCK(p);
+    list_del(&ptr->link);
+
+    if(n == 0) {
+      js_free(ctx, ptr);
+      return 0;
+    }
+
+    ptr = js_realloc(ctx, ptr, n + ALLOC_BLOCK_SIZE);
+  } else {
+    ptr = js_malloc(ctx, n + ALLOC_BLOCK_SIZE);
+  }
+
+  if(ptr) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_js_realloc2(JSContext* ctx, void* p, size_t size, size_t* pslack, const char* file, int line) {
+  void* ptr;
+
+  if((ptr = debug_js_realloc(ctx, p, size, file, line))) {
+    if(pslack) {
+      size_t new_size = debug_js_malloc_usable_size(ctx, ptr, file, line);
+      *pslack = (new_size > size) ? new_size - size : 0;
+    }
+  }
+  return ptr;
+}
+
+void*
+debug_js_strdup(JSContext* ctx, const char* s, const char* file, int line) {
+  ALLOC_PTR ptr;
+  size_t len = strlen(s);
+
+  if((ptr = js_malloc(ctx, len + 1 + ALLOC_BLOCK_SIZE))) {
+    char* p = (char*)&ptr[1];
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = len + 1;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+
+    memcpy(p, s, len + 1);
+    return p;
+  }
+  return 0;
+}
+
+void*
+debug_js_strndup(JSContext* ctx, const char* s, size_t len, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if((ptr = js_malloc(ctx, len + 1 + ALLOC_BLOCK_SIZE))) {
+    char* p = (char*)&ptr[1];
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = len + 1;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+
+    memcpy(p, s, len);
+    p[len] = '\0';
+
+    return p;
+  }
+  return 0;
+}
+
+size_t
+debug_js_malloc_usable_size(JSContext* ctx, const void* p, const char* file, int line) {
+  ALLOC_PTR ptr = ALLOC_BLOCK(p);
+
+  return js_malloc_usable_size(ctx, ptr) - ALLOC_BLOCK_SIZE;
+}
+
+void
+debug_js_free(JSContext* ctx, void* p, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  check_pointer(p);
+  ptr = ALLOC_BLOCK(p);
+  list_del(&ptr->link);
+
+  memset(ptr, 0xff, ALLOC_BLOCK_SIZE);
+
+  js_free(ctx, ptr);
+}
+
+void*
+debug_js_malloc_rt(JSRuntime* rt, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if((ptr = js_malloc_rt(rt, n + ALLOC_BLOCK_SIZE))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_js_mallocz_rt(JSRuntime* rt, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if((ptr = js_mallocz_rt(rt, n + ALLOC_BLOCK_SIZE))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_js_realloc_rt(JSRuntime* rt, void* p, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if(p) {
+    check_pointer(p);
+
+    ptr = ALLOC_BLOCK(p);
+    list_del(&ptr->link);
+    if(n == 0) {
+      js_free_rt(rt, ptr);
+      return 0;
+    }
+    ptr = js_realloc_rt(rt, ptr, n + ALLOC_BLOCK_SIZE);
+  } else {
+    ptr = js_malloc_rt(rt, n + ALLOC_BLOCK_SIZE);
+  }
+
+  if(ptr) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+size_t
+debug_js_malloc_usable_size_rt(JSRuntime* rt, const void* p, const char* file, int line) {
+  ALLOC_PTR ptr = ALLOC_BLOCK(p);
+
+  return js_malloc_usable_size_rt(rt, ptr) - ALLOC_BLOCK_SIZE;
+}
+
+void
+debug_js_free_rt(JSRuntime* rt, void* p, const char* file, int line) {
+  ALLOC_PTR ptr;
+  check_pointer(p);
+
+  ptr = ALLOC_BLOCK(p);
+
+  // printf("debug_js_free_rt %p\n", p);
+
+  list_del(&ptr->link);
+
+  memset(ptr, 0xff, ALLOC_BLOCK_SIZE);
+
+  js_free_rt(rt, ptr);
+}
+
+#undef malloc
+#undef calloc
+#undef realloc
+#undef strdup
+#undef free
+#undef js_malloc
+#undef js_mallocz
+#undef js_realloc
+#undef js_strdup
+#undef js_strndup
+#undef js_malloc_usable_size
+#undef js_free
+#undef js_malloc_rt
+#undef js_mallocz_rt
+#undef js_realloc_rt
+#undef js_malloc_usable_size_rt
+#undef js_free_rt
+
+void*
+orig_malloc(size_t size) {
+  return malloc(size);
+}
+
+void*
+orig_calloc(size_t nelem, size_t elemsz) {
+  return calloc(nelem, elemsz);
+}
+
+void*
+orig_realloc(void* ptr, size_t size) {
+  return realloc(ptr, size);
+}
+
+void*
+orig_strdup(const char* str) {
+  return strdup(str);
+}
+
+void
+orig_free(void* ptr) {
+  free(ptr);
+}
+
+void*
+orig_js_malloc(JSContext* ctx, size_t size) {
+  return js_malloc(ctx, size);
+}
+
+void*
+orig_js_mallocz(JSContext* ctx, size_t size) {
+  return js_mallocz(ctx, size);
+}
+
+void*
+orig_js_realloc(JSContext* ctx, void* p, size_t size) {
+  return js_realloc(ctx, p, size);
+}
+
+void*
+orig_js_strdup(JSContext* ctx, const char* str) {
+  return js_strdup(ctx, str);
+}
+
+void*
+orig_js_strndup(JSContext* ctx, const char* str, size_t size) {
+  return js_strndup(ctx, str, size);
+}
+
+size_t
+orig_js_malloc_usable_size(JSContext* ctx, const void* p) {
+  return js_malloc_usable_size(ctx, p);
+}
+
+void
+orig_js_free(JSContext* ctx, void* p) {
+  return js_free(ctx, p);
+}
+
+void*
+orig_js_malloc_rt(JSRuntime* rt, size_t size) {
+  return js_malloc_rt(rt, size);
+}
+
+void*
+orig_js_mallocz_rt(JSRuntime* rt, size_t size) {
+  return js_mallocz_rt(rt, size);
+}
+
+void*
+orig_js_realloc_rt(JSRuntime* rt, void* p, size_t size) {
+  return js_realloc_rt(rt, p, size);
+}
+
+size_t
+orig_js_malloc_usable_size_rt(JSRuntime* rt, const void* p) {
+  return js_malloc_usable_size_rt(rt, p);
+}
+
+void
+orig_js_free_rt(JSRuntime* rt, void* p) {
+  return js_free_rt(rt, p);
+}
+
+/**
+ * @}
+ */

src/quickjs/debug.h

@@ -0,0 +1,165 @@
+#ifndef DEBUG_H
+#define DEBUG_H
+
+#include <quickjs.h>
+#include <cutils.h>
+#include "defines.h"
+
+#ifndef QUICKJS_H
+#error "quickjs.h not included"
+#endif
+
+/**
+ * \defgroup debug debug: Debugging helpers
+ * @{
+ */
+
+extern thread_local struct list_head alloc_block_list;
+
+int64_t check_pointer(void*);
+void* debug_malloc(size_t, const char*, int);
+void* debug_calloc(size_t, size_t, const char*, int line);
+void* debug_realloc(void*, size_t, const char*, int line);
+void* debug_strdup(const char*, const char*, int);
+void debug_free(void*, const char*, int);
+void* debug_js_malloc(JSContext*, size_t, const char*, int line);
+void* debug_js_mallocz(JSContext*, size_t, const char*, int line);
+void* debug_js_realloc(JSContext*, void*, size_t, const char* file, int line);
+void* debug_js_realloc2(JSContext*, void*, size_t, size_t* pslack, const char* file, int line);
+void* debug_js_strdup(JSContext*, const char*, const char*, int line);
+void* debug_js_strndup(JSContext*, const char*, size_t, const char* file, int line);
+size_t debug_js_malloc_usable_size(JSContext*, const void*, const char*, int line);
+void debug_js_free(JSContext*, void*, const char*, int line);
+void* debug_js_malloc_rt(JSRuntime*, size_t, const char*, int line);
+void* debug_js_mallocz_rt(JSRuntime*, size_t, const char*, int line);
+void* debug_js_realloc_rt(JSRuntime*, void*, size_t, const char* file, int line);
+size_t debug_js_malloc_usable_size_rt(JSRuntime*, const void*, const char*, int line);
+void debug_js_free_rt(JSRuntime*, void*, const char*, int line);
+
+#if !defined(_IN_DEBUG_C)
+
+#if defined(DEBUG_ALLOC)
+#define malloc(size) debug_malloc(size, __FILE__, __LINE__)
+#define calloc(nelem, size) debug_calloc(nelem, size, __FILE__, __LINE__)
+#define realloc(ptr, size) debug_realloc(ptr, size, __FILE__, __LINE__)
+#define strdup(str) debug_strdup(str, __FILE__, __LINE__)
+#define free(ptr) debug_free(ptr, __FILE__, __LINE__)
+#define js_malloc(ctx, size) debug_js_malloc(ctx, size, __FILE__, __LINE__)
+#define js_mallocz(ctx, size) debug_js_mallocz(ctx, size, __FILE__, __LINE__)
+#define js_realloc(ctx, ptr, size) debug_js_realloc(ctx, ptr, size, __FILE__, __LINE__)
+#define js_strdup(ctx, str) debug_js_strdup(ctx, str, __FILE__, __LINE__)
+#define js_strndup(ctx, str, len) debug_js_strndup(ctx, str, len, __FILE__, __LINE__)
+#define js_free(ctx, ptr) debug_js_free(ctx, ptr, __FILE__, __LINE__)
+#define js_malloc_usable_size(ctx, ptr) debug_js_malloc_usable_size(ctx, ptr, __FILE__, __LINE__)
+#define js_malloc_rt(rt, size) debug_js_malloc_rt(rt, size, __FILE__, __LINE__)
+#define js_mallocz_rt(rt, size) debug_js_mallocz_rt(rt, size, __FILE__, __LINE__)
+#define js_realloc_rt(rt, ptr, size) debug_js_realloc_rt(rt, ptr, size, __FILE__, __LINE__)
+#define js_malloc_usable_size_rt(rt, ptr) debug_js_malloc_usable_size_rt(rt, ptr, __FILE__, __LINE__)
+#define js_free_rt(rt, ptr) debug_js_free_rt(rt, ptr, __FILE__, __LINE__)
+#endif
+
+#ifdef DEBUG_ALLOC
+#define realloc_helper(name) \
+  void* name(void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return debug_malloc(size, __FILE__, __LINE__); \
+    if(size == 0) \
+      return debug_free(ptr, __FILE__, __LINE__); \
+    return debug_realloc(ptr, size, __FILE__, __LINE__); \
+  }
+#define realloc2_helper(name) \
+  void* name(void* opaque, void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return debug_malloc(size, __FILE__, __LINE__); \
+    if(size == 0) { \
+      debug_free(ptr, __FILE__, __LINE__); \
+      return 0; \
+    } \
+    return debug_realloc(ptr, size, __FILE__, __LINE__); \
+  }
+#define js_realloc_helper(name) \
+  void* name(JSContext* ctx, void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return debug_js_malloc(ctx, size, __FILE__, __LINE__); \
+    if(size == 0) { \
+      debug_js_free(ctx, ptr, __FILE__, __LINE__); \
+      return 0; \
+    } \
+    return debug_js_realloc(ctx, ptr, size, __FILE__, __LINE__); \
+  }
+#define js_realloc_rt_helper(name) \
+  void* name(JSRuntime* rt, void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return debug_js_malloc_rt(rt, size, __FILE__, __LINE__); \
+    if(size == 0) { \
+      debug_js_free_rt(rt, ptr, __FILE__, __LINE__); \
+      return 0; \
+    } \
+    return debug_js_realloc_rt(rt, ptr, size, __FILE__, __LINE__); \
+  }
+#else
+#define realloc_helper(name) \
+  void* name(void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return malloc(size); \
+    if(size == 0) { \
+      free(ptr); \
+      return 0; \
+    } \
+    return realloc(ptr, size); \
+  }
+#define realloc2_helper(name) \
+  void* name(void* opaque, void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return malloc(size); \
+    if(size == 0) { \
+      free(ptr); \
+      return 0; \
+    } \
+    return realloc(ptr, size); \
+  }
+#define js_realloc_helper(name) \
+  void* name(JSContext* ctx, void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return orig_js_malloc(ctx, size); \
+    if(size == 0) { \
+      orig_js_free(ctx, ptr); \
+      return 0; \
+    } \
+    return orig_js_realloc(ctx, ptr, size); \
+  }
+#define js_realloc_rt_helper(name) \
+  void* name(JSRuntime* rt, void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return orig_js_malloc_rt(rt, size); \
+    if(size == 0) { \
+      orig_js_free_rt(rt, ptr); \
+      return 0; \
+    } \
+    return orig_js_realloc_rt(rt, ptr, size); \
+  }
+#endif
+#endif
+
+void* orig_malloc(size_t);
+void* orig_calloc(size_t, size_t);
+void* orig_realloc(void*, size_t);
+void* orig_strdup(const char*);
+void orig_free(void*);
+void* orig_js_malloc(JSContext*, size_t);
+void* orig_js_mallocz(JSContext*, size_t);
+void* orig_js_realloc(JSContext*, void*, size_t);
+void* orig_js_strdup(JSContext*, const char*);
+void* orig_js_strndup(JSContext*, const char*, size_t);
+size_t orig_js_malloc_usable_size(JSContext*, const void*);
+void orig_js_free(JSContext*, void*);
+void* orig_js_malloc_rt(JSRuntime*, size_t);
+void* orig_js_mallocz_rt(JSRuntime*, size_t);
+void* orig_js_realloc_rt(JSRuntime*, void*, size_t);
+size_t orig_js_malloc_usable_size_rt(JSRuntime*, const void*);
+void orig_js_free_rt(JSRuntime*, void*);
+
+/**
+ * @}
+ */
+#endif /* defined(DEBUG_H) */

src/quickjs/defines.h

@@ -0,0 +1,181 @@
+#ifndef DEFINES_H
+#define DEFINES_H
+
+/**
+ * \defgroup defines defines: Preprocessor definitions
+ * @{
+ */
+
+#ifdef _WIN32
+#include <io.h>
+#define FD_TO_SOCKET(fd) ((SOCKET)_get_osfhandle((fd)))
+#define SOCKET_TO_FD(fh) (_open_osfhandle((intptr_t)(fh), O_RDWR | O_BINARY))
+#else
+#define FD_TO_SOCKET(fd) (fd)
+#define SOCKET_TO_FD(fh) (fh)
+#endif
+
+#ifndef offsetof
+#define offsetof(type, field) ((size_t) & ((type*)0)->field)
+#endif
+
+#ifndef inrange
+#define inrange(value, min, max) ((value) >= (min) && (value) <= (max))
+#endif
+
+#define trim_dotslash(str) (!strncmp((str), "./", 2) ? (str) + 2 : (str))
+
+#ifndef thread_local
+#ifdef _Thread_local
+#define thread_local _Thread_local
+#elif defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
+#define thread_local __thread
+#elif defined(_WIN32)
+#define thread_local __declspec(thread)
+#else
+#error No TLS implementation found.
+#endif
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+#define PACK __attribute__((packed))
+#define ENDPACK
+#else
+#define PACK #pragma pack(push, 1)
+#define ENDPACK #pragma pack(pop)
+#endif
+
+#define JS_CGETSET_ENUMERABLE_DEF(prop_name, fgetter, fsetter, magic_num) \
+  { \
+    .name = prop_name, .prop_flags = JS_PROP_ENUMERABLE | JS_PROP_CONFIGURABLE, .def_type = JS_DEF_CGETSET_MAGIC, .magic = magic_num, .u = { \
+      .getset = {.get = {.getter_magic = fgetter}, .set = {.setter_magic = fsetter}} \
+    } \
+  }
+
+#define JS_CGETSET_MAGIC_FLAGS_DEF(prop_name, fgetter, fsetter, magic_num, flags) \
+  { \
+    .name = prop_name, .prop_flags = flags, .def_type = JS_DEF_CGETSET_MAGIC, .magic = magic_num, .u = { \
+      .getset = {.get = {.getter_magic = fgetter}, .set = {.setter_magic = fsetter}} \
+    } \
+  }
+
+#define JS_CFUNC_DEF_FLAGS(prop_name, length, func1, flags) \
+  { \
+    .name = prop_name, .prop_flags = flags, .def_type = JS_DEF_CFUNC, .magic = 0, .u = {.func = {length, JS_CFUNC_generic, {.generic = func1}} } \
+  }
+
+#define JS_CONSTANT_FLAGS(name, flags) JS_PROP_INT32_DEF(#name, name, (flags))
+#define JS_CONSTANT(name) JS_PROP_INT32_DEF(#name, name, JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE)
+#define JS_CONSTANT_NONENUMERABLE(name) JS_PROP_INT32_DEF(#name, name, JS_PROP_CONFIGURABLE)
+
+#ifdef JS_SHARED_LIBRARY
+#if defined(_WIN32) || defined(__MINGW32__)
+#define VISIBLE __declspec(dllexport)
+#define HIDDEN
+#else
+#define VISIBLE __attribute__((visibility("default")))
+#define HIDDEN __attribute__((visibility("hidden")))
+#endif
+#else
+#define VISIBLE
+#define HIDDEN
+#endif
+
+#ifndef MAX_NUM
+#define MAX_NUM(a, b) ((a) > (b) ? (a) : (b))
+#endif
+#ifndef MIN_NUM
+#define MIN_NUM(a, b) ((a) < (b) ? (a) : (b))
+#endif
+#ifndef ABS_NUM
+#define ABS_NUM(n) ((n) < 0 ? -(n) : (n))
+#endif
+#ifndef MOD_NUM
+#define MOD_NUM(n, divisor) ((((n) % (divisor)) + (divisor)) % (divisor))
+#endif
+#ifndef SIGN_NUM
+#define SIGN_NUM(n) ((n) < 0)
+#endif
+
+#define COLOR_BLACK "\x1b[0;30m"
+#define COLOR_RED "\x1b[0;31m"
+#define COLOR_GREEN "\x1b[0;32m"
+#define COLOR_BROWN "\x1b[0;33m"
+#define COLOR_BLUE "\x1b[0;34m"
+#define COLOR_PURPLE "\x1b[0;35m"
+#define COLOR_MARINE "\x1b[0;36m"
+#define COLOR_LIGHTGRAY "\x1b[0;37m"
+#define COLOR_GRAY "\x1b[1;30m"
+#define COLOR_NONE "\x1b[0m"
+
+#define COLOR_LIGHTRED "\x1b[1;31m"
+
+#define COLOR_LIGHTGREEN "\x1b[1;32m"
+#define COLOR_YELLOW "\x1b[1;33m"
+#define COLOR_LIGHTBLUE "\x1b[1;34m"
+#define COLOR_MAGENTA "\x1b[1;35m"
+#define COLOR_CYAN "\x1b[1;36m"
+#define COLOR_WHITE "\x1b[1;37m"
+
+#define BGCOLOR_RED "\x1b[48;5;124m"
+#define BGCOLOR_BLUE "\x1b[48;5;20m"
+#define BGCOLOR_YELLOW "\x1b[48;5;214m"
+#define BGCOLOR_GREEN "\x1b[48;5;28m"
+#define BGCOLOR_PINK "\x1b[48;5;165m"
+
+#define JS_VALUE_FREE(ctx, value) \
+  do { \
+    JS_FreeValue((ctx), (value)); \
+    (value) = JS_UNDEFINED; \
+  } while(0);
+#define JS_VALUE_FREE_RT(ctx, value) \
+  do { \
+    JS_FreeValueRT((ctx), (value)); \
+    (value) = JS_UNDEFINED; \
+  } while(0);
+
+#if 0
+#define js_object_tmpmark_set(value) \
+  do { \
+    ((uint8_t*)JS_VALUE_GET_OBJ((value)))[5] |= 0x40; \
+  } while(0);
+#define js_object_tmpmark_clear(value) \
+  do { \
+    ((uint8_t*)JS_VALUE_GET_OBJ((value)))[5] &= ~0x40; \
+  } while(0);
+#define js_object_tmpmark_isset(value) (((uint8_t*)JS_VALUE_GET_OBJ((value)))[5] & 0x40)
+#else
+#define js_object_tmpmark_set(value) \
+  do { \
+    JS_VALUE_GET_OBJ((value))->tmp_mark |= 0x40; \
+  } while(0);
+#define js_object_tmpmark_clear(value) \
+  do { \
+    JS_VALUE_GET_OBJ((value))->tmp_mark &= ~0x40; \
+  } while(0);
+#define js_object_tmpmark_isset(value) (JS_VALUE_GET_OBJ((value))->tmp_mark & 0x40)
+#endif
+
+#define js_runtime_exception_set(rt, value) \
+  do { \
+    *(JSValue*)((uint8_t*)(rt) + 216) = value; \
+  } while(0);
+#define js_runtime_exception_get(rt) (*(JSValue*)((uint8_t*)(rt) + 216))
+#define js_runtime_exception_clear(rt) \
+  do { \
+    if(!JS_IsNull(js_runtime_exception_get(rt))) \
+      JS_FreeValueRT((rt), js_runtime_exception_get(rt)); \
+    js_runtime_exception_set(rt, JS_NULL); \
+  } while(0)
+
+#define JS_ATOM_TAG_INT (1U << 31)
+#define JS_ATOM_MAX_INT (JS_ATOM_TAG_INT - 1)
+
+#define JS_ATOM_ISINT(i) ((JSAtom)((i)&JS_ATOM_TAG_INT))
+#define JS_ATOM_FROMINT(i) ((JSAtom)((i)&JS_ATOM_MAX_INT) | JS_ATOM_TAG_INT)
+#define JS_ATOM_TOINT(i) (unsigned int)(((JSAtom)(i) & (~(JS_ATOM_TAG_INT))))
+
+/**
+ * @}
+ */
+#endif /* defined(DEFINES_H) */

src/quickjs/hello.c

@@ -0,0 +1,45 @@
+/* File generated automatically by the QuickJS compiler. */
+
+#include "quickjs-libc.h"
+
+const uint32_t qjsc_hello_size = 87;
+
+const uint8_t qjsc_hello[87] = {
+ 0x43, 0x04, 0x0e, 0x63, 0x6f, 0x6e, 0x73, 0x6f,
+ 0x6c, 0x65, 0x06, 0x6c, 0x6f, 0x67, 0x16, 0x48,
+ 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72,
+ 0x6c, 0x64, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70,
+ 0x6c, 0x65, 0x73, 0x2f, 0x68, 0x65, 0x6c, 0x6c,
+ 0x6f, 0x2e, 0x6a, 0x73, 0x0c, 0x00, 0x06, 0x00,
+ 0xa2, 0x01, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00,
+ 0x14, 0x01, 0xa4, 0x01, 0x00, 0x00, 0x00, 0x38,
+ 0xe3, 0x00, 0x00, 0x00, 0x42, 0xe4, 0x00, 0x00,
+ 0x00, 0x04, 0xe5, 0x00, 0x00, 0x00, 0x24, 0x01,
+ 0x00, 0xcf, 0x28, 0xcc, 0x03, 0x01, 0x00,
+};
+
+static JSContext *JS_NewCustomContext(JSRuntime *rt)
+{
+  JSContext *ctx = JS_NewContextRaw(rt);
+  if (!ctx)
+    return NULL;
+  JS_AddIntrinsicBaseObjects(ctx);
+  return ctx;
+}
+
+int main(int argc, char **argv)
+{
+  JSRuntime *rt;
+  JSContext *ctx;
+  rt = JS_NewRuntime();
+  js_std_set_worker_new_context_func(JS_NewCustomContext);
+  js_std_init_handlers(rt);
+  ctx = JS_NewCustomContext(rt);
+  js_std_add_helpers(ctx, argc, argv);
+  js_std_eval_binary(ctx, qjsc_hello, qjsc_hello_size, 0);
+  js_std_loop(ctx);
+  js_std_free_handlers(rt);
+  JS_FreeContext(ctx);
+  JS_FreeRuntime(rt);
+  return 0;
+}

src/quickjs/iso_8859_1.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_1_H
+#define TUTF8E_ISO_8859_1_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_1_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_1, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_1_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_1, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_1_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_1, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_1_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_1, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_10.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_10_H
+#define TUTF8E_ISO_8859_10_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_10_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_10, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_10_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_10, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_10_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_10, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_10_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_10, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_11.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_11_H
+#define TUTF8E_ISO_8859_11_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_11_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_11, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_11_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_11, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_11_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_11, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_11_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_11, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_13.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_13_H
+#define TUTF8E_ISO_8859_13_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_13_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_13, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_13_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_13, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_13_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_13, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_13_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_13, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_14.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_14_H
+#define TUTF8E_ISO_8859_14_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_14_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_14, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_14_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_14, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_14_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_14, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_14_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_14, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_15.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_15_H
+#define TUTF8E_ISO_8859_15_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_15_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_15, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_15_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_15, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_15_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_15, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_15_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_15, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_16.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_16_H
+#define TUTF8E_ISO_8859_16_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_16_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_16, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_16_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_16, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_16_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_16, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_16_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_16, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_2.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_2_H
+#define TUTF8E_ISO_8859_2_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_2_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_2, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_2_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_2, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_2_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_2, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_2_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_2, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_3.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_3_H
+#define TUTF8E_ISO_8859_3_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_3_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_3, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_3_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_3, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_3_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_3, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_3_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_3, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_4.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_4_H
+#define TUTF8E_ISO_8859_4_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_4_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_4, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_4_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_4, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_4_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_4, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_4_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_4, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_5.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_5_H
+#define TUTF8E_ISO_8859_5_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_5_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_5, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_5_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_5, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_5_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_5, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_5_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_5, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_6.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_6_H
+#define TUTF8E_ISO_8859_6_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_6_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_6, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_6_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_6, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_6_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_6, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_6_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_6, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_7.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_7_H
+#define TUTF8E_ISO_8859_7_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_7_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_7, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_7_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_7, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_7_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_7, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_7_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_7, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_8.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_8_H
+#define TUTF8E_ISO_8859_8_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_8_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_8, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_8_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_8, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_8_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_8, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_8_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_8, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_9.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_9_H
+#define TUTF8E_ISO_8859_9_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_9_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_9, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_9_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_9, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_9_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_9, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_9_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_9, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/libbf.h

@@ -0,0 +1,535 @@
+/*
+ * Tiny arbitrary precision floating point library
+ *
+ * Copyright (c) 2017-2021 Fabrice Bellard
+ *
+ * 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.
+ */
+#ifndef LIBBF_H
+#define LIBBF_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#if defined(__SIZEOF_INT128__) && (INTPTR_MAX >= INT64_MAX)
+#define LIMB_LOG2_BITS 6
+#else
+#define LIMB_LOG2_BITS 5
+#endif
+
+#define LIMB_BITS (1 << LIMB_LOG2_BITS)
+
+#if LIMB_BITS == 64
+typedef __int128 int128_t;
+typedef unsigned __int128 uint128_t;
+typedef int64_t slimb_t;
+typedef uint64_t limb_t;
+typedef uint128_t dlimb_t;
+#define BF_RAW_EXP_MIN INT64_MIN
+#define BF_RAW_EXP_MAX INT64_MAX
+
+#define LIMB_DIGITS 19
+#define BF_DEC_BASE UINT64_C(10000000000000000000)
+
+#else
+
+typedef int32_t slimb_t;
+typedef uint32_t limb_t;
+typedef uint64_t dlimb_t;
+#define BF_RAW_EXP_MIN INT32_MIN
+#define BF_RAW_EXP_MAX INT32_MAX
+
+#define LIMB_DIGITS 9
+#define BF_DEC_BASE 1000000000U
+
+#endif
+
+/* in bits */
+/* minimum number of bits for the exponent */
+#define BF_EXP_BITS_MIN 3
+/* maximum number of bits for the exponent */
+#define BF_EXP_BITS_MAX (LIMB_BITS - 3)
+/* extended range for exponent, used internally */
+#define BF_EXT_EXP_BITS_MAX (BF_EXP_BITS_MAX + 1)
+/* minimum possible precision */
+#define BF_PREC_MIN 2
+/* minimum possible precision */
+#define BF_PREC_MAX (((limb_t)1 << (LIMB_BITS - 2)) - 2)
+/* some operations support infinite precision */
+#define BF_PREC_INF (BF_PREC_MAX + 1) /* infinite precision */
+
+#if LIMB_BITS == 64
+#define BF_CHKSUM_MOD (UINT64_C(975620677) * UINT64_C(9795002197))
+#else
+#define BF_CHKSUM_MOD 975620677U
+#endif
+
+#define BF_EXP_ZERO BF_RAW_EXP_MIN
+#define BF_EXP_INF (BF_RAW_EXP_MAX - 1)
+#define BF_EXP_NAN BF_RAW_EXP_MAX
+
+/* +/-zero is represented with expn = BF_EXP_ZERO and len = 0,
+   +/-infinity is represented with expn = BF_EXP_INF and len = 0,
+   NaN is represented with expn = BF_EXP_NAN and len = 0 (sign is ignored)
+ */
+typedef struct {
+    struct bf_context_t *ctx;
+    int sign;
+    slimb_t expn;
+    limb_t len;
+    limb_t *tab;
+} bf_t;
+
+typedef struct {
+    /* must be kept identical to bf_t */
+    struct bf_context_t *ctx;
+    int sign;
+    slimb_t expn;
+    limb_t len;
+    limb_t *tab;
+} bfdec_t;
+
+typedef enum {
+    BF_RNDN, /* round to nearest, ties to even */
+    BF_RNDZ, /* round to zero */
+    BF_RNDD, /* round to -inf (the code relies on (BF_RNDD xor BF_RNDU) = 1) */
+    BF_RNDU, /* round to +inf */
+    BF_RNDNA, /* round to nearest, ties away from zero */
+    BF_RNDA, /* round away from zero */
+    BF_RNDF, /* faithful rounding (nondeterministic, either RNDD or RNDU,
+                inexact flag is always set)  */
+} bf_rnd_t;
+
+/* allow subnormal numbers. Only available if the number of exponent
+   bits is <= BF_EXP_BITS_USER_MAX and prec != BF_PREC_INF. */
+#define BF_FLAG_SUBNORMAL (1 << 3)
+/* 'prec' is the precision after the radix point instead of the whole
+   mantissa. Can only be used with bf_round() and
+   bfdec_[add|sub|mul|div|sqrt|round](). */
+#define BF_FLAG_RADPNT_PREC (1 << 4)
+
+#define BF_RND_MASK 0x7
+#define BF_EXP_BITS_SHIFT 5
+#define BF_EXP_BITS_MASK 0x3f
+
+/* shortcut for bf_set_exp_bits(BF_EXT_EXP_BITS_MAX) */
+#define BF_FLAG_EXT_EXP (BF_EXP_BITS_MASK << BF_EXP_BITS_SHIFT)
+
+/* contains the rounding mode and number of exponents bits */
+typedef uint32_t bf_flags_t;
+
+typedef void *bf_realloc_func_t(void *opaque, void *ptr, size_t size);
+
+typedef struct {
+    bf_t val;
+    limb_t prec;
+} BFConstCache;
+
+typedef struct bf_context_t {
+    void *realloc_opaque;
+    bf_realloc_func_t *realloc_func;
+    BFConstCache log2_cache;
+    BFConstCache pi_cache;
+    struct BFNTTState *ntt_state;
+} bf_context_t;
+
+static inline int bf_get_exp_bits(bf_flags_t flags)
+{
+    int e;
+    e = (flags >> BF_EXP_BITS_SHIFT) & BF_EXP_BITS_MASK;
+    if (e == BF_EXP_BITS_MASK)
+        return BF_EXP_BITS_MAX + 1;
+    else
+        return BF_EXP_BITS_MAX - e;
+}
+
+static inline bf_flags_t bf_set_exp_bits(int n)
+{
+    return ((BF_EXP_BITS_MAX - n) & BF_EXP_BITS_MASK) << BF_EXP_BITS_SHIFT;
+}
+
+/* returned status */
+#define BF_ST_INVALID_OP  (1 << 0)
+#define BF_ST_DIVIDE_ZERO (1 << 1)
+#define BF_ST_OVERFLOW    (1 << 2)
+#define BF_ST_UNDERFLOW   (1 << 3)
+#define BF_ST_INEXACT     (1 << 4)
+/* indicate that a memory allocation error occured. NaN is returned */
+#define BF_ST_MEM_ERROR   (1 << 5)
+
+#define BF_RADIX_MAX 36 /* maximum radix for bf_atof() and bf_ftoa() */
+
+static inline slimb_t bf_max(slimb_t a, slimb_t b)
+{
+    if (a > b)
+        return a;
+    else
+        return b;
+}
+
+static inline slimb_t bf_min(slimb_t a, slimb_t b)
+{
+    if (a < b)
+        return a;
+    else
+        return b;
+}
+
+void bf_context_init(bf_context_t *s, bf_realloc_func_t *realloc_func,
+                     void *realloc_opaque);
+void bf_context_end(bf_context_t *s);
+/* free memory allocated for the bf cache data */
+void bf_clear_cache(bf_context_t *s);
+
+static inline void *bf_realloc(bf_context_t *s, void *ptr, size_t size)
+{
+    return s->realloc_func(s->realloc_opaque, ptr, size);
+}
+
+/* 'size' must be != 0 */
+static inline void *bf_malloc(bf_context_t *s, size_t size)
+{
+    return bf_realloc(s, NULL, size);
+}
+
+static inline void bf_free(bf_context_t *s, void *ptr)
+{
+    /* must test ptr otherwise equivalent to malloc(0) */
+    if (ptr)
+        bf_realloc(s, ptr, 0);
+}
+
+void bf_init(bf_context_t *s, bf_t *r);
+
+static inline void bf_delete(bf_t *r)
+{
+    bf_context_t *s = r->ctx;
+    /* we accept to delete a zeroed bf_t structure */
+    if (s && r->tab) {
+        bf_realloc(s, r->tab, 0);
+    }
+}
+
+static inline void bf_neg(bf_t *r)
+{
+    r->sign ^= 1;
+}
+
+static inline int bf_is_finite(const bf_t *a)
+{
+    return (a->expn < BF_EXP_INF);
+}
+
+static inline int bf_is_nan(const bf_t *a)
+{
+    return (a->expn == BF_EXP_NAN);
+}
+
+static inline int bf_is_zero(const bf_t *a)
+{
+    return (a->expn == BF_EXP_ZERO);
+}
+
+static inline void bf_memcpy(bf_t *r, const bf_t *a)
+{
+    *r = *a;
+}
+
+int bf_set_ui(bf_t *r, uint64_t a);
+int bf_set_si(bf_t *r, int64_t a);
+void bf_set_nan(bf_t *r);
+void bf_set_zero(bf_t *r, int is_neg);
+void bf_set_inf(bf_t *r, int is_neg);
+int bf_set(bf_t *r, const bf_t *a);
+void bf_move(bf_t *r, bf_t *a);
+int bf_get_float64(const bf_t *a, double *pres, bf_rnd_t rnd_mode);
+int bf_set_float64(bf_t *a, double d);
+
+int bf_cmpu(const bf_t *a, const bf_t *b);
+int bf_cmp_full(const bf_t *a, const bf_t *b);
+int bf_cmp(const bf_t *a, const bf_t *b);
+static inline int bf_cmp_eq(const bf_t *a, const bf_t *b)
+{
+    return bf_cmp(a, b) == 0;
+}
+
+static inline int bf_cmp_le(const bf_t *a, const bf_t *b)
+{
+    return bf_cmp(a, b) <= 0;
+}
+
+static inline int bf_cmp_lt(const bf_t *a, const bf_t *b)
+{
+    return bf_cmp(a, b) < 0;
+}
+
+int bf_add(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
+int bf_sub(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
+int bf_add_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec, bf_flags_t flags);
+int bf_mul(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
+int bf_mul_ui(bf_t *r, const bf_t *a, uint64_t b1, limb_t prec, bf_flags_t flags);
+int bf_mul_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec,
+              bf_flags_t flags);
+int bf_mul_2exp(bf_t *r, slimb_t e, limb_t prec, bf_flags_t flags);
+int bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
+#define BF_DIVREM_EUCLIDIAN BF_RNDF
+int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
+              limb_t prec, bf_flags_t flags, int rnd_mode);
+int bf_rem(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
+           bf_flags_t flags, int rnd_mode);
+int bf_remquo(slimb_t *pq, bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
+              bf_flags_t flags, int rnd_mode);
+/* round to integer with infinite precision */
+int bf_rint(bf_t *r, int rnd_mode);
+int bf_round(bf_t *r, limb_t prec, bf_flags_t flags);
+int bf_sqrtrem(bf_t *r, bf_t *rem1, const bf_t *a);
+int bf_sqrt(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
+slimb_t bf_get_exp_min(const bf_t *a);
+int bf_logic_or(bf_t *r, const bf_t *a, const bf_t *b);
+int bf_logic_xor(bf_t *r, const bf_t *a, const bf_t *b);
+int bf_logic_and(bf_t *r, const bf_t *a, const bf_t *b);
+
+/* additional flags for bf_atof */
+/* do not accept hex radix prefix (0x or 0X) if radix = 0 or radix = 16 */
+#define BF_ATOF_NO_HEX       (1 << 16)
+/* accept binary (0b or 0B) or octal (0o or 0O) radix prefix if radix = 0 */
+#define BF_ATOF_BIN_OCT      (1 << 17)
+/* Do not parse NaN or Inf */
+#define BF_ATOF_NO_NAN_INF   (1 << 18)
+/* return the exponent separately */
+#define BF_ATOF_EXPONENT       (1 << 19)
+
+int bf_atof(bf_t *a, const char *str, const char **pnext, int radix,
+            limb_t prec, bf_flags_t flags);
+/* this version accepts prec = BF_PREC_INF and returns the radix
+   exponent */
+int bf_atof2(bf_t *r, slimb_t *pexponent,
+             const char *str, const char **pnext, int radix,
+             limb_t prec, bf_flags_t flags);
+int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
+                     slimb_t expn, limb_t prec, bf_flags_t flags);
+
+
+/* Conversion of floating point number to string. Return a null
+   terminated string or NULL if memory error. *plen contains its
+   length if plen != NULL.  The exponent letter is "e" for base 10,
+   "p" for bases 2, 8, 16 with a binary exponent and "@" for the other
+   bases. */
+
+#define BF_FTOA_FORMAT_MASK (3 << 16)
+
+/* fixed format: prec significant digits rounded with (flags &
+   BF_RND_MASK). Exponential notation is used if too many zeros are
+   needed.*/
+#define BF_FTOA_FORMAT_FIXED (0 << 16)
+/* fractional format: prec digits after the decimal point rounded with
+   (flags & BF_RND_MASK) */
+#define BF_FTOA_FORMAT_FRAC  (1 << 16)
+/* free format:
+
+   For binary radices with bf_ftoa() and for bfdec_ftoa(): use the minimum
+   number of digits to represent 'a'. The precision and the rounding
+   mode are ignored.
+
+   For the non binary radices with bf_ftoa(): use as many digits as
+   necessary so that bf_atof() return the same number when using
+   precision 'prec', rounding to nearest and the subnormal
+   configuration of 'flags'. The result is meaningful only if 'a' is
+   already rounded to 'prec' bits. If the subnormal flag is set, the
+   exponent in 'flags' must also be set to the desired exponent range.
+*/
+#define BF_FTOA_FORMAT_FREE  (2 << 16)
+/* same as BF_FTOA_FORMAT_FREE but uses the minimum number of digits
+   (takes more computation time). Identical to BF_FTOA_FORMAT_FREE for
+   binary radices with bf_ftoa() and for bfdec_ftoa(). */
+#define BF_FTOA_FORMAT_FREE_MIN (3 << 16)
+
+/* force exponential notation for fixed or free format */
+#define BF_FTOA_FORCE_EXP    (1 << 20)
+/* add 0x prefix for base 16, 0o prefix for base 8 or 0b prefix for
+   base 2 if non zero value */
+#define BF_FTOA_ADD_PREFIX   (1 << 21)
+/* return "Infinity" instead of "Inf" and add a "+" for positive
+   exponents */
+#define BF_FTOA_JS_QUIRKS    (1 << 22)
+
+char *bf_ftoa(size_t *plen, const bf_t *a, int radix, limb_t prec,
+              bf_flags_t flags);
+
+/* modulo 2^n instead of saturation. NaN and infinity return 0 */
+#define BF_GET_INT_MOD (1 << 0)
+int bf_get_int32(int *pres, const bf_t *a, int flags);
+int bf_get_int64(int64_t *pres, const bf_t *a, int flags);
+int bf_get_uint64(uint64_t *pres, const bf_t *a);
+
+/* the following functions are exported for testing only. */
+void mp_print_str(const char *str, const limb_t *tab, limb_t n);
+void bf_print_str(const char *str, const bf_t *a);
+int bf_resize(bf_t *r, limb_t len);
+int bf_get_fft_size(int *pdpl, int *pnb_mods, limb_t len);
+int bf_normalize_and_round(bf_t *r, limb_t prec1, bf_flags_t flags);
+int bf_can_round(const bf_t *a, slimb_t prec, bf_rnd_t rnd_mode, slimb_t k);
+slimb_t bf_mul_log2_radix(slimb_t a1, unsigned int radix, int is_inv,
+                          int is_ceil1);
+int mp_mul(bf_context_t *s, limb_t *result,
+           const limb_t *op1, limb_t op1_size,
+           const limb_t *op2, limb_t op2_size);
+limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2,
+              limb_t n, limb_t carry);
+limb_t mp_add_ui(limb_t *tab, limb_t b, size_t n);
+int mp_sqrtrem(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n);
+int mp_recip(bf_context_t *s, limb_t *tabr, const limb_t *taba, limb_t n);
+limb_t bf_isqrt(limb_t a);
+
+/* transcendental functions */
+int bf_const_log2(bf_t *T, limb_t prec, bf_flags_t flags);
+int bf_const_pi(bf_t *T, limb_t prec, bf_flags_t flags);
+int bf_exp(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
+int bf_log(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
+#define BF_POW_JS_QUIRKS (1 << 16) /* (+/-1)^(+/-Inf) = NaN, 1^NaN = NaN */
+int bf_pow(bf_t *r, const bf_t *x, const bf_t *y, limb_t prec, bf_flags_t flags);
+int bf_cos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
+int bf_sin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
+int bf_tan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
+int bf_atan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
+int bf_atan2(bf_t *r, const bf_t *y, const bf_t *x,
+             limb_t prec, bf_flags_t flags);
+int bf_asin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
+int bf_acos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags);
+
+/* decimal floating point */
+
+static inline void bfdec_init(bf_context_t *s, bfdec_t *r)
+{
+    bf_init(s, (bf_t *)r);
+}
+static inline void bfdec_delete(bfdec_t *r)
+{
+    bf_delete((bf_t *)r);
+}
+
+static inline void bfdec_neg(bfdec_t *r)
+{
+    r->sign ^= 1;
+}
+
+static inline int bfdec_is_finite(const bfdec_t *a)
+{
+    return (a->expn < BF_EXP_INF);
+}
+
+static inline int bfdec_is_nan(const bfdec_t *a)
+{
+    return (a->expn == BF_EXP_NAN);
+}
+
+static inline int bfdec_is_zero(const bfdec_t *a)
+{
+    return (a->expn == BF_EXP_ZERO);
+}
+
+static inline void bfdec_memcpy(bfdec_t *r, const bfdec_t *a)
+{
+    bf_memcpy((bf_t *)r, (const bf_t *)a);
+}
+
+int bfdec_set_ui(bfdec_t *r, uint64_t a);
+int bfdec_set_si(bfdec_t *r, int64_t a);
+
+static inline void bfdec_set_nan(bfdec_t *r)
+{
+    bf_set_nan((bf_t *)r);
+}
+static inline void bfdec_set_zero(bfdec_t *r, int is_neg)
+{
+    bf_set_zero((bf_t *)r, is_neg);
+}
+static inline void bfdec_set_inf(bfdec_t *r, int is_neg)
+{
+    bf_set_inf((bf_t *)r, is_neg);
+}
+static inline int bfdec_set(bfdec_t *r, const bfdec_t *a)
+{
+    return bf_set((bf_t *)r, (bf_t *)a);
+}
+static inline void bfdec_move(bfdec_t *r, bfdec_t *a)
+{
+    bf_move((bf_t *)r, (bf_t *)a);
+}
+static inline int bfdec_cmpu(const bfdec_t *a, const bfdec_t *b)
+{
+    return bf_cmpu((const bf_t *)a, (const bf_t *)b);
+}
+static inline int bfdec_cmp_full(const bfdec_t *a, const bfdec_t *b)
+{
+    return bf_cmp_full((const bf_t *)a, (const bf_t *)b);
+}
+static inline int bfdec_cmp(const bfdec_t *a, const bfdec_t *b)
+{
+    return bf_cmp((const bf_t *)a, (const bf_t *)b);
+}
+static inline int bfdec_cmp_eq(const bfdec_t *a, const bfdec_t *b)
+{
+    return bfdec_cmp(a, b) == 0;
+}
+static inline int bfdec_cmp_le(const bfdec_t *a, const bfdec_t *b)
+{
+    return bfdec_cmp(a, b) <= 0;
+}
+static inline int bfdec_cmp_lt(const bfdec_t *a, const bfdec_t *b)
+{
+    return bfdec_cmp(a, b) < 0;
+}
+
+int bfdec_add(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags);
+int bfdec_sub(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags);
+int bfdec_add_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
+                 bf_flags_t flags);
+int bfdec_mul(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags);
+int bfdec_mul_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
+                 bf_flags_t flags);
+int bfdec_div(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags);
+int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
+                 limb_t prec, bf_flags_t flags, int rnd_mode);
+int bfdec_rem(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
+              bf_flags_t flags, int rnd_mode);
+int bfdec_rint(bfdec_t *r, int rnd_mode);
+int bfdec_sqrt(bfdec_t *r, const bfdec_t *a, limb_t prec, bf_flags_t flags);
+int bfdec_round(bfdec_t *r, limb_t prec, bf_flags_t flags);
+int bfdec_get_int32(int *pres, const bfdec_t *a);
+int bfdec_pow_ui(bfdec_t *r, const bfdec_t *a, limb_t b);
+
+char *bfdec_ftoa(size_t *plen, const bfdec_t *a, limb_t prec, bf_flags_t flags);
+int bfdec_atof(bfdec_t *r, const char *str, const char **pnext,
+               limb_t prec, bf_flags_t flags);
+
+/* the following functions are exported for testing only. */
+extern const limb_t mp_pow_dec[LIMB_DIGITS + 1];
+void bfdec_print_str(const char *str, const bfdec_t *a);
+static inline int bfdec_resize(bfdec_t *r, limb_t len)
+{
+    return bf_resize((bf_t *)r, len);
+}
+int bfdec_normalize_and_round(bfdec_t *r, limb_t prec1, bf_flags_t flags);
+
+#endif /* LIBBF_H */

src/quickjs/libregexp-opcode.h

@@ -0,0 +1,57 @@
+/*
+ * Regular Expression Engine
+ *
+ * Copyright (c) 2017-2018 Fabrice Bellard
+ *
+ * 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.
+ */
+
+#ifdef DEF
+
+DEF(invalid, 1) /* never used */
+DEF(char, 3)
+DEF(char32, 5)
+DEF(dot, 1)
+DEF(any, 1) /* same as dot but match any character including line terminator */
+DEF(line_start, 1)
+DEF(line_end, 1)
+DEF(goto, 5)
+DEF(split_goto_first, 5)
+DEF(split_next_first, 5)
+DEF(match, 1)
+DEF(save_start, 2) /* save start position */
+DEF(save_end, 2) /* save end position, must come after saved_start */
+DEF(save_reset, 3) /* reset save positions */
+DEF(loop, 5) /* decrement the top the stack and goto if != 0 */
+DEF(push_i32, 5) /* push integer on the stack */
+DEF(drop, 1)
+DEF(word_boundary, 1)
+DEF(not_word_boundary, 1)
+DEF(back_reference, 2)
+DEF(backward_back_reference, 2) /* must come after back_reference */
+DEF(range, 3) /* variable length */
+DEF(range32, 3) /* variable length */
+DEF(lookahead, 5)
+DEF(negative_lookahead, 5)
+DEF(push_char_pos, 1) /* push the character position on the stack */
+DEF(check_advance, 1) /* pop one stack element and check that it is different from the character position */
+DEF(prev, 1) /* go to the previous char */
+DEF(simple_greedy_quant, 17)
+
+#endif /* DEF */