Merge pull request #261120 from MuKnIO/gerbil-0.18

Gerbil 0.18

pkgs/development/compilers/gambit/build.nix

···
   stampYmd ? 0, stampHms ? 0,
   gambit-support,
   optimizationSetting ? "-O1",
-  gambit-params ? pkgs.gambit-support.stable-params }:
+  gambit-params ? pkgs.gambit-support.stable-params,
+  rev ? git-version }:
 
 # Note that according to a benchmark run by Marc Feeley on May 2018,
 # clang is 10x (with default settings) to 15% (with -O2) slower than GCC at compiling
···
   inherit src version git-version;
   bootstrap = gambit-support.gambit-bootstrap;
 
+  passthru = {
+    inherit src version git-version rev stampYmd stampHms optimizationSetting openssl;
+  };
+
+
   nativeBuildInputs = [ git autoconf ];
 
   # TODO: if/when we can get all the library packages we depend on to have static versions,
···
     "--enable-c-opt=${optimizationSetting}"
     "--enable-c-opt-rts=-O2"
     "--enable-gcc-opts"
+    "--enable-trust-c-tco"
     "--enable-shared"
     "--enable-absolute-shared-libs" # Yes, NixOS will want an absolute path, and fix it.
     "--enable-openssl"
···
     # "--enable-char-size=1" # default is 4
     # "--enable-march=native" # Nope, makes it not work on machines older than the builder
   ] ++ gambit-params.extraOptions
+    # TODO: pick an appropriate architecture to optimize on on x86-64?
+    # https://gcc.gnu.org/onlinedocs/gcc-4.8.4/gcc/i386-and-x86-64-Options.html#i386-and-x86-64-Options
+    # ++ lib.optional pkgs.stdenv.isx86_64 "--enable-march=core-avx2"
     # Do not enable poll on darwin due to https://github.com/gambit/gambit/issues/498
     ++ lib.optional (!gccStdenv.isDarwin) "--enable-poll";
 

pkgs/development/compilers/gambit/default.nix

···
 
 callPackage ./build.nix rec {
   version = "4.9.5";
-  git-version = version;
+  git-version = "v${version}";
   src = fetchurl {
     url = "https://gambitscheme.org/4.9.5/gambit-v4_9_5.tgz";
     sha256 = "sha256-4o74218OexFZcgwVAFPcq498TK4fDlyDiUR5cHP4wdw=";

pkgs/development/compilers/gambit/gambit-support.nix

···
         --replace "$(grep '^PACKAGE_VERSION=.*$' configure)" 'PACKAGE_VERSION="v${git-version}"' \
         --replace "$(grep '^PACKAGE_STRING=.*$' configure)" 'PACKAGE_STRING="Gambit v${git-version}"' ;
       substituteInPlace include/makefile.in \
-        --replace "echo > stamp.h;" "(echo '#define ___STAMP_VERSION \"${git-version}\"'; echo '#define ___STAMP_YMD ${toString stampYmd}'; echo '#define ___STAMP_HMS ${toString stampHms}';) > stamp.h;";
+        --replace "\$\$(\$(GIT) describe --tag --always | sed 's/-bootstrap\$\$//')" "v${git-version}" \
+        --replace "echo > stamp.h;" "(echo '#define ___STAMP_VERSION \"v${git-version}\"'; echo '#define ___STAMP_YMD ${toString stampYmd}'; echo '#define ___STAMP_HMS ${toString stampHms}';) > stamp.h;";
+      grep -i ' version=\|echo..#define ___STAMP_VERSION' include/makefile.in # XXX DEBUG -- REMOVE ME
     '';
     modules = true;
-    #extraOptions = [];
-    extraOptions = ["--enable-trust-c-tco" "CFLAGS=-foptimize-sibling-calls"];
+    extraOptions = ["CFLAGS=-foptimize-sibling-calls"];
   };
 
   unstable-params = stable-params // {
     stable = false;
-    extraOptions = ["--enable-trust-c-tco"]; # "CFLAGS=-foptimize-sibling-calls" not necessary in latest unstable
+    extraOptions = []; # "CFLAGS=-foptimize-sibling-calls" not necessary in latest unstable
   };
 
   export-gambopt = params : "export GAMBOPT=${params.buildRuntimeOptions} ;";

pkgs/development/compilers/gambit/unstable.nix

···
 { callPackage, fetchFromGitHub, gambit-support }:
 
