lovesan / bike Goto Github PK

Building with SBCL 2.3.11.165-7fa632585 / ASDF 3.3.5 for quicklisp dist creation.

Trying to build commit id fb3fdfb

bike-examples fails to build with the following error:

Unhandled METHOD-RESOLUTION-ERROR in thread #<SB-THREAD:THREAD tid=498994 "main thread" RUNNING {1040480133}>: 

bike-tests fails to build with the following error:

Unhandled METHOD-RESOLUTION-ERROR in thread #<SB-THREAD:THREAD tid=499083 "main thread" RUNNING {10017D8003}>: 

bike fails to build with the following error:

Unhandled METHOD-RESOLUTION-ERROR in thread #<SB-THREAD:THREAD tid=499101 "main thread" RUNNING {10017D8003}>: 

Full log here

Not sure if its something I did or not, pardon!
SBCL built from source using CCL, I get the same issue with the older ubuntu apt SBCL too.

`
This is SBCL 2.2.3, an implementation of ANSI Common Lisp.
More information about SBCL is available at http://www.sbcl.org/.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.

• (ql:quickload :bike)
  To load "bike":
  Load 1 ASDF system:
  bike
  ; Loading "bike"
  [package alexandria]..............................
  [package alexandria-2]............................
  [package babel-encodings].........................
  [package babel]...................................
  ..................................................
  [package cffi-sys]................................
  [package cffi]....................................
  ..................................................
  [package cffi-features]...........................
  [package cl-ppcre]................................
  ..................................................
  [package split-sequence]..........................
  [package impl-specific-gray]......................
  [package trivial-gray-streams]....................
  [package flexi-streams]...........................
  ..................................................
  ..................................................
  ..................................................
  [package trivial-garbage].........................
  [package bordeaux-threads]........................
  [package editor-hints.named-readtables]...........
  [package editor-hints.named-readtables]...........
  ..................................................
  ...........................CORRUPTION WARNING in SBCL pid 152662 tid 152675:
  Received signal 8 @ 7f77a251479f in non-lisp tid 152675, resignaling to a lisp thread.
  The integrity of this image is possibly compromised.
  Continuing with fingers crossed.
  Floating point exception (core dumped)

`

I was hoping someone could give me a simple example to get me started?

I'd like to access an object by instancing it and activate some of its methods, e.g:

SomeObject ob = new SomeObject();
ob.SubObject.SubObject2.Method("data");

I've been able to instantiate via (defvar x (new ...)) and even (invoke ob Method arg), but I can't seem to drill down through other objects.

Also an example on using a .Net float or string array (unboxing?) would be fantastic.

Any help would be greatly appreciated, thanks so much for writing this library! I've been hoping to access some .Net-only libraries for a very long time.

So currently one needs to manually invoke .Net reflection APIs if he wants to utilize COM, and especially, IDispatch-based interfaces.

E.g.https://gist.github.com/Lovesan/843a5daf6ff1564668c51f2a3886c8ea

The problem with reflection-property and its setf counterpart is that it checks for .Net property first, using Type.GetProperty and then utilizes property.GetValue instead of Type.InvokeMember, and the former does not work for COM objects.

The workaround would be to explicitly check whether an object type came from COM.

The code :
f.lisp:

(load "~/quicklisp/setup.lisp")
(declaim (optimize (speed 3) (safety 3)))
(ql:quickload :uiop)
(ql:quickload :bike)

To run :

rm *.exe
sbcl --script f.lisp

The error:

[package dref]....................................
[package mgl-pax].................................
[package mgl-pax].................................
[package editor-hints.named-readtables]...........
[package editor-hints.named-readtables]...........
MSBuild version 17.7.4+3ebbd7c49 for .NET
  Determining projects to restore...
  All projects are up-to-date for restore.
  BikeInterop -> /home/x/quicklisp/dists/quicklisp/software/bike-20220707-git/src/BikeInterop/bin/netstandard2.0/BikeInterop.dll
Build succeeded.
    0 Warning(s)
    0 Error(s)
