anchor.diff:          precedence table to the constructed parser table to (possibly) resolve some
           of them. At this point, if there aren't any remaining conflicts, report that
           the grammar is LR(0) and return. *)
  -    //
  -    let lr0Table = Lr0.createTable grammar
  +    
  +    /// The LR(0) parser table.
  +    let lr0Table =
  +        tprintf "  Creating the LR(0) parser table..."
  +        let lr0Table = Lr0.createTable grammar
  +        tprintfn "done."
  +        lr0Table
   
       (*  Upgrade the LR(0) automaton to SLR(1); report the remaining number of S/R and
           R/R conflicts. If there aren't any remaining conflicts, report that the grammar
           is SLR(1) and return. *)
       //
  -    let slr1Table = Slr1.upgrade (grammar, lr0Table, productionRuleIds)        
  +    let slr1Table =
  +        tprintf "  Upgrading the LR(0) parser table to SLR(1)..."
  +        let slr1Table = Slr1.upgrade (grammar, lr0Table, productionRuleIds)
  +        tprintfn "done."
  +        slr1Table
   
       (*  Upgrade the LR(0)/SLR(1) automaton to LALR(1); report the remaining number of
           S/R and R/R conflicts. If there aren't any remaining conflicts, report that the
           grammar is LALR(1) and return. *)
       //
       let lalrLookaheadSets =
  -        Lalr1.lookaheadSets (grammar, slr1Table)
  +        tprintf "  Computing LALR(1) look-ahead sets..."
  +        let lalrLookaheadSets = Lalr1.lookaheadSets (grammar, slr1Table)
  +        tprintfn "done."
  +        lalrLookaheadSets
   
       // If we detected that the grammar is not LR(k), stop and return an error message.
       match lalrLookaheadSets with
  
positive.code:     | Choice1Of2 lookaheadSets ->
          //
          let lalr1Table =
              Lalr1.upgrade (grammar, slr1Table, productionRuleIds, lookaheadSets)
  
          (* Apply precedence settings to resolve as many conflicts as possible. *)
          /// The LALR(1) parser table, after applying precedence settings.
          let lalr1Table =
              // Apply precedences to resolve conflicts.
              Lr0.applyPrecedence (lalr1Table, precedenceSettings)
              
          (*  If we reach this point, the grammar is not LALR(1), but we can still create a
              parser by taking certain actions to resolve any remaining conflicts.
  
negative.code: /// Compiles a parser specification into a deterministic pushdown automaton (DPDA),
  /// then invokes a specified backend to generate code implementing the parser automaton.
  let compile (processedSpec : ProcessedSpecification<_,_>, options : CompilationOptions) : Choice<_,_> =
      tprintfn "Compiling the parser specification..."
  
      /// The grammar created from the parser specification.
      let grammar =
          //
  