-callPackage ./build.nix {
-  version = "unstable-2023-08-06";
-  git-version = "4.9.5-5-gf1fbe9aa";
-  stampYmd = 20230806;
-  stampHms = 195822;
+callPackage ./build.nix rec {
+  version = "unstable-2023-10-07";
+  git-version = "4.9.5-59-g342399c7";
+  stampYmd = 20231007;
+  stampHms = 170745;
+  rev = "342399c736ec560c0ff4faeaeb9599b45633f26c";
   src = fetchFromGitHub {
     owner = "gambit";
     repo = "gambit";
-    rev = "f1fbe9aa0f461e89f2a91bc050c1373ee6d66482";
-    sha256 = "0b0gd6cwj8zxwcqglpsnmanysiq4mvma2mrgdfr6qy99avhbhzxm";
+    inherit rev;
+    sha256 = "121pj6lxihjjnfq33lq4m5hi461xbs9f41qd4l46556dr15cyf8f";
   };
   gambit-params = gambit-support.unstable-params;
 }

pkgs/development/compilers/gerbil/build.nix

···
 { pkgs, gccStdenv, lib, coreutils,
-  openssl, zlib, sqlite, libxml2, libyaml, libmysqlclient, lmdb, leveldb, postgresql,
-  version, git-version,
+  openssl, zlib, sqlite,
+  version, git-version, src,
   gambit-support,
-  gambit ? pkgs.gambit, gambit-params ? pkgs.gambit-support.stable-params, src }:
+  gambit-git-version,
+  gambit-stampYmd,
+  gambit-stampHms,
+  gambit-params }:
 
 # We use Gambit, that works 10x better with GCC than Clang. See ../gambit/build.nix
 let stdenv = gccStdenv; in
···
   inherit version;
   inherit src;
 
-  buildInputs_libraries = [ openssl zlib sqlite libxml2 libyaml libmysqlclient lmdb leveldb postgresql ];
+  buildInputs_libraries = [ openssl zlib sqlite ];
 
   # TODO: either fix all of Gerbil's dependencies to provide static libraries,
   # or give up and delete all tentative support for static libraries.
   #buildInputs_staticLibraries = map makeStaticLibraries buildInputs_libraries;
 
-  buildInputs = [ gambit ]
-    ++ buildInputs_libraries; # ++ buildInputs_staticLibraries;
-
-  env.NIX_CFLAGS_COMPILE = "-I${libmysqlclient}/include/mysql -L${libmysqlclient}/lib/mysql";
+  buildInputs = buildInputs_libraries;
 
   postPatch = ''
     echo '(define (gerbil-version-string) "v${git-version}")' > src/gerbil/runtime/gx-version.scm ;
···
     grep -Fl '#!/usr/bin/env' `find . -type f -executable` | while read f ; do
       substituteInPlace "$f" --replace '#!/usr/bin/env' '#!${coreutils}/bin/env' ;
     done ;
+    substituteInPlace ./configure --replace 'set -e' 'set -e ; git () { echo "v${git-version}" ;}' ;
+    substituteInPlace ./src/build/build-version.scm --replace "with-exception-catcher" '(lambda _ "v${git-version}")' ;
+    #rmdir src/gambit
+    #cp -a ${pkgs.gambit-unstable.src} ./src/gambit
+    chmod -R u+w ./src/gambit
+    ( cd src/gambit ; ${gambit-params.fixStamp gambit-git-version gambit-stampYmd gambit-stampHms} )
+    for f in src/bootstrap/gerbil/compiler/driver__0.scm \
+             src/build/build-libgerbil.ss \
+             src/gerbil/compiler/driver.ss ; do
+      substituteInPlace "$f" --replace '"gcc"' '"${gccStdenv.cc}/bin/${gccStdenv.cc.targetPrefix}gcc"' ;
+    done
   '';
 
 ## TODO: make static compilation work.
···
 # OPENSSL_LIBSSL=${makeStaticLibraries openssl}/lib/libssl.a # MISSING!
 # ZLIB=${makeStaticLibraries zlib}/lib/libz.a
 # SQLITE=${makeStaticLibraries sqlite}/lib/sqlite.a # MISSING!
