anchor.diff:          "// Create the interpreter from the transition and action tables."
           |> indentingWriter.WriteLine
   
  -        sprintf "FSharpx.Text.Lexing.UnicodeTables.Create (%s, %s)"
  +        sprintf "FSharpx.Text.Lexing.%sTables.Create (%s, %s)"
  +            (if options.Unicode then "Unicode" else "Ascii")
               transitionTableVariableName
               actionTableVariableName
           |> indentingWriter.WriteLine
  
positive.code:         |> ignore
  
      //
      let emit (compiledSpec : CompiledSpecification) (writer : #TextWriter) : unit =
          // Preconditions
          if writer = null then
              nullArg "writer"
  
negative.code:     let [<Literal>] private lexingStateVariableName = "_fslex_state"
  
      //
      let private asciiTransitionVectorElements (compiledRule, ruleDfaStateId, ruleStartingStateId, indentingWriter : IndentedTextWriter) =
          (*  The transition vector for each state in an 'fslex'-compatible ASCII transition table
              has 257 elements. The first 256 elements represent each possible ASCII value; the last
              element represents the 'end-of-file' marker and is always set to the sentinel value. *)
  
          // TEST
          let rightCurlyTransitions =
              (Set.empty, compiledRule.Dfa.Transitions.AdjacencyMap)
              ||> Map.fold (fun transitions edgeKey charSet ->
                  if CharSet.contains '}' charSet then
                      Set.add edgeKey transitions
                  else
                      transitions)
  
          // Emit the transition vector elements, based on the transitions out of this state.
          let ruleDfaTransitions = compiledRule.Dfa.Transitions
          for c = 0 to 255 do
              let targetStateId =
                  // Determine the id of the state we transition to when this character is the input.
                  // OPTIMIZE : This lookup is *really* slow -- we should create an optimized
                  // lookup table on-the-fly while compiling the DFA.
                  let targetStateId =
                      ruleDfaTransitions.AdjacencyMap
                      |> Map.tryPick (fun edgeKey edgeSet ->
                          if int edgeKey.Source = ruleDfaStateId &&
                              CharSet.contains (char c) edgeSet then
                              // Add the starting state of this rule to the relative DFA state id
                              // to get the DFA state id for the combined DFA table.
                              Some (int edgeKey.Target + ruleStartingStateId)
                          else None)
  
                  // If no transition edge was found for this character, return the
                  // sentinel value to indicate there's no transition.
                  defaultArg targetStateId (int sentinelValue)
  
              // Emit the state number of the transition target.
              sprintf "%uus; " targetStateId
              |> indentingWriter.Write
  
          // Emit the element representing the 'end-of'file' marker.
          sprintf "%uus; " sentinelValue
          |> indentingWriter.Write
  
      //
      let private unicodeTransitionVectorElements (compiledRule, ruleDfaStateId, ruleStartingStateId, indentingWriter : IndentedTextWriter) =
          raise <| System.NotImplementedException "unicodeTransitionVectorElements"
          ()
  
      //
      let private transitionAndActionTables (compiledRules : Map<RuleIdentifier, CompiledRule>) (options : CompilationOptions) (indentingWriter : IndentedTextWriter) =
          /// The combined number of DFA states in all of the DFAs.
          let combinedDfaStateCount =
              (0, compiledRules)
  