AltME groups: search

Giuseppe, those are called properties. The getter/setter functions 
you often find in GUIs are basically the same thing, but properties 
hide that in regular assignment syntax. We don't need getter properties 
in REBOL-like languages because we don't use parentheses to call 
functions, but setter functions appearing to be assignment statements 
might appeal to some.


I've had a lot of experience with properties in languages like Delphi; 
most of the popular languages that currently have property support, 
either in syntax or as a convention, are derived from Delphi. It 
makes code a little easier to write, and a lot harder to debug. The 
main advantage to implementing them in Red or R3 would be to make 
it easier to interoperate with .NET or COM objects.


Automatic delegation is something else. With automatic delegation, 
you automatically forward a method call from one object to another, 
just by declaring it as such. That doesn't really work in REBOL-style 
direct-bound functions because we don't have an implicit self parameter 
(we have self, but it's not a parameter). Red would need to have 
a completely different function binding model for that kind of thing 
to work; which it would likely have anyways, due to it being compiled 
rather than interpreted.

Thanks, I will debug that tonight.

I could live without that feature for Red compiler, but it will help 
it be cleaner and easier to debug. Currently, I'm using prefixes 
to mark contexts for variables and function calls in Red compiler 
output code, I hope to be able to remove them and use contexts instead 
once I merge this new branch.

Yes, that would require to add a lot of new code to existing features 
and would take probably several days to code and debug regressions. 
If we could avoid it, that would be nice.

going to lunch, willing to debug, if I can get any instructions ....

Doc, will it be necessary or possible to have a debug version of 
Red with deep level of integration with debugging tools as well as 
a non-debug version with higher performance, or is this something 
that can be turned on/off in the same runtime?

Depend on what you mean by "debug version" and what debugging tools 
you're thinking about. My plan for Red is to deeply integrate it 
with the IDE, so that you'll be able to have advanced debugging capabilities, 
like step-by-step debugging. Such feature could maybe also be ported 
to the console version, so you'll be able to use it even without 
the IDE installed.


Also, I have thought the Red execution architecture to be as reflective 
as possible in order to try to support memory image loading/saving 
and stopping/resuming (think Smalltalk). It's very tricky (not sure 
we'll have it in the end), but if we can achieve it, you'll be able 
to get a snapshot of a running Red program on file, transfer it and 
resume it somewhere else....ideal for reproducing exact bugs occuring 
conditions. EDIT: the right expression for that is "Image-based persistence".


In the meantime, we already have some "debug mode": -d switch for 
Red and -g switch for Red/System (we'll probably adopt -d for both, 
-g will be reserved for gdb support). It's mainly intended for internal 
usage for now, the Red/System one can be useful to locate runtime 
errors in source code (usable, but still needs some fixes though).

It's probably a CALL issue, we had similar issues a year ago, and 
it was CALL-related IIRC. I and Peter need to install a Win8 system 
to be able to debug that.

Ladislav, I fully agree. I don't think that "0 points backwards" 
is particularly elegant either, but I'm willing to explain it ("0 
points to the element before 1") and find it much better than having 
to explain when and why you have to very careful with computing indices, 
or even debug (R2) code that was written unaware of this fact.

In REBOL, 'a and 'A are aliases of the same symbol. Red/System converts 
them to their integer identifier, right?


Symbols have two representations in Red compiler, one is at runtime 
(like in REBOL), the other is a compile-time, in the form of Red/System 
variables. In a very early version of the compiler, I was using integers 
(indexes in symbol table) instead of variables, but quickly realizef 
that it was obfuscating the generated Red/System code a lot, making 
it difficult to debug. Also, the integer approach had an additional 
runtime cost at it required to make an array access in order to retrieve 
the symbol value.


Currently, the Red/System ~<name> variables directly point to a word! 
value version, instead of a symbol! for simplicity and efficiency.

@ Doc : Will the interpreter have included (some time in the future) 
some of the debug features planned for R3 (Hooks, stack ops, etc...) 
? That would be nice but it's just my wish list ;-)

Hi Doc: Here is about the above Debug Hook mention. It is drawn from 
http://www.rebol.net/r3blogs/0011.html.Don't miss some interesting 
comments from the 16 then  posted.

Gerard: thanks for the links. It is too early for debug hooks, when 
Red IDE will be there, it will be completly integrated with Red, 
so those debug hooks as a public interface will probably be unnecessary.

State of Red's PARSE: 


It's not on the roadmap because it's too low-level for the bird view 
(maybe I need to add it anyway?). Moreover, PARSE is not (for now) 
useful for the internal construction of Red/System and Red, so from 
that perspective, it's quite low-priority.


OTOH, it is quite simple to implement in Red/System, and users could 
see that as a sign of good progress, so I probably need to schedule 
it for a weekend to implement a R2-level PARSE (with a couple of 
features from R3's PARSE) and a few more days to test and debug it.


Also, Gabriele is interested in implementing a "compiled" PARSE version 
for Red, but unfortunately, Red has not yet all the features that 
Gab needs for it (mainly object! support). So, he's waiting on me 
to get Red ready first.


As currently, object! support is much more important to implement 
(for completing the context/binding model of Red and enabling ports) 
than PARSE, you might get Gab's version first. Also if it's fast 
enough, I wouldn't need to make a Red/System version then.


Last but not least, I don't agree with 100% of the changes/addition 
in PARSE for R3, so I would need to review R3 parse and make a "cleaned-up" 
version for Red. Also, Topaz has some interesting improvements on 
PARSE what I might want to include in Red's version too, so that 
needs a bit of preliminary review work.


So, as you can see, it's hard to give you a precise timeframe, I 
guess we would have a first version of it during Q2 2013.

It's hard to debug in the interpreter because it doesn't warn for 
undefined values. Would that be much work to implement?

Doc, will we have anything like R3 environment stuff - e.g. delayed 
loading/bootstraping, some debug stuff, being able to trace memory, 
time of running app, etc?

Have you compiled the console in debug mode? (-d option)

Java: "write once, debug everywhere" ;-)

I use a Linux/ARM image running on QEMU to help me debug the low-level 
parts of Android port (which is a really hostile environment for 
low-level coding).

@Arnold and Pekr : What is the current behaviour of the Hello.apk 
? I thought it was displaying some welcome msg and then askin for 
some input before disappearing gracefully. Now on my machine a while 
screen is displayed with a "Hello" as its window name and nothing 
else is going on.... For the previous Red/System Hello, something 
almost similar was going on too. So it's not for the Red part fault 
but it is due to the lower layer ... I knew this but I can't diagnose 
what ios coming myself as I'm missing some vital knowlwdge here to 
be really helpful to debug anything ... on my own - sorry for having 
acquired some product in the first pioneers just to test how this 
kind of product was running on Android. I required some Flash and 
my Apple products just could'nt do it - but my tablet Android tablet 
was much slower on display than my iDevices. Hope that under Red 
and Red/System there will be some products running at full speed 
- if not I plan to let it go at a real bargain price very soon ... 
to get some more powerful device ASAP.

I can specify Release or Debug. I used the Debug up till now.
loop 1000 times Red/System script 
real	0m18.446s
user	0m18.385s
sys	0m0.023s
Then I have 
real	0m2.424s
user	0m2.405s
sys	0m0.006s

My C is not what is used to be. No doubechecked should do same loop. 
Well if this is the case there is some improvement ahead.

Thanks for the compliment Doc, not really sure what you mean exactly 
by making it more like Red/System and less C: use more descriptive 
names? I will take a closer look at some ed/System examples out there.

Thanks Kaj for finding those and for the tips, the size of MM makes 
it the same in effect in this case, but it has to be <= then. Program 
not crashing, I was lucky then! off-by-one errors? My index goes 
from 1 up, where in C it is from 0 up, I had to debug this to make 
sure elements were swapped in the same way as in the original program. 
That is also why I declare KKP and LLP to as to save from adding 
1 to KK and LL over and over again. 


Knuth's algorythm was the first one I found, and I knew already of 
its existence, so it made sense to use what you have. Sure my Red/System 
code is not optimised.


Going to work on it now and tomorrow, and later I take on the Twister. 
It is a good exercise!

The only reasons I can think of for that issue are:
1) Not enough internal memory available for new apps.
2) You have a debug version of the same app already installed.

