World: r3wp

That was ment just as example of how one small thing can make life 
much easier.....

Well, I used rebol to make lookup table data for my asm code :)

I guess its something like that? making code from data ? sort of....

when you know enough REBOL, you can flip a problem in any angle to 
your advantage. here it was advantageous to keep two separate parts 
strictly in sync.

got it.... :)

yes, like state tables. I use that too. :-)

actually, I added some doc descriptions to the dialect, so I could 
have autogenerated docs from the dialect too.

So what I got from this small discussion (in no particullar order)::
1. Create gui, create data, add supporting code...
2. Create rebol code with rebol...
3. Create a dialect or two (or more :)) specific to the task...

4. Create small code files and put them together using preprocessor...
5. Figure out a "reasonable" way to do it :)

I guess this is one of the freedoms you have, when no IDE is bogging 
you down or telling you how to do things. :-)

:) I already started writing self modifying code :) at least I think 
thats what it is... :)

Its working :) I guess this is cool.... Made a function in a separate 
file that calculates sum. But with a press on a button, I rewrote 
part of that  file with function that multiplies two numbers instead 
of adding... And from that point on its multiply that you get...
It has a lot of potential but have to find good use for it.... :)
Thanks guys, Im of to sleep, its been a long day.....

What I have found working with asynchronous functions that return 
data from database calls ... one should create some type of gui at 
the start of the call, and then replace that in the callback.

What I initially did was only create the GUI on completion of the 
call which was fine when testing on the LAN, but as soon as you got 
internet latencies ... it was not so good.

Does anyone know of a way to have a rebol script continue to execute 
even after it recieves an error?


I have a script VERSION-TESTER, that will gather code examples and 
create another script VT-SCRIPT that will test them all out against 
the newest version of R3 alpha.


VT-SCRIPT is extremely simple, capturing all console results into 
an ECHO file, but I need a way to have the script continue even when 
it finds an error.
Any ideas?  See this simple example:

Rebol [script: %VT-Script.r   will verify R3 documented examples]
echo  %VT-Results.txt
print {Results below generated from %VT-Script.r}
print {---------------------------------------TIME examples			}
print {var: now														}
       var: now
print {print var													}
       print var
print {7-Apr-2009/11:53:26-6:00             	<-- same?			}
print {}
print {---------------------------------------WRITE examples		}
print {write %junkme.txt "This is a junk file."						}
       write %junkme.txt "This is a junk file."
print {print read %junkme.txt										}
       print read %junkme.txt
print {This is a junk file.                 	<-- same?			}
print {}
print {write/binary %data compress "this is compressed data"		}
       write/binary %data compress "this is compressed data"
print {print decompress read %data									}
print {this is compressed data              	<-- same?			}
print {}
print {---------------------------------------PROTECT examples		}
print {test: "text"													}
       test: "text"
print {protect test													}
       protect test
print {append test "a"												}

print {** Script error: protected value or series - cannot modify	}
print {** Where: append												}
print {** Near: append test "a"										}
print {}
print {** Note: use WHY? for more about this error					}
print {}
print {----------------------------------------OTHER examples		}
print {unset [var]													}
       unset [var]
print {print var													}
       print var
print {** Script error: var has no value    	<-- same?			}
print {}
print {** Note: use WHY? for more about this error					}
print {}
print {---------------------------------------TEST COMPLETED		}

print {See results stored in %VT-Results.txt file}
echo off

How does ERROR work?  What does the kernal actually do when it encounters 
an error?

I see that errors condition can be trapped with commands such as 
TRY, DISARM, ATTEMPT, but is there a way I can capture the printed 
results of an error without the error causing my script to stop running?

I think you can't, unless you settle for printing the error object. 
That's possible. The console error messages themselves can't be reached, 
I think.

Hi Henrik

It is just fine that the console error messages print whatever they 
print, but I want some way of having my script continue depsite the 
error message encountered.

Is there a way to have REBOL invoke a separate independent console 
that it could do its own commands in.  Then, I could simply submit 
one rebol command per session, and capture the results in the ECHO 
file regardless of wheter the command errored out or not.  

Could that work?

it should be enough to:

probe disarm error

I added that at the head of my VT-SCRIPT, but it didn't work

** Script error: error has no value

sorry, I thought you had a result to test.

I've been reading up a little on generating errors at http://rebol.com/r3/docs/concepts/errors-generating.html
one line in particular captured my attention:


The error message generated for my-error can be printed without stopping 
the script:

