# Regular Expressions

This section gives some examples of useful regular expressions, together with a table that defines the expressions supported by HCL Workload Automation. Further information about regular expressions is also widely available in the Internet.

## Useful regular expressions

The following table shows some useful regular expressions for use with the plan extractor, both for filtering jobs and job streams, and for configuring business unit names.

Requirement | Regular expression | Example |
---|---|---|

To obtain the same effect as using the "@"character in the Tivoli Workload Scheduler command line | .* | -JScpu .* Used as a parameter to the plan extractor, filters for all job stream workstations. |

To join different criteria in an "OR" relationship | | | (XYZ.*)|(.*ABC.*)Filters for all items that begin with the string "XYZ or that contain the string "ABC" (regular expressions are case-sensitive). |

To select objects that begin with one of several characters | [<the characters to be included>] |
[ABC].*Filters for all items that begin with either "A", "B", or "C". |

To select objects that do not begin with one of several characters | [^<the characters to be excluded>] |
[^ABC].*Filters for all items that do not begin with either "A", "B", or "C". |

To select objects in which certain characters appear a certain number of times | <the character to be counted>{<the
character count>} |
A{3}.*Filters for all items that begin with the string "AAA". |

To select objects in which certain characters appear at least a certain number of times | <the character to be counted>{<the
character count>} |
A{3,}.*Filters for all items that begin with the string "AAA", "AAAA", "AAAAA", and so on. |

To select objects in which certain characters appear at least a certain number of times, but not more than a certain number of times | <the character to be counted>{<the
lower character count>,<the upper character count>,} |
A{3,4}.*Filters for all items that begin with the string "AAA", or "AAAA"; a string that began with "AAAAA" would not be selected. |

## Complex expressions

These individual regular expressions can be combined to make a complex expression, as shown in the following table.

Example requirement | Regular expression |
---|---|

Select all strings that begin with "AA", "AB", "AC", "BA", "BB", "BC", "CA", "CB", or "CC", and also those that do not end in "X", "Y", or "Z". | ([ABC]{2}.*)|(.*[^XYZ]) |

Select all strings that begin with "AA" followed
by either one or more numbers or one or more letters, and then by
the character "_". It can finish with any characters. This would,
for example, select the string |
A{2}([0-9]+|[A-Z]+)_.* |

## Regular expressions supported by the plan extractor

The following tables provide full details of the regular expressions supported by the plan extractor.

Syntax | Filters for? |
---|---|

x |
The character x (regular expressions
are case-sensitive) |

\\ |
The backslash character |

\0n |
The character with octal value 0n (0 <=
n <= 7) |

\0nn |
The character with octal value \0nn (0 <=
n <= 7) |

\0mnn |
The character with octal value \0mnn(0 <=
m <= 3, 0 <= n <= 7) |

\0xhh |
The character with hexadecimal value 0xhh |

\uhhhh |
The character with hexadecimal value 0xhhhh |

\t |
The tab character ('\u0009') |

\n |
The newline (line feed) character ('\u000A') |

\r |
The carriage-return character ('\u000D') |

\f |
The form-feed character ('\u000C') |

\a |
The alert (bell) character ('\u0007') |

\e |
The escape character ('\u001B') |

\cx |
The control character corresponding to x |

Syntax | Filters for? |
---|---|

[abc] |
a, b, or c (simple
class) |

[^abc] |
Any character except a, b,
or c (negation) |

[a-zA-Z] |
a through z or A through Z,
inclusive (range) |

[a-d[m-p]] |
a through d,
or m through p: [a-dm-p] (union) |

[a-z&&[def]] |
d, e, or f (intersection) |

[a-z&&[^bc]] |
a through z,
except for b and c: [ad-z] (subtraction) |

[a-z&&[^m-p]] |
a through z,
and not m through p: [a-lq-z] (subtraction) |

Syntax | Filters for? |
---|---|

