World: r3wp

what about kind of protect/with 'value 'key ?

you cannot protect mutable values, even if you protect the words. 
Is that an answer to your question?

yes .... I thought so, but then I thought maybe there will be some 
way of how to do it :-)

only one - make a value you don't want to be changed immutable. The 
problem is, that REBOL does not have immutable strings, blocks, functions 
or objects.

what about extending secure scheme? to allow e.g. pre-boot, post-boot 
changes etc.? hmm, not sure it has a solution in my particular case, 
e.g. that I would like to hae system/locale translated, but then 
blocked against the changes ...

just thinking loud, sorry if nonsenses :-)

the only solution to your problem is to make your values immutable. 
The trouble is, that REBOL does not have immutable datatypes you 
might need

ok, thanks ...

but that would not solve my case, if RT would do system/locale immutable, 
then I would not be able to change it. I though about protection 
by some kind of key, e.g., but dunno if it might work. at first change 
the key would be provided, for unprotect, the key would be needed 
...

Ladislav - one more - can you imagine subinterpreter? e.g. you have 
kind of rebol interpreter master server in your school, then you 
have students, global context gets cloned for them and all they do 
they can do like in normal rebol, just that their scripts are executed 
in subcontext :-) hmm, maybe it would be easier to launch new interpreter 
for them anyway ... :-)

:-) On the other hand, this is a question of philosophy. RT did not 
forbid you to change the data, because they felt you may have a good 
reason to do so. Your "philosophy" is opposite - you think, that 
your users may not have a good reason to change the data.

I just came to the request by simply thinking about localisation 
and how it can be missued. E.g. "do you want your file to be deleted?" 
could be replaced by "Do you want to keep your file?" :-)

Right you are, the above is possible in English too and it may be 
considered a safety problem in some circumstances as I pointed out 
quite long ago.

post-webserver: Cals %webserv.r with

read-cgi: func [/local data len] [
    either system/options/cgi/request-method = "POST" [

        set-modes system/ports/input [lines: false binary: true no-wait: 
        false]
        len: to-integer system/options/cgi/content-length
        data: to-string copy/part system/ports/input len
    ] [
        data: system/options/cgi/query-string
    ]
    data
 ]

http://www.rebol.org/cgi-bin/cgiwrap/rebol/view-script.r?script=webserv.r

I patched it a bit to be more verbose: http://www.rebol.org/cgi-bin/cgiwrap/rebol/view-script.r?script=volkswebserv.r

But that one has bugs after a few calls. Don't know about webserv.r 
itself, i guess it is more stable.

protecting system/locale: if user cant run code, user cant change 
it. if user can run code, he does not need to change those strings.

(my volkswebserv.r is for debugging, to show errors and such in console. 
So i can live with that instability.

if REBOL 3 is going to support modules, then it will provide the 
kind of security requested by Petr.

well, I believe that rebol 3 will actually support modules, as it 
will be kind of main product release, which can afford new ideas 
here or there and new incompatibilities here or there, if done for 
good. The only question is of course the timing - Rebol 3 in two 
years? :-)

Any one interested in getting this ?

>> printf ["%10.2E %s" to decimal! 1000 "dinar"]
  1.00E+03 dinar
>> sprintf ["%10.2E %s" to decimal! 1000 "dinar"]
== "  1.00E+03 dinar"

It is an actual wrap of the C printf routines.

Lots of people have asked for a printf in the past.

Here it is consider it why-wire's team new years gift. team: [cyphre 
ladislav jaime]

Rebol []

comment [
	; example usage:
	kernel: load/library %kernel32.dll

 routine-call kernel "MulDiv" [int] [3 [integer!] 2 [integer!] 1 [integer!]] 
 ; == 6
]

