World: r3wp

no, they don't use the same macros.

so, it's user specific.

personal shorthand

yes

hmm I am in the bussiness of sharing biological information and I 
got to say  please strongly consider  creating  an ontology if one 
does not exist already

Oh .. sure there's ontologies ....

but people don't use them when typing.

SNOMED CT is the one being currently promulgated

and there's the proprietary MEDCIN

so, personal shorthand should expand into a controlled vocab ideally

yes

Ii Type II Diabetes #250.00
here the macro expansion includes a code (CPT) from the AMA.

and the macros should  also be part of that  ontology

Medcin contains over 100,000 clinical propositions

no one is going to remember that!

Can you make sure that no whitespace sneaks into your macro names?

tom, I can't force the guy to change his macros!

no that is what browaers are for

right

I mean at the beginning.

there is no whitespace inside a macroname

LOINC, another controlled vocab, contains over 30,000 items.

so there is a seperate extendable file with the macro=expansion

tom, yes.

actually  the file will be saved in a database and loaded when the 
program starts

Make sure to trim the names before you use them. I am rewriting your 
function.

Tom, what exactly are you involved in ?

zebrafish

as a model orginism

fish!

http://zfin.org

Ok, I understand the need for an ontology here.

but medicine is full of uncontrolled words which are in common use.

and the ontologically controlled programs are very expensive due 
to licensing fees

The AMA charge to use their codes, the American College of Pathologists 
charge to use their SMOMED-CT codes .. and so it goes on.

LOINC, from the Univ. of Indiana has open sourced their codes.

ahh  my mind is corrupted by giving everything away I forget that 
that is not what everyone does

so back to your problem  I

seems it will take n passes

where n is the # of macros.

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 ...