World: r3wp

Again, I don't care much what it is (although I wouldn't expect ALLOCATE 
to return a c-string!), just that the definitions are compatible, 
so you don't have to insert confusing typecasts everywhere

I'm just following what you have written in the manual about pointers

the definitions are compatible
: which ones?

NULL, byte-ptr! and the manual use three type incompatible definitions. 
I must compare and pass these types

NULL and documentation will be fixed during this weekend.

So will they be compatible with byte-ptr! thereafter?

NULL should work with any kind of pointer/struct or be removed.

I haven't decided yet on the right solution, but you can safely use 
ALLOCATE as it is defined right now, that won't be changed.

Not really, because casts are needed on every use of ALLOCATE and 
FREE

That would be the case whatever type you would put in the return 
definition of ALLOCATE?

As you can allocate memory space for various datatypes.

No, because there's one exception: the type that ALLOCATE and FREE 
choose to use

You've lost me...what type are you talking about?

They currently use c-string! I'm not sure that's the clearest one. 
It's unintuitive to me, as if the type returned is very specific 
and comes with a zero byte at the end

That is why I have not put c-string! but byte-ptr!.

I know, but that gets lost during compilation. What the compiler 
complains about is that you have to cast to and from c-string!

Do I really need to add a new [pointer! [byte!]] to the compiler 
just to make this error message looks nicer?

(I mean adding a new datatype in the compiler).

I think that would be very useful, but that's the more fundamental 
pointer discussion. I'm now just concerned about making casts the 
least confusing

I pretty sure that some ppl would complain that [pointer! [byte!]] 
is exactly the same as c-string!...;-)

I don't get what is the issue with casting (expect the error message)?

Sure, but I mean, we had two definitions of a generic pointer: integer! 
or pointer! [integer!]. Why confuse it with c-string! now?

expect => except

Well, I have already answered that question above. I am sorry if 
that change breaks existing code. Once again, the C void pointer 
is a very confusing concept that should not be used outside of C 
language. If you refer to a C void pointer without any context, it 
is just a memory address, so integer! (or handle!) would be the closest 
corresponding concept. If you refer to a C function returning a void 
pointer like malloc(), the closest transposition in Red/System would 
be ALLOCATE returning a byte! pointer.

Malloc() allocates a memory region that granularity is by default 
a byte (until you cast is to something else).

So, in summary, there is no 1 to 1 transposition of the C void pointer 
concept in Red/System, it is 1 to 2 (or more), depending on the context.

If you would write a C function such as: 

void *bar() { return((void *)&foo);)


where foo would be another function. If I had to make a binding to 
this function from Red, I would use integer! (or preferably the handle! 
macro) to define the return value.

Six months ago, I wanted to introduce an address! type to be the 
equivalent of C void pointer. It would have worked as an integer!. 
But as it would have been only used to in C binding definitions, 
I thought it would be a waste to have a first-class datatype just 
for that, when integer!, pointer! [...], or a macro could do the 
same job.

If [pointer! [byte!]] could do the job and make C coders happy, I 
will add it to Red/System.

I'm not concerned with all that here. Let me make this very concrete. 
In runtime/common.reds, changing

#define byte-ptr!	c-string!

to

#define byte-ptr!	pointer [integer!]

Would solve all my current concerns

Well, this is certainly not the right definition a byte! pointer. 
:-) Can't you wait until monday when all the current issues regarding 
NULL and documentation will be fixed?

We have been aware that pointer [integer!] does not accurately describe 
a pointer [byte!] but you don't want to implement that in the current 
development cycle and that's fair enough. It's only a cosmetic problem 
right now

Originally I though binary! was going to fulfill this role, but it 
was removed

Will the NULL enhancement change the types handled by ALLOCATE and 
FREE to one generic pointer definition? Let's stop calling it void, 
but instead variant, which it really is

Binary!: you're right, that was an option I considered at the beginning. 
But I thought that it would be even more confusing for REBOL coders.

It felt very natural to me

We're in a morass now ;-)

Think about ppl that would have complained about LENGTH? not working 
on binary! type. ;-)

No, that would not change the types of ALLOCATE and FREE, I would 
only change them to pointer! [byte!] when it will be available.

There is no generic pointer in Red/System.

Even if binary! was there, it would work as a byte! pointer.

I thought so, so ALLOCATE and FREE will still deliver types that 
I wouldn't expect from them, and that effectively introduce an extra 
definition of a variant pointer

The LENGTH? example is interesting, because people will now use it 
on an allocated binary, expecting that it's zero-terminated, and 
even if it is, the expected length will be off by one

Or much more if there's a zero somewhere in the middle

You're extrapolating from the error message. The definition says 
"byte-ptr!" not "c-string!".

Yes, that's a fundamental problem with a preprocessor