World: r3wp

Shadwolf: "in rebol a: SMD2Header and b: SMD2Header will point to 
the same memory chunk ..."


yes, but you should do it as follows: a: make struct! SMD2Header 
b: make struct! SMD2Header

in rebol you will need to load 3 files to declare SDM2Header_f1 SMD2Header_f3 
and SMD2Header_f3 with for both the stricly identical content tso 
your recoding 3 times or X times the same thing ...

I'm not an expert on struct! far of that (wel in C yes but in REBOL 
no and I think it's because I'm not using load/library capability 
until now) but that's a good discution to point to difficulties on 
this kind of task and I hope help rebol Core to have a bettre handling 
of that

ladyslav on declaration statement REBOL need me to give him the datas 
I ust tryed what you just propose:

>> a: make struct! SMD2Header
** Script Error: Invalid argument: (missing value)
** Near: a: make struct! SMD2Header

a: make struct! SMD2Header none ; or [some values here]

if you supply none, you generate an "empty" struct

shadwolf: have you read this? http://www.rebol.com/docs/library.html

yes so I had to read the file first then make my variable content 
basing me on a precut of the rode datas from file to be allowed to 
fill my variable content on inititialisation

you can create an empty struct using NONE and fill it using the read 
data

yes I read it cyphre long time ago when it was recently published 
but one thing that's apear to me dangerous is for example use:

a-struct: make struct! [
        in-string [string!] "Input string"
        in-int [integer!] "Input integer"
    ] ["This is input" 42]

what is dangerous on that?

while in C my struct is struct a-struct { char in-string[25]; int 
in-int; }

how can I be certain using string! unlimited REBOL countainer to 
correctly feet with the char 25 strictly sized contained in C

no contained but countainer

the dangerous thing is that with rebal I can over pass easly the 
25 limitation and write every where in the countigous memeryy area 
;)

If I understand you well you have tu create string! of length 25 
in rebol for your purpose.

that's not a direct use for me I intent thru thi discution to enlight 
some problems that every one can infront using rebol external library 
capability

or reusing C/C++/VB binary struct based data type (like MD2 file 
format)

It is on you to not override the length of the string IMO You have 
to deal with this as you are working with static  memory so it is 
not a problem of Rebol itself. I think you ca easily write 'dangerous' 
code when dealing with DLL interfaces ;) Making error in this are 
usually ends up with crash (memory acces violation).

yes I know that ;)

maybe that IS a good point to make it harder to crash at the interface. 
 The toughest code to write is always the in-between stuff.

the main purpose I purchase is to enhance and simplify the rebol 
interaction with external lib and C/C++/VB structure binary file 
based

and that's why I can here to expose the difficulties I see on that 
issue and try with you to get infos or solutions to propose to Carl

so what is your solution? Do you know how to improve the interface?

It takes a guru level REBOLer who is also profishant in C to write 
an interface to a DLL, although there are becoming more and simple 
examples...but maybe shadwolf wants to make it a graphical process?

not that far .... lol

an ez-dll.r which takes in a .h and a .dll and lets you play, experiment, 
and try to controll any .dll might be a fun project.

Cyphre not at all and that's why I came here first to expose the 
problems then to seek solutions with you

I have written a research proposal grant for such a tool...

Interfacing with lower-level naguages (such as C) from Rebol looks 
a bit harder but when you gain more experience with it (=no crashes 
anymore ;)) you realize it works logically. I was also dissapointed 
for the firt time I tried to use some DLL. But now I'm more optimistic. 
The only think I miss is the callback handling.

grant proposal (ah, was writing backwards in French)

eFishAnt your right !!! in a C# ressource explorer motion (wich you 
can see in Shardevolp IDE for example ) could be an amazing thing 
and even more if the same code all you to do so on evry OS rebol 
stands in

Cyphre - you should let Carl know that you want callback handling. 
 I know several of us have wanted that.

Josh wrote a simple hello example .dll a while back, including how 
to write the .dll...I started to mention this to him, but we talk 
about lots of things...so not done yet...guess I can tell him to 
read this.

I mentioned this to Carl few times but you know... ;-)

ah, you must have made him think then of REBOL Platform ... ;-)

If I take Cal Dixon's libopengl.r software for example we clearly 
notice that it only use the multi float functions in opengl and not 
the vectorial float functions that leads me to think  glColor3fv( 
my_colors[ 0.3, 0.5, 0.0 ]) kind of function are un explotable as 
is in rebol and many are the external libray that deal with array 
of data for arguments instead of fractionnal multi datas

I used succesfully such arrays of floats as argument in my interface 
to AGG...this is no problem IMO

Cyphre do you have documentation on AGG anywhere?

cyphre how do you do it ?

it's curiosity not evilness ...

Paul: the docs aren't still for public..due to alpha state. When 
we reach beta the information in the docs will be 'stable' enough 
so all people could write code which syntax don't change.

Excellent at least there exist some docs :)

Shadwolf: let me show you some example...

oki

to-double-array: func [blk /no-header /local result][
	result: make binary! []
	if not no-header [

  insert tail result third make struct! [d [double]] reduce [length? 
  blk]
	]
	foreach dbl blk [
		insert tail result third make struct! [d [double]] reduce [dbl]
	]
	result
]


pass-doubles: make routine! [
	doubles [binary!]
	return: [int]
] some-lib "PassDoubles"

my-doubles: to-double-array [10.5 2.8 3.0 2.325]


pass-doubles my-doubles

---------------------------

on your C side:

extern "C"
MYDLL_API int GradientPen(unsigned char* doubles)
{
	<your code here>
	return 1;
}

this way you can pass a block of decimal!s to C side

note: the first value is the length of the array if you don't use 
the /no-header refinement