Micro Focus Enterprise Test Server 2.3 Update 2 > Working with Mainframe Files > Using Enterprise Server with a Mainframe > Compare and Synchronization Monitor > Advanced filters > Advanced filter details

Advanced filter details.

The Advanced filter database contains filter rules that can be strung together during the option configuration process. These filters can include and exclude files during the transfer process.

The database is held in text format in a file called monrule.ini.

Rule Name	The name that the rule is known by. The only restriction on this field is that it cannot contain spaces.
Rule Description	Free format field containing a meaningful description of the rule. This description is displayed during the selection of rules during the options configuration process.
Rule	A free format field containing the rule expression. The rule itself is called a "regular expression". The syntax is simple, but the expressions can be very complex. There is a short description of the syntax below. There are numerous tutorials on the Internet. Using any Internet search engine, search for "regexp tutorials".
OK	Click this button to store any changes to the database.
Cancel	Click this button to abandon any changes made to the database

Regular expressions have a syntax in which a few characters are special constructs and the rest are "ordinary". An ordinary character is a simple regular expression which matches that character and nothing else. The special characters are '\$', '^', '.', '*', '+', '?', '[', ']' and '\'. Any other character appearing in a regular expression is ordinary, unless preceded by '\'.

For example, 'f' is not a special character, so it is ordinary. It is a regular expression that matches the string 'f' and no other string. (It does not match the string 'ff'.) Likewise, 'o' is a regular expression that matches only 'o'.

Any two regular expressions A and B can be concatenated. The result is a regular expression which matches a string if A matches some amount of the beginning of that string and B matches the rest of the string.

As a simple example, we can concatenate the regular expressions 'f' and 'o' to get the regular expression 'fo', which matches only the string 'fo'.

The following are the characters and character sequences which have special meaning within regular expressions. Any character not mentioned here is not special; it stands for exactly itself for the purposes of searching and matching.