routine-call: func [
	library [library!]
	routine-name [string!]
	return-spec [block!]
	arguments [block!] 

 /typed {Arguments is block structure is: [argument-value [datatype] 
 ...]}
	/local routine spec call argument type typed-rule
] [
	spec: make block! length? arguments
	call: make block! (length? arguments) / 2 + 1
	insert call [return routine]
	typed-rule: copy []
	if typed [typed-rule: [set type skip]]
	parse reduce arguments [
		any [
			set argument skip
			typed-rule
			(
				insert/only tail spec 'argument
				insert/only tail spec either typed [
					type
				][
					reduce [type?/word get/any 'argument]
				]
				insert/only tail call get/any 'argument
			)
		]
	]
	insert tail spec [return:]
	insert/only tail spec return-spec
	routine: make routine! spec library routine-name
	do call
]

use [libc zero-char as-rebol-string malloc][
	libc: load/library %/usr/lib/libc.dylib ; osx variable

	zero-char: #"^@"

	as-rebol-string: func [
		[catch]
		s [string!] 
		/local pos
	][

  unless pos: find s zero-char [throw make error! "s is not a c-string"]
		s: head remove/part pos tail s
		replace/all s "\n" newline
		replace/all s "\t" tab
	]
	
	malloc: func [
        size [integer!] "size in bytes"
    ][
        head insert/dup copy {} zero-char size
    ]

	sprintf: func [
		spec {block structure is: [format values ...]}
		/local s
	][
		s: malloc 4096
		insert/only head spec 's
		routine-call libc "sprintf" [int] spec
		as-rebol-string s
	]
	
	printf: func [
		spec {block structure is: [format values ...]}
	][
		print sprintf spec
	]
]

You need to change the location of your libc. The code above is hard 
coded for OSX.

Now is possible to pretty print things with short code ;-)


>> repeat i 3 [printf reduce ["%2d-station%s" i either i > 1 ["s"][""]]] 
 1-station
 2-stations
 3-stations

1) (paranoid): how do you handle buffer-overruns?

2) I could make a little script which takes the format string and 
explains it. If you get this into rebol :)

1) Buffer overruns seem to be protected by the GC. I try over run 
a very small buffer and I was uncessful.

2) That will be nice.

The work above was mostly ladislave on the call-routine and the rest 
is mine. I will probably post it to rebol.org after a few changes 
and additions to make it work in all platforms. Maybe Carl will like 
to include it by default in rebol.

set object none ; sets all the members of an object to none

set object [ "first" ] ; sets the first member of the object to "first"


how to set another member of the object only knowing the name of 
the member ?
Is there a quick way?

no matter.

; Try this
object/member: value
; or this
set in object 'member value

thanks .. set in object 'member value is what I was looking for .

Yeah, IN can speed things up a bit when repeatedly accessing the 
same member of a object, saving on lookup time. It can be used to 
provide object field access in rebcode by calling it with apply too. 
Useful function.

Jaime - we have request for printf or similar functionality on ml 
- maybe you could help the newbie?

Pekr. I don't understand what you want here? Do you want me to post 
the printf code to the ML?

yes, there is conicidentally newbie's post asking for some formatting 
functions ... there is some discussion already, Ladislav participated 
too ....

Aha. I have not being in the ML for ages.

:-) do you suffer "altme syndrome"? :-)

I think so.  Besides some how the ML software kick-me out in one 
of the upgrades, so I didn't bother to register again.

Does anyone know when rebol will support unicode?

Interesting... I thought percent! would be a legal datatype in REBOL, 
since we have so many other common types. Wonder why it's left out?

Extensive discussion on the merits and demerits of percent! here:

http://www.rebol.org/cgi-bin/cgiwrap/rebol/ml-display-thread.r?m=rmlZXTJ

amazing, it seems I even responded to that thread :-)

That's probably why you thought there was a percent! datatype!

but what we need is custom datatypes

graham, the fact that it isn't there, kinda ruins my idea for implementing 
percent based widths in LIST-VIEW so that it's easy to discern between 
integers and percentages such as [50% 30%]. That's not so easy now, 
unless I do it the hokey way and use issue! or some other type to 
describe percent.