World: r3wp

Well, sure, the speed may not be the most important property.

Copying a cyclic block:

>> blk: [a b c]
== [a b c]
>> insert/only blk blk
== [a b c]
>> blk
== [[...] a b c]
>> copy blk
== [[[...] a b c] a b c]

That's not correct, right?

Ah, it is. I just realized, when I wrote it. :)

One question to library wrapping. I have a function, which should 
return a bool from C level, according to if the communication card 
is open, or not. When I am able to open the card, it returns 1 (mapped 
to R2 integer!), if not, it returns  30605312 - does that integer 
make any sence? I mean, does it e.g. translate to some C level slot, 
overflow, or -1 value? Just curious ...

w> to binary! 30605312 
== #{0000000001D30000}

Maybe you read too many bits?

I can't influence it, it is just result from the mapped function 
 C level code bool (dunno how it is defined) to R2's integer! value. 
Was just curious ....

Pekr, bool in C is usually of char type so you should try to set 
the returned value in your routine! spec to char.

Cyphre: thanks, will try that ...

Isn't it usually integer? It's must be defined somewhere btw.

In win.h include file in LCC compiler;
typedef int BOOL;
typedef unsigned char BOOLEAN;

BOOL != bool.

bool is in C since C99, and it's, in fact, *drumroll* a typedef/#define 
for _Bool

(before C99, there's simply no standard boolean type available in 
C)

Yep, WG14/N869 January 18, 1999 Page 257
#define bool _Bool

There are some other definitions in different include files:

typedef  enum _BoolValue {True=1, False=0, BoolValue_Max=2147483647L 
} BoolValue;
typedef int bool;  //lowercase
typedef unsigned char boolean;

typedef enum { false, true } bool;  // this is for Borland C I guess

BOOL != bool

 - this is strange, I never found any note mentioning other datatype 
 than int for bool. While Pekr may be experiencing bool to be defined 
 as something smaller, all the documentation I found mentions it should 
 be int.

The C standard is (as always) very vague and doesn't specify a particular 
storage size. I think it just defines that _Bool must be able to 
hold 0 and 1.

So when encountering a "bool", one really has to ask what kind of 
bool that is. More often than not, it won't be a C99 _Bool and will 
actually be int-sized.

If it is a C99 _Bool, it will typically be char-sized, though.

And I think Pekr really has a different case, because he's trying 
to use a C++ lib. C++ really has a bool, and I think it's char-sized 
(but I don't know whether that's impl-specific in C++ or defined 
in the C++ standard).

If it is a C99 _Bool, it will typically be char-sized, though.
 - hmm, I found explicitly stated that it should be int

The same for C++

I guess that other sizes are atypical and not exactly respecting 
the standard

when it is int it could be 64bit or 32bit.. depend on the compiler 
and the OS. 

Pekr: So may be the C library returns a 64bit integer: #{0000000001D30000} 
= #{00000000 - 01D30000}, the left part is 0 (=false) the second 
part is just a number from stack.. 
When you get in from R2 it become #{01D30000} = 30605312

Or it's a 16 bit return, and the machine, it's from, is little endian, 
where World is big endian. Then it's the last 4 zeros in the result, 
that is the bool.

That could be too.

Lad, In C I tried:
#include <stdbool.h>
int main (int argc, const char * argv[]) {
    printf ("bool length %d\n", sizeof(bool));
    return 0;
}

The output was:
bool length 1

So it is usually char, at least in GNU C/C++

I haven't found any explicit type definition in the C99 though.

{"If it is a C99 _Bool, it will typically be char-sized, though." 
-- hmm, I found explicitly stated that it should be int}

Where?

A slightly better test would be:

#include <stdio.h>

int main(int argc, char *argv[]) {printf("%ld\n", sizeof(_Bool)); 
return 0;}


And then compile that in C99 mode (i.e. -std=c99 for GCC; but C89/90 
compilers will bark on the unknown _Bool keyword anyway).


Better, because there exist(ed) a few stdbool.h versions prior to 
the final C99 standard which used e.g. unsigned integers for bools. 
Should be gone/fixed by now, but one never knows :)

Under OS X using gcc, I get bool length 1 both with Cyphre and Andreas 
versions, and also with or without -std=c99 option.

Yes, I also used the C99 compiler flag. Andreas version is more correct 
test ofcourse.