XML Schema Character Classes and Subtraction Explained (Page 24)

XML Schema introduces unique character classes and features not commonly found in other regular expression flavors. These classes are particularly useful for validating XML names and values, making XML Schema regex syntax essential for working with XML data.

Special Character Classes in XML Schema

In addition to the six standard shorthand character classes (e.g., \d for digits, \w for word characters), XML Schema introduces four unique shorthand character classes designed specifically for XML name validation:

These character classes simplify the creation of regex patterns for XML validation. For example, to match a valid XML name, you can use:

\i\c*

This regex matches an XML name like "xml:schema". Without these shorthand classes, the same pattern would need to be written as:

[_:A-Za-z][-._:A-Za-z0-9]*

The shorthand version is much more concise and easier to read.

Practical Examples Using XML Schema Character Classes

Here are some common use cases for these shorthand classes in XML validation:

For example, the pattern:

<(\i\c*(\s+\i\c*\s*=\s*("[^"]*"|'[^']*'))*|/\i\c*)\s*>

Matches both opening tags with attributes and closing tags.

Character Class Subtraction in XML Schema

XML Schema introduces a powerful feature called character class subtraction, which allows you to exclude certain characters from a class. The syntax for character class subtraction is:

[class-[subtract]]

This feature simplifies regex patterns that would otherwise be lengthy or complex. For example:

[a-z-[aeiou]]

This pattern matches any lowercase letter except vowels (i.e., consonants). Without class subtraction, you’d have to list all consonants explicitly:

[b-df-hj-np-tv-z]

Character class subtraction is more than just a shortcut — it allows you to use complex character class syntax within the subtracted class. For instance:

[\p{L}-[\p{IsBasicLatin}]]

This matches all Unicode letters except basic ASCII letters, effectively targeting non-English letters.

Nested Character Class Subtraction

One of the more advanced features of XML Schema regex is nested class subtraction, where you can subtract a class from another class that is already being subtracted. For example:

[0-9-[0-6-[0-3]]]

Let’s break this down:

1. 0-6 matches digits from 0 to 6.
2. Subtracting 0-3 leaves 4-6.
3. The final class becomes 0-9-[4-6], which matches "0123789".

Important Rules for Class Subtraction

• The subtraction must always be the last element in the character class. For example:

  ✅ Correct: [0-9a-f-[4-6]]
  ❌ Incorrect: [0-9-[4-6]a-f]

• Subtraction applies to the entire class, not just the last part. For example:

  [\p{Ll}\p{Lu}-[\p{IsBasicLatin}]]
  

  This pattern matches all uppercase and lowercase Unicode letters, excluding basic ASCII letters.

Notational Compatibility with Other Regex Flavors

While character class subtraction is a unique feature of XML Schema, it’s also supported by .NET and JGsoft regex engines. However, most other regex flavors (like Perl, JavaScript, and Python) don’t support this feature.

If you try to use a pattern like [a-z-[aeiou]] in a regex engine that doesn’t support class subtraction, it won’t throw an error — but it won’t behave as expected either. Instead, it will interpret the pattern as:

[a-z-[aeiou]]

This is treated as a character class followed by a literal closing bracket (]), which is not what you intended. The pattern will match:

• Any lowercase letter (a-z)
• A hyphen (-)
• An opening bracket ([)
• Any vowel (aeiou)

Because of this, be cautious when using character class subtraction in cross-platform regex patterns. Stick to traditional character classes if compatibility is a concern.

Best Practices for XML Schema Regex

When using XML Schema regular expressions:

1. Leverage shorthand character classes like \i and \c to simplify patterns.
2. Use character class subtraction to exclude specific characters, especially when working with Unicode.
3. Be mindful of compatibility with other regex flavors. XML Schema regex syntax may not work in Perl, JavaScript, or Python without modification.

Summary of XML Schema Regex Features

XML Schema regular expressions introduce useful shorthand character classes and the powerful feature of character class subtraction, making them essential for validating XML documents efficiently. However, it’s important to understand the limitations and compatibility issues when using these features outside of XML Schema-specific environments.

By mastering these features, you’ll be able to write concise, effective regex patterns for parsing and validating XML content.