Time Elapsed 00:00:02.28
................................................CORRUPTION WARNING in SBCL pid 5576 tid 5684:
Received signal 8 @ 7f74caf46d70 in non-lisp tid 5684, resignaling to a lisp thread.
The integrity of this image is possibly compromised.
Exiting.

OS: -Linux gentoo 6.6.13-gentoo-x86_64
SBCL : -v2.3.5
dotnet : -v7.0.404

This example is a great help for people to get started with. I think GUI apps, especially if they can be done cross-platform, are the 'killer apps' for bike.

Two things would help a lot in the example:

• Make it a two-pane window and use a collapsible tree for browsing symbols. Tree navigation seems to have become the standard paradigm for browsing hierarchical information structures (e.g. directories)
• Add a menu bar. It doesn't have to have much, just the 'standard' one (File, Edit ?) to show how it's done.
• Major bonus points if you could wire up a REPL somewhere in the window.

I just began testing bike. The hello example on the project page works from the repl, but when I run the resulting executable, I get the following error:

Internal error #11 "Object is of the wrong type." at 0000001000DFAF07 SC: 0, Offset: 7 0x00000061: other immediate 0, no tls value marker: data=0 SC: 3, Offset: 12 $1= 0x015e6bd7: list pointer fatal error encountered in SBCL pid 1700(tid 0000000000A916D0): internal error too early in init, can't recover