The difference is that the new one is supposed to work. :-) Have 
you uninstalled the previous one? (It was most probably a "debug" 
version you had while the new one is a "release" version, this is 
one of the cases where the installer would block the new app installation)

Okay, AdrianS install problem is solved (debug vs release version 
signature conflict). So, so far, no reported issues with the new 
Red APK! :-)

I tried the until [no], but the console window just flashes up and 
disappears really quickly.  I'm assuming that's because it is erroring 
out.  Is there any document on how to debug this type of thing?

I have this bit of Red/System code that I wrote, but for some reason, 
it just closes the console window.  So I don't know if there is an 
error, and if there was, how would I debug it?

#include %../C-library/ANSI.reds

img1: as-binary 0
size1: 0
img2: as-binary 0
size2: 0

img1: read-file-binary "img1.bin" :size1

print-line img1
print-line size1

print-line as integer! img1/1

img2: read-file-binary "img2.bin" :size2

print-line img2
print-line size2

img3: as-binary size1

i: 0
until [
	i: i + 1
	img3/i: img2/i - img1/i
	i = size1
]

write-file-binary "img3.bin" img3 size1

until [no]

Bo, it seems you're starting Red/System programs by clicking on them? 
If that's the case, it's not the best way to debug such programs. 
You need to open a DOS window and launch the programs from there. 
The window will never close, so you'll be able to see all the messages 
and avoid doing infinite loops at the end of your code.

Red/System []

#import ["ntoskrnl.exe" stdcall [

 log-error: "DbgPrint" [				"Print formatted message to debug log."
		[variadic]
		; format		[c-string!]
		;	value		[variant!]
		;	...
	]
]]

on-load: function ["DriverEntry"
	DriverObject	[driver-object!]
	RegistryPath 	[byte-ptr!]
	return:			[integer!]
][
	log-error "Hello Red/System from Windows kernel driver!"
	0
]

Early results were that PE format is less complex than ELF, but if 
you count in debug extensions, it's the other way around

Well, MS not wanting people to debug their software explains a lot

With Red, you'll be able to debug your programs on the other platforms, 
before running them on Windows

Bo: The issue I had to fight with in my hotel room was just that 
my own prebol replacement lib was adding  an extra layer of MOLDing 
to the input source, because of the workarounds to avoid the #include 
(and others) directive collisions. This resulted in disabling some 
parts of the code leading to  odd runtime errors. I couldn't focus 
enough on it to see it that night because I was too exhausted and 
wanted to listen to the discussion at the same time. :-) (For others: 
my room was a kind of meeting point in the hotel ;-)).


To debug that, I reproduced the preprocessing changes step by step 
in a console until I located the "disabled" parts of the code, once 
I PROBEd those parts in the console, the cause was clear and the 
fix easy.

To view the debug message generated by sc start, you need to install 
a (kernel) debug tool such as DebugView, and enable kernel debugging 
in the Windows boot options.


Other than that, you should see sc query showing the driver as running.

Ah, found a verbose: 1 left in natives.reds thanks to your presentation...and 
the code is missing a macro....funny way to debug/improve my own 
code. ;-)

MSVCRT.DLL errors are often related to compiling in Debug mode or 
version mismatch in installed redistributables with requried ones.

debug builds: maybe. i'd like to get this added to the mainline sources 
first. once that's done, i'm still not so sure if they really are 
that useful at the moment, as I think they won't help much without 
a build environment set up.

well, with the basic build farm in place and the website launched, 
i'll maybe get to some more build process revisions (including debug 
builds) soon.