-# LIBXML2=${makeStaticLibraries libxml2}/lib/libxml2.a # MISSING!
-# YAML=${makeStaticLibraries libyaml}/lib/libyaml.a # MISSING!
-# MYSQL=${makeStaticLibraries libmysqlclient}/lib/mariadb/libmariadb.a
-# LMDB=${makeStaticLibraries lmdb}/lib/mysql/libmysqlclient_r.a # MISSING!
-# LEVELDB=${makeStaticLibraries leveldb}/lib/libleveldb.a
 # EOF
 
+  configureFlags = [
+    "--prefix=$out/gerbil"
+    "--enable-zlib"
+    "--enable-sqlite"
+    "--enable-shared"
+    "--disable-deprecated"
+    "--enable-march=" # Avoid non-portable invalid instructions
+  ];
+
   configurePhase = ''
-    (cd src && ./configure \
-      --prefix=$out/gerbil \
-      --with-gambit=${gambit}/gambit \
-      --enable-libxml \
-      --enable-libyaml \
-      --enable-zlib \
-      --enable-sqlite \
-      --enable-mysql \
-      --enable-lmdb \
-      --enable-leveldb)
+    export CC=${gccStdenv.cc}/bin/${gccStdenv.cc.targetPrefix}gcc \
+           CXX=${gccStdenv.cc}/bin/${gccStdenv.cc.targetPrefix}g++ \
+           CPP=${gccStdenv.cc}/bin/${gccStdenv.cc.targetPrefix}cpp \
+           CXXCPP=${gccStdenv.cc}/bin/${gccStdenv.cc.targetPrefix}cpp \
+           LD=${gccStdenv.cc}/bin/${gccStdenv.cc.targetPrefix}ld \
+           XMKMF=${coreutils}/bin/false
+    unset CFLAGS LDFLAGS LIBS CPPFLAGS CXXFLAGS
+    (cd src/gambit ; ${gambit-params.fixStamp gambit-git-version gambit-stampYmd gambit-stampHms})
+    ./configure ${builtins.concatStringsSep " " configureFlags}
+    (cd src/gambit ;
+    substituteInPlace config.status \
+      ${lib.optionalString (gccStdenv.isDarwin && !gambit-params.stable)
+         ''--replace "/usr/local/opt/openssl@1.1" "${lib.getLib openssl}"''} \
+        --replace "/usr/local/opt/openssl" "${lib.getLib openssl}"
+    ./config.status
+    )
   '';
+
+  extraLdOptions = [
+      "-L${zlib}/lib"
+      "-L${openssl.out}/lib"
+      "-L${sqlite.out}/lib"
+    ];
 
   buildPhase = ''
     runHook preBuild
···
     export GERBIL_BUILD_CORES=$NIX_BUILD_CORES
     export GERBIL_GXC=$PWD/bin/gxc
     export GERBIL_BASE=$PWD
-    export GERBIL_HOME=$PWD
+    export GERBIL_PREFIX=$PWD
     export GERBIL_PATH=$PWD/lib
     export PATH=$PWD/bin:$PATH
     ${gambit-support.export-gambopt gambit-params}
···
     # Build, replacing make by build.sh
     ( cd src && sh build.sh )
 
+    f=build/lib/libgerbil.so.ldd ; [ -f $f ] && :
+    substituteInPlace "$f" --replace '(' \
+      '(${lib.strings.concatStrings (map (x: "\"${x}\" " ) extraLdOptions)}'
+
     runHook postBuild
   '';
 
   installPhase = ''
     runHook preInstall
     mkdir -p $out/gerbil $out/bin
