World: r3wp

This seems to be working, but is this the best solution?
	REBSER* block = RL_MAKE_BLOCK(2);
	RXIARG val;
	RXV_DEC64(val) = mean;
	RL_SET_VALUE(block, 0, val, RXT_DECIMAL);
	RXV_DEC64(val) = standard_deviation;
	RL_SET_VALUE(block, 1, val, RXT_DECIMAL);
	RXA_TYPE(frm, 1) = RXT_BLOCK;
	RXA_SERIES(frm, 1) = block;

I have MP3 playing from R3 console using FMOD extension... at this 
moment just a very first test:) Must go sleep unfortunately.

really cool.

I started using Code::Blocks and now I get error:
	invalid conversion from 'const char*' to 'REBYTE*'
for code:
	RL->print("init\n");
Which was fine with GCC. Any idea why?

Also I see such a warnings:

 ..\src\include\reb-config.h|109|warning: ignoring #pragma warning 
 |

A110?

yes

Windows? Linux?

Windows

I've got it... the file was .cpp instead of .c

(the warning is still there, but I can print again)

Do you know, if it's (or will be) possible to get struct! from handle!?

Or to return struct! from the C side?

Passing around heap-allocated structs should work right now.

Ah, struct!, sorry, I misread.

..because I somehow miss what is struct useful for in R3 without 
routines.

I think struct! is just a datatype for future use. Not used at the 
moment.

yes, struct! is 'reserved' for now. It may be even removed later.

What if I expect float on the C side, but still want to allow to 
use integer from REBOL (using number!).. what's the best way to do 
it?

Maybe a wrapper interface function in the init block?

That's possible, but I was more thinking how to do it on the C side 
and not end with wrapper for each extension command.

Yeah, more elegant, but more work

How about defining the command with `command [arg [integer! decimal!]]` 
and then detecting in C when you where passed an int and converting 
it to a float?

Yes.. but how? Remember, I'm still C newbie:)

and the command can be just  [number!]

Then you'll have to handle percent! as well :)

oh.. right.. but that could be fine in some cases.. like volume.

also decimal! and percent! are both as RXA_DEC64

In the extension examples in the docs are examples of detecting multiple 
types

I guess I can use RXA_TYPE(f,n) to get the value type, but hot to 
convert the integer to decimal?

I don't think it's very easy to get at the REBOL conversion functions

float value = (float)RXA_DEC64(frm, 1);
if (RXA_TYPE(frm, 1) == RXT_INTEGER)
  value = (float)RXA_INT64(frm, 1);
}

thanks, that looks good

In fact, this is not really necessary, as both integer and decimal 
values are stored in a union anyway. But if you want to rely on as 
little implementation internals as possible, that's probably the 
way to go.

And your compile will quite possibly optimise the redundancy away 
for you behind your back :)

compiler*

I was trying to do just  (float)RXA_DEC64(frm, 1) with integer value 
and it was not working.

Do you think it's better to export all commands in flat structure 
like:
	export System_GetNumDrivers: command[]
	export System_GetDriverInfo: command[id [integer!]]
	...
Or rather close them to contexts like:
	export system: context [
		GetNumDrivers: command[]
		GetDriverInfo: command[id [integer!]]
		...
	]

Depends on the purpose of the module

It depends on the situation, and how the commands are supposed to 
be used. In that case above, don't export 'system.

I think that was just an example :-)

Direct word access is faster than path access, but some words are 
logically grouped (like enums).

You mean the name?

Yes :)

At this moment I have a flat structure, but problem is, that there 
is so much exported commands that I tender to froup them... I know 
it's slower, but how many times one need to know driver name like 
in the commands used in the example above?

For instance, in the AGG wrapper the commands that are used to implement 
the Draw dialect are exported in their own context rathar than globally, 
because they aren't meant to be called directly as functions. Other 
APIs may need to do the same thing for similar reasons.

In a lot of cases you want to make commands at the marshaling boundary, 
and make REBOL wrapper code that you export. REBOL code can encapsuate 
a lot of functionality, whether you are doing so in an object type, 
a scheme or a dialect.

Back to the name..  what if I export System extension context into 
main context, where is already System defined? Now it looks it just 
silently do not overwrites the existing one.. shouldn't it throw 
an error?

If you are just exporting the native API then make the extension's 
module private rather than public, and just import the extension 
into the module that provides a simple REBOL-like public API for 
others to use.

The current build doesn't have most of the security protections implemented. 
We want to fix the *many* protection bugs first.