World: r3wp

that's what I want. I'm catching fish :-) or rather information to 
store them safely for processing later.

but let me try Oldes thing to see what it does

it works the exact opposite :-) Only the outer 'txt is set, and I 
can't reach the variable inside the block

Henrik, I parse your test attr block successfully:

>> parse [image test-image "Search" [print "action"]] ['image any 
[set txt string! (?? txt) | set img word! | set action block!]]
txt: "Search"
== true

Need more test data to parse.

anton: yes, but what is txt after processing?

I don't want to handle it inside the parse block but after it

it is none.

right. that's the problem

add a block to control the evaluation.

>> parse [image test-image "Search" [print "action"]] ['image any 
[[set txt string! (?? txt)] | set img word! | set action block!]]
txt: "Search"
== true
>> txt
== "Search"

it always set the variables to none, if it fails to match

You have to be careful in your interpretation of  |

interesting, this is the solution:

 txt: 123 parse/all attr ['image any [[set txt string! (print txt)] 
 | [set img word!] | [set action block! (print txt)]] (print txt) 
 | 'face]

oldes solution seems to work

the wonders of parse... :-)

it's just improved anton's solution:-)

I'm trying to figure out a simple example to show why.

I wonder what the difference is? If it's only for controlling how 
global a variable is, it seems a little backwards to me

without the extra brackets, the parse set the variables to none if 
it failes

the brackets would make it a "real" rule, wouldn't it? it would be 
possible to replace the rule with a variable and have the rule block 
placed elsewhere in your code

You have to think of a rule like this:
	[ integer! | ]
as equivalent to
	[ integer! | none ]
or
	opt [ integer! ]

I don;t know how much complex will be the source to parse, but I 
would use the OPT settings as used above

But Henrick wants it in any order, like LAYOUT code. (Thus, it's 
worth to look how LAYOUT works. :)

>> parse ["hi"] [[set num integer! | ] string!]   ?? num
num: none

I just think he can end with endless loop easily, as he will never 
be able to catch the second 'image

>> parse ["hi"] [[set num [integer! | string!]] ] ?? num
num: "hi"

Note the | .     "set NUM to an integer or NONE, then... oh. it's 
the end of this block..."  but in Henrick's rule above he continues 
to set other variables, which is of no concern to parse, it still 
has successfully set NUM to NONE.

there is only one 'image in the block fortunately

ok, so you will not catch the 'face word:-) as it end up in the img 
variable:-)

I think he might be using 'test-image in place of a real image! for 
this example ?

oldes, nope, because I have many different blocks. they either start 
with 'face or with 'image

never both

That's good.

So you can use ANY in an unlimited fashion.

and it makes the parse scalable, so I can add options later

thanks for your help, everyone :-)

cool :)

It's also a good thing with these discussions. I've never really 
grown 100% comfortable with parse.

About Layout : parse handles only the layout words (origin, space, 
at...), see source layout.

The face description is handled by a loop, not by parse. See system/view/vid/grow-facets

Hi, need a bit of help ....

I tried doing myself small template "engine", which will simply look-up 
for some marks, and replace values accordingly. I decided to look 
for the end of the marks and my friend suggested me, that I should 
name even ending marks, to be clear there is not an error. My parse 
looks like this:

REBOL []

template: {

<b><!--[mark-x]-->Hello x!<!--/[mark-y]--></b>
<b><!--[mark-y]-->Hello y!<!--/[mark-y]--></b>
<b><!--[mark-z]-->Hello z!<!--/[mark-z]--></b>
<b><!--[mark-w]-->Hello w!<!--/[mark-w]--></b>

}

parse/all template [
   some [
         thru "<!--["
         copy mark to "]-->"
         "]-->" 
         start:
         copy text to "<!--/["
         end:
         "<!--/[" mark "]-->"
         (print text)
         |
         skip
    ]
]           
         
halt

I now can create simply a func, which will accept mark name, and 
do some code-block accordingly - sql query, simple replace of value, 
whatever (well, it will not work for cases like img tags, so it is 
not as flexible as full html parser in temple for e.g., but hey, 
it is meant being simple)

... but should not be simpler, so I wonder - so far, as you can see, 
mark-x is not finished, so it is ignored. How to catch this case 
properly and eventually generate error, send email, write to log, 
whatever?

I did that recently for COMLib. Look for  build-comlib-website.r 
 in the files section of the COMLib website.

(my end tags are simpler though)

ok, will look into. Is that much complicated than mine is? :-)

this one works better for me:

parse/all template [
   some [
         thru "<!--["
         copy mark to "]-->"
         "]-->" 
         start:
         copy text to "<!--/["
         end:
         "<!--/[" 

         [mark "]-->" (print text) | (print ["not found end of: " mark]) :start]
         |
         skip
    ]
]

Petr.... you just reinvented erebol, rsp, .... build-markup?