disarmed: disarm err
print bind (get disarmed/id) (in disarmed 'id)
this doesn't go into that using my-function

-- Not sure if this has any legs for me?

if you want to generally test the entire script, the only way is 
to wrap it in a TRY or the elements you run in a TRY. REBOL will 
stop evaluating a block if it encounters an error in it.

Yes, but there must be ways to trap an error without stopping the 
script.

Or are you saying that another function such as TRY will "insulate" 
the error from causing my script to stop running?

'err in that example means you have evaluated a block and the result 
is returned to 'err. you can then test if 'err contains a good result 
or an error like so:

if error? err [
	print "oops"
]

or more useful:

if error? err [probe disarm err]

that's the only way. the only way to simply keep going is to wrap 
small bits of code in TRY and that's not good style.

trying to understand -- :-/  (still a newbie!!!)

OK, lets take a simple example that I know errors out
UNSET [x]
print x

x is undefined and has no value

so how would I change the PRINT X in such a way to capture an error 
withotu stopping the script?

But, if the command succeeds without error, I want to get the results 
of that as well

unset [x]
set/any 'err try [print x]
if error? err [
	probe disarm err
]

and you may continue after that if err is not an error.

giving it a try!

but... it all depends on what the ultimate goal of trapping the errors 
is. if the code was written properly, you'd do this:

unset [x]
unless value? 'x [
	print "X has no value"
]

Yes, you are correct,  The purpose of THIS script is to test and 
verify the R3 documents and see if the results printed on the website 
is the same as the results you get (for r3alpha)

So, I want to capture the error message as it would appear -- even 
though I know it will stop the script.  I just hoped there was a 
way of having R3 print the error message as it normally would, but 
then have R3 continue to run the script instead of stopping it.  


For example, if I knew that R3 was using the HALT command, then I 
could temprarily redefine the HALT command to an empty block and 
R3 should continue to run, but I am just spouting this off the top 
of my head -- I don't know how R3 "stops" the script.

Henrik,  Your suggestion did achomplish the task of trapping an error 
when it happened so it is better than nothing -- see resutls:

Rebol []
echo  %VT-Results.txt
print {Results below generated from %VT-Script.r}
          print {unset [x]}
                 unset [x]
           print {print x}

set/any 'err try [print x] if error? err [ disarm err print "** error"]
print ""
           print {print x}

set/any 'err try [print x] if error? err [ disarm err print "** error"]
print ""
print {See results stored in %VT-Results.txt file}
echo off
halt

will generate:

Results below generated from %VT-Script.r
unset [x]
print x
print x
See results stored in %VT-Results.txt file

oops, wrong cut and paste -- here is the revised results:

Results below generated from %VT-Script.r
unset [x]
print x
** error

print x
** error

See results stored in %VT-Results.txt file

If only there was a way to "capture" the specific error message at 
the time of disarm err, and print those results 
Could that be done?

of course.. just do:
 probe disarm err

I'm ussing:
attempt: func [value][
    either error? set/any 'value try :value [
        print parse-error disarm value none
    ] [get/any 'value]
]
parse-error: func [
    error [object!]
    /local type id arg1 arg2 arg3 wh
][
    type: error/type
    id: error/id
    wh: mold get/any in error 'where
    either any [
        unset? get/any in error 'arg1
        unset? get/any in error 'arg2
        unset? get/any in error 'arg3
    ] [
        arg1: arg2: arg3: "(missing value)"
    ] [
        arg1: error/arg1
        arg2: error/arg2
        arg3: error/arg3
    ]

    rejoin ["** " system/error/:type/type ": " reduce either block? system/error/:type/:id 
    [
            bind to-block system/error/:type/:id 'arg1
        ] [
            form system/error/:type/:id
        ]
        newline

        reform ["** Where: " wh newline "** Near: " mold error/near newline]
    ]
]

Now when I see the code (which is probably not mine), the handling 
of args is not correct as any missing arg will now set all of them 
as "(missing value)". But at least you can have an idea, how to work 
with the disarmed error!

Anyway, I use modified append to be able see if there is an error 
somewhere (where is unexpected) without stoping the execution. If 
I know, that somewhere can be an error, then I use just simple  error? 
try []

*append = attempt

Thanks Oldes, I'll play with it!

Wrap your tests in a block, then you can do at least in R2
until [ 
	either error? set/any 'err try [
		t:  do/next tests
	] [
		print disarm err
		tests: next tests
	] [
		tests: second t
	]
	empty? tests
]
 
Unfortunately it does not work with R3. .(

There you have to wrap every statement in a block  inside the main 
block.
Then you can do them one  by one.

if I have rebol object  R2 >>


A: make object [ add: func [ ] [ .... ]   remove: func [ ] [ ....... 
]  parse-rule: [ ..... ] ]
B: make A [ change: func [ ] [ .... ] ]

<< 

and if I make 100 objects like B from A ... does this mean each of 
them has it's own "add remove parse-rules" copy in memory or there 
is just one copy of these functions/blocks that they share it?

it seems it makes copies

I believe you are correct. There is no separate "prototype" in Rebol.