World: r3wp

Right. And language-specific and library-specific on any given platform. 
That is why it needs to have a good way to specify it.

wouldn't the arithmetic, just use the padding as part of the size?

That's why C compilers have pragmas for padding.

C is the target here.

For C and a given platform (and a given compiler, for some weird 
corner cases), default alignment/padding behaviour is specified.

Right. And since that changes from platform to platform and compiler 
to compiler we need a way to match those differences, with declarations 
or options or pragmas, same as the C compilers do.

The important issue is that the defaults match, if we want to have 
any.

Otherwise we can just drop the whole attempt at easier integration 
with C and go with a much more sensible storage layout dialect (think 
e.g. Erlang bitstrings).

Another important issue is that the defaults be settable on a per-platform 
or per-app basis, and that the behavior of Red/System is explicitly 
defined in a cross-platform way. We don't want to repeat the mistakes 
of C just because we're interfacing with C.

A lot of the stuff we have to integrate with will have C interfaces, 
but those interfaces will have struct layouts in them that were declared 
with precision for binary compatibility, using the pragmas and stuff 
that C was retrofitted with to allow such precision. We need those 
kinds of abilities from the beginning, or we'll have to retrofit 
it on later just like C did.

We'll probably still want to cater to the vast majority of C interfaces 
which just uses platform/compiler defaults.

Plus, struct references will be used to convert data to and from 
binary data read from files and network protocols, and those also 
need precise definitions.

I'd use a different and far more powerful dialect for that.

Right, we need settable defaults that can match the local C standard 
or whatever it is that sets the standard locally (JNI perhaps).

But if you don't have a way to specify the padding and maybe alignment, 
you won't be able to interface with C code that sets that stuff too.

One dialect for conveniently interfacing with C ("structs"), a different 
dialect ("records"?) for 100% precise control over bit layouts. Plus 
a way to convert between the two.

The former quite possibly replicating some C quirks, probably a few 
of the most important ones, as needed.

C structs are what I'm talking about, particularly ones declared 
with the pragmas. The quirks can go in the settable defaults, including 
things like the size of certain datatypes that have ill-specified 
types in the C standard.

You are a little spoiled on Unix-like platforms, Andreas. On Windows 
there is no standard C compiler; there are a bunch of competing ones 
instead. Each has its own quirks and defaults. Since Red is not itself 
written in C, you can't just go with the quirks of the same compiler 
it is written in. And different libraries are compiled by different 
people with different compilers. If you want to interface with them, 
you have to be specific.

I'm unfortunately more aware of this than I would like to be :)

It's worse for me usually, since most of the libraries I need to 
interface with are written in languages other than C (C++, Delphi, 
.NET, Java), or have to match precise binary interoperability standards 
(COM, etc.). Simple C compatibility would not work for me at all, 
and this has also been the case with R2's library interface. Fortunately 
the database access has made my SDK license worth it :)

Thanks guys for the insights and propositions. I found it a bit difficult 
to follow in realtime, I'm not sure that AltME is the best tool for 
such conversations. Maybe we should give a try to the Red web forum 
next time: http://groups.google.com/group/red-lang?

Nenad , how would reading something in a forum be better than reading 
it here?

Different mode of communication. Less "real-time", more asynchronism.

Well, usually, you have more time to read and reply on a web forum 
before the post you're referring to, gets lost in the flow of new 
ones.

AltME is nice, but sometimes, when users are posting too fast on 
deep topics, I have a hard time following the conversation. My english 
is not that good, so I have to check for some words exact spelling 
or meaning when reading/posting. Also, I like to take time to think 
about things before saying them, especially when the topic is deep/complex. 
The old REBOL ML was great for that. That's why I was proposing moving 
such conversations to Google groups, which is just a web front-end 
to a ML.

With mailing-lists, you can have a threaded view of conversations 
in your email client, so you can easily follow replies to differents 
posts. I usually have no issues following replies on AltME except 
when several users are talking together and posting replies fast, 
it becomes hard to follow in realtime.

I miss the ML as well...

I guess that in AltME, if we could have a way to "mark" the post 
we're replying to when required, and the ability to switch to a "threaded" 
view, that would help a lot. In such "threaded" view, related posts 
could be grouped together with a [+] button somewhere allowing to 
unfold it and see all the replies to a given post. If posting while 
a thread is unfolded, the post would be considered a reply without 
having to "mark" the post related to the reply.

yep

+1 Doc.

move it to groups and make it visible to the outside world

Ok, I've got new error - "Bus error"

Error message is shorter than the previous one, I guess it is a good 
sign. ;-)

Yes, I agree :)

If you need some external eyes to look at your code or test it (I 
can test on OS X), you can "gist" it  (https://gist.github.com/) 
and put the link here. I, Andreas, or someone else could have a look 
at it.

I'd guess a bus error is an invalid address

rebolek, I thought bus errors were seg faults?

Yes, I think so

cause, I never get seg faults, always bus errors :-)

I know how to get both :)

Doc, I will do some cleanup and put it there.

segfault is caused by kernel and bus error by memory

User space?

Or at the hardware level?

hardware

Ah, that makes sense

https://gist.github.com/896960

(using .r2 and .r3 extension would give proper code colorisation 
at github)

Thanks Oldes!