<beach>
This page mention what happens when no handler is found and SIGNAL or ERROR is the signaling form, but it doesn't mention WARN. Can anybody see a reason, other than an omission?
chsasank has quit [Quit: Ping timeout (120 seconds)]
<beach>
Right. But it should be mentioned in HANDLER-BIND, just like SIGNAL and ERROR are mentioned.
<agm>
oh, I agree
<beach>
Thanks.
<agm>
you're welcome!
waleee has joined #commonlisp
<agm>
clhs 9.1.4.1 also doesn't mention WARN, except in the list at the bottom
<agm>
it seems the clhs often considers warnings as separate from other signals
<beach>
Hmm, I hadn't noticed that.
<agm>
but it should be mentioned, in my opinion
<beach>
Yeah.
<younder>
So warnings don't require a error handler as they can be ignored?
<beach>
Right, WARN returns if the condition is not handled.
<younder>
To me that sounds like you grade conditions by severity and that if you expect people to handler-case the condition it should be flagged as a error not a warning.
<younder>
So a erroneous reading in a sensor log flags a entry-error. A condition-restart allows ignoring the error. Where other languages might issue a warning a continue.
<beach>
It is important to be able to establish a handler for warnings as well as errors. A file compiler might handle warnings of undefined functions by accumulating the conditions until the end of compilation, and signal a single warning for each undefined function at the end of compilation, rather than signaling a warning for each call.
rgherdt has joined #commonlisp
<beach>
And when the function is defined in the file after the occurrence of calls to it, no warning is signaled at all.
X-Scale has joined #commonlisp
danza has quit [Read error: Connection reset by peer]
jjnkn has joined #commonlisp
jonatack has quit [Ping timeout: 260 seconds]
iNomad has joined #commonlisp
danza has joined #commonlisp
igemnace has joined #commonlisp
dino_tutter has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 252 seconds]
thuna` has joined #commonlisp
Lord_of_Life_ is now known as Lord_of_Life
_cymew_ has quit [Ping timeout: 260 seconds]
thuna` has quit [Ping timeout: 264 seconds]
thuna` has joined #commonlisp
vyrsh has joined #commonlisp
waleee has quit [Ping timeout: 264 seconds]
vyrsh has quit [Read error: Connection reset by peer]
vyrsh has joined #commonlisp
random-nick has joined #commonlisp
McParen has left #commonlisp [#commonlisp]
tyson2 has joined #commonlisp
danza has quit [Ping timeout: 252 seconds]
thuna` has quit [Ping timeout: 245 seconds]
thuna` has joined #commonlisp
thuna` has quit [Ping timeout: 264 seconds]
rgherdt has quit [Read error: Connection reset by peer]
rgherdt_ has joined #commonlisp
decweb has joined #commonlisp
ebrasca has joined #commonlisp
nij- has joined #commonlisp
McParen has joined #commonlisp
ec has quit [Remote host closed the connection]
ec has joined #commonlisp
Inline has joined #commonlisp
wbooze has joined #commonlisp
waleee has joined #commonlisp
josrr has joined #commonlisp
jjnkn has quit [Ping timeout: 260 seconds]
zacque has joined #commonlisp
Lycurgus has joined #commonlisp
vyrsh has quit [Quit: Konversation terminated!]
b00p has joined #commonlisp
<McParen>
when I build an executable with sbcl, it seems that all sbcl command line options are still captured by sbcl. Does anyone know how to pass all options to the new executable?
<McParen>
i.e. when passing --help, how do i display my help instead of sbcl's help?
nij- has left #commonlisp [Using Circe, the loveliest of all IRC clients]
jonatack has joined #commonlisp
* Lycurgus
checks to make sure sbcl isn actually creating native object code
zacque has quit [Quit: Goodbye :D]
<McParen>
mhm, there is an option :save-runtime-options which does that.
<Lycurgus>
shoulda phrased that as if there is a common lisp that isn vm + image
<Lycurgus>
wrappers is wrappers
<beach>
Lycurgus: Why would SBCL not create native machine code?
* Lycurgus
realizes he stepped into the what constitutes an executable doody
<Lycurgus>
emitting machine operators alone doesn in my understanding of a 'regular binary such as a c program or lib'
<Lycurgus>
the type case of an executable
<Lycurgus>
the essence is 'what is running?'
<beach>
Lycurgus: I don't know what that means. An ordinary ELF executable is usually just machine code. Why would it not be?
<Lycurgus>
if the answer is just the iron and the OS, then that's a regular executable in that sense
<Lycurgus>
yes but sbcl doesn sfaik produce ELF executables other than ofc the sbcl binary
<Lycurgus>
and the wrapper if any
<Lycurgus>
to the extent it just wraps it's not a native executable in my understanding, it's an sbcl executable which has been wrapped to be locally executable
<beach>
What does this "wrapper" consist of?
<Lycurgus>
the code that fields argc, argv and invokes the implemention on the image
<b00p>
I think they are referring to the SBCL runtime?
<Lycurgus>
*implementation
<Lycurgus>
which is easily enough self done, the big to do made about it notwithstanding
<younder>
As long as you are not running sbcl from the command line that sbcl eating options shouldn't be a problem.
<younder>
SBCL images are somewhat bloated. There is no tree walker to strip off unused code. But it is machine code it is not interpreted.
<pranavats>
Lycurgus: readelf correctly reports the stumpwm executable created using sbcl as class:ELF64. So clearly sbcl can create elf binaries.
<Riviera>
Hm, I always thought SBCL had some built-in means for creating standalone executables.
<beach>
It does.
<Riviera>
ah sorry, was discussed above.
reb has quit [Remote host closed the connection]
<beach>
Riviera: But Lycurgus has the impression that the executable generated that way is not just machine code, but also contains some kind of "wrapper" that is something other than machine code.
reb has joined #commonlisp
<younder>
Sure.. Just like everything else like erm ELF
<beach>
I don't know whether that's the case, but I would be very surprised if it were. It would have been a very strange design decision.
<Lycurgus>
no that's not the case
jjnkn has joined #commonlisp
* Lycurgus
has the impression that an sbcl executable, with machine operators in the state younder referred to is something less than 'a regular executable' in the sense given
<beach>
Lycurgus: What evidence do you have for that?
<Lycurgus>
by the standard of a pure c program or lib
<beach>
I guess there is no great point in discussing something that is either true of false. We can just wait for someone who knows SBCL well.
<beach>
hayley: Do you know?
b00p has quit [Quit: b00p]
<hayley>
(save-lisp-and-die ... :executable t) concatenates the SBCL runtime executable and image in some way, from memory.
mgl has quit [Ping timeout: 264 seconds]
<beach>
hayley: Yes, but Lycurgus is under the impression that it also contains a "wrapper" that does not consist of machine code.
<hayley>
What does the wrapper consist of then?
<beach>
Beats me.
<beach>
My understanding is that the usual SBCL executable is an ordinary ELF executable that mmap()s the "core" and that with :EXECUTABLE T, it is just both of them together.
<hayley>
Me too, sorry. I'm apparently very good at writing compilers at 01:00, but not so good at answering SBCL trivia.
<beach>
Heh, it's OK. Don't worry about it.
<hayley>
The intrepid #commonlisp reader might want to read gc_and_save in src/runtime/save.c, especially what happens with the prepend_runtime parameter.
<hayley>
The generated executable is a concatenation of the SBCL runtime and the core. The function search_for_embedded_core in src/runtime/coreparse.c searches for an embedded core in the executable file.
<younder>
I can say modern processors distinguish executable segments from data segments in a harward architecture. Lisp must to. In my sctetch of the SICL runtime I have more executable segments than a traditional C program. It not a strict data section, a SSB (constants) section and a code section.
<hayley>
Processors don't force a distinction, so Lisp needn't. OpenBSD, and macOS on ARM do force the distinction to a degree though.
<hayley>
macOS fortunately allows a thread to switch between writing and executing "JIT" pages; SBCL in Lisp can toggle between those modes before and after writing machine code to code pages.
<younder>
So only forced if you want to support those architectures? Sounds pretty forced to me..
<hayley>
Or to be more precise, the processors SICL and SBCL target are not strictly Harvard-architecture.
<beach>
Any Common Lisp system that generates native code interactively must be able to write that code and then execute it later. Whether that's done by having those pages both writable and executable at the same time, or whether one has to switch between the two is just a matter of how complicated things have to be.
<hayley>
SBCL works just fine on macOS/ARM. OpenBSD requires SBCL to live on a file system mounted with wxallowed (according to the README), but my impression is that OpenBSD does a lot of "interesting" things to minimise the damage caused by stupid unsafe programs.
<beach>
Yes, and instead of using a safer programming language, they make life harder for all those who use dynamic programming languages.
<semarie>
yes, OpenBSD requires W^X (write XOR execute) on memory pages. so to have sbcl working, you need to whitelist the process in some way (wxallowed)
Guest52 has quit [Ping timeout: 250 seconds]
<hayley>
Although my lab told me that the V8 JavaScript implementation basically enforces W^X and some more memory protection on itself, because the compiler authors can't trust the compiler output, and V8 is used on untrusted JavaScript code.
<hayley>
(The lab told me that because my research project is about not trusting the compiler output, without resorting to memory protection or other nasty things.)
<semarie>
for MacOS, the memory is allocated with MAP_JIT to tell the system in advance that WX will be fine
<hayley>
Look for uses of THREAD_JIT_WP in src/runtime/; THREAD_JIT_WP(0) enables writes and THREAD_JIT_WP(1) enables execution.
<hayley>
That was a fun port to do; Doug and I had to figure out if the GC (which we also had just ported to Linux/ARM) was broken or the memory protection was broken.
<younder>
cool
Mezzie has joined #commonlisp
<Mezzie>
Hello
<younder>
At least I feel I leaned a few things.
donleo has joined #commonlisp
<beach>
Hello Mezzie.
awlygj has quit [Quit: leaving]
<beach>
Mezzie: Are you new here? I don't recognize your nick.
McParen has left #commonlisp [#commonlisp]
<hayley>
I finally compiled a loop today. As silly as that sounds, my source language does control flow by tail calls and method dispatch, so I had to get the inlining and analysis right to detect that I should make a loop.
<beach>
hayley: Remind me why you are not creating a Common Lisp implementation, and instead working on a new language?
nij- has quit [Ping timeout: 240 seconds]
b00p has joined #commonlisp
<pranavats>
hayley: Is that graph layout using mcclim-dot?
<hayley>
pranavats: It is.
flip214 has quit [Read error: Connection reset by peer]
tyson2 has quit [Read error: Connection reset by peer]
<pranavats>
Cool.
<hayley>
beach: Gnuxie and I are developing the language around object capabilities. It's also convenient as a minimal language to test things with; a colleague suggested implementing some simple Lisp or featherweight Java.
flip214 has joined #commonlisp
<beach>
I see, sort of.
<hayley>
Essentially I want a "model" of some fancy compiler like HotSpot or V8 to test against, and I'm not sure if I have the time to develop something like that for Common Lisp.
Odin-FOO has quit [Remote host closed the connection]
X-Scale has quit [Quit: Client closed]
<beach>
I understand.
<hayley>
There are other concessions to save time, like that I'm writing a batch compiler and no redefinition or interaction is possible.
rogi has joined #commonlisp
rogi is now known as giro
mgl has joined #commonlisp
b00p has quit [Quit: b00p]
b00p has joined #commonlisp
<hayley>
That said, only the frontend is really language-specific, and that comprises about 1/4 of the compiler; the other 3/4 could be reusable for Common Lisp. I mean, I haven't tried. The compiled code also has safepoints with debug information, so theoretically one could add the machinery for redefinition and deoptimisation.
tyson2 has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
<younder>
Yes, I have noted you have done considerable work in the dataflow analysis.
<hayley>
There are only three passes which get iterated upon in the compiler: peepholes, inlining, and removing the scaffolding IR for tail calls ("Unscaffold"). Types and dominators are computed incrementally and when demanded by each pass.
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
rtypo has joined #commonlisp
mm007emko has quit [Ping timeout: 255 seconds]
<younder>
Well I give you that hayley your pace is relentless. I can't keep up
mm007emko has joined #commonlisp
mm007emko has quit [Read error: Connection reset by peer]
mivanchev has joined #commonlisp
<mivanchev>
Gents, is it true that FASL are only compatible to the specific compiler version they were built with
<mivanchev>
i.e. for SBCL
<younder>
yes
<mivanchev>
ok, interesting
<beach>
mivanchev: Are you deliberately excluding lots of participants here by addressing only the "gents"?
mm007emko has joined #commonlisp
<hayley>
(Guy Steele said Java brought C++ programmers halfway to Lisp. Perhaps Gnuxie and I are bringing Lisp programmers halfway to Newspeak.)
<mivanchev>
not at all beach, it's just how i speak, if anyone is offended I offer appologies and augmentation
<beach>
mivanchev: So for instance, SBCL FASLs contain machine code, but SICL FASLs contain just a printed representation of a minimally compiled AST.
<mivanchev>
sort of like LLVM?
<beach>
SICL FASLs? Not at all. Just a printed representation of a tree of instances of standard classes that represent the source code with macros expanded.
<mivanchev>
well that doesn't sound very fast at all
<beach>
Right. I am of the opinion that FASLs are more-or-less obsolete, so I do the minimal thing required to be conforming.
<beach>
Plus, since no machine code is contained, the FASLs are portable and safe from arbitrary malware.
<mivanchev>
what would be better than FASLs?
<beach>
Nothing. I think they are mostly not needed.
<mivanchev>
with my StumpWM the difference between compiled code and interpreted code is roughly 10 degrees C
<mivanchev>
and ~4% CPU activity
<beach>
Who said something about interpreted code?
<beach>
When a SICL FASL is loaded, the AST is compiled to machine code (or will be).
<mivanchev>
ah, JITed
<mivanchev>
yeah, that might be acceptable
<younder>
For what it's wort beach I estimated 3 years to make a full SICL compiler.
<mivanchev>
maybe JIT + caching is optimal
<beach>
No, just compiled like any form.
<beach>
... depending on your definition of JIT of course.
<beach>
younder: Luckily, you don't have to make a SICL compiler; only a library to convert MIR to machine code. The rest is already done.
matt` has joined #commonlisp
<mivanchev>
you both sound like reinventing LLVM
<hayley>
Suit yourself, I'm reinventing C2.
<mivanchev>
at least not C-4
<beach>
mivanchev: LLVM is way too slow (as the Clasp developers learned the hard way) and is not written in Common Lisp.
<hayley>
mivanchev: Azul already uses C4 for garbage collection.
<beach>
mivanchev: The essential difference between source code and FASL code, according to the standard, is that FASL code must be "minimally compiled" which basically means macroexpanded.
<mivanchev>
hayley, you didn't get the joke =)
<mivanchev>
C-4 the explosive
<hayley>
To be honest, I thought the fragmentation would be really bad.
<hayley>
mivanchev: No, you didn't wait for my punchline.
<mivanchev>
daaaaamn
<mivanchev>
sorry sorry
<mivanchev>
<3
<hayley>
No worries.
<mivanchev>
haha
<younder>
kids.. argh
<mivanchev>
beach, that's true however we are slowly moving forward on all fronts so i am sure in 20 years we'll have very usable performant software with both lisp and LLVM
<hayley>
"Kids"!? I can't even enjoy being 22.
<beach>
mivanchev: That's past my remaining life expectancy, so I am not going to wait.
<younder>
Why not? I did. A long time ago
<mivanchev>
i'm also moving towards the geriatric category
<younder>
hayley you mental acuity is at it's peak. Enjoy it and use it for what it's worth while it lasts.
<mivanchev>
stop telling them to enjoy something that's transient, it's not the buddha way
<mivanchev>
they should just enjoy the now whenever
<younder>
I'm not budda
Inline has quit [Read error: Connection reset by peer]
wbooze has quit [Read error: Connection reset by peer]
Inline has joined #commonlisp
b00p has quit [Quit: b00p]
rbcarleton has left #commonlisp [ERC 5.5.0.29.1 (IRC client for GNU Emacs 29.1)]
vyrsh has joined #commonlisp
b00p has joined #commonlisp
zxcvz has joined #commonlisp
zxcvz has quit [Client Quit]
Guest52 has joined #commonlisp
rnfn has joined #commonlisp
wbooze has joined #commonlisp
rnfn has quit [Quit: rnfn]
rnfn has joined #commonlisp
b00p has quit [Quit: b00p]
Algernon91 has joined #commonlisp
Algernon666 has joined #commonlisp
Algernon69 has quit [Ping timeout: 255 seconds]
Algernon91 has quit [Ping timeout: 268 seconds]
ec has quit [Ping timeout: 260 seconds]
ec has joined #commonlisp
igemnace has quit [Read error: Connection reset by peer]
Algernon666 has quit [Quit: Leaving]
mivanchev has quit [Ping timeout: 245 seconds]
zetef has joined #commonlisp
igemnace has joined #commonlisp
igemnace has quit [Quit: WeeChat 4.2.1]
mm007emko has quit [Ping timeout: 264 seconds]
mm007emko has joined #commonlisp
mm007emko has quit [Read error: Connection reset by peer]
mm007emko has joined #commonlisp
chiselfuse has quit [Remote host closed the connection]
chiselfuse has joined #commonlisp
vyrsh has quit [Quit: Konversation terminated!]
b00p has joined #commonlisp
mgl has quit [Ping timeout: 256 seconds]
zetef has quit [Ping timeout: 272 seconds]
Perflosopher has quit [Quit: Ping timeout (120 seconds)]
mivanchev has joined #commonlisp
Perflosopher has joined #commonlisp
<mivanchev>
stumpwm ready for review, thanks everyone for the help!
<mivanchev>
no on to the contrib package
amb007 has quit [Ping timeout: 255 seconds]
amb007 has joined #commonlisp
anticomputer has quit [Ping timeout: 260 seconds]
anticomputer_ has joined #commonlisp
zetef has joined #commonlisp
rnfn has quit [Ping timeout: 264 seconds]
b00p has quit [Quit: b00p]
b00p has joined #commonlisp
b00p has quit [Quit: b00p]
b00p has joined #commonlisp
istewart has joined #commonlisp
mgl has joined #commonlisp
nij- has joined #commonlisp
occ has quit [Ping timeout: 255 seconds]
a51 has joined #commonlisp
mivanchev has quit [Ping timeout: 245 seconds]
karvus has joined #commonlisp
szkl has joined #commonlisp
wacki has joined #commonlisp
jjnkn has quit [Quit: leaving]
Lycurgus has quit [Quit: leaving]
mgl has quit [Ping timeout: 256 seconds]
<Mezzie>
OK
nij- has quit [Ping timeout: 245 seconds]
karvus has quit [Remote host closed the connection]
akoana has joined #commonlisp
dinomug has joined #commonlisp
Mon_Ouie has quit [Quit: WeeChat 4.2.1]
Lycurgus has joined #commonlisp
iNomad has quit [Ping timeout: 252 seconds]
iNomad has joined #commonlisp
josrr has quit [Remote host closed the connection]
wacki has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
josrr has joined #commonlisp
iNomad has quit [Ping timeout: 245 seconds]
b00p has quit [Quit: b00p]
iNomad has joined #commonlisp
agm has quit [Ping timeout: 264 seconds]
kevingal has joined #commonlisp
arbn has quit [Remote host closed the connection]
amb007 has quit [Ping timeout: 256 seconds]
b00p has joined #commonlisp
zetef has quit [Remote host closed the connection]
amb007 has joined #commonlisp
dino_tutter has quit [Ping timeout: 264 seconds]
amb007 has quit [Ping timeout: 256 seconds]
chiselfuse has quit [Remote host closed the connection]
chiselfuse has joined #commonlisp
shka has quit [Ping timeout: 252 seconds]
brokkoli_origin has quit [Ping timeout: 268 seconds]