World: r4wp

Sorry to change topic from the current issues (pun intended), but 
I wanted to say thanks to Doc and Kaj for the information about graphics 
on Red/System on Linux running on ARM!  Where could I download the 
GTK.reds file?

Sorry if the answer is obvious and I just missed reading it somewhere.

http://www.red-lang.org/p/contributions_20.html

You also need the Red-GLib and Red-common repositories which aren't 
listed there

Where would I find those?

In the same place, using the same name pattern

About reflection, will there be a compile option to turn it off, 
for commercial code that should stay closed?


What I planned so far is a compile option to switch between different 
modes of bundling the functions/routines source code into the final 
executable. Main options are: 

- in form of native "build instructions" (the current behavior)
- in form of compressed text


The latter option will generate smaller executables, but will be 
slow down boot time a little, as it will require the interpreter 
to process it. The former option provides a high level of obfuscation, 
that requires a lot of work to decompile (cracking REBOL's SDK protection 
is probably an easier job).

interpreter => tokenizer

Hm, I guess interpreted functions make it hard to leave out the source 
in some form. That would be another argument for being able to designate 
it per function

Actually, every statically defined Red function will get compiled, 
only functions created at runtime will be passed to the interprerter 
(or JIT-compiled).

Yes, but the source is still included for reflection, isn't it? That 
could be removed

So the "interpreted functions" do not exists at compile-time nor 
in the executable in source form, as their are created at runtime.

they

what about function argument, like in Rebol? I mean, those catch 
etc. arguments?

I thought the source is added as extra for body-of?

We could remove the body block of compiled function! values, yes, 
so it doesn't get added to the executable. That could be an optional 
switch that would also disable undefine 'body-of accessor.

Yes, that's exactly what I mean

Pekr: I don't understand your question, could you be more specific?

Doc - Kaj wants some option to trigger functions being complied in 
various ways. I just said, that maybe it can be done on per function 
basis, using special parameters ...

my-func: func [[dynamic] a [integer!]][]

Yes, I was also thinking in that direction

The problem might be, that it has to be decided during compile time, 
so the source code would have to be analyzed. Otoh it might be the 
right place (instead of preprocessor) to fit in, along with catch, 
throw ....

You can still define it at runtime in such case, instead of statically 
define it. No need to add another attribute.

Functions created at runtime will always retain their body block.

You will be able to achieve that using different approaches:

1) Using DO: do [foo: func [...][...]]

2) Indirectly specifying the spec and/or body block: 

    body: [...]
    foo: func [...] body

This will result in 'foo function been created at runtime (then JIT-compiled 
or interpreted on each call).

Kaj: you should add your syntax proposition for keyword! + issue! 
to github tracker as a wish, so we don't forget about it.

If we don't find any big drawback, I think I will implement it.

OK, thanks

Added routines invocation support to interpreter.

Congratulations: the rhythm of changes in Red is just fast!

I scripted a little command that I run from time to time, just to 
see how both Rebol3 and Red are going:
cd ~/dev/Red/ && git pull && cd && cd dev/r3/ && git pull

And I can see through gitk that the rythm of Red's work is just amazing. 
Courage!

Merci Pierre ! :-)

De rien, merci à toi!

I cannot really find a startup guide for Red: so, if no one shouts, 
I'll try to write one, during my long hours of flight next week.

That would be good

ok, then!

Pierre, have you scrolled down throw this page: https://github.com/dockimbel/Red
?

through

Let me know if there are missing information there.

I had read another version of these instructions; it looks like it 
was reworked a bit.

Yes it was, the Red/System README was merged in Red's one.

I looked into the docs subdirectory, ran
rebol makedoc2.r 

It made red-system-quick-test.html, but then I got my eyes sore with 
the black background, so I wanted the light version, clicked and 
... oops:

Firefox ne peut trouver le fichier à l'adresse /home/pierre/heaume_pierre/developpt/Red/docs/$LIGHT$.

I found a reference to $LIGHT$ at the bottom of red-system-quick-test.txt 
, in what looks like a rebol script below a make-doc document.

REBOL []

do/args %makedoc2.r 'load-only
doc: scan-doc read file: system/options/script
set [title out] gen-html/options doc [(options)]

file: last split-path file
replace file ".txt" ".html"
file2: copy file
insert find file2 "." "-light"
replace out "$DARK$"  file
replace out "$LIGHT$" file2

write file out
replace out "dark.css" "light.css"
write file2 out

Makedoc format allows the addition of REBOL code at the end. The 
proper way to generate the doc files is to CD to the folder, then 
run REBOL on %red-system-quick-test.txt

ok

BTW, you can find these documentations already generated online here: 
http://www.red-lang.org/p/documentation.html

Isn't it a bit dark?...

It's to save power ... fewer photons emitted

What? The site or the docs?

;-) the site emits too few photons

to my taste...