World: r4wp

An ALIAS is handy for such cases

If I run this code

s: declare struct! [
	f [float!]
]
s/f: 12345678.9
p: as byte-ptr! s
v: p/value
w: 256 * as integer! p/value
x: 256 * as integer! v
print [x ".." w]

I get  this result: 52480..4194304


Why the difference? Shouldn't W and X be same as V is same as P/VALUE?

Leaving for the heavy metal festival. Hopefully on my return on monday, 
there will be some refreshed news towards when Red development will 
resume :-)

Leaving for the heavy metal festival.

 - It's good to see people celebrating parts of the periodic table 
 of elements. Oh, maybe it means something else... :-)

Why the difference? Shouldn't W and X be same as V is same as P/VALUE? 
  I checekd that v = p/value so it would appear to be the type casting 
that is the problem. I checekd the spec and casting a byte! to and 
integer! should be okay. So it seems like it is a bug.

When will they put beer on the periodic table of elements? Hopefully 
after Red is finished?

f: func [
	val	[integer!]
	return:	[struct! [value [integer!]]]
	/local s
][
	s: declare struct! [value [integer!]]
	s/value: val
	s
]

s1: f 1
print ["s1/value:" s1/value lf]
s2: f 10
print ["s1/value:" s1/value lf]

; --- outputs:

C:\code\Red\red-system\builds>test
s1/value:1
s1/value:10


After setting S2 value, S1 is changed. Why? Is it a bug?

Looks like it. Odd

I don't think it's a bug. s is a local (static) variable in function 
'f. f returns a reference to s. So if you change the contants of 
s/value, all references to s will now refer to its new value.

I added prints of s1 and s2 to your program; this is the output :

s1 9348
s2 9348

So how I can return new struct! each time?

Only by declaring the struct! in your main program and passing it 
(its reference) as an arugment:

f: func [
	val [integer!]
	s [struct! [value [integer!]]]
][
	s/value: val
]

Well that's the only way that I've found so far.

Once the Red memory manager is available it may well be possible 
to use it to allocate struct! in a function but then there is the 
problem of how to release the memory later.


From a memory mangement point of view, it seems easiest not to allocate 
variables inside functions to be returned to the calling program/function.

ok, thanks

Oh right, the pointer is returned from the function, not the value

There's no problem in allocating memory to return from a function, 
but you have to use ALLOCATE and later FREE it

Ok, so this version does what I expected :)

f: func [
	val	[integer!]
	return:	[struct! [value [integer!]]]
	/local s
][
	s: declare struct! [value [integer!]]
	t: allocate size? s
	s/value: val
	t: copy-memory t as byte-ptr! s size? s
	as struct! [value [integer!]] t
]

s1: f 1
print ["s1/value:" s1/value lf]	; == 1
s2: f 10
print ["s1/value:" s1/value lf]	; == 1

You don't have to declare an intermediate struct and copy it

t: as struct! [value [integer!]] allocate size? s

t/value: val

t

You should check the allocation for being a null pointer, though

how that can happen?

If you don't get the memory from the operating system

The form-* functions in the C library binding do pretty much that:

http://red.esperconsultancy.nl/Red-C-library/artifact/a1a55e070454c421657185b1d9d09f480d6c5587

Another question :) Is there any easy way to convert integer! to 
float! ? I wrote something for float! to integer!, but with integer! 
to float! I'm bit lost.

Another question :) Is there any easy way to convert integer! to 
float! ? I wrote something for float! to integer!, but with integer! 
to float! I'm bit lost.
 - see http://www.fm.tul.cz/~ladislav/rebol/library-utils.r

The approach is as follows:
1) convert integer to double (=decimal!)
2) convert double to float

aha, sorry, this is a Red group...

yes, I'm looking for Red/System solution.

Why does this code throw *** Runtime Error 11: float stack check 
?

i: 0
f: 0.0
p: declare pointer! [float!]
arr: allocate 100

while [i < 10][
	p: as pointer! [float!] arr + (i * 8)
	p/value: f
	f: f + 0.1
	i: i + 1
]

Sounds like a bug, although the program is overly complex

i: 0
f: 0.0
arr: as pointer! [float!] allocate 10 * size? float!

while [i < 10][
	p/i/value: f
	f: f + 0.1
	i: i + 1
]

That should work, and be more secure

arr/i/value: f

Oh, with path notation, you need to adjust the loop to start counting 
the index from 1

I'm still discovering how Red/System works :)

If your original program keeps erroring out, please enter it in the 
bug tracker

Kaj, your code throws compilation error invalid struct member i in: 
arr/i/value

Ah, it's actually even simpler :-)

i: 1
f: 0.0
arr: as pointer! [float!] allocate 10 * size? float!

while [i <= 10] [
	arr/i: f
	f: f + 0.1
	i: i + 1
]

In Linux, on your original code, I get:

*** Runtime Error 9: float invalid operation
*** at: 08048397h

With your latest version I get *** Runtime Error 11: float stack 
check (on windows).

Better enter both in the bug tracker, then

Rebolek: yes, add them to the bugtracker, I will fix them this weekend.

That's great, thanks!

Just an update, I just tried latest Kaj's code on Ubuntu under VirtualBox 
and I get *** Runtime Error 9: float invalid operation