anchor.diff:          |> Option.iter indentingWriter.WriteLine
   
   //
  -let generateString (compiledSpec : CompiledSpecification) =
  +let generateString (compiledSpec : CompiledSpecification) (options : CompilationOptions) =
       //
       let codeStringBuilder = StringBuilder ()
       
       //
  -    using (new StringWriter (codeStringBuilder)) (FsLex.emit compiledSpec)
  +    using (new StringWriter (codeStringBuilder)) (FsLex.emit compiledSpec options)
   
       // Return the generated code string.
       codeStringBuilder.ToString ()
  
positive.code:                     indentingWriter.Write "[| "
  
                      // Emit the transition vector elements, based on the transitions out of this state.
                      let maxCharValue = int maxCharValue
                      for c = 0 to maxCharValue 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 closing bracket of the transition vector for this state,
                      // plus a semicolon to separate it from the next state's transition vector.
  
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)
  