I'm refering to this example:
(defun hello () (bike:invoke 'System.Console 'WriteLine "Hello, World!")) (setf uiop:*image-entry-point* #'hello) (uiop:dump-image "hello.exe" :executable t)

Building with sb-ext:save-lisp-and-die directly, or via roswell fails to build an executable. I'm still really new to CL, so my apologies if this is a product of my ignorance.

On running (ql:quickload "bike"), I received the following error:

  Load 11 ASDF systems:
    alexandria asdf bordeaux-threads cffi cl-ppcre
    flexi-streams named-readtables split-sequence
    trivial-features trivial-garbage uiop
  Install 1 Quicklisp release:
    bike
; Fetching #<URL "http://beta.quicklisp.org/archive/bike/2021-10-20/bike-20211020-git.tgz">
; 72.44KB
==================================================
74,178 bytes in 0.04 seconds (1975.66KB/sec)
; Loading "bike"
..................
The value
  NIL
is not of type
  CONS
when binding MAX
   [Condition of type TYPE-ERROR]

Restarts:
 0: [RETRY] Retry compiling #<CL-SOURCE-FILE "bike" "src" "libraries">.
 1: [ACCEPT] Continue, treating compiling #<CL-SOURCE-FILE "bike" "src" "libraries"> as having been successful.
 2: [RETRY] Retry ASDF operation.
 3: [CLEAR-CONFIGURATION-AND-RETRY] Retry ASDF operation after resetting the configuration.
 4: [RETRY] Retry ASDF operation.
 5: [CLEAR-CONFIGURATION-AND-RETRY] Retry ASDF operation after resetting the configuration.
 --more--

System information:
Linux 5.18.7
SBCL 2.2.5
Mono 6.12.0.177

I get this:

; caught WARNING:
;   The fourth argument of type (UNSIGNED-BYTE 62) cannot be used as a keyword.
; 
; caught WARNING:
;   The sixth argument of type (UNSIGNED-BYTE 62) cannot be used as a keyword.

Full log here: http://report.quicklisp.org/2020-02-24/failure-report/bike.html#bike

This is a VERY impressive piece of work!!

Some questions:

• Are you using this work in production in some capacity?
• What are your future plans for the code?
• I am evaluating this code for possible use at work. While I am very impressed with the code base, there is always the inevitable "hidden issues" on code that is not used in production. At what stage do you think the current version is at? (proof of concept, alpha, beta, production, etc)?

When I try running (QL:QUICKLOAD :BIKE), I see this error message: "Unable to load foreign library (CORECLR)."

Any ideas?

Complete Error Message:
Unable to load foreign library (CORECLR).
Error opening shared object "C:\Program Files\dotnet\shared\Microsoft.NETCore.App\6.0.4\coreclr.dll":
%1 is not a valid Win32 application.
[Condition of type CFFI:LOAD-FOREIGN-LIBRARY-ERROR]

Environment:
Windows 10
.NET 6
SBCL 2.2.4
Emacs 26.3

Backtrace: generated by calling: (sb-debug:backtrace-as-list)
(((LAMBDA (#:G1)
:IN
"C:/Users/JohnH/quicklisp/dists/quicklisp/software/bike-20211020-git/src/libraries.lisp")
#)
(SWANK::EVAL-IN-FRAME-AUX 0 "(sb-debug:backtrace-as-list)" "CFFI"
#)
(SB-INT:SIMPLE-EVAL-IN-LEXENV
(SWANK:EVAL-STRING-IN-FRAME "(sb-debug:backtrace-as-list)" 0 "CFFI")
#)
(EVAL (SWANK:EVAL-STRING-IN-FRAME "(sb-debug:backtrace-as-list)" 0 "CFFI"))
(SWANK:EVAL-FOR-EMACS
(SWANK:EVAL-STRING-IN-FRAME "(sb-debug:backtrace-as-list)" 0 "CFFI")
"COMMON-LISP-USER" 32)
(SWANK::SLDB-LOOP 1)
((FLET SWANK/BACKEND:CALL-WITH-DEBUGGING-ENVIRONMENT :IN "C:/Users/JohnH/quicklisp/dists/quicklisp/software/slime-v2.27/swank/sbcl.lisp")
#<FUNCTION (LAMBDA () :IN SWANK::DEBUG-IN-EMACS) {2480637D}>)
(SWANK::DEBUG-IN-EMACS
#<CFFI:LOAD-FOREIGN-LIBRARY-ERROR "Unable to load foreign library (A).% ~A" {28DAAE09}>)
(SWANK:INVOKE-SLIME-DEBUGGER
#<CFFI:LOAD-FOREIGN-LIBRARY-ERROR "Unable to load foreign library (A).% ~A" {28DAAE09}>)
(SWANK/SBCL::CALL-WITH-BREAK-HOOK #
#<FUNCTION (LAMBDA ()
:IN
SWANK:SWANK-DEBUGGER-HOOK) {28DAB325}>)
((FLET SWANK/BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "C:/Users/JohnH/quicklisp/dists/quicklisp/software/slime-v2.27/swank/sbcl.lisp")
#
#<FUNCTION (LAMBDA () :IN SWANK:SWANK-DEBUGGER-HOOK) {28DAB325}>)
(SWANK:SWANK-DEBUGGER-HOOK
#<CFFI:LOAD-FOREIGN-LIBRARY-ERROR "Unable to load foreign library (A).% ~A" {28DAAE09}>
#)
(SB-DEBUG::RUN-HOOK DEBUGGER-HOOK
#<CFFI:LOAD-FOREIGN-LIBRARY-ERROR "Unable to load foreign library (A).% ~A" {28DAAE09}>)
(INVOKE-DEBUGGER
#<CFFI:LOAD-FOREIGN-LIBRARY-ERROR "Unable to load foreign library (A).% ~A" {28DAAE09}>)
(ERROR CFFI:LOAD-FOREIGN-LIBRARY-ERROR :FORMAT-CONTROL
"Unable to load foreign library (A).% ~A" :FORMAT-ARGUMENTS
(BIKE::CORECLR
"Error opening shared object "C:\\Program Files\\dotnet\\shared\\Microsoft.NETCore.App\\6.0.4\\coreclr.dll":
%1 is not a valid Win32 application."))
(CFFI::FL-ERROR "Unable to load foreign library (A).% ~A" BIKE::CORECLR
"Error opening shared object "C:\\Program Files\\dotnet\\shared\\Microsoft.NETCore.App\\6.0.4\\coreclr.dll":
%1 is not a valid Win32 application.")
(CFFI::REPORT-SIMPLE-ERROR BIKE::CORECLR
#<SIMPLE-ERROR "Error opening shared object ~S:
~A" {28DAA8F9}>)
((FLET CFFI::%DO-LOAD :IN CFFI::%DO-LOAD-FOREIGN-LIBRARY)
#<CFFI:FOREIGN-LIBRARY CORECLR> BIKE::CORECLR "coreclr.dll")
(CFFI:LOAD-FOREIGN-LIBRARY BIKE::CORECLR :SEARCH-PATH NIL)
(SB-INT:SIMPLE-EVAL-IN-LEXENV (CFFI:LOAD-FOREIGN-LIBRARY 'BIKE::CORECLR)
#)
(SB-INT:SIMPLE-EVAL-IN-LEXENV
(PROGN (CFFI:LOAD-FOREIGN-LIBRARY 'BIKE::CORECLR)) #)
(EVAL-TLF (PROGN (CFFI:LOAD-FOREIGN-LIBRARY 'BIKE::CORECLR)) 2
#)
((FLET SB-C::FROB :IN SB-C::EVAL-COMPILE-TOPLEVEL))
(SB-C::EVAL-COMPILE-TOPLEVEL ((CFFI:LOAD-FOREIGN-LIBRARY 'BIKE::CORECLR))
((CFFI:LOAD-FOREIGN-LIBRARY 'BIKE::CORECLR)
SB-C::ORIGINAL-SOURCE-START 4 3 2))
(SB-C::PROCESS-TOPLEVEL-FORM (CFFI:LOAD-FOREIGN-LIBRARY 'BIKE::CORECLR)
(SB-C::ORIGINAL-SOURCE-START 4 3 2)
(:COMPILE-TOPLEVEL))
(SB-C::PROCESS-TOPLEVEL-FORM (CFFI:USE-FOREIGN-LIBRARY BIKE::CORECLR)
(SB-C::ORIGINAL-SOURCE-START 0 2)
(:COMPILE-TOPLEVEL))
(SB-C::PROCESS-TOPLEVEL-PROGN
((CFFI:DEFINE-FOREIGN-LIBRARY BIKE::CORECLR
(T "coreclr.dll"))
(CFFI:USE-FOREIGN-LIBRARY BIKE::CORECLR))
(SB-C::ORIGINAL-SOURCE-START 0 2) (:COMPILE-TOPLEVEL))
(SB-C::PROCESS-TOPLEVEL-FORM
(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
(CFFI:DEFINE-FOREIGN-LIBRARY BIKE::CORECLR
(T "coreclr.dll"))
(CFFI:USE-FOREIGN-LIBRARY BIKE::CORECLR))
(SB-C::ORIGINAL-SOURCE-START 0 2) NIL)
((LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS)
:IN
SB-C::SUB-COMPILE-FILE)
(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
(CFFI:DEFINE-FOREIGN-LIBRARY BIKE::CORECLR
(T "coreclr.dll"))
(CFFI:USE-FOREIGN-LIBRARY BIKE::CORECLR))
:CURRENT-INDEX 2)
(SB-C::%DO-FORMS-FROM-INFO
#<FUNCTION (LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS)
:IN
SB-C::SUB-COMPILE-FILE) {230D8C25}>
#<SB-C::SOURCE-INFO {28D0AB79}> SB-C::INPUT-ERROR-IN-COMPILE-FILE)
((FLET "LAMBDA0" :IN "SYS:SRC;COMPILER;MAIN.LISP"))
((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
(SB-C::SUB-COMPILE-FILE #<SB-C::SOURCE-INFO {28D0AB79}> NIL)
(SB-C::%COMPILE-FILES
(#P"C:/Users/JohnH/quicklisp/dists/quicklisp/software/bike-20211020-git/src/libraries.lisp")
:UTF-8 T
#P"C:/Users/JohnH/AppData/Local/cache/common-lisp/sbcl-2.2.4-win-x86/C/Users/JohnH/quicklisp/dists/quicklisp/software/bike-20211020-git/src/libraries-tmpMO2T7PGC.fasl"
NIL NIL)
(COMPILE-FILE
#P"C:/Users/JohnH/quicklisp/dists/quicklisp/software/bike-20211020-git/src/libraries.lisp"
:OUTPUT-FILE
#P"C:/Users/JohnH/AppData/Local/cache/common-lisp/sbcl-2.2.4-win-x86/C/Users/JohnH/quicklisp/dists/quicklisp/software/bike-20211020-git/src/libraries-tmpMO2T7PGC.fasl"
:VERBOSE NIL :PRINT NIL :EXTERNAL-FORMAT :UTF-8 :PROGRESS NIL :TRACE-FILE
NIL :BLOCK-COMPILE NIL :ENTRY-POINTS NIL :EMIT-CFASL NIL)
(UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS
#<FUNCTION (LAMBDA () :IN UIOP/LISP-BUILD:COMPILE-FILE*) {28D09345}> NIL)
(UIOP/PATHNAME:CALL-WITH-ENOUGH-PATHNAME
#P"C:/Users/JohnH/quicklisp/dists/quicklisp/software/bike-20211020-git/src/libraries.lisp"
NIL
#<FUNCTION (LAMBDA (UIOP/LISP-BUILD::INPUT-FILE)
:IN
UIOP/LISP-BUILD:COMPILE-FILE*) {28D09305}>)
(UIOP/LISP-BUILD:COMPILE-FILE*
#P"C:/Users/JohnH/quicklisp/dists/quicklisp/software/bike-20211020-git/src/libraries.lisp"
:OUTPUT-FILE
#P"C:/Users/JohnH/AppData/Local/cache/common-lisp/sbcl-2.2.4-win-x86/C/Users/JohnH/quicklisp/dists/quicklisp/software/bike-20211020-git/src/libraries.fasl"
:EXTERNAL-FORMAT :UTF-8 :WARNINGS-FILE NIL)
(ASDF/LISP-ACTION:PERFORM-LISP-COMPILATION #<ASDF/LISP-ACTION:COMPILE-OP >
#<ASDF/LISP-ACTION:CL-SOURCE-FILE "bike" "src" "libraries">)
((SB-PCL::EMF ASDF/ACTION:PERFORM) # #
#<ASDF/LISP-ACTION:COMPILE-OP >
#<ASDF/LISP-ACTION:CL-SOURCE-FILE "bike" "src" "libraries">)
((LAMBDA () :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T))
#<ASDF/LISP-ACTION:COMPILE-OP >
#<ASDF/LISP-ACTION:CL-SOURCE-FILE "bike" "src" "libraries">)
((:METHOD ASDF/PLAN:PERFORM-PLAN (T))
#<ASDF/PLAN:SEQUENTIAL-PLAN {288AAF91}>)
((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T))
#<ASDF/PLAN:SEQUENTIAL-PLAN {288AAF91}>)
((:METHOD ASDF/OPERATE:OPERATE
(ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT))
#<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "bike"> :PLAN-CLASS NIL
:PLAN-OPTIONS NIL)
((SB-PCL::EMF ASDF/OPERATE:OPERATE) # #
#<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "bike"> :VERBOSE NIL)
((LAMBDA () :IN ASDF/OPERATE:OPERATE))
((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP >
#<ASDF/SYSTEM:SYSTEM "bike"> :VERBOSE NIL)
((SB-PCL::EMF ASDF/OPERATE:OPERATE) # #
ASDF/LISP-ACTION:LOAD-OP "bike" :VERBOSE NIL)
((LAMBDA () :IN ASDF/OPERATE:OPERATE))
((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP
"bike" :VERBOSE NIL)
(ASDF/SESSION:CALL-WITH-ASDF-SESSION
#<FUNCTION (LAMBDA () :IN ASDF/OPERATE:OPERATE) {288A418D}> :OVERRIDE T
:KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
((LAMBDA () :IN ASDF/OPERATE:OPERATE))
(ASDF/SESSION:CALL-WITH-ASDF-SESSION
#<FUNCTION (LAMBDA () :IN ASDF/OPERATE:OPERATE) {2889CA5D}> :OVERRIDE NIL
:KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP
"bike" :VERBOSE NIL)
(ASDF/OPERATE:LOAD-SYSTEM "bike" :VERBOSE NIL)
(QUICKLISP-CLIENT::CALL-WITH-MACROEXPAND-PROGRESS
#<FUNCTION (LAMBDA ()
:IN
QUICKLISP-CLIENT::APPLY-LOAD-STRATEGY) {2889C965}>)
(QUICKLISP-CLIENT::AUTOLOAD-SYSTEM-AND-DEPENDENCIES "bike" :PROMPT NIL)
((:METHOD QL-IMPL-UTIL::%CALL-WITH-QUIET-COMPILATION (T T))
#
#<FUNCTION (FLET QUICKLISP-CLIENT::QL :IN QUICKLISP-CLIENT:QUICKLOAD) {28890BAD}>)
((:METHOD QL-IMPL-UTIL::%CALL-WITH-QUIET-COMPILATION :AROUND
(QL-IMPL:SBCL T))
#<QL-IMPL:SBCL {25AEE931}>
#<FUNCTION (FLET QUICKLISP-CLIENT::QL :IN QUICKLISP-CLIENT:QUICKLOAD) {28890BAD}>)
((:METHOD QUICKLISP-CLIENT:QUICKLOAD (T)) :BIKE :PROMPT NIL :SILENT NIL
:VERBOSE NIL)
(QL-DIST::CALL-WITH-CONSISTENT-DISTS
#<FUNCTION (LAMBDA () :IN QUICKLISP-CLIENT:QUICKLOAD) {2888C79D}>)
(SB-INT:SIMPLE-EVAL-IN-LEXENV (QUICKLISP-CLIENT:QUICKLOAD :BIKE)
#)
(EVAL (QUICKLISP-CLIENT:QUICKLOAD :BIKE))
(SWANK::EVAL-REGION "(ql:quickload :bike)
")
((LAMBDA () :IN SWANK-REPL::REPL-EVAL))
(SWANK-REPL::TRACK-PACKAGE
#<FUNCTION (LAMBDA () :IN SWANK-REPL::REPL-EVAL) {2888C735}>)
(SWANK::CALL-WITH-RETRY-RESTART "Retry SLIME REPL evaluation request."
#<FUNCTION (LAMBDA ()
:IN
SWANK-REPL::REPL-EVAL) {2888C705}>)
(SWANK::CALL-WITH-BUFFER-SYNTAX NIL
#<FUNCTION (LAMBDA ()
:IN
SWANK-REPL::REPL-EVAL) {2888C6F5}>)
(SWANK-REPL::REPL-EVAL "(ql:quickload :bike)
")
(SB-INT:SIMPLE-EVAL-IN-LEXENV
(SWANK-REPL:LISTENER-EVAL "(ql:quickload :bike)
")
#)
(EVAL
(SWANK-REPL:LISTENER-EVAL "(ql:quickload :bike)
"))
(SWANK:EVAL-FOR-EMACS
(SWANK-REPL:LISTENER-EVAL "(ql:quickload :bike)
")
"COMMON-LISP-USER" 24)
(SWANK::PROCESS-REQUESTS NIL) ((LAMBDA () :IN SWANK::HANDLE-REQUESTS))
((LAMBDA () :IN SWANK::HANDLE-REQUESTS))
(SWANK/SBCL::CALL-WITH-BREAK-HOOK #
#<FUNCTION (LAMBDA ()
:IN
SWANK::HANDLE-REQUESTS) {24FC007D}>)
((FLET SWANK/BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "C:/Users/JohnH/quicklisp/dists/quicklisp/software/slime-v2.27/swank/sbcl.lisp")
#
#<FUNCTION (LAMBDA () :IN SWANK::HANDLE-REQUESTS) {24FC007D}>)
(SWANK::CALL-WITH-BINDINGS
((STANDARD-INPUT . #<SWANK/GRAY::SLIME-INPUT-STREAM {24DC8689}>))
#<FUNCTION (LAMBDA () :IN SWANK::HANDLE-REQUESTS) {24FC008D}>)
(SWANK::HANDLE-REQUESTS #<SWANK::MULTITHREADED-CONNECTION {24518F51}> NIL)
((FLET SB-UNIX::BODY :IN SB-THREAD::RUN))
((FLET "WITHOUT-INTERRUPTS-BODY-9" :IN SB-THREAD::RUN))
(SB-THREAD::RUN #<SB-THREAD:THREAD "repl-thread" RUNNING {24FB91C1}> NIL
#<FUNCTION (LAMBDA ()
:IN
SWANK-REPL::SPAWN-REPL-THREAD) {24FB9145}>
NIL)
((FLET "WITHOUT-INTERRUPTS-BODY-1" :IN SB-THREAD::START-THREAD))
((FLET SB-THREAD::START-ROUTINE :IN SB-THREAD::START-THREAD))
("foreign function: #x42D25D") ("foreign function: #x404309")
("foreign function: #x4183B5"))

Trying out a basic bike-sbcl program produces ,

...................Unhandled SIMPLE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING
                                    {1005E200A3}>:
  Unable to get executable name

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {1005E200A3}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<SIMPLE-ERROR "Unable to get executable name" {1004A53033}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK SB-EXT:*INVOKE-DEBUGGER-HOOK* #<SIMPLE-ERROR "Unable to get executable name" {1004A53033}>)
2: (INVOKE-DEBUGGER #<SIMPLE-ERROR "Unable to get executable name" {1004A53033}>)
3: (ERROR "Unable to get executable name")
4: (GET-EXE-PATH)
5: (FIND-CORECLR)

OS : FreeBSD 14.0
Dotnet: TheFrank Crossbuild.
https://github.com/Thefrank/dotnet-freebsd-crossbuild
https://github.com/Thefrank/dotnet-freebsd-crossbuild/releases/tag/v7.0.405
sbcl: v 2.3.1

Just putting this in the issues as a suggestion to improve the example of using WPF. A more extensive example would go a long way to getting CL folks up and running for desktop GUI's. Perhaps a package browser? Bonus points if it's cross-platform. With this someone could 'run with it' and start a quicklisp manager, ASDF system browser, etc.

sbcl 2.0.0
dotnet-sdk-6.0.20
.Net exception System.BadImageFormatException
Could not load file or assembly 'System.IO.Compression.Native, Culture=neutral, PublicKeyToken=null'. The module was expected to contain an assembly manifest.
at System.Reflection.RuntimeAssembly.InternalLoad(ObjectHandleOnStack assemblyName, ObjectHandleOnStack requestingAssembly, StackCrawlMarkHandle stackMark, Boolean throwOnFileNotFound, ObjectHandleOnStack assemblyLoadContext, ObjectHandleOnStack retAssembly)
at System.Reflection.RuntimeAssembly.InternalLoad(AssemblyName assemblyName, RuntimeAssembly requestingAssembly, StackCrawlMark& stackMark, Boolean throwOnFileNotFound, AssemblyLoadContext assemblyLoadContext)
at System.Reflection.Assembly.Load(String assemblyString)
at lambda_method10(Closure , IntPtr , IntPtr& , Int32& , IntPtr& )
[Condition of type BIKE:DOTNET-ERROR]

Restarts:
0: [TRY-RECOMPILING] Recompile assemblies and try loading it again
1: [RETRY] Retry loading FASL for #<CL-SOURCE-FILE "bike" "src" "assemblies">.
2: [ACCEPT] Continue, treating loading FASL for #<CL-SOURCE-FILE "bike" "src" "assemblies"> as having been successful.
3: [RETRY] Retry ASDF operation.
4: [CLEAR-CONFIGURATION-AND-RETRY] Retry ASDF operation after resetting the configuration.
5: [RETRY] Retry ASDF operation.
--more--

I've just come across your README discussion about SBCL's exception handling on Windows. That has recently been fixed in SBCL, so you can update the README if you wish.

SBCL implementation crashes randomly on Linux should you load .Net Core runtime into a process.

This has something to do with unix signals, most likely, because the usual displayed error is the following:

fatal error encountered in SBCL pid 14564(tid 0x7fc8af4bbb80):
blockables unblocked

The resolution, though hardly defined, is, as you might except, would be, as you would guess - the execution of the tests, with no error, and no crashes, using 'sbcl --script tests.lisp'.

So currently out and ref parameters (i.e. ByRef parameter types) are not handled in library public APIs, despite the fact that both trampoline compilers and DEFKNOWN can work with it.

This means, for example, that methods like int.TryParse are not quite available unless you use library internals.

This needs to be fixed.