World: r3wp

except if the local vars are all set in the primary one too

the code is an handler so it could be everything

y

I'm looking in lfulc code by ladislav, the parse rule to catch the 
set-words is quite simple

lfunc

you could write your handler in a context directly, it's the most 
simple thing to do

it's in a context

but the words used are still global, no ?

not those which are scoped directly by the context

ctx: context [
a: 1
block-code: [a: a + 1]
]

a is defined local to the context ctx

I'm not sure if this can apply to my app. It's a web server so I 
have to mantain client values between session

the context is unset after single request

and ??? it's not related with your previous request

If I change the code as:

ctx: context [
saveobj/a: 1
block-code: [saveobj/a: saveobj/a + 1]
] 

I can retain the counter between web session

you lost your context, because you don't keep him  in memory (i don't 
know how to answer to this problem)

saveobj is not in your context

ctx: context [
localobj: saveobj
localobj/a: 1
block-code: [localobj/a: localobj/a + 1]
]

this should work...

yes ! saveobj is global, so I can use it for saving values that are 
in my context . In my context values will be lost. I'm writing a 
function to change every var in my handler like "var" to "saveobj/var"

i don't see y

i don't see your point... ctx is global too... you shoul'd not lose 
it

Yes, I'm not too clear .... I unset the handler block every request 
I get

so If I need to keep the values of the hadler I need to store them 
in a global ojb

i think you have several problems not not necessarily linked, you 
should have a look on rebol.org, there are many web servers examples

sorry...

Wow another webserver.  Does REBOL have the record in webservers?

thanks ! only talking about this cleared my mind, I'm thinking about 
keeping the handler in memory

That is really cool Davide.

surely ;-)

thanks paul, this is not a standard web server... it's a comet web 
server (where the browser use an endless connection)

ok, very cool.

I'm building it to use a browser instead of view in multiuser app
The page don't need to be refreshed so It's quite fast

You won't be able to remove fields from an object in R3, just add 
them.

C still has the record in webservers :(

Davide: Can't you do this?

>> my-object: make object! [a: 0 b: [1 2 3 4 5] c: "abcde"]

>> insert my-object/b 0                                   
 
== [1 2 3 4 5]

>> my-object/a: 1
== 1

>> probe my-object

make object! [
    a: 1
    b: [0 1 2 3 4 5]
    c: "abcde"
]

>> my-object: make my-object [d: #0123]

>> probe my-object

 make object! [
    a: 1
    b: [0 1 2 3 4 5]
    c: "abcde"
    d: 
 #0123
]

thanks peter that sintax is very handy ! I didn't remember that

Now I can ask a more precise question:

here is my problem:
I have an application object app that "serve" two client c1, c2

app: make object! [
	hset: func [c] [k: c/name]
	hget: func [c] [print ["k=" k]]
]

c1: make object! [
	name: "pippo"
]

c2: make object! [
	name: "pluto"
]


The handlers of app, use k as internal container, but of course it's 
shared between clients:

>> app/hset c1
== "pippo"
>> app/hset c2
== "pluto"
>> app/hget c1
k= pluto   


I would bind k (and every set-word in the handler) to the object 
passed as parameter so the last line would produce:

>> app/hget c1
k= pippo

Now I come to this solution, using blocks instead of funcs in app

app: make object! [
	hset: [k: name]
	hget: [print ["k=" k]]
]

c1: make object! [
	name: "pippo"
	vars: make object! [
		k: none
	]
]

c2: make object! [
	name: "pluto"
	vars: make object! [
		k: none
	]
]

This produce:

>>  do bind bind app/hset c1/vars c1
== "pippo"
>> do bind bind app/hset c2/vars c2
== "pluto"
>> do bind bind app/hget c1/vars c1
k= pippo


This works, but I have to collect every set-words used in the handler, 
into the clients (using Ladislav set-words http://www.fm.tul.cz/~ladislav/rebol/set-words.r
)


sw: copy [] repeat h next first app [sw: union sw set-words app/:h]

b: copy [] repeat w sw [insert tail b reduce [to set-word! w none]] 
vars: make object! head b
c1/vars: vars
c2/vars: vars


Now, my questions are:
1) Is this approch "rebolish" ? There's a smarter way to do it ?
2) If I need a function in my app like:

app: make object! [
	hset: [k: avg a b]
	hget: [print ["k=" k]]
	avg: func [x y] [aux: x + y aux: aux / 2]
]


How can I collect the aux: word in avg function, and bind this function 
to c1/vars ?

Well I can bind avg to c1 with: 


app/avg: func first get in app 'avg bind bind second get in app 'avg 
c1/vars c1


Still hold the first question: there is a better approach ? If we 
suppose the app object is large, with hundreds of clients, would 
be better, for example, copy the entire app obj in every client, 
so I can execute the code without bind ?

I don't seem to understand what you're trying to do... why isn't 
hget defined as func [c] [print c/name] ?

k: c/name and print ["k=" k] are only one (stupid) example that use 
a word k that I want to keep distinct between client.. Every client 
need its instances of words.

again, why don't you define K and aux localy to your object ?
app: make object! [
	k: aux: none
	hset: does [k: avg a b]
	hget: does [print ["k=" k]]
	avg: func [x y] [aux: x + y aux: aux / 2]
]

If I define aux locally it is shared to every client:

app: make object! [
	aux: none
	hset: [avg a b]
	hget: [print ["avg=" aux]]
	avg: func [x y] [aux: x + y aux: aux / 2]
]

c1: make object! [
	a: 2
	b: 4
]

c2: make object! [
	a: 3
	b: 5
]

>> do bind app/hset c1
== 3
>> do bind app/hget c1
avg= 3
>> do bind app/hset c2
== 4
>> do bind app/hget c1
avg= 4 <<< error this shoud be 3 !

erf, app should use your object as parameter instead of using unbound 
vars:
app: make object! [
	hset: func [obj][avg obj/a obj/b]
	hget: func [obj][print ["avg=" obj/aux]]
	avg: func [obj x y] [obj/aux: x + y obj/aux: obj/aux / 2]
]
c1: make object! [
	a: 2
	b: 4
	aux: none
]
...

>>app/hset c1
==3
>>app/hget c1
==3
>>app/hset c2
==4
>>app/hget c1
==3

hset: func [obj][avg obj obj/a obj/b]

ok, "aux" need to be defined in every client, this is the key to 
 ensure correct results.

About function vs blocks: don't you think that using binded blocks, 
instead of functions, the code would be simplier ? 

Using functions is very "javascript style", but it looks not very 
natural to me in rebol.

Has anyone created any code that is used to ensure a series doesn't 
contain function that when reduced produce harmful code?

for example something that could prevent the execution of a block 
suchas [delete %somefile] when reduced.

I have produced some code to do this but curious if others have as 
well.  Seems it could be useful.

It would be useful.....Here's a previous discussion that looks at 
various related issues:
http://www.rebol.org/ml-display-thread.r?m=rmlDMBC

That is somewhat simliar but that sounds like you were interested 
in executing any script code in a sandbox.  What I'm doing is allowing 
all other values to be reduced except allowed functions and natives.

I think Maxim mentioned that he had done a lot of work when he sandboxed 
Elixir.  I didn't study enough of the magic Elixir to know how he 
pulled it off, but if it's Max, it's good and ahead of it's time.