World: r3wp

Andreas is supposed to give it a try this week.

OMQ: still getting the same error message, got at least 3 versions 
of Visual C++ 2008 redistribuable package (added the one from your 
link too).

Odd; must be something else

very nice, doc. the ELF hello works like a charm here :)

Goog to know.

re the size of executables, for comparison: basic 0MQ examples ("hwserver/hwclient") 
written in C compiled & linked dynamically with GCC & gold on Linux 
are ~6KB in size.

The 0MQ error code function is called zmq_errno. If the error message 
is about zmq_err0 it seems the name is being truncated somewhere 
on Windows

This function differs in that it has no parameters, only a return 
value. Might have something to do with it

Actually, this name truncation is in the symbol table, so it's a 
bug in the Red code generator that doesn't disturb WINE if the function 
isn't called

Looking at the server.exe content, I see the zmq_err0 in the imported 
functions list. So it seems to be corrupted inside the executable.

The name is garbled from zmq_errno to zmq_err0

I'm looking into the linker to find the cause.

Found the issue: #define no 0 :-))

heh, good catch :)

The preprocessor is a bit too aggressive.

is it case-sensitive?

yes

yep

so sticking to the C convention of ALL_CAPS_DEFINES is probably a 
good idea (at least for now) :)

That would be safer, until we get a smarter one.

I thought about adding a full macros system, I think it will be useful 
until we can compose Red/System code from Red itself.

Right, I ran into the preprocessor zeal before, and replaced some 
other values with variables

Once that definition fixed in %ZeroMQ-binding.reds, I can compile 
working versions of client & server...testing...seems to work ok, 
the server is receiving a list of Hello messages from the client. 
:-)

Congrats!

Thanks :-)

Is the preprocessor necessary at all? It's usually much nicer to 
implement this functionality at a more integrated level in a language

I'm thinking about descending it one level below to process the script 
at block! level instead of string! level, after all, the compiler 
has the full power of REBOL.

Yes

That should avoid the nasty side-effects.

With the Linux backend, did the system loose its ability to cross-compile 
to Windows?

Nope, I just need to adjust the compiler front-end (rsc.r) to pass 
an option for the desired format (PE, ELF, ...).

Currently, a default format is applied depending on the REBOL binary 
used.

You can compose Red/System from REBOL in lieu of a preprocessor, 
until the compiler is ported to Red.

I mean in lieu of preprocessor macros

Do you mean replacing .reds scripts by .r scripts?

Kaj: if you want to cross-compile, you currently need to hardcode 
the target format in %compiler.r at:

    fmt: select [			;TBD: allow cross-compilation!
        3	'PE			;-- Windows
        4	'ELF			;-- Linux
        5	'Mach-o		;-- Mac OS X
    ] system/version/4

No, I mean that when you say that your long-term strategy is to compose 
Red/System code in Red, thus making preprocessor macros unnecessary 
in Red/System, you could start that strategy much earlier by composing 
the code in REBOL. What you learn from doing so and the code you 
write can be adapted to Red later once that exists.

Doc, would you mind if I started some research on generating Dalvik 
binaries? I notice it's not on your list of planned platforms.

Sure, no problem.

I plan to support ARM directly.

Thanks, Doc, I just found it. I wanted to take the scenic route :-)

It's amazing how much more approachable this system is compated to 
everything else out there - save for the very early teaching examples 
in computer science history

compared

I wanted to get back to the roots (80's for me) of computing, a time 
where an entire OS + programming langage could fit in a 16KB ROM 
;-).

Brilliant

That was the ZX Spectrum ROM to be specific.

I'd allow for 20KB, though. Atari was 8K OS + 8K BASIC + 4K decimal 
floating point :-)

Or was it 2K math? I'm really getting old. Anyway, it beats the pants 
off that Intel stuff

I think that up to 64K, it's acceptable. :-)

The Commodore Max beats that.