World: r3wp

Btw. in World, natives are being called functions too (it's easier 
for the user to understand, I think). You can distinguish them with 
PICK, as the second item is an integer. Examples:

w> type? pick :add 2
== integer!			; so ADD is a native function
w> type? pick :loop 2
== block!			; so LOOP is a mezzanine function

If LOOP becomes a native, we can just move it in the dictionary. 
I try to create as few natives as possible to keep World simple, 
but my need for good performance too might lead to a few mezzanines 
becoming natives.

World is awesome John, I'm in.

+

Don't use the old R2-style reflectors, like that pick 2 in your example 
above. Any support at all for that kind of reflection makes it harder 
to secure code. Use the R3-style reflectors.

+1 Brian, though we can write mezz wrappers using the PICK interface. 
Is there a reason they need to be native?

The important thing is to *not* use PICK for this, to use a different 
function instead. If you use PICK, it will make it more difficult 
for PICK to be useful in secure code that should have limited or 
no access to the reflectors. It slows down PICK too. That is why 
R3 uses REFLECT instead.

I'm pretty sure, it doesn't slow down PICK, but I need to make test 
to be absolutely sure.

R3 uses mezz wrappers around REFLECT, so mezz wrappers aren't the 
problem. The problem is having it be possible to use PICK for reflection. 
Consider what would be invloved in turning off reflection but keeping 
PICK working for non-reflection uses.

Or we could consider a more practical situation directly related 
to World: If you can compile blocks, it would make sense to use the 
reflection facilities to get access to metadata about the compiled 
blocks (especially since that would be something that you might want 
to secure, or since functions would need similar reflectors), but 
PICK already has a defined meaning for blocks.

New release at https://github.com/Geomol/World

- Added datatype, struct!
- Ctrl-A at the prompt toggle auto-brackets
- Ctrl-D at the prompt quits World
- Fixed networking like: open tcp://8080

This is first release with struct!, so not all features are there, 
and it needs further testing.

Struct can be made in different ways:

	make struct! [[float f] none]
	make struct! [[f float] [1.0]]		; var name before type

And there is a STRUCT helper func:

	struct [float f] none

I'll write something about it in cortex_alpha.pdf

Example of using struct! in routine definition:

	my-routine: make routine! [
		library "routine" [
			[struct!] pointer
		]
	]

A real example under OS X:

timeval: make struct! [[
	slong sec
	sint32 usec
] none]

timezone: make struct! [[
	sint minuteswest
	sint dsttime
] none]

gettimeofday: make routine! [
	[typecheck]
	libc "gettimeofday" [
		tp [struct!] pointer
		tzp [struct!] pointer
	]
	sint
]

w> gettimeofday timeval timezone
== 0
w> timeval/sec
== 1323951188
w> timeval/usec
== 314011
w> timezone/minuteswest
== -60
w> timezone/dsttime    
== 0

In the above example, libc is defined as:

libc: load/library %/usr/lib/libc.dylib

Hi, I am interested into building an maintaining documentation for 
those programming languages based on REBOL.
It would be nice to have a DOCBASE for them.
What I search is:
- Someone ABLE to SETUP the Linux and the Wiki Software
- Someone which would share with me the cost of hosting.
Do you like the idea ?
Write me at [giuseppe-:-chillemi-:-eu]

There seem to be a problem with routines returning a handle. A library 
like MagickWand (part of ImageMagick) works this way. I'm not able 
to test it with MagickWand, as I'm not able to load that library 
for different reasons, and I don't wanna use too much time on it.


So I'm after another library, that has a routine, which returns a 
handle, so I can test. A library easily to get for OS X, Linux and 
Windows would be nice. Any suggestions?

I was able to load MagickWand under Linux, and it seems to work with 
uint32 datatypes to hold the handle (a C pointer). But it doens't 
work so well when using the handle! datatype for that. It would be 
nice, if it worked, I guess. It's probably some type casting problem.