-    (cd src; ./install)
+    ./install.sh
     (cd $out/bin ; ln -s ../gerbil/bin/* .)
     runHook postInstall
   '';
···
     platforms   = lib.platforms.unix;
     maintainers = with lib.maintainers; [ fare ];
   };
+
+  outputsToInstall = [ "out" ];
 }

pkgs/development/compilers/gerbil/default.nix

···
-{ callPackage, fetchFromGitHub }:
+{ callPackage, fetchFromGitHub, gambit-unstable, gambit-support, pkgs, gccStdenv }:
 
 callPackage ./build.nix rec {
-  version = "0.17";
-  git-version = version;
+  version = "0.18";
+  git-version = "0.18";
   src = fetchFromGitHub {
-    owner = "vyzo";
+    owner = "mighty-gerbils";
     repo = "gerbil";
-    rev = "v${version}";
-    sha256 = "0xzi9mhrmzcajhlz5qcnz4yjlljvbkbm9426iifgjn47ac0965zw";
+    rev = "8ca36a928bc9345f9d28e5f2dfcb55ca558e85f9";
+    sha256 = "sha256-EMiYgQM/Gl+dh6AxLYRZ0BKZ+VKFd+Lkyy9Pw11ivE8=";
+    fetchSubmodules = true;
   };
+  inherit gambit-support;
+  gambit-params = gambit-support.unstable-params;
+  gambit-git-version = "4.9.5-40-g24201248"; # pkgs.gambit-unstable.passthru.git-version
+  gambit-stampYmd = "20230917"; # pkgs.gambit-unstable.passthru.git-stampYmd
+  gambit-stampHms = "182043"; # pkgs.gambit-unstable.passthru.git-stampHms
 }

pkgs/development/compilers/gerbil/gerbil-crypto.nix

···
 
 {
   pname = "gerbil-crypto";
-  version = "unstable-2023-03-27";
-  git-version = "0.0-18-ge57f887";
+  version = "unstable-2023-09-27";
+  git-version = "0.0-23-g341e09d";
   gerbil-package = "clan/crypto";
   gerbilInputs = with gerbilPackages; [ gerbil-utils gerbil-poo ];
   nativeBuildInputs = [ pkgs.pkg-config ];
···
 
   pre-src = {
     fun = fetchFromGitHub;
-    owner = "fare";
+    owner = "mighty-gerbils";
     repo = "gerbil-crypto";
-    rev = "e57f88742d9b41640b4a7d9bd3e86c688d4a83f9";
-    sha256 = "08hrk3s82hbigvza75vgx9kc7qf64yhhn3xm5calc859sy6ai4ka";
+    rev = "341e09dcb15c09c836eae18093c0f63f71c0a72f";
+    sha256 = "1rq50q4p4vhr5drjvirmdkxaa4wszj1rxnhjaqz98bfpjm90yk4j";
   };
 
   meta = with lib; {

pkgs/development/compilers/gerbil/gerbil-ethereum.nix

···
 
 rec {
   pname = "gerbil-ethereum";
-  version = "unstable-2023-05-30";
-  git-version = "0.0-375-g989a5ca";
+  version = "unstable-2023-10-06";
+  git-version = "0.1-1-g08b08fc";
   softwareName = "Gerbil-ethereum";
-  gerbil-package = "mukn/ethereum";
+  gerbil-package = "clan/ethereum";
   version-path = "version";
 
-  gerbilInputs = with gerbilPackages; [ gerbil-utils gerbil-crypto gerbil-poo gerbil-persist ];
+  gerbilInputs = with gerbilPackages; [
+    gerbil-utils gerbil-crypto gerbil-poo gerbil-persist gerbil-leveldb ];
 
   pre-src = {
     fun = fetchFromGitHub;
-    owner = "fare";
+    owner = "mighty-gerbils";
     repo = "gerbil-ethereum";
-    rev = "989a5ca78958e42c4a1ec242786ade89f1887e48";
-    sha256 = "0bs2knhx3hy3k72yidgaplwjd48y86arqscdik8hgxwmhm9z8kwp";
+    rev = "08b08fce8c83cb59bfb532eebb1c7a2dd4bd57ab";
+    sha256 = "1sy7l869d2xqhq2qflsmkvr343jfhzsq43ixx75rqfpr3cdljz0b";
   };
 
   postInstall = ''
-    cp scripts/{croesus.prv,genesis.json,logback.xml,yolo-evm.conf,yolo-kevm.conf,run-ethereum-test-net.ss} $out/gerbil/lib/mukn/ethereum/scripts/
+    cp scripts/{croesus.prv,genesis.json,logback.xml,yolo-evm.conf,yolo-kevm.conf,run-ethereum-test-net.ss} $out/gerbil/lib/clan/ethereum/scripts/
     mkdir -p $out/bin
     cat > $out/bin/run-ethereum-test-net <<EOF
     #!/bin/sh
···
     export GERBIL_PATH GERBIL_LOADPATH GLOW_SOURCE ORIG_GERBIL_PATH ORIG_GERBIL_LOADPATH
     exec ${gerbil}/bin/gxi "\$0" "\$@"
     |#
-    (import :mukn/ethereum/scripts/run-ethereum-test-net :clan/multicall)
+    (import :clan/ethereum/scripts/run-ethereum-test-net :clan/multicall)
     (apply call-entry-point (cdr (command-line)))
     EOF
     chmod a+x $out/bin/run-ethereum-test-net

pkgs/development/compilers/gerbil/gerbil-leveldb.nix

···
+{ pkgs, lib, fetchFromGitHub, gerbilPackages, leveldb, ... }:
+
+{
+  pname = "gerbil-leveldb";
+  version = "unstable-2023-09-23";
+  git-version = "c62e47f";
+  gerbil-package = "clan";
+  gerbilInputs = [ ];
+  nativeBuildInputs = [ pkgs.pkg-config ];
+  buildInputs = [ leveldb ];
+  version-path = "";
+  softwareName = "Gerbil-LevelDB";
+
+  pre-src = {
+    fun = fetchFromGitHub;
+    owner = "mighty-gerbils";
+    repo = "gerbil-leveldb";
+    rev = "c62e47f352377b6843fb3e4b27030762a510a0d8";
+    sha256 = "177zn1smv2zq97mlryf8fi7v5gbjk07v5i0dix3r2wsanphaawvl";
+  };
+
+  meta = with lib; {
+    description = "LevelDB bindings for Gerbil";
+    homepage    = "https://github.com/mighty-gerbils/gerbil-leveldb";
+    license     = licenses.asl20;
+    platforms   = platforms.unix;
+    maintainers = with maintainers; [ fare ];
+  };
+
+  # "-L${leveldb}/lib"
+}

pkgs/development/compilers/gerbil/gerbil-libxml.nix

···
+{ pkgs, lib, fetchFromGitHub, gerbilPackages, libxml2, ... }:
+
+{
+  pname = "gerbil-libxml";
+  version = "unstable-2023-09-23";
+  git-version = "b08e5d8";
+  gerbil-package = "clan";
+  gerbilInputs = [ ];
+  nativeBuildInputs = [ pkgs.pkg-config ];
+  buildInputs = [ libxml2 ];
+  version-path = "";
+  softwareName = "Gerbil-LibXML";
+
+  pre-src = {
+    fun = fetchFromGitHub;
+    owner = "mighty-gerbils";
+    repo = "gerbil-libxml";
+    rev = "b08e5d8fe4688a162824062579ce152a10adb4cf";
+    sha256 = "1zfccqaibwy2b3srwmwwgv91dwy1xl18cfimxhcsxl6mxvgm61pd";
+  };
+
+  meta = with lib; {
+    description = "libxml bindings for Gerbil";
+    homepage    = "https://github.com/mighty-gerbils/gerbil-libxml";
+    license     = licenses.asl20;
+    platforms   = platforms.unix;
+    maintainers = with maintainers; [ fare ];
+  };
+}

pkgs/development/compilers/gerbil/gerbil-libyaml.nix

···
+{ pkgs, lib, fetchFromGitHub, gerbilPackages, libyaml, ... }:
+
+{
+  pname = "gerbil-libyaml";
+  version = "unstable-2023-09-23";
+  git-version = "398a197";
+  gerbil-package = "clan";
+  gerbilInputs = [ ];
+  nativeBuildInputs = [ pkgs.pkg-config ];
+  buildInputs = [ libyaml ];
+  version-path = "";
+  softwareName = "Gerbil-LibYAML";
+
+  pre-src = {
+    fun = fetchFromGitHub;
+    owner = "mighty-gerbils";
+    repo = "gerbil-libyaml";
+    rev = "398a19782b1526de94b70de165c027d4b6029dac";
+    sha256 = "0plmwx1i23c9nzzg6zxz2xi0y92la97mak9hg6h3c6d8kxvajb5c";
+  };
+
+  meta = with lib; {
+    description = "libyaml bindings for Gerbil";
+    homepage    = "https://github.com/mighty-gerbils/gerbil-libyaml";
+    license     = licenses.asl20;
+    platforms   = platforms.unix;
+    maintainers = with maintainers; [ fare ];
+  };
+
+  # "-L${libyaml}/lib"
+}

pkgs/development/compilers/gerbil/gerbil-lmdb.nix

···
+{ pkgs, lib, fetchFromGitHub, gerbilPackages, lmdb, ... }:
+
+{
+  pname = "gerbil-lmdb";
+  version = "unstable-2023-09-23";
+  git-version = "6d64813";
+  gerbil-package = "clan";
+  gerbilInputs = [ ];
+  nativeBuildInputs = [ pkgs.pkg-config ];
+  buildInputs = [ lmdb ];
+  version-path = "";
+  softwareName = "Gerbil-LMDB";
+
+  pre-src = {
+    fun = fetchFromGitHub;
+    owner = "mighty-gerbils";
+    repo = "gerbil-lmdb";
+    rev = "6d64813afe5766776a0d7ef45f80c784b820742c";
+    sha256 = "12kywxx4qjxchmhcd66700r2yfqjnh12ijgqnpqaccvigi07iq9b";
+  };
+
+  meta = with lib; {
+    description = "LMDB bindings for Gerbil";
+    homepage    = "https://github.com/mighty-gerbils/gerbil-lmdb";
+    license     = licenses.asl20;
+    platforms   = platforms.unix;
+    maintainers = with maintainers; [ fare ];
+  };
+
+  # "-L${lmdb.out}/lib"
+}

pkgs/development/compilers/gerbil/gerbil-mysql.nix

···
+{ pkgs, lib, fetchFromGitHub, gerbilPackages, mariadb-connector-c, ... }:
+
+{
+  pname = "gerbil-mysql";
+  version = "unstable-2023-09-23";
+  git-version = "ecec94c";
+  gerbil-package = "clan";
+  gerbilInputs = [ ];
+  nativeBuildInputs = [ pkgs.pkg-config ];
+  buildInputs = [ mariadb-connector-c ];
+  version-path = "";
+  softwareName = "Gerbil-MySQL";
+
+  pre-src = {
+    fun = fetchFromGitHub;
+    owner = "mighty-gerbils";
+    repo = "gerbil-mysql";
+    rev = "ecec94c76d7aa23331b7e02ac7732a7923f100a5";
+    sha256 = "01506r0ivgp6cxvwracmg7pwr735ngb7899ga3lxy181lzkp6b2c";
+  };
+
+  meta = with lib; {
+    description = "MySQL bindings for Gerbil";
+    homepage    = "https://github.com/mighty-gerbils/gerbil-mysql";
+    license     = licenses.asl20;
+    platforms   = platforms.unix;
+    maintainers = with maintainers; [ fare ];
+  };
+
+  # "-L${mariadb-connector-c}/lib/mariadb"
+}

pkgs/development/compilers/gerbil/gerbil-persist.nix

···
 { lib, fetchFromGitHub, gerbilPackages, ... }:
 {
   pname = "gerbil-persist";
-  version = "unstable-2023-03-02";
-  git-version = "0.1.0-24-ge2305f5";
+  version = "unstable-2023-10-07";
+  git-version = "0.1.1-1-g3ce1d4a";
   softwareName = "Gerbil-persist";
   gerbil-package = "clan/persist";
   version-path = "version";
 
-  gerbilInputs = with gerbilPackages; [ gerbil-utils gerbil-crypto gerbil-poo ];
+  gerbilInputs = with gerbilPackages; [ gerbil-utils gerbil-crypto gerbil-poo gerbil-leveldb ];
 
   pre-src = {
     fun = fetchFromGitHub;
-    owner = "fare";
+    owner = "mighty-gerbils";
     repo = "gerbil-persist";
-    rev = "e2305f53571e55292179286ca2d88e046ec6638b";
-    sha256 = "1vsi4rfzpqg4hhn53d2r26iw715vzwz0hiai9r34z4diwzqixfgn";
+    rev = "3ce1d4a4b1d7be290e54f884d780c02ceee8f10e";
+    sha256 = "1kzvgpqkpq4wlc0hlfxy314fbv6215aksrrlrrpq9w97wdibmv7x";
   };
 
   meta = with lib; {

pkgs/development/compilers/gerbil/gerbil-poo.nix

···
 
 {
   pname = "gerbil-poo";
-  version = "unstable-2023-04-28";
-  git-version = "0.0-106-g418b582";
+  version = "unstable-2023-10-07";
+  git-version = "0.1-1-g367ab43";
   softwareName = "Gerbil-POO";
   gerbil-package = "clan/poo";
   version-path = "version";
···
 
   pre-src = {
     fun = fetchFromGitHub;
-    owner = "fare";
+    owner = "mighty-gerbils";
     repo = "gerbil-poo";
-    rev = "418b582ae72e1494cf3a5f334d31d4f6503578f5";
-    sha256 = "0qdzs7l6hp45dji5bc3879k4c8k9x6cj4qxz68cskjhn8wrc5lr8";
+    rev = "367ab4376fdd6fc0b0892da2becef35a5039c583";
+    sha256 = "0ci88zqi7gb55ahl0n7dk1ihij2j6dn8jb6rzfiilck773x46kdh";
   };
 
   meta = with lib; {

pkgs/development/compilers/gerbil/gerbil-support.nix

···
 { pkgs, lib, callPackage, ... }:
 
-  with pkgs.gerbil-support; {
+with pkgs.gerbil-support; {
+
+  pppToName = ppp: lib.removeSuffix ".nix" (baseNameOf ppp); # from pre-package path to name
+  callPpp = ppp: callPackage ppp prePackage-defaults; # from pre-package path to pre-package
+  pppToKV = ppp: { name = pppToName ppp; value = callPpp ppp; }; # from pre-package path to name
+  ppplToPpa = ppps: builtins.listToAttrs (map pppToKV ppps); # from pre-package path list to name/pre-package attr
 
   prePackages-unstable =
-    let pks = [ ./gerbil-libp2p.nix ./smug-gerbil.nix ./ftw.nix
-                ./gerbil-utils.nix ./gerbil-crypto.nix ./gerbil-poo.nix
-                ./gerbil-persist.nix ./gerbil-ethereum.nix ./glow-lang.nix ];
-        call = pkg: callPackage pkg prePackage-defaults;
-        pkgName = pkg: lib.removeSuffix ".nix" (baseNameOf pkg);
-        f = pkg: { name = pkgName pkg; value = call pkg; }; in
-    builtins.listToAttrs (map f pks);
+    ppplToPpa
+      [ ./gerbil-leveldb.nix ./gerbil-lmdb.nix ./gerbil-mysql.nix
+        ./gerbil-libxml.nix ./gerbil-libyaml.nix
+        ./smug-gerbil.nix # ./ftw.nix
+        ./gerbil-utils.nix ./gerbil-crypto.nix ./gerbil-poo.nix
+        ./gerbil-persist.nix ./gerbil-ethereum.nix
+        # ./gerbil-libp2p.nix
+        ./glow-lang.nix
+      ];
 
   prePackage-defaults = {
     gerbil = pkgs.gerbil-unstable;
···
     softwareName = "";
   };
 
-  gerbilPackages-unstable =
-    builtins.mapAttrs (_: gerbilPackage) prePackages-unstable;
+  ppaToPl = builtins.mapAttrs (_: gerbilPackage);
+  gerbilPackages-unstable = ppaToPl prePackages-unstable;
 
   resolve-pre-src = pre-src: pre-src.fun (removeAttrs pre-src ["fun"]);
 
-  gerbilVersionFromGit = pkg:
-    let version-path = "${pkg.passthru.pre-pkg.version-path}.ss"; in
-    if builtins.pathExists version-path then
+  gerbilVersionFromGit = srcDir: version-path:
+    let version-file = "${srcDir}/${version-path}.ss"; in
+    if builtins.pathExists version-file then
       let m =
         builtins.match "\\(import :clan/versioning.*\\)\n\\(register-software \"([-_.A-Za-z0-9]+)\" \"([-_.A-Za-z0-9]+)\"\\) ;; ([-0-9]+)\n"
-          (builtins.readFile version-path); in
-          { version = builtins.elemAt m 2; git-version = builtins.elemAt m 1; }
-     else { version = "0.0";
-            git-version = let gitpath = "${toString pkg.src}/.git"; in
+          (builtins.readFile version-file); in
+          { version = "${builtins.elemAt m 2}-git"; git-version = builtins.elemAt m 1; }
+     else { version = "0.0-git";
+            git-version = let gitpath = "${srcDir}/.git"; in
               if builtins.pathExists gitpath then lib.commitIdFromGitRepo gitpath else "0"; };
 
-  gerbilSkippableFiles = [".git" ".build" ".build_outputs" "run" "result" "dep" "BLAH"
-                          "version.ss" "tmp.nix"];
+  gerbilSkippableFiles = [".git" ".build" ".build_outputs" "run" "result" "dep" "BLAH" "tmp.nix"];
 
   gerbilSourceFilter = path: type:
     let baseName = baseNameOf path; in
···
     if old-sha256 == new-sha256 then {} else
     view "Overriding ${name} old-sha256: ${old-sha256} new-sha256: ${new-sha256}"
     { ${name} = super.${name} // {
-        pre-src = new-pre-src;
-        version = "override";
-        git-version = if new-pre-src ? rev then lib.substring 0 7 new-pre-src.rev else "unknown";};};
+                       pre-src = new-pre-src;
+                       version = "override";
+                       git-version = if new-pre-src ? rev
+                                     then lib.substring 0 7 new-pre-src.rev
+                                     else "unknown";};
+                     };
 
   pkgsOverrideGerbilPackageSrc = name: pre-src: pkgs: super: {
     gerbil-support = (super-support:

pkgs/development/compilers/gerbil/gerbil-utils.nix

···
 
 {
   pname = "gerbil-utils";
-  version = "unstable-2023-07-22";
-  git-version = "0.2-198-g2fb01ce";
+  version = "unstable-2023-10-08";
+  git-version = "0.3-3-g2914428";
   softwareName = "Gerbil-utils";
   gerbil-package = "clan";
   version-path = "version";
 
   pre-src = {
     fun = fetchFromGitHub;
-    owner = "fare";
+    owner = "mighty-gerbils";
     repo = "gerbil-utils";
-    rev = "2fb01ce0b302f232f5c4daf4987457b6357d609d";
-    sha256 = "127q98gk1x6y1nlkkpnbnkz989ybpszy7aiy43hzai2q6xn4nv72";
+    rev = "29144289b40ce624adf30eab23b796ddd6b6b55d";
+    sha256 = "0qysw2zs5acgri3wrjb3ngnnhd17xpr9hcdr4ya383k8k7jacr8a";
   };
 
   meta = with lib; {

pkgs/development/compilers/gerbil/glow-lang.nix

···
 
 rec {
   pname = "glow-lang";
-  version = "unstable-2023-04-26";
-  git-version = "0.3.2-222-gb19cd980";
+  version = "unstable-2023-10-06";
+  git-version = "0.3.2-232-ga1a7a9e5";
   softwareName = "Glow";
   gerbil-package = "mukn/glow";
   version-path = "version";
 
   gerbilInputs = with gerbilPackages;
     [ gerbil-utils gerbil-crypto gerbil-poo gerbil-persist gerbil-ethereum
-      gerbil-libp2p smug-gerbil ftw ];
+      smug-gerbil gerbil-leveldb # gerbil-libp2p ftw
+    ];
 
   pre-src = {
     fun = fetchFromGitHub;
     owner = "Glow-Lang";
     repo = "glow";
-    rev = "b19cd98082dfc5156d1b4fc83cde161572d6a211";
-    sha256 = "0k3qy5826pxqr9ylnnpq4iikxf4j50987vhpa5qiv99j0p643xr3";
+    rev = "a1a7a9e51ba9a466d91c397d9da55af90076110c";
+    sha256 = "0wgav4gbg6mlxgisjjbyhvhz94b29vv2rkjkjy1jl7v0hs3wbm52";
     };
 
   postPatch = ''

pkgs/development/compilers/gerbil/unstable.nix

···
-{ callPackage, fetchFromGitHub, gambit-unstable, gambit-support }:
+{ callPackage, fetchFromGitHub, gambit-unstable, gambit-support, pkgs, gccStdenv }:
 
 callPackage ./build.nix rec {
-  version = "unstable-2023-08-07";
-  git-version = "0.17.0-187-gba545b77";
+  version = "unstable-2023-10-13";
+  git-version = "0.18-2-g8ed012ff";
   src = fetchFromGitHub {
-    owner = "vyzo";
+    owner = "mighty-gerbils";
     repo = "gerbil";
-    rev = "ba545b77e8e85118089232e3cd263856e414b24b";
-    sha256 = "1f4v1qawx2i8333kshj4pbj5r21z0868pwrr3r710n6ng3pd9gqn";
+    rev = "8ed012ff9571fcfebcc07815813001a3f356150d";
+    sha256 = "056kmjn7sd0hjwikmg7v3a1kvgsgvfi7pi9xcx3ixym9g3bqa4mx";
+    fetchSubmodules = true;
   };
   inherit gambit-support;
-  gambit = gambit-unstable;
   gambit-params = gambit-support.unstable-params;
+  gambit-git-version = "4.9.5-40-g24201248"; # pkgs.gambit-unstable.passthru.git-version
+  gambit-stampYmd = "20230917"; # pkgs.gambit-unstable.passthru.git-stampYmd
+  gambit-stampHms = "182043"; # pkgs.gambit-unstable.passthru.git-stampHms
 }