anchor.diff:      let compiledPatternDfa =
           let regexOriginalClauseIndices, ruleClauseRegexes =
               Array.unzip ruleClauseRegexes
  -            
  -        (* TEMP :   For compatibility with fslex, we need to determine the alphabet used
  -                    by the rule, then rewrite any negated character sets so the transition
  -                    table is generated in a way that fslex can handle. *)
  -
  -        // Rewrite the regexes so they don't contain negated character sets.
  +
  +        // TEMP : Rewrite the regexes so they don't contain negated character sets.
  +        //        This avoids a non-termination bug which is triggered by certain patterns containing negated character sets.
           let ruleClauseRegexes =
  -            let ruleAlphabet =
  -                ruleClauseRegexes
  -                |> Array.mapReduce regexAlphabetMapReduce
  -                // fslex compatibility: Always add the standard (low) ASCII characters, like fslex does.
  -                |> CharSet.union (CharSet.ofRange (char 0) (char 127))
  +            let universe =
  +                if options.Unicode then
  +                    CharSet.ofRange System.Char.MinValue System.Char.MaxValue
  +                else
  +                    CharSet.ofRange (char System.Byte.MinValue) (char System.Byte.MaxValue)
   
               ruleClauseRegexes
  -            |> Array.map (rewriteNegatedCharSets ruleAlphabet)
  +            |> Array.map (rewriteNegatedCharSets universe)
   
           rulePatternsToDfa ruleClauseRegexes regexOriginalClauseIndices options
   
  
positive.code: /// </param>
  /// <param name="regex">A regular expression.</param>
  /// <returns>A regular expression created by transforming negated character sets into positive character sets.</returns>
  /// <remarks>
  /// This is only necessary for fslex compatibility; once fsharplex has it's own backend (e.g., direct-style),
  /// this won't be needed anymore (though it may be retained as a library function for diagnostics purposes).
  /// </remarks>
  let private rewriteNegatedCharSets universe regex =
      let rec rewriteNegatedCharSets regex =
          cont {
  
negative.code:             // Only the earliest use of the "eof" pattern will be matched.
              let acceptingClauseIndex, neverMatchedClauseIndices = Set.extractMin eofClauseIndices
  
              // TODO : Return warning messages (with location info) about patterns which will never be matched.
              // TEMP : In the meantime, print warnings to the debug console for development purposes.
              neverMatchedClauseIndices
              |> Set.iter (fun clauseIndex ->
                  Printf.dprintfn "This pattern will never be matched. (ClauseIndex = %i)" <| int clauseIndex)
  
              Some acceptingClauseIndex
  
  