So to work on / debug R3-GUI (Cyphre please correct me, if I'm wrong):

;; Load INCLUDE (once)
>>  do https://raw.github.com/saphirion/include/master/include.r


;; (Re-)load R3-GUI (multiple times; assumes you are in the R3-GUI 
toplevel directory)
>> include %loader/loader.r3

I have a problem renaming files. rename does not change the filename 
on MacOSx. In the terminal it is no problem but in my script the 
filenames are not changed.

            fileo: to-file rejoin [what-dir add-suffix naam-oud-z-ext extensie]
            filen: to-file add-suffix naam-oud-z-ext extensie
            rename fileo filen

I have tested with probe that the types are ok and with the resulting 
values for fileo and filen the rename command worked like a charm. 
Any more ideas what is happening and how to debug this further? Thanks.

If I could switch it from a text to a label it would be nice. As 
yet I have this puzzling experience:
REBOL []
high-on: high-on-odd: false
swap-even: func [/local n] [

    either high-on [for n 2 8 2 [ panel-rechts/pane/:n/font/color: 'white] 
    high-on: false

    ][              for n 1 7 2 [ panel-rechts/pane/:n/font/color: 'black] 
    high-on: true ]
    show panel-rechts]

swap-odd: func [/local n] [

    either high-on-odd [for n 1 7 2 [panel-rechts/pane/:n/font/color: 
    'white

                                     panel-rechts/pane/:n/style: 'lbl-h-la-white] high-on-odd: false
    ][for n 1 7 2 [panel-rechts/pane/:n/font/color: 'black

                   panel-rechts/pane/:n/style: 'lbl-h-la-normal] high-on-odd: true]
    show panel-rechts]

spiegel-styles: stylize [
    lbl-h-la-normal: text left middle 40x100
    lbl-h-la-white: label left middle 40x100]
    
view layout [styles spiegel-styles
	across
	panel-rechts: panel [below space 0x0

    lbl-h-la-white "_" lbl-h-la-white "_" lbl-h-la-normal "_" lbl-h-la-normal 
    "_"

    lbl-h-la-normal "_" lbl-h-la-normal "_" lbl-h-la-normal "_" lbl-h-la-normal 
    "_"]
    return
    button "Even" [swap-even] button "Odd" [swap-odd]
    button "Debug" [print dump-face panel-rechts
    print panel-rechts/pane/1/font/color
    print panel-rechts/pane/1/color
    print panel-rechts/pane/1/style]
]

Where the first two labels change when button Odd is clicked. and 
then stay unchanged and the debug button shows the changes as expected 
(by me)

Caelem, D'oh moments are possible in any language.
I once wrote
    return: true
rather than
    return true

The protracted debug session that followed taught me the value of 
protect-system.

:)
is this because pool-list is empty?

i put in a debug "print" cmd in the on-new-client function of task-master.r, 
which is the only place i could see pool-list being appended to...but 
it seems the function is not called

I sometimes do that when I am trying to debug a lot of nested statements, 
because if you use parens, Rebol will let you know that it didn't 
receive something it was expecting instead of just pulling the output 
from the next nested statement.

Andreas, thanks for the Windows build changes. Works fine here with 
VS2012 installed. Question re. size - the exe seems about twice as 
big as the r3.exe before open sourcing - is the debug version being 
built by default?

Beside fixing some anyoing bugs using debug builds, one of the first 
things I'm interested in is, taking a look to move to 64bit.

Actually, to keep things as simple as possible for people, all you 
need is Code::Blocks, the CB project file and a slightly modified 
make-make.r that is soon to be checked in by Andreas (or which I 
could provide). Then, you can build from CB (and debug), navigate 
your C source propertly, etc.

The printf ... W->P != NULL is just some debug code, that should 
be removed.

Has anyone tried building R3 on Windows with CodeBlocks? I want to 
run R3 in debug mode, to track down native bugs.

btw, there's currently no difference between the release and debug 
targets - CB just builds the all target with whatever flags were 
there. We could change this to create distinct builds, obviously.

Would it be worth putting what compiler switches were used for the 
builds? Do you think you'll want to provide debug builds at any point?

yes, still so ... now If we had kind of debug mode, to track it down 
....

ah...wait...it does work..some other debug code in my script I was 
testing it in...I had isolated the same thing he did.

Carl, Gabriele : I have created group "Debug p1.3" to continue on 
my bug and for others too

If you automatically repeat the apply when appropriate, that could 
lead to some really obscure, hard-to-debug code. An /all option?

Anton -- I had to debug the problems with Sort/all/skip/compare  
-- code that worked on one platform, but failed on another. It got 
burned into the brain.

For Post 1.3 discussion (moved here from the Debug 1.3 group) ...


What would your "perfect" FOR interface look like (anyone and everyone)? 
For me, I want it to hide the mechanical details more than CFOR does, 
and is nicer to read than the current FOR (for i 1 9 1 [...]). It 
might look like this:

for [i: from 1 to 9]	[...]
for [i: 1 .. 9 step 2]	[...]
for [i from 1..9 step 3]	[...]
for [i: 1 — 9 step 4]	[...]
for [i 0 to 1 step .1]	[...]

or maybe move the word outside the block:

for i [1 to 9]		[...]
for i [1 to 9 step 2]	[...]


Python has an Else clause, though it works backwards from what I 
expect it to; the idea is to have a clause that executes if 'break 
is used. It also has a Continue op that jumps to the head of the 
body for the next iteration.

You misunderstand my point. Since Henrik was suggesting that  index? 
none  be changed to a non-erroneous condition to handle certain coding 
patterns, I was showing an example of such a pattern that can be 
accomplished with the existing index? behavior. The advantage to 
the existing index? behavior is that it forces you to deal with exceptional 
(but not erroneous) conditions closer to where they occur, and thus 
make your code easier to debug. I would write the second version 
of your example as  if pos: find data value [print index? pos]  which 
flows just as well as the first.

I don't know how many of this type of examples are there, but is 
quite annoying to debug these side effects.

REBOL is an interpreted, internet messaging language. Highly flexible, 
REBOL 

saves time by reducing the amount of code you need to write. Code 
and data are 

the same. You can find and collapse repetitive patterns in data or 
code. Write 

your own dialects. Very easy to install, test and debug. Use the 
text editor you 
like.

Apologies -- REBOL.org was unavailable for just under a day, it's 
back now.

The problem originated with the ISP, and it took them a little while 
to work out what they'd done wrong.

Using a "non-standard" language seems to have added to their debug 
time:
Extracts from two emails from the ISP's technical support:

<<Hi, Sunanda.  Sorry this is taking a bit.  As I'm sure you know 
you have

a non-standard setup :-)  We aren't familiar with it and are puzzling 
it

out.  Am I right that you have your own scripting language?  And 
that
[snipped] is the [path to the] interpreter?>>

<<Aha!  Our web server rebooted yesterday.  It's a FreeBSD server, 
and for

a reason we haven't determined yet, the Linux compatability module

didn't load.  We loaded it and your site works again.  We'll figure 
out
why that module didn't load at boot.>>

Please do, although perhaps the Debug p1.3 or View group might be 
better for that :)

with debug on do you  see it ?

update: I just extended make-doc-pro to support forms. Looks like 
this:

Test of Form Dialect in make-doc-pro

=toc

=options debug

===Introduction
This file test the form generation dialect.

\form test.cgi
	cgi-bin http://localhost/cgi-bin/

	; same-width with fields & buttons
	same-width left [
		field "Name1"
		field "Name12" 10
		field "Name123" 10 20
		field "Name"
		radio "R1" [Robby Linna Bunny Blacky]

		btn-enter "Abschicken"
		btn-cancel "Abbrechen"
	]

/form

Obviously people who do code golf come to it from different perspectives, 
I think Rebol's key here is just to engage by giving lively and flexible 
solutions which pique interest.  I intentionally didn't clone the 
deranged "winner" of the roman numeral contest because he'd thrown 
out the program logic, it was no longer source code.  I can edit, 
debug, and insert probe messages into mine easily.

As I predicted, it's actually not so bad.  Especially when you can 
break into native Rebol at any point if you want to debug (so long 
as you use lowercase!)

Getting this error, not sure what source files I am missing. It Is 
a simple view script that reads from http. (I'm already including 
mezz.r, prot.r, view.r) 

** Script Error: user-prefs has no value
** Where: vbug
** Near: if not dbg: user-prefs/debug [exit]

You can do some structural pattern matching with parse rules, but 
with how parse is currently implemented it can be a little awkward. 
The lack of arguments to parse rules make recursion quite difficult, 
and the lack of local variables make the rules difficult to use concurrently. 
It is difficult to examine both the data type and the value of elements 
in block parsing, to switch to string parsing mode for string elements, 
to parse lists, hashes or parens, to direct the parse flow based 
on semantic criteria (which is needed to work around any of these 
other problems).


And don't even get me started on the difficulties of structure rebuilding. 
The thing that is the most difficult to do in parse is the easiest 
thing to do with regexes: Search and replace. Didn't we make a web 
site years ago collecting suggestions for improving parse? Wasn't 
a replace operation one of those suggestions? What happened with 
that?


Structural pattern matching and rebuilding currently has to be done 
with a mix of parse and REBOL code that is tricky to write and debug. 
If parse doesn't get improved, I'd rather use a nice declarative 
dialect, preferably with before and after structures, and have the 
dialect processor generate the parse and REBOL code for me. If that 
dialect is powerful enough to be written in itself then we'll really 
be cooking.

All works, "read/custom url reduce ['POST query-string]" did the 
trick! Thanks guys.

My little 64 line script now does the following:


 1) Read Address Book vCard file and extract a list of number/name 
 pairs (I prefix the numbers with 'n to assist with lookups)

 2) Read each Linksys SPA942 IP Phone's call history and create a 
 sorted list of number/frequency pairs

 3) Join these 2 lists and create a query string for matches and an 
 exception report for numbers without an address book entry
	4) POST merged and updated name/number pairs back to each phone


