World: r3wp

We never heard from such people again

Sure most parts of Syllable Server have been ported to ARM in other 
projects, but porting the system will be many man months of work 
at best

thats why i was asking which parts are the problematic. i was just 
wondering if there is already an ubuntu running on that thing, then 
probably most of the build tools for syllable server are ready

It's not that any of the parts is particularly problematic, it's 
that it's an awful lot of work with today's software bloat

And if you don't know all the parts intimately, they can easily pose 
a big problem to a particular developer

ok, got it. i was building lfs back then , so i know what u r talking 
about

Then you know that the ports of LFS to various architectures are 
separate projects, that are partly rearchitected

i was just trying the x86 version, but i can imagine

It can easily take me half a year to create a next version of Syllable 
Server, and that's on the same architecture

Doc - there is many such small platforms, even x86 based IIRC. Gumstix 
is e.g. for real, a bit pricey, but definitely not vapor - http://www.gumstix.com/store/catalog/product_info.php?products_id=256

Right, but not at $25 (the one you posted is sold $229).

Right, but is sold right now, without the "we plan to develop" attitude 
:-)

I personally bought Beagleboard. Pandora Board might be even better 
....

Small enough for us.

I think we can have faith in David Braben

I have updated the 0MQ binding to the latest Red version, and moved 
it to a Fossil repository:

http://rebol.esperconsultancy.nl/Red-ZeroMQ-binding

Thanks, will test is tomorrow.

From sources: "libzmq.dll" cdecl [  ; stdcall for Windows? => should 
be cdecl, stdcall is used in Windows DLL (and rarely by C libs).

vsm-data1	[integer!]  ; unsigned char [ZMQ_MAX_VSM_SIZE] (default 
30)

 => we will need a better way to handle such arrays when interfacing 
 with third-party libs...

Yes

I found the same info that Windows system libraries use stdcall, 
but that MSVC defaults to cdecl. I had been compiling the binding 
with stdcall, and both work. I standardised on cdecl and retained 
the comment for the moment being

I'm getting this:

Compiling /users/administrator/Red/Red-ZeroMQ-binding/examples/reply-server.reds 
...
*** Compilation Error: invalid struct syntax: [pointer!]

*** in: %/users/administrator/Red/Red-ZeroMQ-binding/examples/../ZeroMQ-binding.reds
*** at:  [struct [
        content [pointer!]
        flags [byte!]

What's the new syntax for a pointer field in a struct?

pointer! [integer!]

Actually it isn't a new syntax, it's just that the compiler wasn't 
checking it deep enough until now.

Shouldn't an actual pointer! type be possible?

What you're saying, that's a pointer to an integer, right? But I 
need a pointer to a bigger memory area here

Pointer! alone is equivalent to an integer, it just represent an 
address, but can't be dereferenced.

If you are just passing the pointer! reference but never dereferencing 
it, you could just use integer! instead (or c-string!).

Yes, it's just to reserve the space for a pointer that's used by 
0MQ, but not by Red

I'm trying to use pointer! as much as possible instead of integer! 
because it makes clear that we're talking about an address size, 
not what happens to be the compiler's integer size

Agreed. You could also use aliased types for that: 
    handle!: alias integer!
or
    void-ptr!: alias integer!


Aliased typed are not yet fully supported nor tested, but it should 
work fine in your case.

Sorry, I meant:
    handle!: alias pointer! [integer!]
or
    void-ptr!: alias pointer! [integer!]

You might want to avoid using handle! for these, as it is the best 
candidate for the opaque-pointer-sized-value type in Red proper, 
that all of Red/System's pointer! types would appear to be when they 
leak into Red code.

Well, isn't that exactly the reason to use it?

I mean, don't use the word 'handle! as an alias because it will likely 
be a built-in datatype in Red, and in all Red/System functions and 
datatypes exported to Red.

But it would be exactly what you want, wouldn't it?

handle!: alias integer!

would override the built-in meaning of handle!. All code that uses 
that word would need to be changed when Red comes out.

Keep in mind that there is no bounds-checking for Red/System's pointer 
type, and Red/System has typecasting (rather than conversion). Neither 
of those would be allowed in Red itself because of typesafety issues. 
Red/System will be like the unsafe code of C#.

That would be just a little code, and it's obvious that you have 
to develop your programs to stay in sync with a language that's in 
alpha status

Yup. But it's also good to warn them of planned developments once 
they're definitely planned, and this one is pretty well established.

Exactly, so that's the reason to start using the handle! type now

No, that's a good reason to *add the handle! type to Red/System* 
now, as a preemptively reserved word. Not a reason to use the word 
handle! to refer to a completely different thing.

It still means that I start writing "handle!" in my code now

Perhaps it could be a name for a non-dereferenceable void pointer 
type, since that's the closest C equivalent.

Basically, Red's handle! type would be the same as R3's handle! type. 
Opaque value that is pointer sized, but can't be used as a pointer 
without typecasting, and no arithmetic possible. No conversions to 
other datatypes either in typesafe code.

That's in Red. Red/System is a different context

Yes, but Red/System's main purpose is to do things with Red data, 
so it needs to have access to Red's types, even if its own literal 
types are different. So Red/System needs to have a handle! type, 
even though Red/System code would need to typecast values of that 
type to something else in order to be able to do anything with them.