<aeth>
What implementation? Maybe there's a bug in FORMAT
<PuercoPop>
mfiano: The bug you reported to Sly was supposedly fixed a while ago. (Issue #87). Wonder what happend
<mfiano>
Interesting
lucasb has quit [Quit: Connection closed for inactivity]
gabbiel has quit [Remote host closed the connection]
<PuercoPop>
mfiano: it was re-introduced ~6 months ago in a commit to speed up completion
<PuercoPop>
Are you going to send the PR with your solution?
hhdave has joined #lisp
<mfiano>
I won't be able to today. I'm deep in a bigger mess right now. Feel free to commit it
psqueak` has quit [Remote host closed the connection]
gabbiel has joined #lisp
<gabbiel>
hey guys, how do I print a tab with format
<gabbiel>
I know ~% is a newline
<edgar-rft>
~T prints a Tab
hhdave has quit [Quit: hhdave]
<gabbiel>
i looked it up and that stands for tabulation, which im not familiar about
<oni-on-ion>
column alignment
<gabbiel>
so ~t is tab then?
<aeth>
gabbiel: I often mix and match write functions with format. It's (usually) stream based, so it's okay to mix and match. (write-char #\tab stream) can work
<gabbiel>
I know, but im already using format, i guess Ill ~a and pass it in as an arg
<aeth>
gabbiel: you can also do this: (let ((stream *standard-output*)) (format stream "~cHello, world!~%" #\tab))
<aeth>
Lots of flexibility
<gabbiel>
but it is weird how u can't hardcode it
<gabbiel>
<mooshmoosh>
you can use a literal tab character in your format string
<gabbiel>
how so
<gabbiel>
I tried \t, but it just prints t
<mooshmoosh>
what text editor do you use?
<gabbiel>
emacs
<gabbiel>
there should be a ~ for it
<edgar-rft>
gabbiel: (format t "1<tab>2") where <tab> is just pressing the Tab key, but take care that emacs doesn't convert <tab> to a sequence of spaces
<mooshmoosh>
type the tab key when youre typing the format string
<aeth>
gabbiel: CL strings don't support th \t, \n, etc., that you expect a new programming language to offer, although you could write your own reader macro (don't, that's a lot of work) to support it
<aeth>
s/support th/support the/
<gabbiel>
if newline is supported with ~%, i dont see why tab shouldn't
<gabbiel>
i have a handy old book for this
<gabbiel>
let me fetch it
<aeth>
In emacs it's C-q TAB
<dlowe>
gabbiel: you can add these with the cl-interpol library
<gabbiel>
lmao the book so old it uses guy steels' first edition of the common lisp standard
<mooshmoosh>
gabbiel: if you find a better solution i would love to know
<aeth>
gabbiel: In most programming languages \n is part of the " syntax. So you can just say "Hello\n" and that will be the string. In CL, you'd have to do (format nil "Hello~%") to get the equivalent
<gabbiel>
yeah I checked in the book, no \tab, but I can use ~t
<gabbiel>
I can give it an arg, like so (format t "~4t" meaning it will print 4 spaces
<gabbiel>
good enough for me
<aeth>
I think in CL you just have \\ and \" but I could be forgetting a few
<pjb>
aeth: nope. to get the equivalent in CL you just write "Hello
<pjb>
world"
<pjb>
(write-line "Hello
<pjb>
world
<pjb>
world") #| Hello
<pjb>
--> "Hello ; world" |#
dddddd has quit [Remote host closed the connection]
<aeth>
Interesting extension idea. Arrays can have a dimension (42) which says it's exactly 42. It would be interesting if they could also have the dimension ((42 *)) i.e. at least 42 or ((* 42)) i.e. at most 42. ((42 *)) would be very useful because then (aref foo 32) doesn't need bounds checking, but you don't restrict yourself to one known size if you have a type declaration or check-type that encodes the length.
mindCrime has quit [Ping timeout: 244 seconds]
<Josh_2>
Can't you just use a macro that does bounds checking?
<Josh_2>
Then you don't have to think about it
<aeth>
Josh_2: that will just double the bounds checking unless you're in SBCL and locally turn on (safety 0) in the aref after you do your bounds check.
<gabbiel>
how do I run a command line program with sbcl?
<aeth>
Josh_2: Doing a >= or <= in the type itself gives the compiler more freedom, just like the current = in the type itself
<Bike>
you could go whole hog and make the array dimensions a type themselves.
<Bike>
gabbiel: sb-ext:run-program, i think.
<grewal>
aeth: wouldn't there still be bounds-checking? the implementation would still need to allocate memory as needed
<gabbiel>
I tried that but it gives me errors, says "ls" couldn't be found
<Josh_2>
Why would u allocate memory that isn't going to be used? maybe the implementation can shrink the size down to match when you compile
<Josh_2>
Idk
<aeth>
grewal: It would do the bounds checking as part of the check-type or type declaration (or the, etc.) check, once, and then realize it doesn't need to do any further checks.
<aeth>
grewal: So it's a probable performance win if it's done before a loop, depending on the compiler. Certainly for SBCL
<aeth>
Of course, LOOP itself might do some tricks to avoid bounds checking, if your loop semantics work well with :across
<Bike>
gabbiel: you should check the manual. in particular, did you use :search? if you didn't, it won't check the PATH.
<grewal>
gabbiel: you can also use the full path
<aeth>
Josh_2: The array would still be a (simple-array (unsigned-byte 8) (42)) or whatever, it's just that you could check for a (simple-array (unsigned-byte 8) ((42 *))) and then safely use bounds-unchecked for AREFs up to 41.
<gabbiel>
it works now, but output isn't in the repl
<aeth>
Josh_2: At the moment you'd only be able to do this for an exact match, and it would have to be length 42.
<grewal>
aeth: I see. I thought you were getting at "infinite" lists or something
<aeth>
grewal: No, it's * in the same sense of * currently is in integer, and similar to having a (simple-array (unsigned-byte 8) (*))
<Bike>
gabbiel: the manual expalains this in some detail.
<grewal>
gabbiel: check out the sbcl manual. `info sbcl`. it's also on the web. There are options to send output to particular places
<aeth>
grewal: e.g. (let ((number 42)) (check-type number (integer * 42)) number)
cdegroot has quit [Remote host closed the connection]
oni-on-ion has quit [Read error: Connection reset by peer]
oni-on-ion has joined #lisp
<aeth>
This would just let you have e.g. a (simple-vector (3 *)) or (simple-array (unsigned-byte 8) ((3 *))) in a check-type or type declaration
<gabbiel>
i made ouptut t but still nothing
ebrasca has joined #lisp
wxie has quit [Remote host closed the connection]
<gabbiel>
manual says pty key arg can be a stream?
<grewal>
When I use slimv, :output t sends the output to the xterm that lisp is running in, not the repl in the editor
<gabbiel>
yeah, pty must be set to *stanard-output*
<gabbiel>
but output is iffy, lots of ^M in there
<grewal>
are you on windows?
<gabbiel>
no
wxie has joined #lisp
<gabbiel>
ok i made output be *standard-ouput* and now it works correctly
<gabbiel>
no ^M
<gabbiel>
is pty for windows?
<grewal>
^M is carriage return
<gabbiel>
I guess if u want correct output on windows u must use pty then, and not output
moldybits has quit [Quit: WeeChat 2.4]
Josh_2 has quit [Read error: Connection reset by peer]
<gabbiel>
do you guys know if there's a function in the standard or sbcl's that returns the filename of a path? e.g. (f "/home/user/whatever/file.png") => file.png
<gabbiel>
and also a function that removes the extension of a filename e.g. (g "file.png") => "file"
<Xach>
gabbiel: file-namestring, sort of
<Xach>
gabbiel: pathname-name
Oladon has joined #lisp
wxie has quit [Quit: Bye.]
<stylewarning>
But it doesn’t “remove” the extension that sense. It extracts the file’s name within a pathname
<stylewarning>
in that sense*
<gabbiel>
which one, file-namestring?
<stylewarning>
pathname-name
zotan has quit [Ping timeout: 250 seconds]
<stylewarning>
Which would be read as “get the name out of a pathname”
<gabbiel>
just tested it, it does remove the extension
<gabbiel>
wow, just what I need, thanks guys
<Xach>
heh
<gabbiel>
file-namestring has the extension
<gabbiel>
but pathname-name doesn't
<gabbiel>
perfect
<stylewarning>
Yes, it “removes” the extension, but it’s actually not removing anything. I’m being pedantic about what it’s doing. A pathname is an object, and the “name” within a pathname is sort of the “base name” of the path
<stylewarning>
The file name without the extension
zotan has joined #lisp
<gabbiel>
thanks everyone
arescorpio has joined #lisp
caltelt has joined #lisp
asarch has joined #lisp
<asarch>
If I do in the Unix shell: echo -e "#!/usr/local/bin/sbcl --script\n(ql:quickload 'cl-cffi-gtk-demo-gtk)\n(gtk-demo:main)" > gtk-demo.cls && sh gtk-demo.cls
<asarch>
I would get "Package QL does not exist."
<asarch>
How could I load the cl-cffi-gtk-demo-gtk package?
<gabbiel>
its because the .sbclrc isn't ready
<gabbiel>
*read
<gabbiel>
remember the (ql:add-to-init-file)
<gabbiel>
and u launched sbcl, it read .sbclrc, which made the ql package be available
<asarch>
Because the −−noinform −−disable−ldb −−lose−on−corruption −−end−runtime−options −−no-sysinit −−no-userinit −−disable-debugger −−end−toplevel−options flags implicit with the --script flag
<gabbiel>
basically, make .sbclrc be read I think
<asarch>
That's the point of my question: how?
<Xach>
asarch: you could include (load "~/quicklisp/setup.lisp") somewhere
<asarch>
I was trying with (require ’cl-cffi-gtk-demo-gtk)
<asarch>
D'oh!
<gabbiel>
hey guys do u know if the file-name arg in the with-output-to-file macro needs to already be a string, or can I have a form which evauluates to a path?
<Bike>
clhs with-output-to-file
<specbot>
Couldn't find anything for with-output-to-file.
<gabbiel>
like so (with-output-to-file (*standard-output* (format nil ...))
<Bike>
you mean with-open-file?
<asarch>
I just invented a new MIME file extension: .cls (Common Lisp Script)
<asarch>
Thank you very much guys :-P
<gabbiel>
ohh guys, sorry, I wasn't aware that was from alexandria
psqueak has quit [Ping timeout: 256 seconds]
mindCrime has joined #lisp
<gabbiel>
difference between :supersed and :overwrite?
<mooshmoosh>
If i have two functions that each take a stream, but on reads data from it, and the other writes data to it, is there a canonical/clean way to join them together?
igemnace has joined #lisp
<mooshmoosh>
Specifically, im trying to read a zip file that is contained within another zip file. zip:zipfile-entry-contents takes a stream to write a file to, and zip:with-zipfile-stream opens a stream that is a zipfile.
<pjb>
mooshmoosh: missing semantic information. How do you want to join them?
oni-on-ion has quit [Read error: Connection reset by peer]
madmuppet006 has joined #lisp
oni-on-ion has joined #lisp
t58 has quit [Quit: Night]
femi has quit [Ping timeout: 250 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
femi has joined #lisp
wxie has joined #lisp
wxie has quit [Client Quit]
gxt has quit [Quit: WeeChat 2.4]
<mooshmoosh>
pjb: i want to join the functions together, so that one writes to the stream the other reads from. if these functions returned data instead of writing to a stream, and took data from an argument instead of reading from a stream, then it would be a case of function composition.
<mooshmoosh>
Does that make sense?
arescorpio has quit [Remote host closed the connection]
<pjb>
You're still not precise enough. For example: (progn (write-to-stream stream) (read-to-stream stream)) is a solution.
<pjb>
But: (progn (read-to-stream stream) (write-to-stream stream)) is also a solution.
Bike has quit [Quit: Lost terminal]
<pjb>
Just like (lambda (input) (sink input) (produce-output)) or (lambda () (sink-input (produce-output))) would also be two solutions in your example.
<pjb>
mooshmoosh: streams are communication channels. File stream let you move data between file and memory and between memory and file.
<aeth>
The file solution is the slower, but more general solution.
<pjb>
The cannot function like a queue. Do you need a queue? Why are you using files?
X-Scale has quit [Ping timeout: 255 seconds]
libertyprime has joined #lisp
<pjb>
mooshmoosh: if you need a queue, with a stream API, you may want to have a look at com.informatimago.clext.pipe
quazimodo has joined #lisp
<aeth>
The queue-backed gray-stream solution will either have a maximum size after which it becomes full or it will potentially have very slow "doubling" moments when you're doing a write when at the current-max size
<pjb>
mooshmoosh: but again, if you want to deal with pipes, you have a problem: you need to use threads!
<pjb>
mooshmoosh: again, if you want a queue, why do you want to use files?
<pjb>
see com.informatimago.common-lisp.cesarum.queue
<aeth>
pjb: The way I deal with it is that I don't try to deal with concurrency in the pipe itself and just require the user to use a BT lock when they use different threads (which is probably why the user's even using them in the first place)
<pjb>
mooshmoosh: or com.informatimago.clext.queue
<aeth>
I *think* it might just be possible with inheritance to have one with a lock inherit from the regular one, though.
<mooshmoosh>
pjb: i was given these two functions that only read from and write to streams, but i want to compose them
<pjb>
mooshmoosh: you're still making 0 sense.
<pjb>
It doesn't mean anything to compose functions that read or write to stream. You need to elaborate on your specifications.
<pjb>
mooshmoosh: see my paste!
<aeth>
mooshmoosh: you either have to use files like in pjb's pastebin example or you have to write your own fairly trivial (assuming you have a queue data structure) gray-streams stream
<aeth>
afaik
<aeth>
at least, these are the two general approaches for pipes when I looked into it
<aeth>
(of course, you can also just use someone's library)
keep_learning_M has joined #lisp
<mooshmoosh>
pjb: your paste is helpful
<pjb>
notice that the two reader and writer functions are careful not to write or read the same file range.
<mooshmoosh>
youre using a file as the go between
<pjb>
Therefore they're independent, they can run in any order, or in parallel.
<pjb>
There's no go between there!
<pjb>
So my paste is only useful if you understand that.
<pjb>
There's no dependencency implemende when you just say a function that reads a stream and a function that writes a stream. No dependency, therefore no meaning.
<pjb>
s/implemende/implied/
<mooshmoosh>
Sorry a buffer, not a file
<pjb>
Again, a buffer can be big!
<pjb>
This doesn't imply anything.
<pjb>
You need to be meaningful. Think and say what you mean.
<mooshmoosh>
The dependency i want, is that the data read from or written to streams is the same
<pjb>
So you want the reader to read the data that has been written by the writer?
<mooshmoosh>
So the stream object that i pass to the functions might be different
<mooshmoosh>
Correct
<pjb>
Ok. Do you have a time machine?
<mooshmoosh>
do i need one?
<pjb>
No. But if you don't have one, there's only one solution.
<pjb>
You must first write, then you can read.
<pjb>
So (progn (write-data stream) (read-data stream)) is the only solution.
<pjb>
Assuming those functions set the file-position.
<pjb>
Again, you see that the answer depends on a lot of things you've not told us.
<pjb>
You need to be meaningful!
<aeth>
pjb: What I meant about a queue is that if you want something more fancy than your "(with-input-from-string (stream (with-output-from-string ..." is that you can write a trivial gray-stream backed by a queue data structure
<aeth>
this allows you to e.g. have one thread read and one thread write
<mooshmoosh>
aeth: yes
<pjb>
If you have a lot of data, that is produced and consummed progressively, you can indeed use a pipe. But then you need your producer and your consumer to run in different threads. Meanings that you need to explain.
<mooshmoosh>
aeth: can you link me to some resources about gray streams you mentioned
<mooshmoosh>
I read your gitlab file id like to read more
<pjb>
mooshmoosh: I mentionned: com.informatimago.clext.pipeor com.informatimago.clext.queue
<beach>
gabbiel: "The idea behind establishing this convention was to eliminate noise generated almost every time someone comes in and greets using some form of day-time based greeting, and then channel members on the other side of the globe start pointing out that it's different time of the day for them."
<gabbiel>
lol i just read that
<gabbiel>
ok sorry, im not much accustomed to irc rules
<pjb>
Hence: GTOD = Good Time Of Day
<beach>
gabbiel: No need to apologize. Just learn.
techquila has quit [Read error: Connection reset by peer]
techquila has joined #lisp
<gabbiel>
is that quicklisp
<gabbiel>
'able, sorry accidentally hit enter, i know multiline is frowned upon
<pjb>
in the ultralisp distribution.
techquila has quit [Remote host closed the connection]
<gabbiel>
I should probably sleep, gnite everyone
gabbiel has quit [Quit: ERC (IRC client for Emacs 26.1)]
techquila has joined #lisp
techquila has quit [Remote host closed the connection]
techquila has joined #lisp
v88m has joined #lisp
v88m has quit [Read error: Connection reset by peer]
v88m has joined #lisp
asarch has quit [Quit: Leaving]
manualcrank has quit [Quit: WeeChat 1.9.1]
ggole has joined #lisp
Oladon has quit [Quit: Leaving.]
v88m has quit [Read error: Connection reset by peer]
v88m has joined #lisp
pankajgodbole has joined #lisp
mindthelion has joined #lisp
techquila has quit [Read error: Connection reset by peer]
<minion>
Remembered. I'll tell aozt when he/she/it next speaks.
<pjb>
phoe: you must use the result of nconc, like the result of delete! (setf original-list (nconc original-list (list new-elt))) works on empty lists too!
Josh_2 has joined #lisp
<gabbiel>
what's the reason for () evaluating to nil
elazul has quit [Ping timeout: 252 seconds]
<edgar-rft>
you can use a list as boolean, non-empty list = true, empty-list = false
<pjb>
diip: for small machines, you might want to consider clicc, ecl, or mocl. libecl is about the size of libc, well below your 1GB limit. ecl will compile to native code thru gcc, so your executable will be faster than with clisp. clicc and mocl translate your CL program to C, that you can then compile for your limited machine. clicc is opensource but oldish, would need some love. mocl is commercial but somewhat limited. It target
<pjb>
gabbiel: () evaluates to nil, because the default binding of *readtable* is a standard readtable that has a standard reader macro for #\( which reads () as the symbol CL:NIL, and CL:NIL is defined to be a constant variable bound to the symbol CL:NIL.
<shka_>
i second pjb about ecl
<shka_>
it produces small files
<shka_>
one of non-obvious things it has going for it
<pjb>
diip: in practice, ecl is probably your best option currently. Notably if you can set up a separate development environement for your target, so you can compile binaries on the development workstation and copy just the binaries on your target.
<gabbiel>
ok so its because of readtable then
<gabbiel>
could I make it to give me an error?
<Xach>
gabbiel: yes.
<pjb>
gabbiel: (let ((*readtable* (copy-readtable nil))) (set-macro-character (character "(") (lambda (stream ch) (error "We need no ( !"))) (read-from-string "(hello () nil world)")) => Debug: We need no ( !
mooshmoosh has quit [Ping timeout: 246 seconds]
mooshmoosh has joined #lisp
Arcaelyx has joined #lisp
vms14 has quit [Quit: WeeChat 2.3]
serviteur has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
mindCrime has joined #lisp
sr5h has quit [Ping timeout: 258 seconds]
ring has joined #lisp
ring has quit [Remote host closed the connection]
Oladon has quit [Quit: Leaving.]
makomo has joined #lisp
vlatkoB has joined #lisp
elazul has joined #lisp
gareppa has quit [Quit: Leaving]
makomo has quit [Quit: WeeChat 2.4]
mindCrime has quit [Ping timeout: 246 seconds]
dale has quit [Quit: dale]
dale has joined #lisp
scymtym has quit [Ping timeout: 248 seconds]
idlus_ has quit [Ping timeout: 256 seconds]
idlus_ has joined #lisp
cosimone has quit [Quit: WeeChat 2.3]
kpoeck_ has quit [Quit: Connection closed for inactivity]
didi has joined #lisp
<didi>
Heh, it's not much, but today I realized that function parameters can shadow dynamic variables.
Achylles has quit [Read error: Connection reset by peer]
<didi>
I was wondering why some macros gensym parameters of functions even if the parameters are only visible to the macro. Avoiding shadowing dynamic variables seems like a good reason.
<didi>
It's also another good reason for muffling dynamic variables.
lumm has quit [Ping timeout: 248 seconds]
rumbler31 has quit [Remote host closed the connection]
TheWild has quit [Ping timeout: 248 seconds]
<sjl>
Yeah I've seen it used for streams before, e.g. (defun myprint (object &optional (*standard-output* *standard-output*)) (prin1 object) (terpri) object)
<sjl>
I guess I should gensym parameter names like you said... but I'm lazy, and if someone is declaring a non-earmuffed symbol in MY package to be special... well, I don't lose any sleep over that breakage.
mindCrime has joined #lisp
aeth has quit [Ping timeout: 268 seconds]
ludston has quit [Ping timeout: 244 seconds]
aeth has joined #lisp
mindCrime_ has joined #lisp
mindCrime has quit [Ping timeout: 246 seconds]
<diip>
pjb: Thanks, But I am trying to develop on the target, and it was really a choice between trying sbcl or clisp. I managed to get an old version of clisp working. I might try ecl, but I am not sure I can get all the dependencies (which might also be problem with cffi on clisp)
andrei-n has quit [Remote host closed the connection]
<pjb>
diip: to develop on the target, indeed clisp might be the best choice. Otherwise you can try sbcl and ccl. ccl is smaller than sbcl. If you can do without native code (ie. if you accept clisp), you may also try ecl without gcc. ecl also has a bytecode compiler and a bytecode interpreter like clisp.
<pjb>
That said, 1 GB is enough for a gcc+ecl.
<diip>
I have a version of gcc,
deng_cn has quit [Ping timeout: 252 seconds]
<diip>
but ccl failed
<diip>
now my plan is to move the asdf folder to an external drive which should help somewhat
Lord_of_Life_ has joined #lisp
v88m has quit [Ping timeout: 250 seconds]
aeth has quit [Ping timeout: 248 seconds]
nanoz has quit [Ping timeout: 245 seconds]
aeth has joined #lisp
Lord_of_Life has quit [Ping timeout: 258 seconds]
Lord_of_Life_ is now known as Lord_of_Life
notzmv has joined #lisp
aeth_ has joined #lisp
aeth has quit [Ping timeout: 248 seconds]
mrak has joined #lisp
aeth_ is now known as aeth
xkapastel has joined #lisp
<didi>
How do I turn the sixteen bit-long integer #b1000000000000001 into -1 instead of 32769?
kajo has joined #lisp
<pjb>
(- 32768 #b1000000000000001) #| --> -1 |#
<didi>
pjb: Thanks.
<pjb>
But only when (< 32767 n)
<shka_>
oh
<shka_>
interesting
<shka_>
why does this works?
nowhere_man has joined #lisp
t58 has quit [Quit: buying dinner]
<pjb>
shka_: because the result of 2-complement is to move the negative range to the upper range: 0..32767 32768..65535 = 0..32767 -32768..-1
<shka_>
ok, but how does #b drives this?
<pjb>
#b doesn't matter. Numbers are not their representations.
TheWild has joined #lisp
KLoop has quit [Quit: Konversation terminated!]
<pjb>
#b1000000000000001 #| --> 32769 |#
<shka_>
oh
<shka_>
somewhat i missed the leading 1
<shka_>
silly me
<pjb>
shka_, didi: but right, #b1000000000000001 is not the 2-complement representation of -1. 000001 ~ -> 111110 +1 -> 111111
<pjb>
didi: so what was your question? (it's never a good idea to use examples).
<didi>
pjb: I'm reading bytes from a file and I need to turn them into signed integers.
<pjb>
I mean, people complain all the time about how IQ tests are meaningless because you can infer an infinite number of series from a few examples, but they keep asking questions with only examples.
<pjb>
didi: the question is what is the encoding/decoding rule for those bytes?
<pjb>
didi: then you can ask how to implement a rule.
<shka_>
didi: so you literally want to do c style cast from unsigned to signed
<didi>
Xach: That's it. I thought it might involve log* functions. I also hoped that I finally used BOOLE.
Jesin has quit [Quit: Leaving]
<aeth>
didi: This is how you go ub32 to sb32, which I wrote the other day (for someone else?) in here: (defun ub32-to-sb32 (number) (declare (type (unsigned-byte 32) number)) (multiple-value-bind (quotient remainder) (truncate number (expt 2 31)) (- remainder (* quotient (expt 2 31)))))
<didi>
aeth: Thank you.
<aeth>
For ub16-to-sb16 just substitute 32 with 16 and 31 with 15
Jesin has joined #lisp
<aeth>
The only caveat with this approach is it allocates some bignums for ub64 and sb64... but they're going to be bignums anyway unless you modify that function to set to an array and return that array like so: (setf (aref array) (- remainder (* quotient (expt 2 63)))) array
Blukunfando has quit [Ping timeout: 245 seconds]
<aeth>
For every smaller byte size it should afaik be the most efficient approach, especially in SBCL
elazul has quit [Ping timeout: 244 seconds]
<aeth>
didi: In case you're wondering with how it works, instead of doing mod it does a truncate (or floor, but there's no difference since it's positive input) and it uses the secondary value like mod and the primary value is 1 if it needs to be shifted and 0 if it doesn't, so that can be multiplied and subtracted to do the actual shift of the upper numbers into the negatives
idlus_ has quit [Ping timeout: 256 seconds]
TheWild has quit [Ping timeout: 252 seconds]
<aeth>
It should be more efficient than branching for fixnums, but it might not be as efficient as a more naive approach for ub64-to-sb64 and up
<shka_>
Xachs approach should be optimal
<shka_>
just hint types and it should be ideal
nowhere_man has quit [Ping timeout: 252 seconds]
<aeth>
shka_: That approach is probably the second most efficient, but it has branching.
<shka_>
well, this may not matter in the superscalar
<edgar-rft>
The most efficient approach is throwing away the argument and always return zero. The result might be totally wrong but therfore it's most efficient.
pankajgodbole has quit [Ping timeout: 255 seconds]
vlatkoB has quit [Remote host closed the connection]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
mrak has quit [Remote host closed the connection]
v88m has joined #lisp
<aeth>
edgar-rft: well, that passes my unit test.
v88m has quit [Client Quit]
v88m has joined #lisp
idlus_ has joined #lisp
v88m has quit [Client Quit]
v88m has joined #lisp
cosimone has joined #lisp
cosimone has quit [Client Quit]
TheWild has joined #lisp
rpg has joined #lisp
ian_0xF has joined #lisp
<edgar-rft>
aeth: I was quite sure it does
ian_0xF has quit [Client Quit]
ggole- has quit [Quit: Leaving]
rpg has quit [Ping timeout: 252 seconds]
vms14 has joined #lisp
t58 has joined #lisp
<vms14>
pjb: how can I use ~va "" while iterating from a list?
<vms14>
(defun create-class (name list)
<vms14>
(format t ".~a~%{~%~{~3t~a: ~a;~%~}}" name list))
<pjb>
(dolist (line lines) (format out "~VA~A~%" indent "" line))
<vaartis>
pjb: it actually was the fact that there were not releases for more than a year, it was fixed but not included in a release, so the GH versioin worked fine and the version a made a package for did not
<vaartis>
now, another question
<vaartis>
this time autowrap-related
<vaartis>
there are two functions returning the same thing in C, but autowarp returns a wrapper for one and a raw pointer for another
<aeth>
it looks like the fork borodust maintain has no wrapped pointers, which is my main (performance) objection with cl-autowrap
<aeth>
s/maintain/maintains/
<vaartis>
i don't REALLY care about performance _yet_
<vaartis>
besides, validity checking sounds nice in theory
<aeth>
in theory, but it makes things extremely complicated and the author for cl-autowrap doesn't appear to be active anymore (still accepts pull requests, though?)
<vaartis>
he did accept a pull request of mine into c2ffi
<vaartis>
and said he's working on making it not-so-big-of-a-hack
<aeth>
it's sort of the whole worse is better thing... do you make the library very elaborate and save work for the application author or do you keep things (somewhat) simple and have the application author do more work?
<vaartis>
I'd rather not do more work, i'm doing it mostly for myself rn
<aeth>
as far as the whole game use case goes, though, you put most of your stuff in very clearly defined places with unwind-protect anyway so e.g. cl-sdl2 just adds unnecessary overhead with autowrap
<aeth>
s/your stuff/your foreign stuff/
idlus_ has quit [Ping timeout: 256 seconds]
idlus_ has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
idlus_ has quit [Ping timeout: 256 seconds]
bars0 has quit [Quit: leaving]
t58__ is now known as t58
<vaartis>
aeth: who could've thought.. there are reader macros in there too
idlus_ has joined #lisp
cosimone has joined #lisp
<vaartis>
the problem might be connected to libffi it seems..
<vaartis>
those functions returning raw stuff use libffi
<aeth>
vaartis: it looks like borodust's claw doesn't use libffi, either!
<vaartis>
yeah, it uses a c library..
<aeth>
The solution might just be to try claw instead if you're doing your own wrapping.
<aeth>
borodust: poke
<vaartis>
I'm doing more of a high level thing
didi has left #lisp ["O bella ciao bella ciao bella ciao, ciao, ciao."]
<vaartis>
autowrap helps a lot with that
<borodust>
aeth: yes?
<borodust>
lemme catch on convo :)
<aeth>
borodust: basically vaartis is having issues with stuff autowrap has but your fork doesn't
<vaartis>
yeaaaah it's probably because of libffi, maybe he just forgot to wrap libffi stuff lol
<vaartis>
not really an issue, just an inconsistency
<Xach>
phoe: can't build postmodern-execute-file because of implicit dependency on postmodern.
<borodust>
vaartis: can you link to functions your are trying to wrap that return inconsistent reults? autowrap-generated functions return wrappers for structure pointers
<borodust>
if it's non-structure pointer it would just return it (except for char* which it will turn into lisp string by default)
<vaartis>
thing is, the return type is the same in C
<vaartis>
and the same in the introospection data from autowrap
<vaartis>
but in reality, those that have structure-by-value parameters return raw pointers
<vaartis>
while they should return wrappers
<borodust>
i see, yeah, could be
idlus has joined #lisp
<borodust>
libffi support was the last major feature introduced before rpav left lispdev
idlus_ has quit [Ping timeout: 256 seconds]
<vaartis>
i made an issue, not sure if it will ever be looked at
<vaartis>
eh..
caltelt has quit [Ping timeout: 250 seconds]
<borodust>
vaartis: btw, congratz on submitting a lgj2019 entry :)
<phoe>
Xach: thanks, this library should not be merged anyway.
<borodust>
as aeth mentioned, it is wrapped with claw though
<vaartis>
it's really really thing, huh
shka_ has quit [Ping timeout: 250 seconds]
<vaartis>
thin*
<aeth>
vaartis: A thin wrapper is a good idea because the higher level really should be at... another level. Don't try to do too many things at once.
<aeth>
Ideally, at the lowest level of wrapping you should just be able to use the C (or whatever) API documentation and do the translations in your head imo.
<borodust>
vaartis: yup, some ppl call them raw bindings
<vaartis>
i'm more of a fan of making ideomatic bindings, not like i'm good at it though
<borodust>
:claw doesn't use libffi, but requires a special C wrapper which it generates - hopefully, you can use chipmunk-blob as specified in README
<vaartis>
i might..
<aeth>
vaartis: idiomatic bindings can be built on top of raw bindings, though
<borodust>
vaartis: cl-bodge has idiomatic API based on bodge-chipmunk :)
<aeth>
I'm sensing an incoming trivial-gamekit pitch
<borodust>
because it doesn't has this api exposed
<borodust>
i'm thinking about making a physics plugin for it though - if anyone would be interested
idlus has quit [Ping timeout: 256 seconds]
<vaartis>
borodust: i assume cl-bodge's physics system is tied into everything else it has and wouldn't really work outside?
<borodust>
vaartis: at this moment - no, it won't work outside, but i can splice it into a library - but i'm too lazy optimizing things, so if you are after performant code, you better avoid it ;p
<vaartis>
i see
khisanth_ has quit [Ping timeout: 246 seconds]
<borodust>
anyway, i'm just saying that you can take bodge-chipmunk and make a higher level (rich) library on top of it
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
khisanth_ has joined #lisp
idlus has quit [Ping timeout: 256 seconds]
Jesin has quit [Quit: Leaving]
<vaartis>
i wonder if it would theoretically be possible to somehow make C dynamic libraries use lisp gc
<vaartis>
gee that'd be a cool conect
<vaartis>
concept
Jesin has joined #lisp
idlus has joined #lisp
Achylles has quit [Read error: Connection reset by peer]
vaartis has quit [Read error: Connection reset by peer]
makomo has joined #lisp
idlus_ has joined #lisp
idlus has quit [Ping timeout: 256 seconds]
idlus_ has quit [Ping timeout: 256 seconds]
random-nick has quit [Read error: Connection reset by peer]
TheWild has quit [Ping timeout: 248 seconds]
cosimone has quit [Quit: WeeChat 2.3]
libertyprime has quit [Ping timeout: 252 seconds]
nowhere_man has joined #lisp
ring has joined #lisp
Oladon has joined #lisp
lumm has quit [Ping timeout: 248 seconds]
varjag has quit [Ping timeout: 250 seconds]
rumbler31 has joined #lisp
moei has quit [Quit: Leaving...]
ring has quit [Ping timeout: 255 seconds]
<pjb>
minion: memo for vaartis: not lisp GC, because of limitations of C, but there are several garbage collectors that work with C: BoehmGC, https://www.hboehm.info/gc/ (just try to link with -lgc it's probably already here), MPS https://www.ravenbrook.com/project/mps/ and others.
<minion>
Remembered. I'll tell vaartis when he/she/it next speaks.
Achylles has joined #lisp
karlosz has joined #lisp
idlus_ has joined #lisp
diip has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 248 seconds]
cyberoctopi has quit [Ping timeout: 248 seconds]
caltelt has joined #lisp
sr5h has joined #lisp
Achylles has quit [Remote host closed the connection]