Script took 2 hours to write and debug, runs in 2-3 seconds and gives 
us the features of an advanced call management facility for free. 
Once again, REBOL to the rescue (my business partner shook his head 
when he saw this and just said, "but HOW can REBOL do all this???").

also while working on qtask i used to have the debug console on one 
monitor and the editor / browser on the other. how much faster it 
was than when i was using one monitor only!

Yes, there's a few  insertions to do on lower-level parts. I'll take 
a few minutes to do it after lunch. Btw, I don't have any pgsql server 
available, nor have time to setup one, so I'll let you test and eventually 
debug the new version. ;-)

REBOL [
	Title:		"SVG Demo"
	Owner:		"Ashley G. Trüter"
	Version:	0.0.1
	Date:		21-Jun-2005
	Purpose:	"Loads and displays a resizeable SVG file."
	History: {
		0.0.1	Initial release
	}
	Notes: {
		Tested on very simple SVG icons
		Only a few basic styles / attributes / commands supported

  Does not handle sizes in units other than pixels (e.g. pt, in, cm, 
  mm, etc)

  SVG path has an optional close command, "z" ... AGG shape equivalent 
  auto-closes

  load-svg function needs to be totally refactored / optimized ... 
  *sample only*
	}
]

;	The following commands are available for path data:
;
;		M = moveto
;		L = lineto
;		H = horizontal lineto
;		V = vertical lineto
;		C = curveto
;		S = smooth curveto
;		Q = quadratic Belzier curve
;		T = smooth quadratic Belzier curveto
;		A = elliptical Arc
;		Z = closepath

;print: none	; comment out this line to enable debug messages

