Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
damke has joined #lisp
<pjb>
Shinmera: I wouldn't be so categoric: pointers can have different sizes. eg. in MS-DOS. But also because you may have pointers to different type of data requiring more or less bits.
<Bicyclidine>
cffi doesn't work on such systems, as far as i understand
Bicyclidine is now known as Bike
Kaisyu7 has joined #lisp
ebzzry_ has quit [Ping timeout: 260 seconds]
Rawriful has quit [Quit: WeeChat 1.4]
terpri has quit [Ping timeout: 256 seconds]
LiamH has quit [Quit: Leaving.]
Kyo91 has joined #lisp
Kyo91 has quit [Ping timeout: 256 seconds]
mikecheck has joined #lisp
willmichael has joined #lisp
smurfrobot has joined #lisp
pierpa has joined #lisp
smurfrobot has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 256 seconds]
milanj has quit [Quit: This computer has gone to sleep]
krator44 has quit [Remote host closed the connection]
fikka has joined #lisp
trocado has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Oladon has joined #lisp
al-damiri has quit [Quit: Connection closed for inactivity]
willmichael has quit [Quit: Quit]
willmichael has joined #lisp
Kundry_Wag has joined #lisp
ebzzry_ has joined #lisp
Pixel_Outlaw has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
trocado has quit [Remote host closed the connection]
borei has quit [Quit: Leaving.]
fikka has joined #lisp
ebzzry_ has quit [Ping timeout: 256 seconds]
Mutex7 has quit [Quit: Leaving]
Walex has quit [Quit: leaving]
_krator44 has joined #lisp
pagnol has quit [Ping timeout: 268 seconds]
Oladon1 has joined #lisp
smurfrobot has joined #lisp
EvW has quit [Ping timeout: 265 seconds]
Oladon has quit [Ping timeout: 260 seconds]
ebzzry_ has joined #lisp
smurfrobot has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
epony has quit [Remote host closed the connection]
smurfrobot has quit [Ping timeout: 268 seconds]
asarch has joined #lisp
ebzzry_ has quit [Ping timeout: 268 seconds]
epony has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
lroca has joined #lisp
warweasle has joined #lisp
parjanya has joined #lisp
damke_ has joined #lisp
Kundry_Wag has joined #lisp
damke has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 248 seconds]
chat__ has quit [Remote host closed the connection]
willmichael has quit [Ping timeout: 256 seconds]
d4ryus1 has joined #lisp
terpri has joined #lisp
d4ryus has quit [Ping timeout: 256 seconds]
chat_ has joined #lisp
willmichael has joined #lisp
krwq has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
python476 has quit [Ping timeout: 248 seconds]
smurfrobot has joined #lisp
asarch has quit [Quit: Leaving]
fikka has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
lroca has quit [Quit: lroca]
pagnol has joined #lisp
axg has joined #lisp
epony has quit [Read error: Connection reset by peer]
smokeink has joined #lisp
epony has joined #lisp
smasta has quit [Quit: WeeChat 2.0.1]
mikecheck has left #lisp ["part"]
<Xach>
Hmm
Kundry_Wag has joined #lisp
<loke>
hmm?
Kundry_Wag has quit [Ping timeout: 256 seconds]
nika has joined #lisp
smurfrobot has joined #lisp
broccolistem has joined #lisp
<Xach>
Hmm
<jasom>
pjb: Bike, faff appears to be gone now, but what about this, which doesn't appear to have been suggested: (apply map 'list (lambda (x y) (+ x y)) (k1))
<Xach>
I am excited to go to ELS.
mareskeg has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
mareskeg has quit [Quit: mareskeg]
mareskeg has joined #lisp
mareskeg has quit [Remote host closed the connection]
mareskeg has quit [Remote host closed the connection]
mareskeg has joined #lisp
<emaczen>
I've written a short fully working program that uses CFFI and an external C library without any problems before, but the code was of a different style and didn't pass pointers to be modified like this code does
fikka has quit [Ping timeout: 240 seconds]
<Xach>
that is not C code?
<Xach>
but maybe that doesn't matter much
<emaczen>
Xach: I pasted C code and then CFFI underneath
<Bike>
he means that it's C++
<emaczen>
They use cout but whatever
mareskeg has quit [Remote host closed the connection]
mareskeg has joined #lisp
mareskeg has quit [Remote host closed the connection]
<emaczen>
Sorry
<emaczen>
I pasted the wrong C code
mareskeg has joined #lisp
mareskeg has quit [Remote host closed the connection]
<emaczen>
I also put an explanation right before my lisp code.
damke_ has quit [Ping timeout: 264 seconds]
<emaczen>
|3b|: Now I get an "Unhandled memory fault" error
Pixel_Outlaw has quit [Quit: Leaving]
<|3b|>
you might need to read the pointer from that pointer after calling init to get something you can pass to other functions
* |3b|
is guessing from reading my old code
igemnace has quit [Quit: WeeChat 2.0.1]
<emaczen>
|3d|: I don't understand what you mean by "read the pointer"
DataLinkDroid has joined #lisp
<|3b|>
(cffi:mem-ref context :pointer)
<pjb>
jasom: I proposed: (apply (function map) 'list (function +) (f1)) <-- F1, an operator returning a list of lists. The point of k1 is that it is not possible for a macro to return multiple forms. A macro can only return one form. This form could compute a list of list, so (apply (function map) 'list (function +) (k1)) would be possible. But there would be no point in using a macro, since a function would work as well.
<|3b|>
%3b-libusb1:context is just a cffi typedef for pointer
<|3b|>
that function returns what would be in the ctx variable in the C code
attila_lendvai has quit [Read error: Connection reset by peer]
<|3b|>
which can be passed directly to libusb_get_device_list
<emaczen>
Oh Okay, yes I understand what jasom is saying now
<emaczen>
|3b| That is what you had me do
<|3b|>
but yeah, allocate a pointer variable then mem-ref
<jasom>
emaczen: yes; the lisp code you would would roughly correspond to the c code: context = malloc(sizeof(void **)); libusb_init(context); libusb_get_device_list(*context);
<|3b|>
thanks, that's what i was failing to find words for :) been too long since i used C directly
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<jasom>
because you need to explicitly allocate in lisp anything you are going to pass to C (rather than implicitly allocate on the stack like your C code)
<jasom>
anyway I gotta go
<emaczen>
Now my problem is that libusb-get-device-list returns 6 (so I have 6 usb devices) which means I should be able to (cffi:mem-ref devices :pointer 5)
<emaczen>
But (cffi:null-pointer-p (cffi:mem-ref devices :pointer 4)) evaluates to T
fikka has quit [Ping timeout: 252 seconds]
ku has joined #lisp
fiddlerwoaroof has quit [Ping timeout: 240 seconds]
<|3b|>
might need another mem-ref on devices, since it is & in the c dode
<|3b|>
and you probably want mem-aref there, where the offset is in pointers rather than bytes
<emaczen>
|3b|: I seem to be getting the right results for mem-aref now
fiddlerwoaroof has joined #lisp
<emaczen>
What should I be expecting in the print statements? I have no idea what are reasonable values for the number of configurations, device class, vendor id, or product id
<beach>
Good morning everyone!
<emaczen>
should the same device always print the same values for those 4 fields?
<|3b|>
if you are on linux or similar, lsusb might give you something to compare to
<|3b|>
yeah, sounds like most of those should be fairly constant
<|3b|>
(some devices do strange things though)
<emaczen>
I'm on OSX...
<|3b|>
ah, no idea there
fikka has quit [Ping timeout: 260 seconds]
j0nd0e` has joined #lisp
riibunisu has joined #lisp
SaganMan has joined #lisp
j0nd0e has quit [Ping timeout: 256 seconds]
<beach>
So again, we are on freenode (dedicated to free software) in the #lisp channel (dedicated to Common Lisp), but we are talking about using other languages on commercial operating systems. Go figure.
smurfrobot has joined #lisp
<emaczen>
beach: a question outgrown with a CFFI translation
SaganMan has quit [Client Quit]
<|3b|>
beach: at least the foreign library in question doesn't require the commercial operating systems :)
<beach>
|3b|: that's an improvement.
<|3b|>
(OS only came up in context of external tool to check the lisp results against)(
arescorpio has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
davsebamse has quit [Ping timeout: 256 seconds]
davsebamse has joined #lisp
<emaczen>
|3b|: Did you see anything wrong with my print-dev function?
<|3b|>
how did you get the offsets for the struct def?
riibunisu has quit [Remote host closed the connection]
* |3b|
generally considers falling cffi:foreign-alloc directly to be "something wrong" without good reason, but shouldn't affect output of that
<|3b|>
*calling
willmichael has quit [Ping timeout: 256 seconds]
riibunisu has joined #lisp
<emaczen>
|3b| I looked at the header file and counted the bytes
willmichael has joined #lisp
<loke>
emaczen: That'[s not a reliable thing to do.
fikka has joined #lisp
<emaczen>
loke: It will work for my computer right?
<|3b|>
assuming those are correct, looks reasonable, but i'd probably try to verify the offsets if possible (print results of offsetof from the c code for example)
<loke>
emaczen: Perhaps. Assuming you count correctly (which can be tricky).
<|3b|>
works if you know your ABI well enough to get the alignment etc right when counting bytes :)
<loke>
I'd recommend using cffi-grovel
* |3b|
would just put all the fields in and let cffi figure it out for normal libraries
<emaczen>
|3b| I'll try that
<emaczen>
|3b|: I'm still not getting consistent results with the printing of those 4 fields
<|3b|>
ah, maybe another missing pointer deref if the values are changing
<|3b|>
hmm, maybe not
<emaczen>
I'm returning (cffi:mem-aref devices :pointer) from init
<|3b|>
ah, it is &desc, so yeah, probably need another mem-aref for that
<emaczen>
and then I'm calling (print-dev (cffi:mem-aref devices :pointer 2)) or another index
<|3b|>
wait, not a pointer, ignore that
* |3b|
is looking at too many things at once
<|3b|>
what is current code?
<emaczen>
|3b|: print-dev has not changed -- shall I make another paste for clarity?
<|3b|>
yeah
* |3b|
is back to seeing no problems with print-dev though
<|3b|>
actually, those offsets in the struct look pretty suspicious to me
<emaczen>
uint8_t and uint16_t are 8 and 16 bytes right?
* |3b|
thinks those are bits
<loke>
Bits yes
<loke>
Aldo remember padding
<loke>
Also
<emaczen>
uint8 is 1 byte then?
<|3b|>
yeah
<emaczen>
lol
Xach has quit [Ping timeout: 256 seconds]
* |3b|
thinks padding might not matter for that struct, since it has uint8 in multiples of 2 between the uint16, but multiplying offsets by 8 probably isn't good :)
<|3b|>
(at least in my version of it, which presumably matched the C version well enough for my code to run at some point)
Kundry_Wag has quit [Ping timeout: 240 seconds]
marusich has joined #lisp
<emaczen>
Cool! it seems to display consistent results.
<emaczen>
Now I have to figure out what it means...
<|3b|>
what are you trying to do?
riibunisu has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<emaczen>
|3b|: Right now, I'm just trying to get started with programming with USB devices from CL
<emaczen>
It tried quickloading cl-libusb but it failed
attila_lendvai has quit [Ping timeout: 268 seconds]
Xach has joined #lisp
<|3b|>
yeah, i think cl-libusb is old libusb API
<|3b|>
might see if my lib still works... not very complete but at least might bet you a little bit further to start out
<|3b|>
worked enough to download files off of my camera at one point
<emaczen>
hah, I keep looking at it if I get stuck
sz0 has joined #lisp
<emaczen>
|3b|: Thanks for the help, the hardest part is getting started... I should be able to figure out a lot from here with the pointers given
<emaczen>
pun intended :)
zaquest has quit [Ping timeout: 252 seconds]
axg has quit [Ping timeout: 264 seconds]
Oladon1 has quit [Quit: Leaving.]
<sigjuice>
would it be possible to do something like this to make a custom sbcl binary? (defsystem "mysbcl/exe" :build-operation program-op :build-pathname "mysbcl" :entry-point "launch-sbcl-repl????" :depends-on (...))
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
<pillton>
lisp-executable provides something like that.
ebzzry_ has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
schweers has joined #lisp
* schweers
wonders if filenames like foo.tar.gz might have been a bad idea after all (considering how SBCL handles the type of a namesting/pathname)
pagnol has joined #lisp
<Shinmera>
Not as bad as .so.0 etc
<schweers>
true
fikka has quit [Ping timeout: 264 seconds]
frodef has joined #lisp
smurfrobot has quit [Remote host closed the connection]
python476 has joined #lisp
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
zaquest has quit [Ping timeout: 265 seconds]
Kundry_Wag has joined #lisp
smurfrobot has joined #lisp
<thodg>
i don't understand how cffi handles string constants
<thodg>
as preprocessor defines
<thodg>
(constant ...) in the groveller does not seem to grok them
<pjb>
schweers: for unix, it's not a bad idea. But for common lisp logical pathnames, it's redhibitory, since #\. is not a conforming character for pathname names. cf. 19.3.1
<pjb>
schweers: therefore "foo.tar" can only be a physical pathname component.
<schweers>
Well, how were an implementation to know whether the dot separates the (stack of) type(s), or whether its just a funny name?
Kundry_Wag has quit [Ping timeout: 260 seconds]
<pjb>
schweers: it's implementation dependent.
smurfrobot has quit [Ping timeout: 264 seconds]
EvW has joined #lisp
<schweers>
I know it is, but what I mean is: what might be the best behaviour? guessing is not an option, and the filenames themselves don’t provide enough information
<schweers>
Although I am annoyed that SBCL does not like having a type like "tar.gz".
<thodg>
schweers: well the type really is gz
<schweers>
it kinda is both
<thodg>
you'll get to tar if you gunzip
<schweers>
i.e. a stack of types
<thodg>
like an apple is not an appleseed
<schweers>
true, but can be transformed into such
<thodg>
probably a certain number of times after a while it gets used
<schweers>
pjb: I just now realized you were talking about logical pathnames. Are the rules for them relevant if I don’t use them (directly)?
<schweers>
I think I got my terminology confused a bit :/
<Shinmera>
schweers: The real problem is that the file name matters at all, rather than the type of file being encoded in the data/inode in a standard way.
DataLinkDroid has quit [Quit: Ex-Chat]
smokeink has quit [Ping timeout: 240 seconds]
<schweers>
That is what I would have preferred (I guess), but filesystems are the way they now are, I guess :(
hhdave has joined #lisp
<pjb>
schweers: of course, logical pathnames are not relevant when you don't use them directly. When you talk about a physical pathname such as "foo.tar.gz", nothing matters, since it's entirely implementation dependent how it's interpreted.
<pjb>
schweers: yes, two implementations can choose to cut the name / type on different dots.
<schweers>
okay, that’s what I thought. Not entirely satisfactory, but I guess I’ll just have to live with that
<schweers>
hehe, true
<schweers>
or even just .bashrc
<pjb>
for abcl, ccl, clisp, ecl and sbcl on macosx, (pathname-type "foo.tar.gz") -> "gz"
<schweers>
interesting, sbcl puts ".bashrc" in the name, leaving type nil
<pjb>
yes, they all do that on unix. It's the sane thing to do.
<pjb>
well, not ccl, for .bashrc
<pjb>
they all returns .foo.tar for (pathname-name ".foo.tar.gz")
<schweers>
it is what I also naively expected, but it does seem rather arbitrary
<pjb>
but ccl returns nil for (pathname-name ".bashrc")
<schweers>
so type is "bashrc"?
<pjb>
yes.
<schweers>
considering logical pathnames: are they used in the wild? i.e. do you guys and gals use them?
<pjb>
I use them all the time in lisp sources.
<schweers>
I must admit that I don’t know anything about them, other than that I have read statements online (can’t remember where or by whom) that they are badly designed and one should avoid them
<pjb>
You could have the rule, that you should not have literal physical pathnames in lisp sources. Only literal logical pathnames are allowed.
<pjb>
On the other hand, at run-time, you would process mostly physical pathnames.
<pjb>
logical pathnames offers an indirection level allowing you to manipulate pathnames in an implementation independent way, thru the logical-pathname-translation mapping.
<schweers>
off the top of your head, do you have a nice example?
<pjb>
So you don't have to care where the files and directory your application uses are located; this will be decided by the user (thru load-logical-pathname-translations).
<schweers>
by filling in the users home directory?
raynold has quit [Quit: Connection closed for inactivity]
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
<pjb>
the project is marked Public… Try again?
<schweers>
now they work, thanks
<pjb>
Thanks to you.
<pjb>
I will have to change one permission setting to all my projects … :-)
<pjb>
schweers: in this case, I define the logical hosts and their translations in loghosts.lisp; but it could be left to the user, using load-logical-pathname-translations.
<pjb>
schweers: when you install an application, your installation script could generate the logical pathname translation file to be used by load-logical-pathname-translations for the user, depending in the installation paths.
<schweers>
So one can define a logical path to the applications installation directory and have the user configure where that points to prior to building?
<pjb>
schweers: In this example, this allows the rest of the build scripts such as builder.lisp to use logical pathname literals independently of the locations of the various sources directories.
<pjb>
schweers: yes.
<schweers>
Or can this even be deferred until runtime
<pjb>
Well, installation is a run-time procedure, so you would rather defer it to runtime.
<schweers>
sweet!
<pjb>
Basically, if you save a physical pathname in a lisp image, you failed (because a different user may run the same executable lisp image, so hardwired pathnames may be wrong).
<pjb>
Since logical pathnames are translated at run-time, you can save them in your sources, your fasls, or your lisp images.
<pjb>
The only thing you have to remember is that you can only translate from logical to physical, never the other direction.
<schweers>
its settled, I must learn how to use these beasts :) thanks a lot for the information!
<pjb>
So when you get a physical pathname at run-time (such as with DIRECTORY, or using an "open" dialog, or given by the user), you must keep it as physical pathname (you can still manipulate all the pathnames with pathname functions).
esthlos has quit [Ping timeout: 256 seconds]
<pjb>
The only difficulty there is that there's a lot of implementation and platform specific behavior allowed… So it's delicate to use conformingly.
<pjb>
There are libraries to help, such as cl-fad or uiop.
<schweers>
I’ve seen lots of read time conditionals in your code ;)
esthlos has joined #lisp
Digit has quit [Remote host closed the connection]
frodef has quit [Remote host closed the connection]
frodef has joined #lisp
Digit has joined #lisp
yangby has quit [Quit: Go out for a walk and buy a drink.]
<Shinmera>
too bad logical pathnames don't deal well with case and other special characters, among other things.
<Shinmera>
and by don't deal well I mean, don't deal at all
<pjb>
They deal perfectly well: they don't allow them! So it's perfectly portable!
<pjb>
Just use the logical-pathname-translation table to add them.
<Shinmera>
wow, I can only address a subset of all files on my system, great!
<pjb>
The point of logical pathnames is that you don't polute your sources with implementation and platform specific path literals.
<pjb>
All those implementation and platform specific physical pathnames, with those cases and special characters variants, are collected into a single place, the logical pathname translation table.
jmercouris has joined #lisp
moei has joined #lisp
<pjb>
That said, some implementations may have physical pathnames restrictions that make them unable to represent all the paths of a given platform. Call that a bug.
<schweers>
do I understand correctly that logical pathnames are there to encode well-known-places which depend on the implementation, the OS, or in some other way on the environment? i.e. obtaining the users home directory would be a valid use of logical pathnames?
energizer has quit [Ping timeout: 240 seconds]
<pjb>
schweers: indeed, in some implementations, #"HOME:" is mapped to (user-homedir-pathname).
esthlos has quit [Ping timeout: 256 seconds]
esthlos has joined #lisp
groovy2shoes has quit [Remote host closed the connection]
<schweers>
so when reading user specific configs, a logical pathname might translate to ~/.config/ on unix and to … uh … /Users/$USERNAME/.AppData/ on windows? (I don’t use windows much, so I might be wrong here, but I guess you see my point)
<pjb>
exactly.
<schweers>
cool
<schweers>
groovy2shoes has joined #lisp
<pjb>
on windows it's even more complex, since appdata and other user specific files are not necessarily in (user-homedir-pathname)…
<schweers>
really? sounds bad
zaquest has joined #lisp
_cosmonaut_ has joined #lisp
<jmercouris>
there's not really a convention in Windows, especially because they support basically all legacy programs
<jmercouris>
it's a price they have to pay to have the most "software available"
<schweers>
If I recall correctly MS does have guidelines for these sort of things, but they don’t document it as loudly as they should, as is often the case
<Shinmera>
schweers: You don't put things into AppData, you put them in AppData\Local, AppData\Roaming, or AppData\LocalLow
<schweers>
for instance I think its quite bad that still so many programs put their data directly into the users home on unix
lugh has quit [Ping timeout: 256 seconds]
<jmercouris>
yes, that is really annoying, but there is nothing motivating programs from not doing that
<schweers>
Shinmera: fair enough, as I said, I don’t really use windows ;) Nevertheless, thanks for correcting me
<jmercouris>
if people really wanted to see a change, a distro would have to take a hard stance and somehow make that harder on their platform or something
<Shinmera>
XDG tried to standardise .config, .cache, and .local
<jmercouris>
XDG is a mild success at best, I have about half my programs using it
<jmercouris>
maybe it needs another 20 years :D
<pjb>
Obiously, you could define and use a XDG logical host…
<schweers>
I don’t think a distro can do much about this
<Shinmera>
20 years of linux on the deskto!
<Shinmera>
*desktop
koisoke has quit [Ping timeout: 248 seconds]
lugh has joined #lisp
<schweers>
dunno, I’ve been using it on my desktops for more than 10 years, so go figure ;P
zaquest has quit [Ping timeout: 256 seconds]
koisoke has joined #lisp
<jmercouris>
I am also 10+ years, but at some point Linux made me very bitter and pushed me to bsd...
<schweers>
pjb: yes, but that doesn’t cover the majority of software, which is, sadly, not written in lisp
<schweers>
jmercouris: still in the family
<jmercouris>
indeed :)
deng_cn has quit [Read error: Connection reset by peer]
deng_cn has joined #lisp
smurfrobot has joined #lisp
Amplituhedron has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
<schweers>
pjb: what exactly am I supposed to pass to LOGICAL-PATHNAME-TRANSLATIONS? I tried this, but it gave me an error, because the argument is of the wrong type: (logical-pathname-translations (pathname-host *default-pathname-defaults*))
<pjb>
a logical host.
nika has quit [Remote host closed the connection]
<schweers>
is there such a thing as a default host?
<schweers>
I’d like to know if there are any default translations in a given implementation
<jmercouris>
named-readtables is not a piece of my software, and it load in CCL
<pjb>
jmercouris: :mailto is a new option for asdf systems. Perhaps write #+asdf3 :mailto #+asdf3 "foo@bar.baz"
<pjb>
Conversely, you could first load a recent version of asdf.
<pjb>
(instead of using the old one provided by the implementation).
<jmercouris>
how does one load a recent version of asdf? is it not built into the implementation?
<jmercouris>
can you quickload asdf?
EvW has quit [Ping timeout: 255 seconds]
<pjb>
I download it from https://common-lisp.net/project/asdf/#downloads and then I use (load "asdf.lisp") in my common.lisp rc file. More precisely: (defun load-asdf3 () (unless (member :asdf3 *features*) (load (merge-pathnames #P"src/public/lisp/tools/asdf.lisp" (user-homedir-pathname))))) (load-asdf3)
<jmercouris>
Ok, I see
<pjb>
basic lisp programming.
<jmercouris>
"basic lisp configuration", I wouldn't call that programming
<jmercouris>
seems I am using a very old version of sbcl, let me update it first, then I'll try updating asdf by itself if that doesn't suffice
siraben has joined #lisp
nirved has quit [Ping timeout: 256 seconds]
<jmercouris>
I just went from sbcl 1.1 to 1.4, made a bit of a difference :)
Kevslinger has quit [Quit: Connection closed for inactivity]
<jmercouris>
for future readers, I reccomend just installing from ports/brew
<jmercouris>
the only issue is that I can't jump to definition for built in functions/macros
<jmercouris>
somehow it makes an incorrect pathname
smurfrobot has joined #lisp
<jmercouris>
so for example, jumping to definition on setf makes a path of: /opt/local/var/macports/build/_opt_bblocal_var_buildworker_ports_build_ports_lang_sbcl/sbcl/work/sbcl-1.4.4/src/code/
<jmercouris>
which is not a real path on my system
siraben has quit [Ping timeout: 240 seconds]
<pjb>
jmercouris: install the sources and configure them.
<jmercouris>
when you say "install the sources", you don't mean build the source on my system, but rather download it, place it somewhere, and then this will resolve those paths properly with this function?
<pjb>
Yes.
<pjb>
If you place them in one of the directories scanned by this function. You can edit this function to include your own paths.
<jmercouris>
how will slime-edit-definition know to invoke this function?
<pjb>
implementation dependent.
<jmercouris>
here is the magic: (sb-ext:set-sbcl-source-location "/usr/share/sbcl-source/")
<jmercouris>
so I need to set that up in my sbclrc
<pjb>
Yes.
<pjb>
But since you use your .sbclrc with various versions of sbcl and on different systems, you cannot hardwire the path!
<jmercouris>
well, I actually only have sbcl on my laptop, so I am okay for now :)
EvW has joined #lisp
<jmercouris>
I ended up placing it in /usr/local/source/sbcl to be consistent with the sbcl location
<jmercouris>
though perhaps it should have been /opt/local/source
python476 has quit [Remote host closed the connection]
<jmercouris>
s/sbcl location/ccl location
smurfrobot has quit [Remote host closed the connection]
nowhereman has joined #lisp
nowhereman is now known as Guest82373
smurfrobot has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
Bike has joined #lisp
fikka has joined #lisp
Kundry_Wag has joined #lisp
wxie has quit [Remote host closed the connection]
ku has joined #lisp
damke_ has joined #lisp
siraben has joined #lisp
sjl__ has joined #lisp
Kundry_Wag has quit [Ping timeout: 276 seconds]
banjiewen has quit [Ping timeout: 240 seconds]
m00natic has joined #lisp
banjiewen has joined #lisp
damke has quit [Ping timeout: 264 seconds]
k-hos has quit [Ping timeout: 260 seconds]
sjl has quit [Ping timeout: 260 seconds]
EvW has quit [Remote host closed the connection]
EvW has joined #lisp
attila_lendvai has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
vap1 has quit [Ping timeout: 245 seconds]
siraben has quit [Ping timeout: 276 seconds]
smurfrobot has quit [Remote host closed the connection]
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
siraben has joined #lisp
bjorkintosh has quit [Read error: Connection reset by peer]
bjorkint0sh has joined #lisp
troydm has quit [Ping timeout: 260 seconds]
Oddity has quit [Ping timeout: 269 seconds]
troydm has joined #lisp
dmiles has quit [Ping timeout: 252 seconds]
deng_cn has quit [Read error: Connection reset by peer]
deng_cn has joined #lisp
cmatei has quit [Ping timeout: 256 seconds]
siraben has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
Oddity has joined #lisp
dmiles has joined #lisp
smurfrobot has joined #lisp
Pierpa has joined #lisp
siraben has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
smurfrobot has joined #lisp
attila_lendvai has quit [Quit: Leaving.]
smurfrobot has quit [Ping timeout: 268 seconds]
milanj has quit [Quit: This computer has gone to sleep]
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
EvW has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
<schweers>
pjb: I have to bother you once more about logical pathnames. can I have a logical pathname which refers to a file like foo.tar.gz or is this categorically impossible?
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<schweers>
hm, but what if I want to put the .tar.gz into a directory which I obtain via logical paths? I have a translation which gives me a directory where to store the file. But now I need to store a filename with a double suffix in said dir. i.e I have something like this: (setf (logical-pathname-translations "IMPORTER") '(("OUT-DIR;" "/home/schweers/data/"))) (translate-logical-pathname #P"importer:out-dir;foo.tar.gz") ; =>
<schweers>
#P"importer:out-dir;foo.tar.gz"
<pjb>
this is not conforming.
<schweers>
I thought so. Any idea how to solve this problem?
<schweers>
can I have a second translation to expand into the double suffix and combine them somehow?
<schweers>
aha!
<schweers>
that might do it, thanks
<pjb>
notice that you can also use wildcards in the name.
<schweers>
I’ve not yet found a good description of how exactly wildcards work; I guess this is because they work for pathnames in general, not just for logical pathnames. Is this correct?
<pjb>
but it doesn't seem to help in this case.
<pjb>
because the third * means version, so…
<schweers>
in the example you showed me last I can only have constants, right?
<pjb>
but notice that in this case, ccl doesn't downcase the name (other implementations would downcase it).
<pjb>
This means that: logical -> physical is very strong: you cannot access foo.gz unless you make an explicit translation rule for it.
Ven`` has joined #lisp
mareskeg has joined #lisp
<schweers>
let me try that
<pjb>
schweers: also, the rules about case are very clear: the case that should be used is the customary case for the file system where the component is stored. On unix systems, a path can contain components each on a different kind of file system with a different customary case!
<pjb>
You can mount MS-Windows file systems on MacOS file systems on unix file systems in any order.
<pjb>
So you can have components of a single path stored on all kinds of file systems. and ;a;b;C;D may have to be translated to A/b/C/d
<pjb>
but no implementation implement this!
Amplituhedron has quit [Ping timeout: 268 seconds]
didi has joined #lisp
<didi>
I remember there is a "standard" on this: If I want to write a macro that iterates over a collection, I should write a macro called DOOBJECTS that expands to a call to a function called CALL-ON-OBJECTS, right? These are the names, aren't they?
<jmercouris>
jackdaniel: http://thrift.apache.org/docs/install/ these docs are not updated, do you know what the language specific requirements for a lisp install are?
<pjb>
didi: you don't have to do it, but it is a way to implement the macro.
<didi>
pjb: Cool.
<pjb>
didi: it relies on the compiler being able to inline the function to generate efficient code.
milanj has joined #lisp
* didi
likes to rely on the compiler
<didi>
pjb: Should I annotate the function CALL-ON-OBJECTS in any way?
<pjb>
Also, often you want to have such a function anyways. (doobjects (o) (print o)) (call-with-objects (function print))
<pjb>
you may declare it inline.
<didi>
Thanks.
<didi>
pjb: Oh, you wrote `call-with-objects' instead of `call-on-objects'. Which name people use?
<pjb>
well, for a loop, perhaps iterate-on-objects would be a good name.
<pjb>
with-object / call-with-object
<pjb>
doobjects / iterate-on-objects
<pjb>
or doobject / mapobject
<didi>
Nice. Thank you.
<ecraven>
how does swank handle an error in another thread than the one communicating with slime?
smurfrobot has joined #lisp
makomo has joined #lisp
Ven`` has quit [Ping timeout: 240 seconds]
cmatei has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
Pierpa has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 260 seconds]
siraben has quit [Remote host closed the connection]
mishoo has quit [Ping timeout: 264 seconds]
<jmercouris>
jackdaniel: Thrift seems a rather heavy tool designed to run on servers, no?
<jmercouris>
I mean it generates all of these stubs and this heavy code, doesn't seem designed for standalone applications running on a user system, though I guess it would work just fine
<jmercouris>
the apache people have a different definition of "lightweight" than me it seems
<jmercouris>
I can see the huge value it provides, but I'm not sure I want to bring it in as a dependency
EvW1 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
rumbler31 has quit [Remote host closed the connection]
cmatei has quit [Remote host closed the connection]
cmatei has joined #lisp
<fe[nl]ix>
what's the difference between "servers" and standalone applications ?
<jmercouris>
There's not really a difference, but there is a diffrence in expectations of hardware, how often they'll turn on and off
<jmercouris>
the software installation process etc
<jmercouris>
for example, webservers aren't designed to be stopped and started all the time, they are designed to be long running stable processes
Kundry_Wag has joined #lisp
<jmercouris>
that's what I mean
<fe[nl]ix>
so ?
<jmercouris>
I'm not running a massive organization requiring many different microservices to interact via RPC, so Thrift is not my ideal solution
<jmercouris>
that's my point, I'm making a desktop application that has a server/client
<jmercouris>
so while thrift is very cool, a great technology, it is not appropriate for my application
<fe[nl]ix>
now you make sense
<fe[nl]ix>
I still think it might be wrong because those serialization libraries used in large organizations tend to have much better error reporting than bare JSON
<fe[nl]ix>
or whatever you come up with
siraben has joined #lisp
<jmercouris>
I'm doing bare xml, but I'll control both ends, so it won't be too bad hopefully
Kundry_Wag has quit [Remote host closed the connection]
comborico1611 has joined #lisp
<schweers>
I’m still having trouble with logical pathnames. I want to substitute a directory (works) and I want to substitute a suffix because I have double suffixes. As far as I understand, if the result of a translation is in turn a logical pathname, it is translated again. So it should be possible to combine these cases. However this doesn’t work for me: https://pastebin.com/yrzWhUfe Any ideas what I’m doing wrong?
pmetzger has joined #lisp
thodg has quit [Ping timeout: 240 seconds]
nowhere_man has joined #lisp
Jesin has quit [Quit: Leaving]
warweasle has joined #lisp
mareskeg has quit [Quit: mareskeg]
fikka has joined #lisp
Guest82373 has quit [Ping timeout: 268 seconds]
Kevslinger has joined #lisp
alexmlw has joined #lisp
smurfrobot has joined #lisp
alexmlw has quit [Client Quit]
smurfrobot has quit [Ping timeout: 252 seconds]
_sfiguser has joined #lisp
<_sfiguser>
hello all, who is using in the industry lisp?
<_sfiguser>
and why ?
dddddd has joined #lisp
<beach>
Not many.
<beach>
They are probably insane.
<_sfiguser>
ohh that's why
fikka has quit [Ping timeout: 256 seconds]
<Shinmera>
I am for sure insane
fikka has joined #lisp
<beach>
But you are not industry.
<beach>
So that doesn't count.
<jdz>
I'm probably insane, and I'm using lisp at work, but I would not call my work "industry".
<schweers>
We probably all are. At least other people see us that way ;)
<beach>
jdz: Still, that's close.
<pmetzger>
There are a lot of lisp users out there in industrial contexts.
<pmetzger>
Hell, even Google uses it for some things.
<beach>
Ssshhh!
<pmetzger>
And Clojure is being used very widely.
<_sfiguser>
but it's old
<beach>
pmetzger: Damn. How are we going to maintain our productivity advantage if you blab to everyone.
<schweers>
_sfiguser: not as old as C or C++
Jesin has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<pmetzger>
Lisp dates to the late 1950s. C dates to 1971 or so.
<pmetzger>
C++ dates to the 1980s.
igemnace has joined #lisp
<schweers>
but Common Lisp is not so old
<schweers>
anyways, I don’t see how age itself is that relevant
Oladon has joined #lisp
<beach>
I still remember when my parents were forced to replace the gas stove with an electric one. After seeing how disappointing the electric stove was, my mother said "But I suppose it is more modern".
<jdz>
Only new stuff can be shiny, and everybody likes shiny things.
<jdz>
I should also refrain from saying anything if I don't have anything of substance to say.
fikka has joined #lisp
dmiles has quit [Read error: Connection reset by peer]
<Shinmera>
beach: On the other hand, induction stoves are really great, and more modern.
fikka has quit [Ping timeout: 240 seconds]
<schweers>
Shinmera: but that they came around at a later date is not why they are great
Kundry_Wag has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
Kundry_Wag has quit [Remote host closed the connection]
Oddity has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 248 seconds]
rumbler31 has joined #lisp
mishoo has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
dmiles has joined #lisp
damke_ has joined #lisp
Oddity has joined #lisp
Oddity has joined #lisp
Oddity has quit [Changing host]
Kundry_Wag has joined #lisp
oleo has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Pierpa has joined #lisp
fikka has joined #lisp
<pmetzger>
Common Lisp is arguably older than C++, as the standards effort predates C++.
Kundry_Wag has joined #lisp
<pmetzger>
Common lisp hasn't changed much in the intervening decades either, while C++ keeps metastasizing, er, transforming.
siraben has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
<pmetzger>
I think CLTL1 was 1984, and Stroustrup was only just beginning C++ around then.
<schweers>
Do you know when the standards effort began? I thought the standards are from 89 and 94, respectively
orivej has joined #lisp
<schweers>
oh, well then C++ is indeed younger
<pmetzger>
The ANSI standards were only tweaks to CLTL1 and CLTL2
Kundry_Wag has quit [Remote host closed the connection]
Jesin has quit [Quit: Leaving]
AxelAlex has joined #lisp
Kundry_Wag has joined #lisp
<pmetzger>
Actually... CLTL2 was mostly an update of CLTL1 to reflect the tweaks from the ANSI effort. I think. I wasn't really paying attention at the time and it's been thirty years.
Murii|osx has joined #lisp
pagnol has quit [Ping timeout: 248 seconds]
orivej has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
Kyo91 has joined #lisp
<Xach>
phew
smurfrobot has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
scymtym has quit [Ping timeout: 252 seconds]
LiamH has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
pagnol has joined #lisp
warweasle has joined #lisp
ninegrid has quit [Ping timeout: 252 seconds]
<jmercouris>
Shinmera: induction stoves are also bad, you don't know how hot they are
<jmercouris>
the gas gives a really good visual indication of temperature
<jmercouris>
they are better than pure "traditional electric" stoves though, I'll give you that, they are more responsive
fikka has quit [Ping timeout: 264 seconds]
* schweers
cooks up a nice batch of parentheses on a non-induction stove for everyone to enjoy.
<_sfiguser>
thanks schweers for the batch of parentheses
* _sfiguser
greets
Xof has quit [Ping timeout: 252 seconds]
<pmetzger>
I love gas cooktops but electric ovens are better for baking.
<pmetzger>
Ideally you have each of those.
AxelAlex has quit [Quit: AxelAlex]
<TMA>
I have a different experience with gas->electric stove transition than beach reports (for baking that is); electric cooktop of the old style was awful; the gas-top electric-oven combo is close to ideal
fikka has joined #lisp
* phoe
goes into #lisp
* phoe
sees discussion about gas/electric cooktops
<phoe>
my life gets better every day
ninegrid has joined #lisp
<schweers>
phoe: maybe we should check out some cooking channel and see if they are talking about lisp
<phoe>
this would be interesting, yes
SaganMan has joined #lisp
Oladon has quit [Quit: Leaving.]
drunk_foxx has joined #lisp
rumbler3_ has joined #lisp
<jdz>
Nail clippings in food?
<phoe>
you mean parentheses?
<jdz>
A bad attempt at a joke.
asarch has joined #lisp
<jdz>
Larry Wall is entitled to see lisp code like that since the rest of the world sees Perl code as line noise.
<phoe>
s/Perl/Lisp
<phoe>
s/line noise/parens
didi has left #lisp ["there are always reasons to /part"]
<phoe>
But yes, I know that line about nail clippings.
<schweers>
Larry Wall claimed that lisp code looks like nail clippings?
<pmetzger>
Perl was a big improvement over the practical alternatives for gluing stuff together 25 years ago. Now the alternatives are a big improvement over perl.
<jdz>
Yay, I brought the discussion back on-topic! (not)
<pmetzger>
Perl 6 really killed Perl. Weirdly it wasn't so much second systems effect as third or fourth.
rumbler3_ has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
harryTrout has joined #lisp
butterthebuddha has quit [Max SendQ exceeded]
butterthebuddha has joined #lisp
_cosmonaut_ has quit [Ping timeout: 245 seconds]
<whoman>
let's do \t for ( and \n for )
comborico1611 has quit [Quit: Konversation terminated!]
drunk_foxx has quit [Ping timeout: 260 seconds]
nika has joined #lisp
smurfrobot has quit [Remote host closed the connection]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
comborico1611 has joined #lisp
Cymew has quit [Remote host closed the connection]
<comborico1611>
Has there been any improvements made to evaltrace notation since 1990? I'm thinking mainly in terms of using it with paper and pencil.
marusich has quit [Quit: Leaving]
SaganMan has quit [Read error: Connection reset by peer]
FreeBirdLjj has quit [Ping timeout: 240 seconds]
Xof has joined #lisp
SaganMan has joined #lisp
<beach>
comborico1611: Probably not.
sjl__ is now known as sjl
<comborico1611>
beach: thanks
fikka has quit [Ping timeout: 264 seconds]
<beach>
comborico1611: Are you planning to use it in order to learn the evaluation rules of Common Lisp?
shrdlu68 has joined #lisp
Kundry_Wag has joined #lisp
orivej has joined #lisp
<Bike>
what is evaltrace notation. like > form < result stuff?
<Pierpa>
Hmmm... Never knew that there was a special name for these
smurfrobot has joined #lisp
pmetzger has quit [Remote host closed the connection]
<Pierpa>
How's called the next after triple?
Kundry_Wag has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
<CodeOrangutan>
"Ow my brain hurts."
<Bike>
...quadruple?
<Bike>
it's the same concept no matter which.
<stacksmith>
zero. one. many.
damke has joined #lisp
smurfrobot has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<CodeOrangutan>
I'm not sure if it's required that the function call itself like so: (func x (func y z)) or if (+ (func x) (func y)) is sufficient for double recursion, but the former form looks like it might qualify as a legit math term.
rumbler3_ has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
<Bike>
it's not, really. might be vaguely related to not being primitive recurisve, at best.
smasta has quit [Ping timeout: 264 seconds]
smurfrobot has quit [Ping timeout: 240 seconds]
jcowan has quit [Ping timeout: 240 seconds]
nowhereman has joined #lisp
rumbler3_ has quit [Ping timeout: 240 seconds]
nowhereman is now known as Guest27300
<Pierpa>
All this fuss about recursion is only because Fortran 66 did not allow for the same function be active more than once at the same time.
<Pierpa>
It It was not for this historical accident then then a function would be a function call. Stop.
<Pierpa>
*a function call would be a function call.
nowhere_man has quit [Ping timeout: 240 seconds]
<Bike>
recursivity is an important computational property even without computing devices being involved.
<jmercouris>
I've spent a lot of time thinking about recursion myself
<jmercouris>
I'm not sure if it is good or bad
<jmercouris>
I can think of problem sets it is suited to, but they are all artificial
<Bike>
you might as well ask if orange is good or bad.
<stacksmith>
A new kind of science
<jmercouris>
as in, I've never had a time where recursion has made a problem of mine significantly easier, or maybe I'm not skilled enough to have seen it
<Pierpa>
Hmmm
pfdietz has joined #lisp
<jmercouris>
Bike: when I say "good", I mean "applicable", an orange is not "good" at removing bolts, but a socket is
<stacksmith>
I find that about half of my looping is recursive.
<shrdlu68>
I did once, where an algorithm recursively generated a tree data structure.
<Bike>
yes, you're thinking of it as a technique, but that's not much good.
<Bike>
it is part of the structure of things.
<Bike>
if you want a non artificial example, learn some combinatorics.
<Pierpa>
Jmercouris: have you tried SICP?
<jmercouris>
shrdlu68: even tree manipulations can be done iteratively without issue though
<sukaeto>
so anecdote re: Touretzky
<Bike>
if you have four differently colored balls, how many different ways can you arrange them in a row?
<stacksmith>
It's a very different way of thinking, even if the result is the same.
<jmercouris>
Pierpa: never read it, no
<Bike>
pick one at a time and put it at the head, then arrange the other three balls.
<shrdlu68>
jmercouris: Yes, of course, but recusing makes it _so_ much easier.
<Bike>
so 4! = 4 * 3!
<sukaeto>
I gave his book to my wife, and she became confounded by his introduction to lists - how he goes into detail drawing linked list diagrams of cons cells
<Bike>
using n! as the notation for "number of ways to arrange n things".
<pfdietz>
Not sure you should blame Fortran 66 when the first lisp was in 1958.
<sukaeto>
not because it didn't make sense, but because she became impatient with it. "What's the point of this! Where is he going with this? This is stupid! Is this what you deal with every day at work?"
<jmercouris>
pfdietz: I think it is a "blame" in terms of suggesting a source for popularity
<jmercouris>
sukaeto: I can 100% relate
<Pierpa>
Pfdietz: good point. I meant the first fortrans.
<shka>
hello
<jmercouris>
shrdlu68: definitely true, for some types of traversal and generation, yeah
<shka>
quick question
<sukaeto>
and it got me thinking that yes, maybe talking about how things are laid out in memory that early on is not only unnecessary, it's actually detrimental
<pfdietz>
Tree als can be done iteratively but that often means you are implicitly unwinding a recursive algorithm with your own stack.
<shka>
uh, at least i think it is binary stream
<pfdietz>
algorithms
Guest26752 has joined #lisp
Fare has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<jmercouris>
pfdietz: well, yeah, if you consider a "queue" unwinding a stack
<Bike>
shka: there's no "right" order. you just need to ensure that whatever is reading it back later wants the bytes in that order.
<jmercouris>
s/queue/stack
<jmercouris>
damnit, yes you are 100% correct :D
Guest26752 has quit [Client Quit]
pmetzger has joined #lisp
<shka>
Bike: this goes into C code...
<shka>
on little endian machine
smurfrobot has joined #lisp
<Bike>
okay, so ensure that the c code reading it back wants the bytes in that order.
<jmercouris>
shka: I think it is then system dependent
al-damiri has joined #lisp
<jmercouris>
I'm not much of a C developer, but I believe different implementations didn't implement floats in the same way
<pfdietz>
Stack us natural for depth first traversal.
<shka>
Bike: ideally, i want to memory map file and toss around it as array
<jmercouris>
as in, they had different limitations
<shka>
i would rather write more lisp code, then deal with C
<stacksmith>
shka: there is no standard for serializing floats in Lisp or C - it is _application_ dependent
<shka>
duh
<shka>
eh, ok
<shka>
thanks for help
Kundry_Wag has joined #lisp
Pierpa has quit [Ping timeout: 260 seconds]
pfdietz has quit [Ping timeout: 252 seconds]
harryTrout has quit [Ping timeout: 252 seconds]
pfdietz has joined #lisp
<pfdietz>
Yes that looks ominously relevant.
<pfdietz>
Oops wrong channel
Cymew has joined #lisp
ioa has left #lisp [#lisp]
Pierpa has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
nowhere_man has joined #lisp
Kyo91 has quit [Ping timeout: 256 seconds]
didi has joined #lisp
Guest27300 has quit [Ping timeout: 268 seconds]
<didi>
What should I use if I want to retrieve a key, any key, from a hash table?
pfdietz has quit [Ping timeout: 255 seconds]
pfdietz has joined #lisp
<Xach>
didi: what do you want to do if it is empty?
<didi>
Xach: Good question. (values nil nil) sounds appropriate, as the second value represents emptiness.
<Xach>
In the non-empty case, (block nil (maphash (lambda (k v) (return k)))) is an option.
<didi>
Xach: Thank you.
knobo2 has joined #lisp
pfdietz has quit [Ping timeout: 255 seconds]
Kyo91 has joined #lisp
pfdietz has joined #lisp
vaporatorius has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
knobo1 has quit [Ping timeout: 260 seconds]
vap1 has joined #lisp
Arcaelyx has joined #lisp
pagnol has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<didi>
Xach: What about (with-hash-table-iterator (fn ht) (nth-value 1 (fn))) ?
papachan has joined #lisp
harryTrout has joined #lisp
<Xach>
didi: hey that sounds good too!
<didi>
Xach: Nice. Thank you.
<Xach>
didi: i rarely think about w-h-t-i and that isn't a bad use of it
willmichael has quit [Ping timeout: 255 seconds]
<didi>
:-)
Fare has quit [Ping timeout: 248 seconds]
Sauvin has quit [Read error: Connection reset by peer]
pfdietz has quit [Quit: Bye]
rumbler3_ has joined #lisp
vaporatorius has quit [Quit: Leaving]
vlatkoB has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 240 seconds]
rumbler3_ has quit [Ping timeout: 268 seconds]
comborico1611 has joined #lisp
EvW has joined #lisp
fikka has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
harryTrout has quit [Ping timeout: 245 seconds]
knobo3 has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
knobo2 has quit [Ping timeout: 248 seconds]
<emaczen>
Can I handle a unhandled memory error from CFFI?
<emaczen>
I'm tired of restarting the REPL
Pierpa has quit [Ping timeout: 260 seconds]
<phoe>
emaczen: in general, no.
Rawriful has joined #lisp
<phoe>
The moment you get a segfault, the game is over in general case. Your code might have already written all over your memory and corrupted things that will screw you up later.
<phoe>
SBCL has error handlers installed for that, so when it segfaults, it drops you into its Lisp debugger in most cases.
* didi
shivers
<phoe>
But the fact that your OS detected a segfault is one thing, it's more fun when your system does *not* detect a segfault.
<phoe>
Which is the actually scary case.
chat_ has quit [Ping timeout: 252 seconds]
<phoe>
In other words: welcome to the joys of development with memory-unsafe languages. Please enjoy the view and fasten your seatbSegmentation fault (core dumped)
<didi>
Nice.
<emaczen>
Well yesterday I was learning how CFFI deals with C pointers in terms of getting an address and dereferencing
<emaczen>
the dereferencing equivalent is #'cffi:mem-ref or #'cffi:mem-aref
chat has joined #lisp
<phoe>
Yep, more or less that.
<emaczen>
There is no equivalent for addressof
<emaczen>
cffi just wants a pointer
chat is now known as Guest97363
<phoe>
emaczen: address of *what*?
sjl__ has joined #lisp
<Bike>
i think the official term would be "lvalue"
<emaczen>
phoe: I'm looking at some C code: &config->interface[i]
fikka has joined #lisp
<emaczen>
config is already declared as a pointer
<phoe>
that means &(config->interface[i]), correct?
<emaczen>
In Lisp I used #'cffi:foreign-alloc
<Bike>
it does mean that.
<emaczen>
phoe: Oh, I didn't think of it like that
<phoe>
so the address of ith element of the interface array, right?
sjl has quit [Ping timeout: 264 seconds]
<emaczen>
phoe: that is probably my problem
<Bike>
so mem-aptr i think.
<phoe>
emaczen: it's completely pointless if it was (&config)->interface[i]
<phoe>
because suddenly you have (&config) which is of type size_t
<phoe>
so a numeric value
<phoe>
and you try to dereference its interface slot
energizer has joined #lisp
<phoe>
which will explode even during compilation.
<emaczen>
phoe: when one is just translating they tend not to think lol
<phoe>
emaczen: this is why we can't have nice things.
<emaczen>
phoe: because of C?
<phoe>
no.
<phoe>
translating stuff between languages requires thinking, especially between languages as wildly different as C and Lisp.
<phoe>
where one is a weakly statically typed static language and the other is a strongly dynamically typed interactive language. and that's just one difference out of many.
Guest97363 has quit [Ping timeout: 256 seconds]
energizer has quit [Disconnected by services]
energizer has joined #lisp
<emaczen>
phoe: One of the reasons why I like Lisp so much is that the grammar makes it immediately obvious
dddddd has quit [Remote host closed the connection]
energizer has quit [Remote host closed the connection]
<emaczen>
and you get macros at the same time
<phoe>
emaczen: yeah, in Lisp there's no ambiguity if 2+2*2 is 6 or 8.
energizer has joined #lisp
<emaczen>
I'll never understand how C is more popular than Lisp
fikka has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
<jmercouris>
emaczen: performance on old machines
* phoe
gently nudges this discussion towards #lispcafe though
<Bike>
i suppose the concept of lvalues is a bit like places. i think it makes sense to view & as similar to a macro.
dmiles has quit [Ping timeout: 264 seconds]
Fare has joined #lisp
damke_ has joined #lisp
<Bike>
so if it was in cffi, you'd have like (addressof (mem-aref x y z)) expand to (mem-aptr x y z).
Cymew has joined #lisp
mgsk has joined #lisp
damke has quit [Ping timeout: 264 seconds]
<emaczen>
Bike: Give me a sec, I'm trying out mem-aptr
milanj has quit [Quit: This computer has gone to sleep]
libreman has quit [Ping timeout: 256 seconds]
<emaczen>
Well I'm not getting a segfault now
<emaczen>
One observation I do have though is that I tend to get a lot of segfaults because the C code I am translating is passing pointers to be modified, and then uses this pointer again and I can't tell if it needs dereferenced.
Cymew has quit [Ping timeout: 252 seconds]
smurfrobot has joined #lisp
<emaczen>
Is this a correct observation? There are cases that I can obviously tell where pointers need dereferenced, but it is when these pointers are modified in a function and used later (without looking at the function) nobody can tell they may need dereferenced?
willmichael has joined #lisp
<phoe>
emaczen: pointers are just numbers
<phoe>
and dereferencing pointers in C is always explicit, using the deref operator.
Jesin has joined #lisp
<phoe>
if you pass a number around, that number is always itself, unless you explicitly incf or decf it using C's ++ or -- operators.
<phoe>
same thing with pointers.
fiveop has joined #lisp
dmiles has joined #lisp
<emaczen>
In the code I am looking at, config is declared as a pointer, its address is then passed to a function for initialization, and finally it is used like: &config->interface[i]
<emaczen>
In my lisp code, I had to use mem-ref on config before I could use foreign-slot-value and finally mem-aptr
<phoe>
&((config->interface)[i])
<Bike>
so you need to allocate a pointer to config, which you then pass to the initializer.
chat_ has joined #lisp
<Bike>
and then using *pconfig instead of config, conceptually.
<emaczen>
I already did allocate the pointer
<emaczen>
and pass it to the initializer
smurfrobot has quit [Ping timeout: 256 seconds]
chat_ has quit [Read error: Connection reset by peer]
<emaczen>
I have: (cffi:mem-aptr (cffi:foreign-slot-value (cffi:mem-ref config) ..) ..) and what I don't understand is why I had to mem-ref when I had previously, foreign-alloced config and then passed it to the initializer
chat_ has joined #lisp
<Bike>
you didn't foreign alloc config, you alloced a pointer to config, right?
smurfrobot has joined #lisp
<emaczen>
(let ((config (cffi:foreign-alloc '(:struct libusb-config-descriptor)))) -- that's what I did
Kundry_Wag has quit [Remote host closed the connection]
dyelar has quit [Ping timeout: 248 seconds]
Kundry_Wag has joined #lisp
libreman has joined #lisp
<Bike>
what do you pass to the initializer then?
<Bike>
i thought you had like "struct libusb_config_descriptor* config; initialize(&config);"
chat_ has quit [Remote host closed the connection]
smurfrobot has quit [Ping timeout: 268 seconds]
chat_ has joined #lisp
<emaczen>
BIke: that's right
<Bike>
what do you pass to the initializer then?
<Bike>
in lisp.
dyelar has joined #lisp
<emaczen>
Bike: just config
<emaczen>
it is still a pointer, so my understanding is that CFFI doesn't care
<Bike>
Okay let's think about this for a moment. config, in C, is of type struct libusb_config_descriptor*. Then &config must be of type libusb_config_descriptor**.
<emaczen>
yep
<Bike>
But you're just passing config to the initializer.
harryTrout has joined #lisp
<Bike>
So... that's wrong.
<Bike>
I think you want like (let ((&config (cffi:foreign-alloc '(:pointer (:struct libusb-config-descriptor))))) ...)
<emaczen>
Bike: I was under the impression that it is a pointer and CFFI doesn't care
<Bike>
it could just be (cffi:foreign-alloc :pointer), sure.
<emaczen>
Bike: So foreign-alloc doesn't always return a pointer?
<Bike>
It does return a pointer.
<Bike>
It returns a pointer to the type you give it.
Kyo91 has quit [Ping timeout: 248 seconds]
<emaczen>
(:pointer (:struct ...)) would be a pointer to a pointer then
<Bike>
Yep.
<Bike>
That's what &config is, right?
<Bike>
Or rather, (foreign-alloc '(:pointer (:struct ...))) would be a pointer to a pointer.
<emaczen>
Yep that is what I meant
<emaczen>
Bike: I guess I'll have to start explicitly doing (let ((x) (&x)) ...)
smurfrobot has joined #lisp
<Bike>
I would just only allocate &x
<Bike>
and then mem-ref when you need x
<Bike>
your preference, i guess
arbv has quit [Ping timeout: 240 seconds]
<Bike>
The reason CFFI is conceptually difficult is that it deals with C programs without C's compiler restrictions, which is why all pointers are the same and such. But it still uses some c-like syntax. It can be confusing
<Bike>
well okay. A reason it's difficult
<Bike>
In this situation - the alloc thing - "pointers are all the same" isn't actually so, though.
* |3b|
isn't sure "without ... restrictions" is quite right, since actually keeping track of the types would be a nice feature for correctness :)
Kyo91 has joined #lisp
<Bike>
When you (foreign-alloc '(:struct libusb-config-descriptor)) it allocates however many bytes of memory that struct takes up. That could be, for instance, zero, though I assume it isn't
<|3b|>
problem is more that you can't stack-allocate C things and take address of them, so you can't translate c code directly
<Bike>
you then pass C a pointer to that memory, and the C program assumes that it can mess with as many bytes pointed to as there are in a pointer
<|3b|>
(well, maybe you can stack allocate them and take address of them, but you can't /not/ take the address of them and use them directly)
<Bike>
|3b|: having a ffi layer with compile time checking sounds, interesting
pmetzger has quit [Remote host closed the connection]
<|3b|>
sbcl alien stuff has some of that i think
<Bike>
might be good for a general unsafe-fuck-with-memory lisp language
<|3b|>
would probably help with some of the above problems (assuming correct function definitions), if function wants ** and you pass it *, it could tell you :)
<|3b|>
or if you pass ** and it wants *
willmichael has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 268 seconds]
<emaczen>
Yeah, I just need more experience with CFFI
arbv has joined #lisp
vultyre has joined #lisp
vultyre has quit [Remote host closed the connection]
shka_ has joined #lisp
Mutex7 has joined #lisp
SlowJimmy has joined #lisp
pmetzger has joined #lisp
milanj has joined #lisp
smurfrobot has quit [Remote host closed the connection]
fikka has joined #lisp
Guest39719 has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
Patternmaster has quit [Ping timeout: 265 seconds]
Cymew has joined #lisp
mareskeg has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
jdz has quit [Ping timeout: 256 seconds]
pmetzger has quit []
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
harryTrout has quit [Ping timeout: 245 seconds]
jdz has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Baggers has joined #lisp
Patternmaster has joined #lisp
Jesin has quit [Quit: Leaving]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
smurfrobot has joined #lisp
<pjb>
minion: memo for schweers: "IMPORTER:**;*.tar.gz" is not a logical pathname, because gz is not a valid version number.
<minion>
Remembered. I'll tell schweers when he/she/it next speaks.
<pjb>
minion: memo for schweers: also, you must have the same number of stars in both sides.
<minion>
Remembered. I'll tell schweers when he/she/it next speaks.
smurfrobot has quit [Ping timeout: 240 seconds]
rumbler3_ has joined #lisp
smurfrobot has joined #lisp
rumbler3_ has quit [Remote host closed the connection]
rumbler3_ has joined #lisp
fiveop has quit []
smurfrobot has quit [Ping timeout: 240 seconds]
Naergon_ has quit [Ping timeout: 256 seconds]
rumbler3_ has quit [Remote host closed the connection]
<comborico1611>
pjb, I was looking for something to use with pencil and paper.
<comborico1611>
But I'm sure STepper will help. Thanks!
damke_ has joined #lisp
jcowan has joined #lisp
<pjb>
Yes, I'm sure my teachers was looking for something done with pencil and paper whe I wrote 10 for i=1 to 100 : print "I will not expose the ignorance of the faculty." : next i and used the tty instead.
Naergon has joined #lisp
<pjb>
(it wasn't Basic but LSE, and it wasn't that sentence, but it was 100 times).
<pjb>
And anyways, we all knew the 5 pen trick… :-)
Cymew has quit [Ping timeout: 260 seconds]
<pjb>
Come to think of it, that must be the reason why bic stylos are sent by 5, when one bic is usually enough for the whole year… (and notice their convenient hexagonal section).