anchor.diff:                      sprintf "| %s of (%s)" caseName caseType
                   |> writer.WriteLine)
   
  -    //
  -    let private valueMap (map : Map<'Key, 'T>) =
  +    /// Emits code which declares a literal integer value into a TextWriter.
  +    let private intLiteralDecl (name, isPublic, value : int) (writer : #TextWriter) =
  +        // Preconditions
  +        if System.String.IsNullOrWhiteSpace name then
  +            invalidArg "name" "The variable name cannot be null/empty/whitespace."
  +
  +        if isPublic then
  +            sprintf "let [<Literal>] %s = %i" name value
  +        else
  +            sprintf "let [<Literal>] private %s = %i" name value
  +        |> writer.WriteLine
  +
  +    /// Creates a Map whose keys are the values of the given Map.
  +    /// The value associated with each key is None.
  +    let private valueMap (map : Map<'Key, 'T>) : Map<'T, 'U option> =
           (Map.empty, map)
           ||> Map.fold (fun valueMap _ value ->
               Map.add value None valueMap)
  +
  +    /// The name of the end-of-input terminal.
  +    let [<Literal>] private endOfInputTerminal : TerminalIdentifier = "end_of_input"
  +    /// The name of the error terminal.
  +    let [<Literal>] private errorTerminal : TerminalIdentifier = "error"
   
       //
       let emit (processedSpec : ProcessedSpecification<NonterminalIdentifier, TerminalIdentifier>,
  
positive.code: 
          // Emit the symbolic nonterminal type declaration.
          quickSummary writer "This type is used to give symbolic names to token indexes, useful for error messages."
          unionTypeDecl ("nonterminalId", false, valueMap symbolicNonterminalNames) writer
          writer.WriteLine ()
  
          /// Integer indices (tags) of terminals (tokens).
  
negative.code:                 writer.WriteLine (line.Trim ())
                  ))
  
      /// <summary>Emits the declaration of a discriminated union type into an IndentedTextWriter.</summary>
      /// <param name="typeName">The name of the type.</param>
      /// <param name="isPublic">When set, the type will be publicly-visible.</param>
      /// <param name="cases">A map containing the names (and types, if applicable) of the cases.</param>
      /// <param name="writer">The IndentedTextWriter into which to write the code.</param>
      let private unionTypeDecl (typeName : string, isPublic, cases : Map<string, string option>) (writer : IndentedTextWriter) =
          // Write the type declaration
          if isPublic then
  