Code cleanup: Removed non-ascii characters from comments and replaced tabs by whitespace.

Signed-off-by: Simon Campese <simon.campese@tu-dortmund.de>
Complete rewrite of the wildcard expansion mechanism and introduction of wildcard modifiers.

Wildcard expansion is now done via the purely recursive function
replaceWildcards() (formerly replaceWildcard() - note the missing s). Plain
wildcards (i.e. %a for author etc.) are supported without change, but
additionally there are now wildcard modifiers which act on argument blocks
enclosed by curly braces. A wildcard modifier is of the form

%<modifier>{<string1>}{<string2>}...

where <modifier> is an element of the array 'wildcard_modifiers'. How many
argument blocks a certain modifier needs and how it acts on these can flexibly
be programmed in a case statement inside replaceWildcards(), making it very easy
to add new ones if the need should ever arise. At the moment, the following
wildcard modifiers are supported:

%<{<string>} : recursively expands <string> and then sets it to lowercase

%>{<string>} : recursively expands <string> and then sets it to uppercase

%|{<string1>}{<string2>} : Inserts <string1> if it expands to something
                           non-empty, otherwise expands and inserts <string2>

%?{<string1>}{<string2>} : Expands and inserts <string2> if <string1> expands to
                           something non-empty

%/{<string1>}{<string2>}{<string3>} : Expands all three argument blocks. Then
                                      replaces every occurence of the expanded
                                      <string1> in the expanded <string3> with
                                      the expanded <string2>. Internally, a
                                      regular expression of the expanded
                                      <string1> is constructed, so special
                                      characters inside <string1> have to be
                                      escaped (see example below).

%-{<string1>}{<string2>} : Expands the argument blocks and then removes every
                           occurence of the expanded <string1> in the expanded
                           <string2>

%_{<string>} : Expands <string> and then removes all spaces by underscores

%'{<string>} : Expands <string> and then removes diacritics by calling the
               function ZU.removeDiacritics()

% {<string>} : Expands <string> and then trims whitespace by calling the
               function ZU.trimInternal()

%^{<string>} : Expands <string> and then capitalizes it by calling the function
               ZU.capitalizeTitle()

Examples:

%>{%a} inserts the author in uppercase

%/{and}{und}{<string>} expands <string> and then replaces all occurences of the
 word 'and' by it's German translation "und".

%/{\.}{}{<string>} removes all dots from the expanded <string>. Note that we
 have to escape the dot in the first block, as it's a special regular expression character.

%'{%_{% {<string>}}} expands <string>, trims whitespace, replaces spaces by
 underscores and then removes diacritics. This shows that due to the recursive
 definition of replaceWildcards(), wildcard modifiers can be nested
 arbitrarily. Note that % {%_{<string>}} would not trim any whitespace.

IMPORTANT: This commit is not backwards compatible as the "exclusive" and
"optional" wildcard syntax is not supported anymore.

Signed-off-by: Simon Campese <simon.campese@tu-dortmund.de>