World: r3wp

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

cant say to whitespace

wish you could

tipicaly get around with

that's where my rule got stuck .. on to whitespace

bs: complement ws

any bs

Yeah, I'm changing my code now.

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

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

See, I don't have to test. Graham has the data, he can test :)

that is the part I can't allways be bothered with either