`.`	A special character that matches anything except a newline. Using concatenation, we can make regular expressions like `a.b` which matches any three-character string which begins with `a` and ends with `b`.
`*`	Not a construct by itself; it is a suffix, which means the preceding regular expression is to be repeated as many times as possible. For example, In `fo`, the `` applies to the `o`, so `fo` matches `f` followed by any number of `o`'s. The case of zero `o`'s is allowed: `fo` does match `f`. `` always applies to the smallest possible preceding expression. This means that `fo` has a repeating `o`, not a repeating `fo`. The matcher processes a `` construct by matching, immediately, as many repetitions as can be found. Then it continues with the rest of the pattern. If that fails, backtracking occurs, discarding some of the matches of the ``'d construct in case that makes it possible to match the rest of the pattern. For example, matching `c[ad]ar` against the string `caddaar`, the `[ad]` first matches `addaa`, but this does not allow the next `a` in the pattern to match. So the last of the matches of `[ad]` is undone and the following `a` is tried again. Now it succeeds.
`+`	Like `` except that at least one match for the preceding pattern is required for `+`. This means that `c[ad]+r` does not match `cr` but does match anything else that `c[ad]r` would match.
`?`	Like `*` except that it allows either zero or one match for the preceding pattern. This means that `c[ad]?r` matches `cr` or `car` or `cdr`, and nothing else.
`[`	Begins a "character set", which is terminated by a `]`. In the simplest case, the characters between the two square brackets form the set. This means that `[ad]` matches either `a` or `d`, and `[ad]` matches any string of `a`'s and `d`'s (including the empty string), from which it follows that `c[ad]r` matches `car`, and so forth. Character ranges can also be included in a character set, by writing two characters with a `-` (hyphen) between them. This means that `[a-z]` matches any lower-case letter. Ranges may be intermixed freely with individual characters, as in `[a-z$%.]`, which matches any lowercase letter or `$`, `%` or period. Note that the usual special characters are not special any more inside a character set. A completely different set of special characters exists inside character sets: `]`, `-` and ^. To include a `]` in a character set, you must make it the first character. For example, `[ ]a]` matches `]` or `a`. To include a `-`, you must use it in a context where it cannot possibly indicate a range: that is, as the first character, or immediately after a range.
[^	Begins a "complement character set", which matches any character except the ones specified. So, [^a-z0-9A-Z] matches all characters `except` letters and digits.
^	Not special in a character set unless it is the first character. The character following the ^ is treated as if it were first (it may be a `-` or a `]`). ^ is a special character that matches the empty string -- but only if at the beginning of a line in the text being matched. Otherwise it fails to match anything. This means that ^foo matches a `foo` which occurs at the beginning of a line.
`$`	Similar to ^ but matches only at the end of a line. This means that `xx*$` matches a string of one or more `x`'s at the end of a line.
`\`	Has two functions: it quotes the above special characters (including `\`), and it introduces additional special constructs. Because `\` quotes special characters, `\$` is a regular expression which matches only `$`, and `\ [` is a regular expression which matches only `[`, and so on. For the most part, `\` followed by any character matches only that character. However, there are several exceptions: characters which, when preceded by `\`, are special constructs. Such characters are always ordinary when encountered on their own. No new special characters are ever defined. All extensions to the regular expression syntax are made by defining new two-character constructs that begin with `\`.
`\\|`	Specifies an alternative. Two regular expressions A and B with `\\|` in between form an expression that matches anything that either A or B match. This means that `foo\\|bar` matches either `foo` or `bar` but no other string. `\\|` applies to the largest possible surrounding expressions. Only a surrounding `$ ... $` grouping can limit the grouping power of `\\|`. Full backtracking capability exists when multiple `\\|`'s are used.
`$ ... $`	Specifies a grouping construct to mark a matched substring for future reference. In the Micro Focus implementation, there is only one grouping allowed. The contents of this grouping are treated as the found filename for transfer. This last application is not a consequence of the idea of a parenthetical grouping; it is a separate feature which happens to be assigned as a second meaning to the same `$ ... $` construct because there is no conflict in practice between the two meanings. Here is an explanation of this feature:
`\n`	After the end of a `$ ... $` construct, the matcher remembers the beginning and end of the text matched by that construct. Then, later on in the regular expression, you can use `\` followed by `n` to mean "match the same text matched the n'th time by the `$ ... $` construct." The `$ ... $` constructs are numbered in order of commencement in the regular expression. The strings matching the first nine `$ ... $` constructs appearing in a regular expression are assigned numbers 1 through 9 in order of their beginnings. `\1` through `\9` may be used to refer to the text matched by the corresponding `$ ... $` construct. For example, `$.$\1` matches any string that is composed of two identical halves. The `$.$` matches the first half, which may be anything, but the `\1` that follows must match the same exact text.
`\b`	Matches the empty string, but only if it is at the beginning or end of a word. This means that `\bfoo\b` matches any occurrence of `foo` as a separate word. `\bball$s\\|$\b` matches `ball` or `balls` as a separate word.
`\B`	Matches the empty string, provided it is not at the beginning or end of a word.
`\<`	Matches the empty string, but only if it is at the beginning of a word.
`\>`	Matches the empty string, but only if it is at the end of a word.
`\w`	Matches any word-constituent character.
`\W`	Matches any character that is not a word-constituent.

Examples

^NULLFILE matches a file called NULLFILE and nothing else.
^NUL[0-9][0-9].* matches files beginning with NUL, followed by two numerics in the range 0-9, followed by any number of characters.
.*3$ matches any file ending with the number 3.
^A.*[0-3][1-2]$ matches any file beginning with the letter A, followed by any number of characters, the last two must be numeric and in the range 0-3 for the second last digit, and 1-2 for the last digit.
^(CON)|^(NUL)|^(COM[0-9])|^(LPT[1-9])|^(AUX)|^(CLOCK\$) excludes invalid DOS file names.
Note: You can include the $ character as part of the string by preceding it with a backslash.
If a rule is created like this and put in as an exclude filter when building the synchronisation item it would exclude all the invalid DOS filenames listed in this expression.
The above would also hold true for a file called CONTROL. To stop this put a $ metacharacter as follows : ^(CON)$ .... This would ensure that only CON would be recognised by the filter.