World: r3wp

Happens to me all the time......:-(

Robert: the following approach is better:

a-function: func [] [return make error! "problem"]

error? a-function ; == true

or: error? the-error: a-function

etc.

I want to create a little spreadsheet application where users have 
access to the mathematical functions in rebol and nothing else.

Is there some way to constrain 'do to work within a specific context 
of some mathematical functions, and nothing else?

Or, do I have to write a little mini parser ?

There's a little parser here http://www.rebol.com/docs/core23/rebolcore-15.html

you don't have to write a parser. The approach using my SAFE-EVAL 
function may be faster:

safe-eval: func [
	stm-block [block!]
	/local stm
] [
	stm: make block! (length? stm-block) * 2 + 1
	insert stm first stm-block
	while [stm-block: next stm-block not tail? stm-block] [
		insert tail stm :first
		insert/only tail stm stm-block
	]
	first do/next stm
]

(before using SAFE-EVAL you should test the first element of the 
STM-BLOCK to find out whether it is one of the functions you are 
willing to evaluate)

so, use example?

Do I have to check each value in the block for safety?

error? try [safe-eval [square-root print "gotcha!"]] ; == true

...check each value in the block for safety?
 - no

just the first one

Ok, I'm going to use this example first : 0.56 * sqrt(tender28) + 
0.28 * sqrt(swollen28) + 0.70 * ln(ESR) + 0.014 * GH

turn that into Rebol first ... and then only check the first value?

it looks, like you want to use any expression, not just function 
evaluation?

yes ..

then it is not for you, this was just for a function evaluation

Ok, so looks like it will have to be a parser

yes

but it would be nice to be able to use the rebol parser do evaluate 
words within a mathematical context only

when using a parser, you can even use operator precedence rules and 
such

A non parse based solution ( ie. parse = too hard! )

eval-math: func [ exp [string!]
	/local t allowed okay
][
	allowed: [ + - / square-root log-e * ]
	t: to block! exp
	bind t '+
	okay: true
	allowed: [ + - / square-root log-e * ]
	foreach e t [
		switch/default type?/word e [
			paren! [ eval-math form e ]
			word! [ if not find allowed e [ okay: false break ]]
			decimal! []
			integer! []
		][ okay: false break ]
	]
	either okay [
		do t
	][ none ]
]

Hmm.  Needs debugging

eval-math: func [ exp [string!]
	/local t allowed
][
	allowed: [ + - / square-root log-e * ]
	t: to block! exp
	bind t '+
	foreach e t [
		switch/default type?/word e [
			paren! [ if none? eval-math form e [ return none ]	]
			word! [ 
				if not find allowed e [ 
					print [ "not allowed is : " e ]
					return none
				]
			]
			decimal! []
			integer! []
		][ return none ]
	]
	do t
]

How does one access the parts of a function?

eg; func [face /local var][print face/text] 
how do I get to the [print face/text ] part?

second func [face /local var] [print face/text] ; == [print face/text]

oh?  and third is the locals ?

I was thinking it should be after third and not before :(

first is the simplified spec, third is the complete spec

ah ...

third was added later than first and second IIRC

What was pekr talking about regarding alpha r3 core release?

Do you know?

no

too much beer?

fiction writer, maybe

porkies ?

Seems I have enough clues now to write my little spreadsheet :)

Graham - it was a joke. And I thought as maybe ppl would not understand, 
if I would post it in Announce group, I posted it rather in Humour 
group :-)

graham: why are you using to-block there? (my assumption is that 
you wanted to avoid the binding of load, but then you manually bind 
to the global context, so you can just use load)

a different approach is to create a context with only the words you 
want to allow, then use to-block, then bind it to your context only, 
then do it.

yes, the transformation to string and to block back and forth looks 
a bit messy

in-shadow-context: use first system/words['some-word]

then bind to 'some-word. somewhat  expensive, but you do it only 
on input. 

Escapes: it  does not go into #[object![..]]. I have  a function 
which does  that too.  ifthe user can do a  stringwith a new word, 
that  word is still global.