do :MyTextProperty { /* will iterate over the lines */

   do id%bySemicolon { /* will iterate over elements separated by semicolons */

      variable

         'variable' id%indexPart /* forms the name of the variable */

      write

         id

      close

   }

}

 

You'll need to define the two translators, %bySemicolon to map each semicolon to a newline, and %indexPart to grab the 1_1 from the end of a string like element1_1. They'd go somewhere before the block above, and be something like this:

 

to '%bySemicolon

' endto /* maps semicolon to newline (escaped here with a backslash) */

 

to '%indexPart

/.*([0-9]+_[0-9]+)/ $$1'

endto /* maps any string ending in digit(s)_digit(s) to just that end part */

 

See the _translators generator in Graph for some more example translators. Splitting based on a delimiter character then iterating over the results is a common approach in text processing in MERL, and one of my personal favorite http://www.metacase.com/support/45/program/45sr1.html - new features in 4.5 SR1 . It makes something that would normally be tricky into something fairly easy - for instance I was able to write the above scripts by hand from memory, and they worked first time (partly luck!).

 

Each translator is formed from the output of the commands between to and endto keywords - generally just a single literal string. We'll omit the to, endto and string quotes below, and can concentrate on the syntax of the translators themselves.

 

The first line of a translator can optionally be a name, like %bySemicolon above. This lets you apply the translator easily later, e.g. id%bySemicolon will return the translated id.

 

Subsequent lines are rules, separated by newlines. Each rule has a left hand side and a right hand side, separated by a space. Things on the left hand side will be translated into things on the right hand side. (If you need spaces or new lines in your rules, you can escape them with a backslash.)

 

A common translation is to translate one character into another:

or multiple characters into their corresponding characters:

or to save time, ranges:

 

Sometimes, you need to translate a character into a string. The right hand side is then prefixed by a dollar sign:

 

Sometimes, you need to translate a string into another string, e.g. the reverse of the above (note both sides are not strings):

 

The most powerful form is a regular expression on the left, and a string on the right. The regular expression is enclosed in slashes, /.../. The parenthesized submatches from the regular expression can be referred to on the right as $1, $2 etc. E.g. in %indexPart above, we return a string ($) that contains just the first submatch ($1):