load-svg: function [svg-file [file! string!] size [pair!]] [

 id defs x y to-color to-byte draw-blk append-style svg-size scale-x 
 scale-y
][
	xml: either string? svg-file [parse-xml svg-file] [

  unless %.svg = suffix? svg-file [to error! "File has an invalid suffix!"]
		parse-xml read svg-file
	]

 unless xml/3/1/1 = "svg" [to error! "Could not find SVG header!"]

 ;unless find ["id" "xmlns"] xml/3/1/2/1 [to error! "Could not find 
 ID header!"]

 ;unless xml/3/1/3/1/1 = "defs" [to error! "Could not find DEFS header!"]

	id: xml/3/1/2
	defs: xml/3/1/3


	;
	;	--- Parse SVG id
	;

	svg-size: either find ["32pt" "48pt" "72pt"] select id "width" [
		switch select id "width" [
			"72pt"	[120x120]
			"48pt"	[80x80]
			"32pt"	[60x60]
		]
	][

  as-pair to integer! any [select id "width" "100"] to integer! any 
  [select id "height" "100"]
	]

	x: to integer! any [select id "x" "0"]
	y: to integer! any [select id "y" "0"]

	scale-x: size/x / svg-size/x
	scale-y: size/y / svg-size/y

	;
	;	--- Helper functions
	;


 to-color: func [s [string!]] [	; converts a string in the form "#FFFFFF" 
 to a 4-byte tuple
		to tuple! load rejoin ["#{" next s "00}"]
	]


 to-byte: func [s [string!]] [	; converts a string with a value 0-1 
 to an inverted byte
		255 - to integer! 255 * to decimal! s
	]

	;
	;	--- Parse SVG defs
	;

	draw-blk: copy []

	append-style: function [
		command [string!] blk [block!]
	][
		x xy pen-color fill-color line-width mode size radius shape
		closed? matrix transf-command
	][
		xy: 0x0
		size: 0x0
		line-width: 1
		matrice: make block! []
		radius: none
		transf-command: none
		
		
		foreach [attr val] blk [
			switch attr [
				"transform" [print "tranform have been found" 
						;probe val halt 
						val: parse val "(),"
						transf-command: first val
						probe transf-command
						switch transf-command [
							"matrix" [ 
								foreach word val [
									if not find word "matrix"
									[ 
										insert tail matrice to-decimal word
									]
								]
							
							]
						]
				]
				"style" [
					foreach [attr val] parse val ":;" [
						switch/default attr [
						
							"font-size" [ ]
							"stroke" [
								switch/default first val [
									#"#" [pen-color: to-color val]
									#"n" [pen-color: none]
								][
									print ["Unknown stroke:" val]
								]
							]
							"stroke-width" [line-width: to decimal! val]
							"fill" [
								fill-color: switch/default first val [
									#"#" [to-color val]
									#"n" [none]
								][
									print ["Unknown fill value:" val]
									none
								]
							]
							"fill-rule" [
								mode: switch/default val [
									"evenodd"	['even-odd]
								][
									print ["Unknown fill-rule value:" val]
									none
								]
							]

       "stroke-opacity" [pen-color: any [pen-color 0.0.0.0] pen-color/4: 
       to-byte val]

       "fill-opacity" [fill-color: any [fill-color 0.0.0.0] fill-color/4: 
       to-byte val]
							"stroke-linejoin" [
								insert tail draw-blk switch/default val [
									"miter"		[compose [line-join miter]]
									"round"		[compose [line-join round]]
									"bevel"		[compose [line-join bevel]]
								][
									print ["Unknown stroke-linejoin value:" val]
									none
								]
							]
							"stroke-linecap" [
								insert tail draw-blk 'line-cap
								insert tail draw-blk to word! val
							]
						][
							print ["Unknown style:" attr]
						]
					]
				]
				"x"			[xy/x: scale-x * val]
				"y"			[xy/y: scale-y * val]
				"width"		[size/x: scale-x * val]
				"height"	[size/y: scale-y * val]
				"rx"		[print "rx"]
				"ry"		[radius: to decimal! val]
				"d"	[
					shape: copy []
					x: none
					closed?: false
					foreach token load val [
						switch/default token [
							M	[insert tail shape 'move]
							C	[insert tail shape 'curve]
							L	[insert tail shape 'line]
							z	[closed?: true]
						][

       unless number? token [print ["Unknown path command:" token]]

       either x [insert tail shape as-pair x scale-y * token x: none] [x: 
       scale-x * token]
						]
					]
				]
			]
		]
		insert tail draw-blk compose [
			pen (pen-color)
			fill-pen (fill-color)
			fill-rule (mode)
			line-width (line-width * min scale-x scale-y)
		]
		switch command [
			"rect" [
				insert tail draw-blk compose [box (xy) (xy + size)]
				if radius [insert tail draw-blk radius]
			]
			"path" [
				unless closed? [print "Path closed"]
				either transf-command <> none  [
					switch transf-command [

      "matrix" [insert tail draw-blk compose/only [ (to-word transf-command) 
      (matrice) shape (shape) reset-matrix]]
					]
				][
					insert tail draw-blk compose/only [shape (shape)]
			 	]
				]

   "g" [ print "Write here how to handle G insertion to Draw block" 

    insert tail draw-blk probe compose/only [reset-matrix (to-word transf-command) 
    (matrice)]
				
				]
			]
	]	
  
	probe defs
	foreach blk defs [
		switch first blk [
			"rect"	[append-style first blk second blk]
			"path"	[append-style first blk second blk]
			"g"		[
						print "key word" probe first blk  
						print "matrix and style in G" probe second blk  
						append-style first blk second blk 
						;print "what to draw in G" probe third blk
						foreach blk2 third blk [
							probe blk2
							switch first blk2[ 
								"path" [append-style first blk2 second blk2]
							]
						]
					]
		]
	]
	
	
probe draw-blk
	draw-blk
]

view make face [
	offset:	100x100
	size:	200x200
	action:	request-file/filter/only "*.svg"
	text:	rejoin ["SVG Demo [" last split-path action "]"]
	data:	read action
	color:	white
	effect:	compose/only [draw (load-svg data size)]
	edge: font: para: none
	feel: make feel [
		detect: func [face event] [
			if event/type = 'resize [
				insert clear face/effect/draw load-svg face/data face/size
				show face
			]
			if event/type = 'close [quit]
		]
	]
	options: [resize]
]

REBOL [
	Title:		"SVG Demo"
	Owner:		"Ashley G. Trüter"
	Version:	0.0.1
	Date:		21-Jun-2005
	Purpose:	"Loads and displays a resizeable SVG file."
	History: {
		0.0.1	Initial release
	}
	Notes: {
		Tested on very simple SVG icons
		Only a few basic styles / attributes / commands supported

  Does not handle sizes in units other than pixels (e.g. pt, in, cm, 
  mm, etc)

  SVG path has an optional close command, "z" ... AGG shape equivalent 
  auto-closes

  load-svg function needs to be totally refactored / optimized ... 
  *sample only*
	}
]

;	The following commands are available for path data:
;
;		M = moveto
;		L = lineto
;		H = horizontal lineto
;		V = vertical lineto
;		C = curveto
;		S = smooth curveto
;		Q = quadratic Belzier curve
;		T = smooth quadratic Belzier curveto
;		A = elliptical Arc
;		Z = closepath

;print: none	; comment out this line to enable debug messages

load-svg: function [svg-file [file! string!] size [pair!]] [

 id defs x y to-color to-byte draw-blk append-style svg-size scale-x 
 scale-y
][
	xml: either string? svg-file [parse-xml svg-file] [

  unless %.svg = suffix? svg-file [to error! "File has an invalid suffix!"]
		parse-xml read svg-file
	]

 unless xml/3/1/1 = "svg" [to error! "Could not find SVG header!"]

 ;unless find ["id" "xmlns"] xml/3/1/2/1 [to error! "Could not find 
 ID header!"]

 ;unless xml/3/1/3/1/1 = "defs" [to error! "Could not find DEFS header!"]

	id: xml/3/1/2
	defs: xml/3/1/3


	;
	;	--- Parse SVG id
	;

	svg-size: either find ["32pt" "48pt" "72pt"] select id "width" [
		switch select id "width" [
			"72pt"	[120x120]
			"48pt"	[80x80]
			"32pt"	[60x60]
		]
	][

  as-pair to integer! any [select id "width" "100"] to integer! any 
  [select id "height" "100"]
	]

	x: to integer! any [select id "x" "0"]
	y: to integer! any [select id "y" "0"]

	scale-x: size/x / svg-size/x
	scale-y: size/y / svg-size/y

	;
	;	--- Helper functions
	;


 to-color: func [s [string!]] [	; converts a string in the form "#FFFFFF" 
 to a 4-byte tuple
		to tuple! load rejoin ["#{" next s "00}"]
	]


 to-byte: func [s [string!]] [	; converts a string with a value 0-1 
 to an inverted byte
		255 - to integer! 255 * to decimal! s
	]

	;
	;	--- Parse SVG defs
	;

	draw-blk: copy []

	append-style: function [
		command [string!] blk [block!]
	][
		x xy pen-color fill-color line-width mode size radius shape
		closed? matrix transf-command
	][
		xy: 0x0
		size: 0x0
		line-width: 1
		matrice: make block! []
		radius: none
		transf-command: none
		
		
		foreach [attr val] blk [
			switch attr [
				"transform" [print "tranform have been found" 
						;probe val halt 
						val: parse val "(),"
						transf-command: first val
						probe transf-command
						switch transf-command [
							"matrix" [ 
								foreach word val [
									if not find word "matrix"
									[ 
										insert tail matrice to-decimal word
									]
								]
							
							]
						]
				]
				"style" [
					foreach [attr val] parse val ":;" [
						switch/default attr [
						
							"font-size" [ ]
							"stroke" [
								switch/default first val [
									#"#" [pen-color: to-color val]
									#"n" [pen-color: none]
								][
									print ["Unknown stroke:" val]
								]
							]
							"stroke-width" [line-width: to decimal! val]
							"fill" [
								fill-color: switch/default first val [
									#"#" [to-color val]
									#"n" [none]
								][
									print ["Unknown fill value:" val]
									none
								]
							]
							"fill-rule" [
								mode: switch/default val [
									"evenodd"	['even-odd]
								][
									print ["Unknown fill-rule value:" val]
									none
								]
							]

       "stroke-opacity" [pen-color: any [pen-color 0.0.0.0] pen-color/4: 
       to-byte val]

       "fill-opacity" [fill-color: any [fill-color 0.0.0.0] fill-color/4: 
       to-byte val]
							"stroke-linejoin" [
								insert tail draw-blk switch/default val [
									"miter"		[compose [line-join miter]]
									"round"		[compose [line-join round]]
									"bevel"		[compose [line-join bevel]]
								][
									print ["Unknown stroke-linejoin value:" val]
									none
								]
							]
							"stroke-linecap" [
								insert tail draw-blk 'line-cap
								insert tail draw-blk to word! val
							]
						][
							print ["Unknown style:" attr]
						]
					]
				]
				"x"			[xy/x: scale-x * val]
				"y"			[xy/y: scale-y * val]
				"width"		[size/x: scale-x * val]
				"height"	[size/y: scale-y * val]
				"rx"		[print "rx"]
				"ry"		[radius: to decimal! val]
				"d"	[
					shape: copy []
					x: none
					closed?: false
					foreach token load val [
						switch/default token [
							M	[insert tail shape 'move]
							C	[insert tail shape 'curve]
							S   [insert tail shape 'curv]
							L	[insert tail shape 'line]
							Q   [insert tail shape 'qcurve]
							T   [insert tail shape 'qcurv]
							z	[closed?: true]
							H   [insert tail shape 'hline]
							V   [insert tail shape 'vline]
							A   [insert tail shape 'arc]
						][

       unless number? token [print ["Unknown path command:" token]]

       either x [insert tail shape as-pair x scale-y * token x: none] [x: 
       scale-x * token]
						]
					]
				]
			]
		]
		insert tail draw-blk compose [
			pen (pen-color)
			fill-pen (fill-color)
			fill-rule (mode)
			line-width (line-width * min scale-x scale-y)
		]
		switch command [
			"rect" [
				insert tail draw-blk compose [box (xy) (xy + size)]
				if radius [insert tail draw-blk radius]
			]
			"path" [
				unless closed? [print "Path closed"]
				either transf-command <> none  [
					switch transf-command [

      "matrix" [insert tail draw-blk compose/only [ (to-word transf-command) 
      (matrice) shape (shape) reset-matrix]]
					]
				][
					insert tail draw-blk compose/only [shape (shape)]
			 	]
				]

   "g" [ print "Write here how to handle G insertion to Draw block" 

    insert tail draw-blk probe compose/only [reset-matrix (to-word transf-command) 
    (matrice)]
				
				]
			]
	]	
  
	probe defs
	foreach blk defs [
		switch first blk [
			"rect"	[append-style first blk second blk]
			"path"	[append-style first blk second blk]
			"g"		[
						print "key word" probe first blk  
						print "matrix and style in G" probe second blk  
						append-style first blk second blk 
						;print "what to draw in G" probe third blk
						foreach blk2 third blk [
							probe blk2
							switch first blk2[ 
								"path" [append-style first blk2 second blk2]
							]
						]
					]
		]
	]
	
	
probe draw-blk
	draw-blk
]

view make face [
	offset:	100x100
	size:	200x200
	action:	request-file/filter/only "*.svg"
	text:	rejoin ["SVG Demo [" last split-path action "]"]
	data:	read action
	color:	white
	effect:	compose/only [draw (load-svg data size)]
	edge: font: para: none
	feel: make feel [
		detect: func [face event] [
			if event/type = 'resize [
				insert clear face/effect/draw load-svg face/data face/size
				show face
			]
			if event/type = 'close [quit]
		]
	]
	options: [resize]
]

REBOL [
	Title:		"SVG Demo"
	Owner:		"Ashley G. Trüter"
	Version:	0.0.1
	Date:		21-Jun-2005
	Purpose:	"Loads and displays a resizeable SVG file."
	History: {
		0.0.1	Initial release
	}
	Notes: {
		Tested on very simple SVG icons
		Only a few basic styles / attributes / commands supported

  Does not handle sizes in units other than pixels (e.g. pt, in, cm, 
  mm, etc)

  SVG path has an optional close command, "z" ... AGG shape equivalent 
  auto-closes

  load-svg function needs to be totally refactored / optimized ... 
  *sample only*
	}
]

;	The following commands are available for path data:
;
;		M = moveto
;		L = lineto
;		H = horizontal lineto
;		V = vertical lineto
;		C = curveto
;		S = smooth curveto
;		Q = quadratic Belzier curve
;		T = smooth quadratic Belzier curveto
;		A = elliptical Arc
;		Z = closepath

;print: none	; comment out this line to enable debug messages

load-svg: function [svg-file [file! string!] size [pair!]] [

 id defs x y to-color to-byte draw-blk append-style svg-size scale-x 
 scale-y
][
	xml: either string? svg-file [parse-xml svg-file] [

  unless %.svg = suffix? svg-file [to error! "File has an invalid suffix!"]
		parse-xml read svg-file
	]

 unless xml/3/1/1 = "svg" [to error! "Could not find SVG header!"]

 ;unless find ["id" "xmlns"] xml/3/1/2/1 [to error! "Could not find 
 ID header!"]

 ;unless xml/3/1/3/1/1 = "defs" [to error! "Could not find DEFS header!"]

	id: xml/3/1/2
	defs: xml/3/1/3


	;
	;	--- Parse SVG id
	;

	svg-size: either find ["32pt" "48pt" "72pt"] select id "width" [
		switch select id "width" [
			"72pt"	[120x120]
			"48pt"	[80x80]
			"32pt"	[60x60]
		]
	][

  as-pair to integer! any [select id "width" "100"] to integer! any 
  [select id "height" "100"]
	]

	x: to integer! any [select id "x" "0"]
	y: to integer! any [select id "y" "0"]

	scale-x: size/x / svg-size/x
	scale-y: size/y / svg-size/y

	;
	;	--- Helper functions
	;


 to-color: func [s [string!]] [	; converts a string in the form "#FFFFFF" 
 to a 4-byte tuple
		to tuple! load rejoin ["#{" next s "00}"]
	]


 to-byte: func [s [string!]] [	; converts a string with a value 0-1 
 to an inverted byte
		255 - to integer! 255 * to decimal! s
	]

	;
	;	--- Parse SVG defs
	;

	draw-blk: copy []

	append-style: function [
		command [string!] blk [block!]
	][
		x xy pen-color fill-color line-width mode size radius shape
		closed? matrix transf-command
	][
		xy: 0x0
		size: 0x0
		line-width: 1
		matrice: make block! []
		radius: none
		transf-command: none
		
		
		foreach [attr val] blk [
			switch attr [
				"transform" [print "tranform have been found" 
						;probe val halt 
						val: parse val "(),"
						transf-command: first val
						probe transf-command
						switch transf-command [
							"matrix" [ 
								foreach word val [
									if not find word "matrix"
									[ 
										insert tail matrice to-decimal word
									]
								]
							
							]
						]
				]
				"style" [
					foreach [attr val] parse val ":;" [
						switch/default attr [
						
							"font-size" [ ]
							"stroke" [
								switch/default first val [
									#"#" [pen-color: to-color val]
									#"n" [pen-color: none]
								][
									print ["Unknown stroke:" val]
								]
							]
							"stroke-width" [line-width: to decimal! val]
							"fill" [
								fill-color: switch/default first val [
									#"#" [to-color val]
									#"n" [none]
								][
									print ["Unknown fill value:" val]
									none
								]
							]
							"fill-rule" [
								mode: switch/default val [
									"evenodd"	['even-odd]
								][
									print ["Unknown fill-rule value:" val]
									none
								]
							]

       "stroke-opacity" [pen-color: any [pen-color 0.0.0.0] pen-color/4: 
       to-byte val]

       "fill-opacity" [fill-color: any [fill-color 0.0.0.0] fill-color/4: 
       to-byte val]
							"stroke-linejoin" [
								insert tail draw-blk switch/default val [
									"miter"		[compose [line-join miter]]
									"round"		[compose [line-join round]]
									"bevel"		[compose [line-join bevel]]
								][
									print ["Unknown stroke-linejoin value:" val]
									none
								]
							]
							"stroke-linecap" [
								insert tail draw-blk 'line-cap
								insert tail draw-blk to word! val
							]
						][
							print ["Unknown style:" attr]
						]
					]
				]
				"x"			[xy/x: scale-x * val]
				"y"			[xy/y: scale-y * val]
				"width"		[size/x: scale-x * val]
				"height"	[size/y: scale-y * val]
				"rx"		[print "rx"]
				"ry"		[radius: to decimal! val]
				"d"	[
					shape: copy []
					x: none
					closed?: false
					if all [x not number? token] [

          insert tail shape x * either token = 'V [scale-y][scale-x]
  						    x: none
					]
					foreach token load val [
						switch/default token [
							M	[insert tail shape 'move]
							C	[insert tail shape 'curve]
							S   [insert tail shape 'curv]
							L	[insert tail shape 'line]
							Q   [insert tail shape 'qcurve]
							T   [insert tail shape 'qcurv]
							z	[closed?: true]
							H   [insert tail shape 'hline]
							V   [insert tail shape 'vline]
							A   [insert tail shape 'arc]
						][

       unless number? token [print ["Unknown path command:" token]]

       either x [insert tail shape as-pair x scale-y * token x: none] [x: 
       scale-x * token]
						]
					]
				]
			]
		]
		insert tail draw-blk compose [
			pen (pen-color)
			fill-pen (fill-color)
			fill-rule (mode)
			line-width (line-width * min scale-x scale-y)
		]
		switch command [
			"rect" [
				insert tail draw-blk compose [box (xy) (xy + size)]
				if radius [insert tail draw-blk radius]
			]
			"path" [
				unless closed? [print "Path closed"]
				either transf-command <> none  [
					switch transf-command [

      "matrix" [insert tail draw-blk compose/only [ (to-word transf-command) 
      (matrice) shape (shape) reset-matrix]]
					]
				][
					insert tail draw-blk compose/only [shape (shape)]
			 	]
				]

   "g" [ print "Write here how to handle G insertion to Draw block" 

    insert tail draw-blk probe compose/only [reset-matrix (to-word transf-command) 
    (matrice)]
				
				]
			]
	]	
  
	probe defs
	foreach blk defs [
		switch first blk [
			"rect"	[append-style first blk second blk]
			"path"	[append-style first blk second blk]
			"g"		[
						print "key word" probe first blk  
						print "matrix and style in G" probe second blk  
						append-style first blk second blk 
						;print "what to draw in G" probe third blk
						foreach blk2 third blk [
							probe blk2
							switch first blk2[ 
								"path" [append-style first blk2 second blk2]
							]
						]
					]
		]
	]
	
	
probe draw-blk
	draw-blk
]

view make face [
	offset:	100x100
	size:	200x200
	action:	request-file/filter/only "*.svg"
	text:	rejoin ["SVG Demo [" last split-path action "]"]
	data:	read action
	color:	white
	effect:	compose/only [draw (load-svg data size)]
	edge: font: para: none
	feel: make feel [
		detect: func [face event] [
			if event/type = 'resize [
				insert clear face/effect/draw load-svg face/data face/size
				show face
			]
			if event/type = 'close [quit]
		]
	]
	options: [resize]
]

and look at debug output in console

So, I can debug my programs in the bath :)

As a newbie, what suggestions do you have for me to debug my rebol 
scripts.  For example, I have a script called "Convert_to_Table" 
that I am just starting to write.  I can execute it -stand alone- 
and see the results of the run, but what I would like to do is be 
able to see what the console has for any values.  In other words, 
when I double click the "Convert_to_Table" I can see the results 
but not ask the console questions like print Count or the like.  
How do you suggest a newbie debug a script?  Should I go into console 
first and then perform a "do Convert_to_Table" and then be able to 
ask questions of console, or is there another way?.

(there's an infinite loop in my compiler using your example, i'll 
need to debug it later - too sleepy now ;)

Heck, in debug mode I would like all of the opcodes to act as invalid-as-error.

I really don't understand all the buzz about Ajax. About 1998/1999 
a friend of mine and I made a remote Javascript debugger that used 
IFrames to update the client page without reloading. And we were 
able to remote debug the client side. The problem was, that we really 
drove the Javascript and DOM engines to the limit...

Options are debug-mode, or pointing out that other things are checked 
too.

I think it's easier to debug it in ghostscript. The printers I've 
tried this on will not print stack information. Perhaps only if I 
dive really deep into the capabilities of the printer, which I have 
no time for.

by manual I mean, that you will decide what to debug BEFORE running 
code as opposed to after.

Just in Mozilla: Was reading rss in sage, opened bookmark-editor, 
moved bookmarks, sage was updated. i think liquid is for such things. 
also the wiring can be shown graphically. Have seen that with Visual 
Age did that long ago. If it is well done its not a bad idea. I still 
fear it will be hard to debug, since all this wiring is invisible. 
Or maybe: it was to easy to create for me. BAck in that days i found 
such connetion-stuff cool and created a lot spagethi. (was not using 
VA, that method worked with pure oops too^^)

You can debug my code anytime Petr

That's because the DEBUG mode is activated by default in these beta 
releases. To get ride of it, just edit the httpd.cfg file , find 
the webapp "/testapp" option block and remove the 'debug keyword 
 (then restart the server).

With debug, Redirection Catched.
Without  loops to login screen over and tover

what does the debug say?

If I turn on debug in webapp in httpd.cfg I get the  Redirection 
catched  everytime.


The contents are empty, before and after the "POST", but I'm not 
sure since the

redirect is plopping me back at login.rsp.   Even empty when I change 
the form
to method="GET" and hit return...

Turn off debug in httpd.cfg

I'm getting a few crashes using rsp with debug turned off :(

when debug is true?

in the rsp debug

webapp [
		virtual-root "/cgi-bin"
		root-dir %/c/xitami/cgi-bin/
		debug    
  ]

modules [
;	userdir
	internal
	static
	action
	fastcgi
	rsp
	ssi
	alias
;	embed
]

globals [
	bind SSI to [.shtml .shtm]
	bind fastcgi to [.php .php3 .php4]
	
	bind-extern CGI to [.cgi .r]
	bind-extern RSP to [.j .rsp]
	
;	user  nobody
;	group nobody

]

default [
	root-dir  %/c/!Docs-private/Xidys/cheyenne-r0914/Cheyenne/www/
	
	default [%index.html %index.rsp %index.php]
	
	on-status-code [
		404	  "/custom404.html"
	]
	
	webapp [
		virtual-root "/testapp"
		root-dir %www/testapp/
		auth "/testapp/login.rsp"
		debug
	]
	
;	"/" [
;		redirect http://softinnov.org
;	]
	
;	extern fastcgi [
;		command	 "php -b $port"
;		pool 	 min 1 max 4
;		server	 127.0.0.1 ; port 1234
;		root-dir "/home/dk/fcgi/"
;	]
] 

;rebol.si.org [
;	root-dir %//dev/si-org/old/
;	default %main.html
;	
;	redirect 301 "/mysql*" "http://si.org/rebol/mysql.shtml"
;	redirect 301 "/rebox*" "http://si.org/rebol/rebox.shtml"
;	redirect 301 "/"	   "http://si.org"
;]

; ###
; To add a new virtual host just duplicate and fill the following
; example host :
;
; my.vhost.com [
;	root-dir %/www/			; documents root directory
;	default [...]			; default files
; ]	
; ###

Cheyenne new version 0.9.16 is ready. The new FastCGI multiplexed 
support took me some time to debug, but the resulting PHP interfacing 
is now really stable. I just need to update the RSP API doc and run 
a few tests, so the download link will be published here in a couple 
of hours.

I would like to help debug, what the trouble is, just don't know 
why. Maybe I will set-up WireShark (Ethereal) during my vacation 
next week ...

The green and red writing is debug messages showig cards - this will 
not be visible in final.  White text is currently played card(s) 
this is also replaced by actual cards in final

RebTower 0.0.4 released.  This version is playable :)
Quick notes:

left click a card to select it (it will enlarge in size) then either 
left click it again to replace it or right (Alt) click it to play 
it.

only cards that are alpha/0 (ie solid)  can be played unless you 
are discarding.
if all your cards are transparent you will have to discard.

the object of the game is to destroy your oponnents tower while keeping 
yours alive.


Yes, I know the debug info is still displaying - the final image 
cards are not ready yet :)

version 5 released: http://rebol.mustard.co.nz/rebtower-0.0.5.zip
notes:
0.0.5 	fixed card font display, rebalanced deck (somewhat)
- removed debug-info
- resources: right justified text