docs: void recover()
                      throws HashtableOnDiskException,
                      FileManagerException,
                      ClassNotFoundException,
                      IOException,
                      EOFException {
  
          println("recover(): Hashtable recover starts");
  
          //
          // Step 1 - check the two table pointers.  If only one is set it must
          //          also be the current pointer.  If only one is set we need only
          //          reset the rehashInProgress indicator and return.  Otherwise
          //          we continue to the next step.
  
          boolean done = false;
          if (header.tableLocation[0] == 0) { // Is there a table 0 pointer?
              if (header.currentTablePtr == 1) { // no .check - make sure current
                                                 // is for table 1.
                  if (header.tableLocation[1] != 0) { // And verify that table1 has a pointer
                      header.tableLocation[0] = 0;
                      header.tablesize[0] = 0;
                      done = true; // all ok
                  } else {
                      throw new HashtableOnDiskException( // 
                                                         "Cannot recover hashtable, no valid table pointers.");
                  }
  
              } else {
                  throw new HashtableOnDiskException(
                                                     "Cannot recover hashtable, current table pointer is invalid.");
              }
          } else if (header.tableLocation[1] == 0) { // Is there a table 1 pointer?
              if (header.currentTablePtr == 0) { // no check - make sure current
                                                 // is for table 0.
                  if (header.tableLocation[0] != 0) { // And verify that table1 has a pointer
                      header.tableLocation[1] = 0;
                      header.tablesize[1] = 0;
                      done = true; // all ok
                  } else {
                      throw new HashtableOnDiskException( // 
                                                         "Cannot recover hashtable, no valid table pointers.");
                  }
  
              } else {
                  throw new HashtableOnDiskException(
                                                     "Cannot recover hashtable, current table pointer is invalid.");
              }
          }
  
          if (done) {
              println("Recover(): ended - previous rehash did not enter critical section.");
              header.set_num_objects(0);
              header.rehashInProgress = 0;
              header.write();
              return;
          }
  
          //
          // Step 2. If we get here then both tables have pointers.  We must now
          //         look in every entry in the "new" table to see if it also occurs in
          //         the "old" table. If no entry occurs in both tables we can simply 
          //         restart the rehash.  Otherwise we must do some fixups first.
          //
          //         If we do a fixup, we must not find any other inconsistencies,
          //         since only a single entry is ever allowed to be inconsistent
          //         at a time.        
          //
          long new_table = header.alternateTable();
          int new_table_size = header.alternateSize();
          new_htindex = new long[new_table_size];
  
          println("Recover(): clearing inconsistencies");
  
          //
          clearInconsistencies(new_table, new_table_size);
          // Step 3. Resume the rehash process.
          //
          println("Recover(): resuming rehash.");
  
          iterationLock.p(); // released in rehashAllEntries, which is
                             // invoked in a new thread (see below)
  
          Rehash rehash = new Rehash(this, new_table, new_table_size);
          Thread t = new Thread(rehash);
          t.start();
      }