World: r3wp

I'm pretty certain that Nenad has said that he won't be adding binary 
floating point numbers to Red/System as they will not be needed to 
build the Red runtime. So at the moment, I would only expect them 
once Red is available.

Not anymore, because he has now decided to compile Red to Red/System, 
so Red/System will need full support

I think that's a good thing, but it may still be wise to postpone 
the implementation. Having Red will enable more people to contribute, 
but on the other hand, the lack of floating point is blocking a few 
contributors now

Floating point support should be added to Red/System if my tests 
shows that I can safely do the Red->Red/System compilation, else 
it will be supported at Red level. Anyway, it is not a priority for 
me, so it probably won't be added before Q4 2010 (unless someone 
wants to contribute by adding it to Red/System).

Q4 2010 is in the past... :) but thanks for the info. I can wait.

Sorry, Q4 2011.

Those years are passing too fast. :-)

but at least Red seems to be keeping up

Andreas' fixes to callbacks on Linux work now. I've enabled them 
in the 0MQ binding and with that, the binding is now pretty much 
production ready

Andreas did a great debugging work on that.

Yep

Thanks. Good to hear that it's now working for you as well, Kaj.

Very cool. Thanks to all of you for coordinating on this.

Is it possible to compile R3 extensions right out-of-the-box? That 
would be pretty cool.

Robert: yes, as soon as we add DLL generation support in Red/System.

it will not be much useful without floats ;-)

Nice try :-)

You'll still have to implement the R3 extensions interface

The 64-bit integer support might also be required in Red/System for 
that.

Indeed, it doesn't seem to be possible to get away without that

Once there are 64 bits values, it may be possible to shuffle them 
as floating point values between libraries, without Red being aware 
what they're used for

Good point.

When floats are passed to C functions, can they be in normal registers 
or must they be in FPU registers?

If the calling convention is cdecl, they are just pushed on stack.

That seems like a nice shortcut, then

That would only work for literal float values.

If you use a variable, you need to pass thru the registers.

The FPU registers?

In the float case, yes FPU registers.

IA32 32-bit registers can't hold C double floats (64-bit).

I've started working on a cURL binding. It can print the cURL version 
now :-)

I could call it a port from the R3 binding, but it will be more like 
a rewrite

The dynamics in Red are quite different

You mean in Red/System. Red does not exist yet.

I will improve the web site that make that difference more clear.

Red/System can hardly be compared to REBOL, they don't live at the 
same level of abstraction.

Great to know you are working on a new binding. Let me know when 
you will put it online, so I can add a link from red-lang.org.

As long as Red proper doesn't exist, I use Red to refer to Red/System 
:-)

I'm careful not to do that in publications, though

http://rebol.esperconsultancy.nl/Red-ZeroMQ-binding/doc/trunk/COPYRIGHT.txt
refers to Red :)

Ah, yes, because it will be a binding for Red, even though the binding 
is written in Red/System

Hmm, form me the AltME large font swallowed the "refers to Red :)" 
remark.

Not on my screen size

Since R3 bindings are written in C, their level is comparable to 
a binding in Red/System. But the dynamics are quite different, that's 
what I meant

looking forward to more weird bugs discovered by the curl binding 
:)

I hope they were all shaken out with the other bindings :-)

Hm, a cURL progress callback needs floats. It's pretty limiting if 
you can't get progress feedback

You should be able to pass 2 integers (if it's a 'double or just 
one if it's a 'single), then do the float->integer (by doing a * 
100 e.g.). Probably fun to code. :-)

But you said they must be passed via the FPU?

Right, if you want them in a variable. What I was proposing here 
is to split them from the stack by declaring 2 integers, so that 
the float gets stored in 2 arguments (supposing it is a double).