Yodl recognizes the arguments to a macro as parameter lists, i.e., delimited by 
tt(CHAR(40)) and tt(CHAR(41)). As long as the number of opening and closing
parentheses matches, Yodl will correctly recognize the list. E.g., given a 
hypothetical macro tt(somemacro), the following code sample shows the macro 
followed by one parameter list:

verb(\
somemacro(Here is a chunk of text.)
somemacro(Here is a some (more) text.))

A problem arises when the number of parentheses is unbalanced: i.e., when the 
parameter list consists of more opening than closing parentheses or v.v.. To 
handle such situations, Yodl offers a `literal-character' mechanism (see the 
tt(CHAR) macro in ref(char)) and a `global substitution' mechanism (see the 
tt(SUBST) macro in ref(subst)). For example, to send the text 

verb(here's a "CHAR(41)" closing parenthesis) 

as an argument to our hypothetical macro tt(somemacro), the following can be 
used: 

verb(\
COMMENT(-- Alternative 1: using CHAR --)
somemacro(here's a "CHAR(C)HAR(41)" closing parenthesis)

COMMENT(-- Alternative 2: using SUBST --)
SUBST(closepar)(CHAR(C)HAR(41))
.
.
somemacro(here's a "closepar" closing parenthesis))

Both methods have disadvantages: the tt(CHAR) method requires you to remember 
that an ASCII 41 is a closing parenthesis. The tt(SUBST) method defines a 
string tt(closepar) that is bf(always) expanded to a closing parenthesis, 
wherever in the text it occurs. Nevertheless, unbalanced parameter lists can 
be handled by Yodl. (If the here described method proves to be too much of a 
pain, I'll think of something. As for myself, I've bf(never yet) have felt the 
need to use an unbalanced parameter list -- except in this document..) Also, 
remember that unbalanced parenthesis pairs are only relevant in argument 
lists. Yodl handles parentheses in normal text as ordinary characters.