actually, any library which returns a string could use a handle! 
as a return value instead.    the handle could be used to store the 
reference to the string as-is and give it to another routine which 
requires a string on input.

Yes, I'll check that out.

New release at https://github.com/Geomol/World

- Added native function: TRY
- Added set-path! notation to set values in structs (POKE)
- Added support for: to string! handle
- Added context: system/words
- Added helper function: ROUTINE
- Added mold support for routines (SOURCE)
- Added debugging function: ??
- Bugfixes

Fast work John!

Yeah, I'm in a productive period.

Does TRY have an /except option?

Geomol, what would happen if you evaluate something like

    try [return 1]

World is free to use and can be found at https://github.com/Geomol/World

Why don't you try those things out yourselves? I would like to comment, 
but I feel, you get most from it by trying it.

For minimum install, just pick one of the world_* files and cortex.w

To get a binary, click it, then click raw.

Ladislav, if you did try and mean having that code inside a function, 
then there was a bug, which will be fixed in next release.

w> c: context [a: 1 print a print (a)]
1
** Script error: a has no value
** Near: print (a)

Good one, thanks!

About bit operations, I looked at SHIFT. R2 got it at some point, 
but there is no ROTATE. Wouldn't that be useful too? I think about 
graphics operations and maybe other areas.

yes ROTATE is handy to have native when you need it.   its the kind 
of function which will be much slower to build manually than having 
it native (or hand optimised by the language author ;-)

copying from an opened, but not connected tcp port crashes world-lang,

Don't do that! ;)

I need to find a balance with World for how much should be tested 
for. I'm after good performance.

if you open and connect and the peer closes, this happens too

ok, that's a good argument to do something about it. Thanks!

New release at https://github.com/Geomol/World

- Reimplemented bitset! as binary
- Added native function: COMPLEMENT
- Added native function: ROTATE
- Added native function: SHIFT
- Added << and >> operators to cortex.w
- Added hex form for characters, ^(00) - ^(FF)
- Added REFORM to rebol.w
- Added DETAB to rebol.w
- Added ENTAB to rebol.w
- New test
- Bugfixes

About copying from a port, I get a zero, if the port is closed, but 
just under OS X and Linux. Windows version seems to hang in that 
situation. Networking code is open source, and you're welcome to 
suggest changes. I consider using a lib for networking instead of 
coding it all by hand.

SHIFT and ROTATE can only operate on 64-bit integers for now. We 
have to see, if operating on binary! and maybe other datatypes is 
needed.

at the moment i am just in holiday and have only limited access and 
not the infrastructure i am used too. maybe when i am back, i will 
have a look at the code.

Suggestion:


Some routines return a pointer to a structure, like LOCALTIME (from 
LIBC). The structure is struct tm and consists of 11 fields.


In World, we can define LOCALTIME to return a pointer to a handle!, 
but how should we get to all the data fields?


I suggest, TO should be used to copy data from a handle to a structure, 
like:

tm: struct [
	sint sec
	sint min
	sint hour
	sint mday
	...
] none

h: localtime time	; time is some variable holding seconds
to tm h	; This will copy the data (pointed to by h) to tm

Comments? Concerns?

As I understand localtime is not thread safe, the thread safe version 
locatime_r requires the address of a tm structure as an argument. 
(Though it returns the pointer to that same structure if the call 
is succesful.


In general, isn't it a better option for strucutures to be allocated 
in World rather than the called function?

Yes, it's probably a better idea to use routines, where you can allocate 
the structure in World, and handle the routine a pointer to it. But 
some routines does the other thing. In the case of localtime, it's 
a static buffer. Some routines in some libraries dynamic allocate 
memory, that the user can deallocate again with other routines. (Oldes 
pointed me to such a case in ImageMagick.)


If World should support calling such routines and be able to operate 
on the result, we need something like my suggestion, I think.