World: r3wp

expand-macros: func [data [string!] macros [block!]
	/local whitespace macro-rule macro here there
] compose [
	whitespace: (charset " ^/")
    macro-rule: make block! length? macros
	foreach [macro expansion] macros [
        macro-rule: insert insert macro-rule macro '|
    ]
    macro-rule: head remove back macro-rule
    parse/all data [some [
        here: copy macro macro-rule there: [whitespace | end] (

            there: change/part here select/skip macros macro 2 there
        ) :there |
        skip
    ]]
    macro-rule: none
    data
]

Sorry, need to change the settings in my editor.

expand-macros: func [data [string!] macros [block!]
    /local whitespace macro-rule macro here there
] compose [
    whitespace: (charset " ^/")
    macro-rule: make block! length? macros
    foreach [macro expansion] macros [
        macro-rule: insert insert macro-rule macro '|
    ]
    macro-rule: head remove back macro-rule
    parse/all data [some [
        here: copy macro macro-rule there: [whitespace | end] (

            there: change/part here select/skip macros macro 2 there
        ) :there |
        skip
    ]]
    macro-rule: none
    data
]

my first effort makes n passes ...

that the macro-expansoion fioe needs to self check for incidental 
occurances of  a "macro" in an "expansion" and protect against

This will make one pass.

And it won't have the problem you mention Tomc.

in one pass you can jump over the expansion

My code does that.

Pretty neat ...

Parse is somewhat beyond my skills!

I wouls still sort the macros by longest to shortest so cant glob 
on to part of  a macro  ..

so, basically you created a single parse rule from the macro list 
and then parsed the text in one go.

but if you include the trailing white space that should be avoided

Tomc, that is a good point - I'll fix it. Graham, that's right.

Did you compose that without any testing? :)

We need a masterclass in parse ....

Graham, yes I did. I know parse well enough to run it in my head.

expand-macros: func [data [string!] macros [block!]
    /local whitespace macro-rule macro expansion here there
] compose [
    whitespace: (charset " ^/")
    macro-rule: make block! 2.5 * length? macros
    foreach [macro expansion] macros [
        macro-rule: insert macro-rule
            compose [here: (macro) there: [whitespace | end] '|]
    ]
    macro-rule: head remove back macro-rule
    parse/all data [some [
        macro-rule (
            macro: copy/part here there

            there: change/part here select/skip macros macro 2 there
        ) :there |
        skip
    ]]
    macro-rule: none
    data
]

Whoops, small fix...

expand-macros: func [data [string!] macros [block!]
    /local whitespace macro-rule macro expansion here there
] compose [
    whitespace: (charset " ^/")
    macro-rule: make block! 2.5 * length? macros
    foreach [macro expansion] macros [
        macro-rule: insert macro-rule
            compose [here: (macro) there: [whitespace | end] |]
    ]
    macro-rule: head remove back macro-rule
    parse/all data [some [
        macro-rule (
            macro: copy/part here there

            there: change/part here select/skip macros macro 2 there
        ) :there |
        skip
    ]]
    macro-rule: none
    data
]

Wait, there is another error.

I am glad to see someone else using here and there ;)

expand-macros: func [data [string!] macros [block!]
    /local whitespace macro-rule macro expansion here there
] compose [
    whitespace: (charset " ^/")
    macro-rule: make block! 2.5 * length? macros
    foreach [macro expansion] macros [
        macro-rule: insert macro-rule
            compose [here: (macro) there: [whitespace | end] |]
    ]
    macro-rule: head remove back macro-rule
    parse/all data [some [
        macro-rule (
            macro: copy/part here there

            there: change/part here select/skip macros macro 2 there
        ) :there |
        thru whitespace
    ] to end]
    macro-rule: none
    data
]

That should do it.

I don't feel so bad that my rule wasn't working !

; Now whitespace is dealt with
expand-macros: func [data [string!] macros [block!]
    /local whitespace macro-rule macro expansion here there
] compose [
    whitespace: (charset " ^/")
    macro-rule: make block! 2.5 * length? macros
    foreach [macro expansion] macros [
        macro-rule: insert macro-rule
            compose [here: (macro) there: [whitespace | end] |]
    ]
    macro-rule: head remove back macro-rule
    parse/all data [some [any whitespace [
        macro-rule (
            macro: copy/part here there

            there: change/part here select/skip macros macro 2 there
        ) :there |
        to whitespace
    ]] to end]
    macro-rule: none
    data
]

You might want to add tabs to the whitespace charset.

why do you need to reset macro-rule to none?

it's a local so memory will be released anyway ..

You don't need to, but if you don't it will sit in memory until the 
next time you run the function.

Oh ... ok.

Memory for locals is not released.

when the function is exited ?

Nope.

Hmm.

Only on recursed functions.

I guess it can't be otherwise we wouldn't need to use 'copy on series

It's a speed optimization. This might change with REBOL 3.

memory use is a large with Rebol.

The series copy thing is something different.

speed or memory ..

Most of the excessive memory overhead of REBOL is just sloppy (no 
offense Carl). It's not much of a problem for most, but I have run 
into memory limits when running on embedded or handheld platforms, 
or running hundreds of instances on servers.

You have to design your platform for memory efficiency or it won't 
be.

Little problem :(

** Script Error: Invalid argument: make bitset! #{
0004000001000000000000000000000000000000000000000000000000000000
}
** Where: expand-macros
** Near: parse/all data [some [any whitespace [
            macro-rule (
                macro: copy/part here there
           ...

whi the parens on   whitespace: rule?

nevermind it is in compose

but that can just be a static rule outside of compose

More efficiency. I build my charsets once, rather than on every call.

should probably build the rule outside the function as well since 
it only should be rebuilt when the macro list changes