. |
Any character (might or might not match line terminators) |

\d |
A digit: [0-9] |

\D |
A non-digit: [^0-9] |

\s |
A whitespace character: [ \t\n\x0B\f\r] |

\S |
A non-whitespace character: [^\s] |

\w |
A word character: [a-zA-Z_0-9] |

\W |
A non-word character: [^\w] |

Syntax | Filters for? |
---|---|

\p{Lower} |
A lowercase alphabetic character: [a-z] |

\p{Upper} |
An uppercase alphabetic character:[A-Z] |

\p{ASCII} |
All ASCII:[\x00-\x7F] |

\p{Alpha} |
An alphabetic character: [\p{Lower}\p{Upper}] |

\p{Digit} |
A decimal digit: [0-9] |

\p{Alnum} |
An alphanumeric character: [\p{Alpha}\p{Digit}] |

\p{Punct} |
Punctuation: One of !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ |

\p{Graph} |
A visible character: [\p{Alnum}\p{Punct}] |

\p{Print} |
A printable character: [\p{Graph}] |

\p{Blank} |
A space or a tab: [ \t] |

\p{Cntrl} |
A control character: [\x00-\x1F\x7F] |

\p{XDigit} |
A hexadecimal digit: [0-9a-fA-F] |

\p{Space} |
A whitespace character: [ \t\n\x0B\f\r] |

Syntax | Filters for? |
---|---|

\p{InGreek} |
A character in the Greek block (simple block) |

\p{Lu} |
An uppercase letter (simple category) |

\\p{Sc} |
A currency symbol |

\P{InGreek} |
Any character except one in the Greek block (negation) |

[\p{L}&&[^\p{Lu}]] |
Any letter except an uppercase letter (subtraction) |

Syntax | Filters for? |
---|---|

^ |
The beginning of a line |

$ |
The end of a line |

\b |
A word boundary |

\B |
A non-word boundary |

\A |
The beginning of the input |

\G |
The end of the previous match |

\Z |
The end of the input but for the final terminator, if any |

\z |
The end of the input |

Syntax | Filters for? |
---|---|

X? |
X, once or not at all |

X* |
X, zero or more times |

X+ |
X, one or more times |

X{n} |
X, exactly n times |

X{n,} |
X, at least n times |

X{n,m} |
X, at least n but not
more than m times |

Syntax | Filters for? |
---|---|

X?? |
X, once or not at all |

X*? |
X, zero or more times |

X+? |
X, one or more times |

X{n}? |
X, exactly n times |

X{n,}? |
X, at least n times |

X{n,m}? |
X, at least n but not
more than m times |

Syntax | Filters for? |
---|---|

X?+ |
X, once or not at all |

X*+ |
X, zero or more times |

X++ |
X, one or more times |

X{n}+ |
X, exactly n times |

X{n,}+ |
X, at least n times |

X{n,m}+ |
X, at least n but not
more than m times |

Syntax | Filters for? |
---|---|

XY |
X followed by Y |

X|Y |
Either X or Y |

(X) |
X, as a capturing group |

Syntax | Filters for? |
---|---|

\n |
Whatever the nth capturing group matched |

Syntax | Filters for? |
---|---|

\ |
Nothing, but quotes the following character |

\Q |
Nothing, but quotes all characters until \E |

\E |
Nothing, but quotes all characters until \Q |

Syntax | Filters for? |
---|---|

(?:X) |
X, as a non-capturing group |

(?idmsux-idmsux) |
Nothing, but turns match flags on - off |

(?idmsux-idmsux:X) |
X, as a non-capturing group
with the given flags on - off |

(?=X) |
X, via zero-width positive
lookahead |

(?!X) |
X, via zero-width negative
lookahead |

(?<=X) |
X, via zero-width positive
lookbehind |

(?<!X) |
X, via zero-width positive
lookbehind |

(?>X) |
X, as an independent, non-capturing
group |