Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1936 insertions, 0 deletions

diff --git a/comm/mailnews/db/mork/morkWriter.cpp b/comm/mailnews/db/mork/morkWriter.cpp
new file mode 100644
index 0000000000..dc1bb1a1ed
--- /dev/null
+++ b/comm/mailnews/db/mork/morkWriter.cpp
@@ -0,0 +1,1936 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-  */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _MDB_
+#  include "mdb.h"
+#endif
+
+#ifndef _MORK_
+#  include "mork.h"
+#endif
+
+#ifndef _MORKBLOB_
+#  include "morkBlob.h"
+#endif
+
+#ifndef _MORKNODE_
+#  include "morkNode.h"
+#endif
+
+#ifndef _MORKENV_
+#  include "morkEnv.h"
+#endif
+
+#ifndef _MORKARRAY_
+#  include "morkWriter.h"
+#endif
+
+// #ifndef _MORKFILE_
+// #include "morkFile.h"
+// #endif
+
+#ifndef _MORKSTREAM_
+#  include "morkStream.h"
+#endif
+
+#ifndef _MORKSTORE_
+#  include "morkStore.h"
+#endif
+
+#ifndef _MORKATOMSPACE_
+#  include "morkAtomSpace.h"
+#endif
+
+#ifndef _MORKROWSPACE_
+#  include "morkRowSpace.h"
+#endif
+
+#ifndef _MORKROWMAP_
+#  include "morkRowMap.h"
+#endif
+
+#ifndef _MORKATOMMAP_
+#  include "morkAtomMap.h"
+#endif
+
+#ifndef _MORKROW_
+#  include "morkRow.h"
+#endif
+
+#ifndef _MORKTABLE_
+#  include "morkTable.h"
+#endif
+
+#ifndef _MORKCELL_
+#  include "morkCell.h"
+#endif
+
+#ifndef _MORKATOM_
+#  include "morkAtom.h"
+#endif
+
+#ifndef _MORKCH_
+#  include "morkCh.h"
+#endif
+
+// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
+
+// ````` ````` ````` ````` `````
+// { ===== begin morkNode interface =====
+
+/*public virtual*/ void morkWriter::CloseMorkNode(
+    morkEnv* ev)  // CloseTable() only if open
+{
+  if (this->IsOpenNode()) {
+    this->MarkClosing();
+    this->CloseWriter(ev);
+    this->MarkShut();
+  }
+}
+
+/*public virtual*/
+morkWriter::~morkWriter()  // assert CloseTable() executed earlier
+{
+  MORK_ASSERT(this->IsShutNode());
+  MORK_ASSERT(mWriter_Store == 0);
+}
+
+/*public non-poly*/
+morkWriter::morkWriter(morkEnv* ev, const morkUsage& inUsage,
+                       nsIMdbHeap* ioHeap, morkStore* ioStore,
+                       nsIMdbFile* ioFile, nsIMdbHeap* ioSlotHeap)
+    : morkNode(ev, inUsage, ioHeap),
+      mWriter_Store(0),
+      mWriter_File(0),
+      mWriter_Bud(0),
+      mWriter_Stream(0),
+      mWriter_SlotHeap(0)
+
+      ,
+      mWriter_CommitGroupIdentity(0)  // see mStore_CommitGroupIdentity
+      ,
+      mWriter_GroupBufFill(0)
+
+      ,
+      mWriter_TotalCount(morkWriter_kCountNumberOfPhases),
+      mWriter_DoneCount(0)
+
+      ,
+      mWriter_LineSize(0),
+      mWriter_MaxIndent(morkWriter_kMaxIndent),
+      mWriter_MaxLine(morkWriter_kMaxLine)
+
+      ,
+      mWriter_TableForm(0),
+      mWriter_TableAtomScope('v'),
+      mWriter_TableRowScope(0),
+      mWriter_TableKind(0)
+
+      ,
+      mWriter_RowForm(0),
+      mWriter_RowAtomScope(0),
+      mWriter_RowScope(0)
+
+      ,
+      mWriter_DictForm(0),
+      mWriter_DictAtomScope('v')
+
+      ,
+      mWriter_NeedDirtyAll(morkBool_kFalse),
+      mWriter_Incremental(morkBool_kTrue)  // opposite of mWriter_NeedDirtyAll
+      ,
+      mWriter_DidStartDict(morkBool_kFalse),
+      mWriter_DidEndDict(morkBool_kTrue)
+
+      ,
+      mWriter_SuppressDirtyRowNewline(morkBool_kFalse),
+      mWriter_DidStartGroup(morkBool_kFalse),
+      mWriter_DidEndGroup(morkBool_kTrue),
+      mWriter_Phase(morkWriter_kPhaseNothingDone)
+
+      ,
+      mWriter_BeVerbose(ev->mEnv_BeVerbose)
+
+      ,
+      mWriter_TableRowArrayPos(0)
+
+      // empty constructors for map iterators:
+      ,
+      mWriter_StoreAtomSpacesIter(),
+      mWriter_AtomSpaceAtomAidsIter()
+
+      ,
+      mWriter_StoreRowSpacesIter(),
+      mWriter_RowSpaceTablesIter(),
+      mWriter_RowSpaceRowsIter() {
+  mWriter_GroupBuf[0] = 0;
+
+  mWriter_SafeNameBuf[0] = 0;
+  mWriter_SafeNameBuf[morkWriter_kMaxColumnNameSize * 2] = 0;
+  mWriter_ColNameBuf[0] = 0;
+  mWriter_ColNameBuf[morkWriter_kMaxColumnNameSize] = 0;
+
+  mdbYarn* y = &mWriter_ColYarn;
+  y->mYarn_Buf = mWriter_ColNameBuf;              // where to put col bytes
+  y->mYarn_Fill = 0;                              // set later by writer
+  y->mYarn_Size = morkWriter_kMaxColumnNameSize;  // our buf size
+  y->mYarn_More = 0;                              // set later by writer
+  y->mYarn_Form = 0;                              // set later by writer
+  y->mYarn_Grow = 0;                              // do not allow buffer growth
+
+  y = &mWriter_SafeYarn;
+  y->mYarn_Buf = mWriter_SafeNameBuf;                 // where to put col bytes
+  y->mYarn_Fill = 0;                                  // set later by writer
+  y->mYarn_Size = morkWriter_kMaxColumnNameSize * 2;  // our buf size
+  y->mYarn_More = 0;                                  // set later by writer
+  y->mYarn_Form = 0;                                  // set later by writer
+  y->mYarn_Grow = 0;  // do not allow buffer growth
+
+  if (ev->Good()) {
+    if (ioSlotHeap && ioFile && ioStore) {
+      morkStore::SlotWeakStore(ioStore, ev, &mWriter_Store);
+      nsIMdbFile_SlotStrongFile(ioFile, ev, &mWriter_File);
+      nsIMdbHeap_SlotStrongHeap(ioSlotHeap, ev, &mWriter_SlotHeap);
+      if (ev->Good()) {
+        mNode_Derived = morkDerived_kWriter;
+      }
+    } else
+      ev->NilPointerError();
+  }
+}
+
+void morkWriter::MakeWriterStream(morkEnv* ev)  // give writer a suitable stream
+{
+  mWriter_Incremental = !mWriter_NeedDirtyAll;  // opposites
+
+  if (!mWriter_Stream && ev->Good()) {
+    if (mWriter_File) {
+      morkStream* stream = 0;
+      mork_bool frozen = morkBool_kFalse;  // need to modify
+      nsIMdbHeap* heap = mWriter_SlotHeap;
+
+      if (mWriter_Incremental) {
+        stream =
+            new (*heap, ev) morkStream(ev, morkUsage::kHeap, heap, mWriter_File,
+                                       morkWriter_kStreamBufSize, frozen);
+      } else  // compress commit
+      {
+        nsIMdbFile* bud = 0;
+        mWriter_File->AcquireBud(ev->AsMdbEnv(), heap, &bud);
+        if (bud) {
+          if (ev->Good()) {
+            mWriter_Bud = bud;
+            stream =
+                new (*heap, ev) morkStream(ev, morkUsage::kHeap, heap, bud,
+                                           morkWriter_kStreamBufSize, frozen);
+          } else
+            bud->Release();
+        }
+      }
+
+      if (stream) {
+        if (ev->Good())
+          mWriter_Stream = stream;
+        else
+          stream->CutStrongRef(ev->AsMdbEnv());
+      }
+    } else
+      this->NilWriterFileError(ev);
+  }
+}
+
+/*public non-poly*/ void morkWriter::CloseWriter(
+    morkEnv* ev)  // called by CloseMorkNode();
+{
+  if (this->IsNode()) {
+    morkStore::SlotWeakStore((morkStore*)0, ev, &mWriter_Store);
+    nsIMdbFile_SlotStrongFile((nsIMdbFile*)0, ev, &mWriter_File);
+    nsIMdbFile_SlotStrongFile((nsIMdbFile*)0, ev, &mWriter_Bud);
+    morkStream::SlotStrongStream((morkStream*)0, ev, &mWriter_Stream);
+    nsIMdbHeap_SlotStrongHeap((nsIMdbHeap*)0, ev, &mWriter_SlotHeap);
+    this->MarkShut();
+  } else
+    this->NonNodeError(ev);
+}
+
+// } ===== end morkNode methods =====
+// ````` ````` ````` ````` `````
+
+/*static*/ void morkWriter::NonWriterTypeError(morkEnv* ev) {
+  ev->NewError("non morkWriter");
+}
+
+/*static*/ void morkWriter::NilWriterStoreError(morkEnv* ev) {
+  ev->NewError("nil mWriter_Store");
+}
+
+/*static*/ void morkWriter::NilWriterBudError(morkEnv* ev) {
+  ev->NewError("nil mWriter_Bud");
+}
+
+/*static*/ void morkWriter::NilWriterFileError(morkEnv* ev) {
+  ev->NewError("nil mWriter_File");
+}
+
+/*static*/ void morkWriter::NilWriterStreamError(morkEnv* ev) {
+  ev->NewError("nil mWriter_Stream");
+}
+
+/*static*/ void morkWriter::UnsupportedPhaseError(morkEnv* ev) {
+  ev->NewError("unsupported mWriter_Phase");
+}
+
+mork_bool morkWriter::WriteMore(
+    morkEnv* ev)  // call until IsWritingDone() is true
+{
+  if (this->IsOpenNode()) {
+    if (this->IsWriter()) {
+      if (!mWriter_Stream) this->MakeWriterStream(ev);
+
+      if (mWriter_Stream) {
+        if (ev->Bad()) {
+          ev->NewWarning("writing stops on error");
+          mWriter_Phase = morkWriter_kPhaseWritingDone;
+        }
+        switch (mWriter_Phase) {
+          case morkWriter_kPhaseNothingDone:
+            OnNothingDone(ev);
+            break;
+
+          case morkWriter_kPhaseDirtyAllDone:
+            OnDirtyAllDone(ev);
+            break;
+
+          case morkWriter_kPhasePutHeaderDone:
+            OnPutHeaderDone(ev);
+            break;
+
+          case morkWriter_kPhaseRenumberAllDone:
+            OnRenumberAllDone(ev);
+            break;
+
+          case morkWriter_kPhaseStoreAtomSpaces:
+            OnStoreAtomSpaces(ev);
+            break;
+
+          case morkWriter_kPhaseAtomSpaceAtomAids:
+            OnAtomSpaceAtomAids(ev);
+            break;
+
+          case morkWriter_kPhaseStoreRowSpacesTables:
+            OnStoreRowSpacesTables(ev);
+            break;
+
+          case morkWriter_kPhaseRowSpaceTables:
+            OnRowSpaceTables(ev);
+            break;
+
+          case morkWriter_kPhaseTableRowArray:
+            OnTableRowArray(ev);
+            break;
+
+          case morkWriter_kPhaseStoreRowSpacesRows:
+            OnStoreRowSpacesRows(ev);
+            break;
+
+          case morkWriter_kPhaseRowSpaceRows:
+            OnRowSpaceRows(ev);
+            break;
+
+          case morkWriter_kPhaseContentDone:
+            OnContentDone(ev);
+            break;
+
+          case morkWriter_kPhaseWritingDone:
+            OnWritingDone(ev);
+            break;
+
+          default:
+            this->UnsupportedPhaseError(ev);
+        }
+      } else
+        this->NilWriterStreamError(ev);
+    } else
+      this->NonWriterTypeError(ev);
+  } else
+    this->NonOpenNodeError(ev);
+
+  return ev->Good();
+}
+
+static const char morkWriter_kHexDigits[] = "0123456789ABCDEF";
+
+mork_size morkWriter::WriteYarn(morkEnv* ev, const mdbYarn* inYarn)
+// return number of atom bytes written on the current line (which
+// implies that escaped line breaks will make the size value smaller
+// than the entire yarn's size, since only part goes on a last line).
+{
+  mork_size outSize = 0;
+  mork_size lineSize = mWriter_LineSize;
+  morkStream* stream = mWriter_Stream;
+
+  const mork_u1* b = (const mork_u1*)inYarn->mYarn_Buf;
+  if (b) {
+    int c;
+    mork_fill fill = inYarn->mYarn_Fill;
+
+    const mork_u1* end = b + fill;
+    while (b < end && ev->Good()) {
+      if (lineSize + outSize >= mWriter_MaxLine)  // continue line?
+      {
+        stream->PutByteThenNewline(ev, '\\');
+        mWriter_LineSize = lineSize = outSize = 0;
+      }
+
+      c = *b++;  // next byte to print
+      if (morkCh_IsValue(c)) {
+        stream->Putc(ev, c);
+        ++outSize;  // c
+      } else if (c == ')' || c == '$' || c == '\\') {
+        stream->Putc(ev, '\\');
+        stream->Putc(ev, c);
+        outSize += 2;  // '\' c
+      } else {
+        outSize += 3;  // '$' hex hex
+        stream->Putc(ev, '$');
+        stream->Putc(ev, morkWriter_kHexDigits[(c >> 4) & 0x0F]);
+        stream->Putc(ev, morkWriter_kHexDigits[c & 0x0F]);
+      }
+    }
+  }
+  mWriter_LineSize += outSize;
+
+  return outSize;
+}
+
+mork_size morkWriter::WriteAtom(morkEnv* ev, const morkAtom* inAtom)
+// return number of atom bytes written on the current line (which
+// implies that escaped line breaks will make the size value smaller
+// than the entire atom's size, since only part goes on a last line).
+{
+  mork_size outSize = 0;
+  mdbYarn yarn;  // to ref content inside atom
+
+  if (morkAtom::AliasYarn(inAtom, &yarn)) {
+    if (mWriter_DidStartDict && yarn.mYarn_Form != mWriter_DictForm)
+      this->ChangeDictForm(ev, yarn.mYarn_Form);
+
+    outSize = this->WriteYarn(ev, &yarn);
+    // mWriter_LineSize += stream->Write(ev, inYarn->mYarn_Buf, outSize);
+  } else
+    inAtom->BadAtomKindError(ev);
+
+  return outSize;
+}
+
+void morkWriter::WriteAtomSpaceAsDict(morkEnv* ev, morkAtomSpace* ioSpace) {
+  morkStream* stream = mWriter_Stream;
+  nsIMdbEnv* mdbev = ev->AsMdbEnv();
+  mork_scope scope = ioSpace->SpaceScope();
+  if (scope < 0x80) {
+    if (mWriter_LineSize) stream->PutLineBreak(ev);
+    stream->PutString(ev, "< <(a=");
+    stream->Putc(ev, (int)scope);
+    ++mWriter_LineSize;
+    stream->PutString(ev, ")> // (f=iso-8859-1)");
+    mWriter_LineSize = stream->PutIndent(ev, morkWriter_kDictAliasDepth);
+  } else
+    ioSpace->NonAsciiSpaceScopeName(ev);
+
+  if (ev->Good()) {
+    mdbYarn yarn;           // to ref content inside atom
+    char buf[64];           // buffer for staging the dict alias hex ID
+    char* idBuf = buf + 1;  // where the id always starts
+    buf[0] = '(';           // we always start with open paren
+    morkBookAtom* atom = 0;
+    morkAtomAidMapIter* ai = &mWriter_AtomSpaceAtomAidsIter;
+    ai->InitAtomAidMapIter(ev, &ioSpace->mAtomSpace_AtomAids);
+    mork_change* c = 0;
+
+    for (c = ai->FirstAtom(ev, &atom); c && ev->Good();
+         c = ai->NextAtom(ev, &atom)) {
+      if (atom) {
+        if (atom->IsAtomDirty()) {
+          atom->SetAtomClean();  // neutralize change
+
+          morkAtom::AliasYarn(atom, &yarn);
+          mork_size size = ev->TokenAsHex(idBuf, atom->mBookAtom_Id);
+
+          if (yarn.mYarn_Form != mWriter_DictForm)
+            this->ChangeDictForm(ev, yarn.mYarn_Form);
+
+          mork_size pending =
+              yarn.mYarn_Fill + size + morkWriter_kYarnEscapeSlop + 4;
+          this->IndentOverMaxLine(ev, pending, morkWriter_kDictAliasDepth);
+          mork_size bytesWritten;
+          stream->Write(mdbev, buf, size + 1, &bytesWritten);  //  + '('
+          mWriter_LineSize += bytesWritten;
+
+          pending -= (size + 1);
+          this->IndentOverMaxLine(ev, pending, morkWriter_kDictAliasValueDepth);
+          stream->Putc(ev, '=');  // start alias
+          ++mWriter_LineSize;
+
+          this->WriteYarn(ev, &yarn);
+          stream->Putc(ev, ')');  // end alias
+          ++mWriter_LineSize;
+
+          ++mWriter_DoneCount;
+        }
+      } else
+        ev->NilPointerError();
+    }
+    ai->CloseMapIter(ev);
+  }
+
+  if (ev->Good()) {
+    ioSpace->SetAtomSpaceClean();
+    // this->IndentAsNeeded(ev, 0);
+    // stream->PutByteThenNewline(ev, '>'); // end dict
+
+    stream->Putc(ev, '>');  // end dict
+    ++mWriter_LineSize;
+  }
+}
+
+/*
+(I'm putting the text of this message in file morkWriter.cpp.)
+
+I'm making a change which should cause rows and tables to go away
+when a Mork db is compress committed, when the rows and tables
+are no longer needed.  Because this is subtle, I'm describing it
+here in case misbehavior is ever observed.  Otherwise you'll have
+almost no hope of fixing a related bug.
+
+This is done entirely in morkWriter.cpp: morkWriter::DirtyAll(),
+which currently marks all rows and tables dirty so they will be
+written in a later phase of the commit.  My change is to merely
+selectively not mark certain rows and tables dirty, when they seem
+to be superfluous.
+
+A row is no longer needed when the mRow_GcUses slot hits zero, and
+this is used by the following inline morkRow method:
+
+  mork_bool IsRowUsed() const { return mRow_GcUses != 0; }
+
+Naturally disaster ensues if mRow_GcUses is ever smaller than right.
+
+Similarly, we should drop tables when mTable_GcUses hits zero, but
+only when a table contains no row members.  We consider tables to
+self reference (and prevent collection) when they contain content.
+Again, disaster ensues if mTable_GcUses is ever smaller than right.
+
+  mork_count GetRowCount() const
+  { return mTable_RowArray.mArray_Fill; }
+
+  mork_bool IsTableUsed() const
+  { return (mTable_GcUses != 0 || this->GetRowCount() != 0); }
+
+Now let's question why the design involves filtering what gets set
+to dirty.  Why not apply a filter in the later phase when we write
+content?  Because I'm afraid of missing some subtle interaction in
+updating table and row relationships.  It seems safer to write a row
+or table when it starts out dirty, before morkWriter::DirtyAll() is
+called.  So this design calls for writing out rows and tables when
+they are still clearly used, and additionally, <i>when we have just
+been actively writing to them right before this commit</i>.
+
+Presumably if they are truly useless, they will no longer be dirtied
+in later sessions and will get collected during the next compress
+commit.  So we wait to collect them until they become all dead, and
+not just mostly dead.  (At which time you can feel free to go through
+their pockets looking for loose change.)
+*/
+
+mork_bool morkWriter::DirtyAll(morkEnv* ev)
+// DirtyAll() visits every store sub-object and marks
+// them dirty, including every table, row, cell, and atom.  The return
+// equals ev->Good(), to show whether any error happened.  This method is
+// intended for use in the beginning of a "compress commit" which writes
+// all store content, whether dirty or not.  We dirty everything first so
+// that later iterations over content can mark things clean as they are
+// written, and organize the process of serialization so that objects are
+// written only at need (because of being dirty).  Note the method can
+// stop early when any error happens, since this will abort any commit.
+{
+  morkStore* store = mWriter_Store;
+  if (store) {
+    store->SetStoreDirty();
+    mork_change* c = 0;
+
+    if (ev->Good()) {
+      morkAtomSpaceMapIter* asi = &mWriter_StoreAtomSpacesIter;
+      asi->InitAtomSpaceMapIter(ev, &store->mStore_AtomSpaces);
+
+      mork_scope* key = 0;       // ignore keys in map
+      morkAtomSpace* space = 0;  // old val node in the map
+
+      for (c = asi->FirstAtomSpace(ev, key, &space); c && ev->Good();
+           c = asi->NextAtomSpace(ev, key, &space)) {
+        if (space) {
+          if (space->IsAtomSpace()) {
+            space->SetAtomSpaceDirty();
+            morkBookAtom* atom = 0;
+            morkAtomAidMapIter* ai = &mWriter_AtomSpaceAtomAidsIter;
+            ai->InitAtomAidMapIter(ev, &space->mAtomSpace_AtomAids);
+
+            for (c = ai->FirstAtom(ev, &atom); c && ev->Good();
+                 c = ai->NextAtom(ev, &atom)) {
+              if (atom) {
+                atom->SetAtomDirty();
+                ++mWriter_TotalCount;
+              } else
+                ev->NilPointerError();
+            }
+
+            ai->CloseMapIter(ev);
+          } else
+            space->NonAtomSpaceTypeError(ev);
+        } else
+          ev->NilPointerError();
+      }
+    }
+
+    if (ev->Good()) {
+      morkRowSpaceMapIter* rsi = &mWriter_StoreRowSpacesIter;
+      rsi->InitRowSpaceMapIter(ev, &store->mStore_RowSpaces);
+
+      mork_scope* key = 0;      // ignore keys in map
+      morkRowSpace* space = 0;  // old val node in the map
+
+      for (c = rsi->FirstRowSpace(ev, key, &space); c && ev->Good();
+           c = rsi->NextRowSpace(ev, key, &space)) {
+        if (space) {
+          if (space->IsRowSpace()) {
+            space->SetRowSpaceDirty();
+            if (ev->Good()) {
+#ifdef MORK_ENABLE_PROBE_MAPS
+              morkRowProbeMapIter* ri = &mWriter_RowSpaceRowsIter;
+#else  /*MORK_ENABLE_PROBE_MAPS*/
+              morkRowMapIter* ri = &mWriter_RowSpaceRowsIter;
+#endif /*MORK_ENABLE_PROBE_MAPS*/
+              ri->InitRowMapIter(ev, &space->mRowSpace_Rows);
+
+              morkRow* row = 0;  // old key row in the map
+
+              for (c = ri->FirstRow(ev, &row); c && ev->Good();
+                   c = ri->NextRow(ev, &row)) {
+                if (row && row->IsRow())  // need to dirty row?
+                {
+                  if (row->IsRowUsed() || row->IsRowDirty()) {
+                    row->DirtyAllRowContent(ev);
+                    ++mWriter_TotalCount;
+                  }
+                } else
+                  row->NonRowTypeWarning(ev);
+              }
+              ri->CloseMapIter(ev);
+            }
+
+            if (ev->Good()) {
+              morkTableMapIter* ti = &mWriter_RowSpaceTablesIter;
+              ti->InitTableMapIter(ev, &space->mRowSpace_Tables);
+
+#ifdef MORK_BEAD_OVER_NODE_MAPS
+              morkTable* table = ti->FirstTable(ev);
+
+              for (; table && ev->Good(); table = ti->NextTable(ev))
+#else  /*MORK_BEAD_OVER_NODE_MAPS*/
+              mork_tid* tableKey = 0;  // ignore keys in table map
+              morkTable* table = 0;    // old key row in the map
+
+              for (c = ti->FirstTable(ev, tableKey, &table); c && ev->Good();
+                   c = ti->NextTable(ev, tableKey, &table))
+#endif /*MORK_BEAD_OVER_NODE_MAPS*/
+              {
+                if (table && table->IsTable())  // need to dirty table?
+                {
+                  if (table->IsTableUsed() || table->IsTableDirty()) {
+                    // table->DirtyAllTableContent(ev);
+                    // only necessary to mark table itself dirty:
+                    table->SetTableDirty();
+                    table->SetTableRewrite();
+                    ++mWriter_TotalCount;
+                  }
+                } else
+                  table->NonTableTypeWarning(ev);
+              }
+              ti->CloseMapIter(ev);
+            }
+          } else
+            space->NonRowSpaceTypeError(ev);
+        } else
+          ev->NilPointerError();
+      }
+    }
+  } else
+    this->NilWriterStoreError(ev);
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::OnNothingDone(morkEnv* ev) {
+  mWriter_Incremental = !mWriter_NeedDirtyAll;  // opposites
+
+  if (!mWriter_Store->IsStoreDirty() && !mWriter_NeedDirtyAll) {
+    mWriter_Phase = morkWriter_kPhaseWritingDone;
+    return morkBool_kTrue;
+  }
+
+  // morkStream* stream = mWriter_Stream;
+  if (mWriter_NeedDirtyAll) this->DirtyAll(ev);
+
+  if (ev->Good())
+    mWriter_Phase = morkWriter_kPhaseDirtyAllDone;
+  else
+    mWriter_Phase = morkWriter_kPhaseWritingDone;  // stop on error
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::StartGroup(morkEnv* ev) {
+  nsIMdbEnv* mdbev = ev->AsMdbEnv();
+  morkStream* stream = mWriter_Stream;
+  mWriter_DidStartGroup = morkBool_kTrue;
+  mWriter_DidEndGroup = morkBool_kFalse;
+
+  char buf[4 + morkWriter_kGroupBufSize + 2];  // "@$${" + groupid + "{@"
+  char* p = buf;
+  *p++ = '@';
+  *p++ = '$';
+  *p++ = '$';
+  *p++ = '{';
+
+  mork_token groupID = mWriter_CommitGroupIdentity;
+  mork_fill idFill = ev->TokenAsHex(p, groupID);
+  mWriter_GroupBufFill = 0;
+  // ev->TokenAsHex(mWriter_GroupBuf, groupID);
+  if (idFill < morkWriter_kGroupBufSize) {
+    // TokenAsHex appends a '\0', but it's not included in idFill count.
+    MORK_MEMCPY(mWriter_GroupBuf, p, idFill + 1);
+    mWriter_GroupBufFill = idFill;
+  } else {
+    *mWriter_GroupBuf = '\0';
+  }
+
+  p += idFill;
+  *p++ = '{';
+  *p++ = '@';
+
+  stream->PutLineBreak(ev);
+
+  morkStore* store = mWriter_Store;
+  if (store)  // might need to capture commit group position?
+  {
+    mork_pos groupPos;
+    stream->Tell(mdbev, &groupPos);
+    if (!store->mStore_FirstCommitGroupPos)
+      store->mStore_FirstCommitGroupPos = groupPos;
+    else if (!store->mStore_SecondCommitGroupPos)
+      store->mStore_SecondCommitGroupPos = groupPos;
+  }
+
+  mork_size bytesWritten;
+  stream->Write(mdbev, buf, 4 + idFill + 2,
+                &bytesWritten);  // '@$${' + idFill + '{@'
+  stream->PutLineBreak(ev);
+  mWriter_LineSize = 0;
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::CommitGroup(morkEnv* ev) {
+  if (mWriter_DidStartGroup) {
+    nsIMdbEnv* mdbev = ev->AsMdbEnv();
+    mork_size bytesWritten;
+    morkStream* stream = mWriter_Stream;
+
+    if (mWriter_LineSize) stream->PutLineBreak(ev);
+
+    stream->Putc(ev, '@');
+    stream->Putc(ev, '$');
+    stream->Putc(ev, '$');
+    stream->Putc(ev, '}');
+
+    mork_fill bufFill = mWriter_GroupBufFill;
+    if (bufFill) stream->Write(mdbev, mWriter_GroupBuf, bufFill, &bytesWritten);
+
+    stream->Putc(ev, '}');
+    stream->Putc(ev, '@');
+    stream->PutLineBreak(ev);
+
+    mWriter_LineSize = 0;
+  }
+
+  mWriter_DidStartGroup = morkBool_kFalse;
+  mWriter_DidEndGroup = morkBool_kTrue;
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::AbortGroup(morkEnv* ev) {
+  if (mWriter_DidStartGroup) {
+    morkStream* stream = mWriter_Stream;
+    stream->PutLineBreak(ev);
+    stream->PutStringThenNewline(ev, "@$$}~~}@");
+    mWriter_LineSize = 0;
+  }
+
+  mWriter_DidStartGroup = morkBool_kFalse;
+  mWriter_DidEndGroup = morkBool_kTrue;
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::OnDirtyAllDone(morkEnv* ev) {
+  if (ev->Good()) {
+    nsIMdbEnv* mdbev = ev->AsMdbEnv();
+    morkStream* stream = mWriter_Stream;
+    mork_pos resultPos;
+    if (mWriter_NeedDirtyAll)  // compress commit
+    {
+      stream->Seek(mdbev, 0, &resultPos);  // beginning of stream
+      stream->PutStringThenNewline(ev, morkWriter_kFileHeader);
+      mWriter_LineSize = 0;
+    } else  // else mWriter_Incremental
+    {
+      mork_pos eos = stream->Length(ev);  // length is end of stream
+      if (ev->Good()) {
+        stream->Seek(mdbev, eos, &resultPos);  // goto end of stream
+        if (eos < 128)                         // maybe need file header?
+        {
+          stream->PutStringThenNewline(ev, morkWriter_kFileHeader);
+          mWriter_LineSize = 0;
+        }
+        this->StartGroup(ev);  // begin incremental transaction
+      }
+    }
+  }
+
+  if (ev->Good())
+    mWriter_Phase = morkWriter_kPhasePutHeaderDone;
+  else
+    mWriter_Phase = morkWriter_kPhaseWritingDone;  // stop on error
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::OnPutHeaderDone(morkEnv* ev) {
+  morkStream* stream = mWriter_Stream;
+  if (mWriter_LineSize) stream->PutLineBreak(ev);
+
+  // if ( mWriter_NeedDirtyAll )
+  //   stream->PutStringThenNewline(ev, "// OnPutHeaderDone()");
+  mWriter_LineSize = 0;
+
+  if (mWriter_NeedDirtyAll)  // compress commit
+  {
+    morkStore* store = mWriter_Store;
+    if (store)
+      store->RenumberAllCollectableContent(ev);
+    else
+      this->NilWriterStoreError(ev);
+  }
+
+  if (ev->Good())
+    mWriter_Phase = morkWriter_kPhaseRenumberAllDone;
+  else
+    mWriter_Phase = morkWriter_kPhaseWritingDone;  // stop on error
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::OnRenumberAllDone(morkEnv* ev) {
+  morkStream* stream = mWriter_Stream;
+  if (mWriter_LineSize) stream->PutLineBreak(ev);
+
+  // if ( mWriter_NeedDirtyAll )
+  //  stream->PutStringThenNewline(ev, "// OnRenumberAllDone()");
+  mWriter_LineSize = 0;
+
+  if (mWriter_NeedDirtyAll)  // compress commit
+  {
+  }
+
+  if (ev->Good())
+    mWriter_Phase = morkWriter_kPhaseStoreAtomSpaces;
+  else
+    mWriter_Phase = morkWriter_kPhaseWritingDone;  // stop on error
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::OnStoreAtomSpaces(morkEnv* ev) {
+  morkStream* stream = mWriter_Stream;
+  if (mWriter_LineSize) stream->PutLineBreak(ev);
+
+  // if ( mWriter_NeedDirtyAll )
+  //   stream->PutStringThenNewline(ev, "// OnStoreAtomSpaces()");
+  mWriter_LineSize = 0;
+
+  if (mWriter_NeedDirtyAll)  // compress commit
+  {
+  }
+
+  if (ev->Good()) {
+    morkStore* store = mWriter_Store;
+    if (store) {
+      morkAtomSpace* space = store->LazyGetGroundColumnSpace(ev);
+      if (space && space->IsAtomSpaceDirty()) {
+        // stream->PutStringThenNewline(ev, "// ground column space dict:");
+
+        if (mWriter_LineSize) {
+          stream->PutLineBreak(ev);
+          mWriter_LineSize = 0;
+        }
+        this->WriteAtomSpaceAsDict(ev, space);
+        space->SetAtomSpaceClean();
+      }
+    } else
+      this->NilWriterStoreError(ev);
+  }
+
+  if (ev->Good())
+    mWriter_Phase = morkWriter_kPhaseStoreRowSpacesTables;
+  else
+    mWriter_Phase = morkWriter_kPhaseWritingDone;  // stop on error
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::OnAtomSpaceAtomAids(morkEnv* ev) {
+  morkStream* stream = mWriter_Stream;
+  if (mWriter_LineSize) stream->PutLineBreak(ev);
+
+  // if ( mWriter_NeedDirtyAll )
+  //   stream->PutStringThenNewline(ev, "// OnAtomSpaceAtomAids()");
+  mWriter_LineSize = 0;
+
+  if (mWriter_NeedDirtyAll)  // compress commit
+  {
+  }
+
+  if (ev->Good())
+    mWriter_Phase = morkWriter_kPhaseStoreRowSpacesTables;
+  else
+    mWriter_Phase = morkWriter_kPhaseWritingDone;  // stop on error
+
+  return ev->Good();
+}
+
+void morkWriter::WriteAllStoreTables(morkEnv* ev) {
+  morkStore* store = mWriter_Store;
+  if (store && ev->Good()) {
+    morkRowSpaceMapIter* rsi = &mWriter_StoreRowSpacesIter;
+    rsi->InitRowSpaceMapIter(ev, &store->mStore_RowSpaces);
+
+    mork_scope* key = 0;      // ignore keys in map
+    morkRowSpace* space = 0;  // old val node in the map
+    mork_change* c = 0;
+
+    for (c = rsi->FirstRowSpace(ev, key, &space); c && ev->Good();
+         c = rsi->NextRowSpace(ev, key, &space)) {
+      if (space) {
+        if (space->IsRowSpace()) {
+          space->SetRowSpaceClean();
+          if (ev->Good()) {
+            morkTableMapIter* ti = &mWriter_RowSpaceTablesIter;
+            ti->InitTableMapIter(ev, &space->mRowSpace_Tables);
+
+#ifdef MORK_BEAD_OVER_NODE_MAPS
+            morkTable* table = ti->FirstTable(ev);
+
+            for (; table && ev->Good(); table = ti->NextTable(ev))
+#else  /*MORK_BEAD_OVER_NODE_MAPS*/
+            mork_tid* key2 = 0;    // ignore keys in table map
+            morkTable* table = 0;  // old key row in the map
+
+            for (c = ti->FirstTable(ev, key2, &table); c && ev->Good();
+                 c = ti->NextTable(ev, key2, &table))
+#endif /*MORK_BEAD_OVER_NODE_MAPS*/
+            {
+              if (table && table->IsTable()) {
+                if (table->IsTableDirty()) {
+                  mWriter_BeVerbose =
+                      (ev->mEnv_BeVerbose || table->IsTableVerbose());
+
+                  if (this->PutTableDict(ev, table)) this->PutTable(ev, table);
+
+                  table->SetTableClean(ev);
+                  mWriter_BeVerbose = ev->mEnv_BeVerbose;
+                }
+              } else
+                table->NonTableTypeWarning(ev);
+            }
+            ti->CloseMapIter(ev);
+          }
+          if (ev->Good()) {
+            mWriter_TableRowScope = 0;  // ensure no table context now
+
+#ifdef MORK_ENABLE_PROBE_MAPS
+            morkRowProbeMapIter* ri = &mWriter_RowSpaceRowsIter;
+#else  /*MORK_ENABLE_PROBE_MAPS*/
+            morkRowMapIter* ri = &mWriter_RowSpaceRowsIter;
+#endif /*MORK_ENABLE_PROBE_MAPS*/
+            ri->InitRowMapIter(ev, &space->mRowSpace_Rows);
+
+            morkRow* row = 0;  // old row in the map
+
+            for (c = ri->FirstRow(ev, &row); c && ev->Good();
+                 c = ri->NextRow(ev, &row)) {
+              if (row && row->IsRow()) {
+                // later we should also check that table use count is nonzero:
+                if (row->IsRowDirty())  // && row->IsRowUsed() ??
+                {
+                  mWriter_BeVerbose = ev->mEnv_BeVerbose;
+                  if (this->PutRowDict(ev, row)) {
+                    if (ev->Good() && mWriter_DidStartDict) {
+                      this->EndDict(ev);
+                      if (mWriter_LineSize < 32 && ev->Good())
+                        mWriter_SuppressDirtyRowNewline = morkBool_kTrue;
+                    }
+
+                    if (ev->Good()) this->PutRow(ev, row);
+                  }
+                  mWriter_BeVerbose = ev->mEnv_BeVerbose;
+                }
+              } else
+                row->NonRowTypeWarning(ev);
+            }
+            ri->CloseMapIter(ev);
+          }
+        } else
+          space->NonRowSpaceTypeError(ev);
+      } else
+        ev->NilPointerError();
+    }
+  }
+}
+
+mork_bool morkWriter::OnStoreRowSpacesTables(morkEnv* ev) {
+  morkStream* stream = mWriter_Stream;
+  if (mWriter_LineSize) stream->PutLineBreak(ev);
+
+  // if ( mWriter_NeedDirtyAll )
+  //   stream->PutStringThenNewline(ev, "// OnStoreRowSpacesTables()");
+  mWriter_LineSize = 0;
+
+  if (mWriter_NeedDirtyAll)  // compress commit
+  {
+  }
+
+  // later we'll break this up, but today we'll write all in one shot:
+  this->WriteAllStoreTables(ev);
+
+  if (ev->Good())
+    mWriter_Phase = morkWriter_kPhaseStoreRowSpacesRows;
+  else
+    mWriter_Phase = morkWriter_kPhaseWritingDone;  // stop on error
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::OnRowSpaceTables(morkEnv* ev) {
+  morkStream* stream = mWriter_Stream;
+  if (mWriter_LineSize) stream->PutLineBreak(ev);
+
+  // if ( mWriter_NeedDirtyAll )
+  //   stream->PutStringThenNewline(ev, "// OnRowSpaceTables()");
+  mWriter_LineSize = 0;
+
+  if (mWriter_NeedDirtyAll)  // compress commit
+  {
+  }
+
+  if (ev->Good())
+    mWriter_Phase = morkWriter_kPhaseStoreRowSpacesRows;
+  else
+    mWriter_Phase = morkWriter_kPhaseWritingDone;  // stop on error
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::OnTableRowArray(morkEnv* ev) {
+  morkStream* stream = mWriter_Stream;
+  if (mWriter_LineSize) stream->PutLineBreak(ev);
+
+  // if ( mWriter_NeedDirtyAll )
+  //   stream->PutStringThenNewline(ev, "// OnTableRowArray()");
+  mWriter_LineSize = 0;
+
+  if (mWriter_NeedDirtyAll)  // compress commit
+  {
+  }
+
+  if (ev->Good())
+    mWriter_Phase = morkWriter_kPhaseStoreRowSpacesRows;
+  else
+    mWriter_Phase = morkWriter_kPhaseWritingDone;  // stop on error
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::OnStoreRowSpacesRows(morkEnv* ev) {
+  morkStream* stream = mWriter_Stream;
+  if (mWriter_LineSize) stream->PutLineBreak(ev);
+
+  // if ( mWriter_NeedDirtyAll )
+  //   stream->PutStringThenNewline(ev, "// OnStoreRowSpacesRows()");
+  mWriter_LineSize = 0;
+
+  if (mWriter_NeedDirtyAll)  // compress commit
+  {
+  }
+
+  if (ev->Good())
+    mWriter_Phase = morkWriter_kPhaseContentDone;
+  else
+    mWriter_Phase = morkWriter_kPhaseWritingDone;  // stop on error
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::OnRowSpaceRows(morkEnv* ev) {
+  morkStream* stream = mWriter_Stream;
+  if (mWriter_LineSize) stream->PutLineBreak(ev);
+
+  // if ( mWriter_NeedDirtyAll )
+  //   stream->PutStringThenNewline(ev, "// OnRowSpaceRows()");
+  mWriter_LineSize = 0;
+
+  if (mWriter_NeedDirtyAll)  // compress commit
+  {
+  }
+
+  if (ev->Good())
+    mWriter_Phase = morkWriter_kPhaseContentDone;
+  else
+    mWriter_Phase = morkWriter_kPhaseWritingDone;  // stop on error
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::OnContentDone(morkEnv* ev) {
+  morkStream* stream = mWriter_Stream;
+  if (mWriter_LineSize) stream->PutLineBreak(ev);
+
+  // if ( mWriter_NeedDirtyAll )
+  //   stream->PutStringThenNewline(ev, "// OnContentDone()");
+  mWriter_LineSize = 0;
+
+  if (mWriter_Incremental) {
+    if (ev->Good())
+      this->CommitGroup(ev);
+    else
+      this->AbortGroup(ev);
+  } else if (mWriter_Store && ev->Good()) {
+    // after rewriting everything, there are no transaction groups:
+    mWriter_Store->mStore_FirstCommitGroupPos = 0;
+    mWriter_Store->mStore_SecondCommitGroupPos = 0;
+  }
+
+  stream->Flush(ev->AsMdbEnv());
+  nsIMdbFile* bud = mWriter_Bud;
+  if (bud) {
+    bud->Flush(ev->AsMdbEnv());
+    bud->BecomeTrunk(ev->AsMdbEnv());
+    nsIMdbFile_SlotStrongFile((nsIMdbFile*)0, ev, &mWriter_Bud);
+  } else if (!mWriter_Incremental)  // should have a bud?
+    this->NilWriterBudError(ev);
+
+  mWriter_Phase = morkWriter_kPhaseWritingDone;  // stop always
+  mWriter_DoneCount = mWriter_TotalCount;
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::OnWritingDone(morkEnv* ev) {
+  mWriter_DoneCount = mWriter_TotalCount;
+  ev->NewWarning("writing is done");
+  return ev->Good();
+}
+
+mork_bool morkWriter::PutTableChange(morkEnv* ev,
+                                     const morkTableChange* inChange) {
+  nsIMdbEnv* mdbev = ev->AsMdbEnv();
+  if (inChange->IsAddRowTableChange()) {
+    this->PutRow(ev, inChange->mTableChange_Row);  // row alone means add
+  } else if (inChange->IsCutRowTableChange()) {
+    mWriter_Stream->Putc(ev, '-');  // prefix '-' indicates cut row
+    ++mWriter_LineSize;
+    this->PutRow(ev, inChange->mTableChange_Row);
+  } else if (inChange->IsMoveRowTableChange()) {
+    this->PutRow(ev, inChange->mTableChange_Row);
+    char buf[64];
+    char* p = buf;
+    *p++ = '!';  // for moves, position is indicated by prefix '!'
+    mork_size posSize = ev->TokenAsHex(p, inChange->mTableChange_Pos);
+    p += posSize;
+    *p++ = ' ';
+    mork_size bytesWritten;
+    mWriter_Stream->Write(mdbev, buf, posSize + 2, &bytesWritten);
+    mWriter_LineSize += bytesWritten;
+  } else
+    inChange->UnknownChangeError(ev);
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::PutTable(morkEnv* ev, morkTable* ioTable) {
+  if (ev->Good()) this->StartTable(ev, ioTable);
+
+  if (ev->Good()) {
+    if (ioTable->IsTableRewrite() || mWriter_NeedDirtyAll) {
+      morkArray* array = &ioTable->mTable_RowArray;  // vector of rows
+      mork_fill fill = array->mArray_Fill;           // count of rows
+      morkRow** rows = (morkRow**)array->mArray_Slots;
+      if (rows && fill) {
+        morkRow** end = rows + fill;
+        while (rows < end && ev->Good()) {
+          morkRow* r = *rows++;  // next row to consider
+          this->PutRow(ev, r);
+        }
+      }
+    } else  // incremental write only table changes
+    {
+      morkList* list = &ioTable->mTable_ChangeList;
+      morkNext* next = list->GetListHead();
+      while (next && ev->Good()) {
+        this->PutTableChange(ev, (morkTableChange*)next);
+        next = next->GetNextLink();
+      }
+    }
+  }
+
+  if (ev->Good()) this->EndTable(ev);
+
+  ioTable->SetTableClean(ev);  // note this also cleans change list
+  mWriter_TableRowScope = 0;
+
+  ++mWriter_DoneCount;
+  return ev->Good();
+}
+
+mork_bool morkWriter::PutTableDict(morkEnv* ev, morkTable* ioTable) {
+  morkRowSpace* space = ioTable->mTable_RowSpace;
+  mWriter_TableRowScope = space->SpaceScope();
+  mWriter_TableForm = 0;         // (f=iso-8859-1)
+  mWriter_TableAtomScope = 'v';  // (a=v)
+  mWriter_TableKind = ioTable->mTable_Kind;
+
+  mWriter_RowForm = mWriter_TableForm;
+  mWriter_RowAtomScope = mWriter_TableAtomScope;
+  mWriter_RowScope = mWriter_TableRowScope;
+
+  mWriter_DictForm = mWriter_TableForm;
+  mWriter_DictAtomScope = mWriter_TableAtomScope;
+
+  // if ( ev->Good() )
+  //  this->StartDict(ev); // delay as long as possible
+
+  if (ev->Good()) {
+    morkRow* r = ioTable->mTable_MetaRow;
+    if (r) {
+      if (r->IsRow())
+        this->PutRowDict(ev, r);
+      else
+        r->NonRowTypeError(ev);
+    }
+    morkArray* array = &ioTable->mTable_RowArray;  // vector of rows
+    mork_fill fill = array->mArray_Fill;           // count of rows
+    morkRow** rows = (morkRow**)array->mArray_Slots;
+    if (rows && fill) {
+      morkRow** end = rows + fill;
+      while (rows < end && ev->Good()) {
+        r = *rows++;  // next row to consider
+        if (r && r->IsRow())
+          this->PutRowDict(ev, r);
+        else
+          r->NonRowTypeError(ev);
+      }
+    }
+    // we may have a change for a row which is no longer in the
+    // table, but contains a cell with something not in the dictionary.
+    // So, loop through the rows in the change log, writing out any
+    // dirty dictionary elements.
+    morkList* list = &ioTable->mTable_ChangeList;
+    morkNext* next = list->GetListHead();
+    while (next && ev->Good()) {
+      r = ((morkTableChange*)next)->mTableChange_Row;
+      if (r && r->IsRow()) this->PutRowDict(ev, r);
+      next = next->GetNextLink();
+    }
+  }
+  if (ev->Good()) this->EndDict(ev);
+
+  return ev->Good();
+}
+
+void morkWriter::WriteTokenToTokenMetaCell(morkEnv* ev, mork_token inCol,
+                                           mork_token inValue) {
+  morkStream* stream = mWriter_Stream;
+  mork_bool isKindCol = (morkStore_kKindColumn == inCol);
+  mork_u1 valSep = (mork_u1)((isKindCol) ? '^' : '=');
+
+  char buf[128];  // buffer for staging the two hex IDs
+  char* p = buf;
+
+  mork_size bytesWritten;
+  if (inCol < 0x80) {
+    stream->Putc(ev, '(');
+    stream->Putc(ev, (char)inCol);
+    stream->Putc(ev, valSep);
+  } else {
+    *p++ = '(';  // we always start with open paren
+
+    *p++ = '^';  // indicates col is hex ID
+    mork_size colSize = ev->TokenAsHex(p, inCol);
+    p += colSize;
+    *p++ = (char)valSep;
+    stream->Write(ev->AsMdbEnv(), buf, colSize + 3, &bytesWritten);
+
+    mWriter_LineSize += bytesWritten;
+  }
+
+  if (isKindCol) {
+    p = buf;
+    mork_size valSize = ev->TokenAsHex(p, inValue);
+    p += valSize;
+    *p++ = ':';
+    *p++ = 'c';
+    *p++ = ')';
+    stream->Write(ev->AsMdbEnv(), buf, valSize + 3, &bytesWritten);
+    mWriter_LineSize += bytesWritten;
+  } else {
+    this->IndentAsNeeded(ev, morkWriter_kTableMetaCellValueDepth);
+    mdbYarn* yarn = &mWriter_ColYarn;
+    // mork_u1* yarnBuf = (mork_u1*) yarn->mYarn_Buf;
+    mWriter_Store->TokenToString(ev, inValue, yarn);
+    this->WriteYarn(ev, yarn);
+    stream->Putc(ev, ')');
+    ++mWriter_LineSize;
+  }
+
+  // mork_fill fill = yarn->mYarn_Fill;
+  // yarnBuf[ fill ] = ')'; // append terminator
+  // mWriter_LineSize += stream->Write(ev, yarnBuf, fill + 1); // +1 for ')'
+}
+
+void morkWriter::WriteStringToTokenDictCell(morkEnv* ev, const char* inCol,
+                                            mork_token inValue)
+// Note inCol should begin with '(' and end with '=', with col in between.
+{
+  morkStream* stream = mWriter_Stream;
+  mWriter_LineSize += stream->PutString(ev, inCol);
+
+  this->IndentAsNeeded(ev, morkWriter_kDictMetaCellValueDepth);
+  mdbYarn* yarn = &mWriter_ColYarn;
+  // mork_u1* yarnBuf = (mork_u1*) yarn->mYarn_Buf;
+  mWriter_Store->TokenToString(ev, inValue, yarn);
+  this->WriteYarn(ev, yarn);
+  stream->Putc(ev, ')');
+  ++mWriter_LineSize;
+
+  // mork_fill fill = yarn->mYarn_Fill;
+  // yarnBuf[ fill ] = ')'; // append terminator
+  // mWriter_LineSize += stream->Write(ev, yarnBuf, fill + 1); // +1 for ')'
+}
+
+void morkWriter::ChangeDictAtomScope(morkEnv* ev, mork_scope inScope) {
+  if (inScope != mWriter_DictAtomScope) {
+    ev->NewWarning("unexpected atom scope change");
+
+    morkStream* stream = mWriter_Stream;
+    if (mWriter_LineSize) stream->PutLineBreak(ev);
+    mWriter_LineSize = 0;
+
+    char buf[128];  // buffer for staging the two hex IDs
+    char* p = buf;
+    *p++ = '<';  // we always start with open paren
+    *p++ = '(';  // we always start with open paren
+    *p++ = (char)morkStore_kAtomScopeColumn;
+
+    mork_size scopeSize = 1;  // default to one byte
+    if (inScope >= 0x80) {
+      *p++ = '^';  // indicates col is hex ID
+      scopeSize = ev->TokenAsHex(p, inScope);
+      p += scopeSize;
+    } else {
+      *p++ = '=';  // indicates col is imm byte
+      *p++ = (char)(mork_u1)inScope;
+    }
+
+    *p++ = ')';
+    *p++ = '>';
+    *p = 0;
+
+    mork_size pending = scopeSize + 6;
+    this->IndentOverMaxLine(ev, pending, morkWriter_kDictAliasDepth);
+    mork_size bytesWritten;
+
+    stream->Write(ev->AsMdbEnv(), buf, pending, &bytesWritten);
+    mWriter_LineSize += bytesWritten;
+
+    mWriter_DictAtomScope = inScope;
+  }
+}
+
+void morkWriter::ChangeRowForm(morkEnv* ev, mork_cscode inNewForm) {
+  if (inNewForm != mWriter_RowForm) {
+    morkStream* stream = mWriter_Stream;
+    if (mWriter_LineSize) stream->PutLineBreak(ev);
+    mWriter_LineSize = 0;
+
+    char buf[128];  // buffer for staging the two hex IDs
+    char* p = buf;
+    *p++ = '[';  // we always start with open bracket
+    *p++ = '(';  // we always start with open paren
+    *p++ = (char)morkStore_kFormColumn;
+
+    mork_size formSize = 1;  // default to one byte
+    if (!morkCh_IsValue(inNewForm)) {
+      *p++ = '^';  // indicates col is hex ID
+      formSize = ev->TokenAsHex(p, inNewForm);
+      p += formSize;
+    } else {
+      *p++ = '=';  // indicates col is imm byte
+      *p++ = (char)(mork_u1)inNewForm;
+    }
+
+    *p++ = ')';
+    *p++ = ']';
+    *p = 0;
+
+    mork_size pending = formSize + 6;
+    this->IndentOverMaxLine(ev, pending, morkWriter_kRowCellDepth);
+    mork_size bytesWritten;
+    stream->Write(ev->AsMdbEnv(), buf, pending, &bytesWritten);
+    mWriter_LineSize += bytesWritten;
+
+    mWriter_RowForm = inNewForm;
+  }
+}
+
+void morkWriter::ChangeDictForm(morkEnv* ev, mork_cscode inNewForm) {
+  if (inNewForm != mWriter_DictForm) {
+    morkStream* stream = mWriter_Stream;
+    if (mWriter_LineSize) stream->PutLineBreak(ev);
+    mWriter_LineSize = 0;
+
+    char buf[128];  // buffer for staging the two hex IDs
+    char* p = buf;
+    *p++ = '<';  // we always start with open angle
+    *p++ = '(';  // we always start with open paren
+    *p++ = (char)morkStore_kFormColumn;
+
+    mork_size formSize = 1;  // default to one byte
+    if (!morkCh_IsValue(inNewForm)) {
+      *p++ = '^';  // indicates col is hex ID
+      formSize = ev->TokenAsHex(p, inNewForm);
+      p += formSize;
+    } else {
+      *p++ = '=';  // indicates col is imm byte
+      *p++ = (char)(mork_u1)inNewForm;
+    }
+
+    *p++ = ')';
+    *p++ = '>';
+    *p = 0;
+
+    mork_size pending = formSize + 6;
+    this->IndentOverMaxLine(ev, pending, morkWriter_kDictAliasDepth);
+
+    mork_size bytesWritten;
+    stream->Write(ev->AsMdbEnv(), buf, pending, &bytesWritten);
+    mWriter_LineSize += bytesWritten;
+
+    mWriter_DictForm = inNewForm;
+  }
+}
+
+void morkWriter::StartDict(morkEnv* ev) {
+  morkStream* stream = mWriter_Stream;
+  if (mWriter_DidStartDict) {
+    stream->Putc(ev, '>');  // end dict
+    ++mWriter_LineSize;
+  }
+  mWriter_DidStartDict = morkBool_kTrue;
+  mWriter_DidEndDict = morkBool_kFalse;
+
+  if (mWriter_LineSize) stream->PutLineBreak(ev);
+  mWriter_LineSize = 0;
+
+  if (mWriter_TableRowScope)  // blank line before table's dict?
+    stream->PutLineBreak(ev);
+
+  if (mWriter_DictForm || mWriter_DictAtomScope != 'v') {
+    stream->Putc(ev, '<');
+    stream->Putc(ev, ' ');
+    stream->Putc(ev, '<');
+    mWriter_LineSize = 3;
+    if (mWriter_DictForm)
+      this->WriteStringToTokenDictCell(ev, "(f=", mWriter_DictForm);
+    if (mWriter_DictAtomScope != 'v')
+      this->WriteStringToTokenDictCell(ev, "(a=", mWriter_DictAtomScope);
+
+    stream->Putc(ev, '>');
+    ++mWriter_LineSize;
+
+    mWriter_LineSize = stream->PutIndent(ev, morkWriter_kDictAliasDepth);
+  } else {
+    stream->Putc(ev, '<');
+    // stream->Putc(ev, ' ');
+    ++mWriter_LineSize;
+  }
+}
+
+void morkWriter::EndDict(morkEnv* ev) {
+  morkStream* stream = mWriter_Stream;
+  if (mWriter_DidStartDict) {
+    stream->Putc(ev, '>');  // end dict
+    ++mWriter_LineSize;
+  }
+  mWriter_DidStartDict = morkBool_kFalse;
+  mWriter_DidEndDict = morkBool_kTrue;
+}
+
+void morkWriter::StartTable(morkEnv* ev, morkTable* ioTable) {
+  mdbOid toid;  // to receive table oid
+  ioTable->GetTableOid(ev, &toid);
+
+  if (ev->Good()) {
+    morkStream* stream = mWriter_Stream;
+    if (mWriter_LineSize) stream->PutLineBreak(ev);
+    mWriter_LineSize = 0;
+    // stream->PutLineBreak(ev);
+
+    char buf[64 + 16];  // buffer for staging hex
+    char* p = buf;
+    *p++ = '{';  // punct 1
+    mork_size punctSize =
+        (mWriter_BeVerbose) ? 10 : 3;  // counting "{ {/*r=*/ "
+
+    if (ioTable->IsTableRewrite() && mWriter_Incremental) {
+      *p++ = '-';
+      ++punctSize;  // counting '-' // punct ++
+      ++mWriter_LineSize;
+    }
+    mork_size oidSize = ev->OidAsHex(p, toid);
+    p += oidSize;
+    *p++ = ' ';  // punct 2
+    *p++ = '{';  // punct 3
+    if (mWriter_BeVerbose) {
+      *p++ = '/';  // punct=4
+      *p++ = '*';  // punct=5
+      *p++ = 'r';  // punct=6
+      *p++ = '=';  // punct=7
+
+      mork_token tableUses = (mork_token)ioTable->mTable_GcUses;
+      mork_size usesSize = ev->TokenAsHex(p, tableUses);
+      punctSize += usesSize;
+      p += usesSize;
+
+      *p++ = '*';  // punct=8
+      *p++ = '/';  // punct=9
+      *p++ = ' ';  // punct=10
+    }
+    mork_size bytesWritten;
+
+    stream->Write(ev->AsMdbEnv(), buf, oidSize + punctSize, &bytesWritten);
+    mWriter_LineSize += bytesWritten;
+
+    mork_kind tk = mWriter_TableKind;
+    if (tk) {
+      this->IndentAsNeeded(ev, morkWriter_kTableMetaCellDepth);
+      this->WriteTokenToTokenMetaCell(ev, morkStore_kKindColumn, tk);
+    }
+
+    stream->Putc(ev, '(');  // start 's' col cell
+    stream->Putc(ev, 's');  // column
+    stream->Putc(ev, '=');  // column
+    mWriter_LineSize += 3;
+
+    int prio = (int)ioTable->mTable_Priority;
+    if (prio > 9)  // need to force down to max decimal digit?
+      prio = 9;
+    prio += '0';             // add base digit zero
+    stream->Putc(ev, prio);  // priority: (s=0
+    ++mWriter_LineSize;
+
+    if (ioTable->IsTableUnique()) {
+      stream->Putc(ev, 'u');  // (s=0u
+      ++mWriter_LineSize;
+    }
+    if (ioTable->IsTableVerbose()) {
+      stream->Putc(ev, 'v');  // (s=0uv
+      ++mWriter_LineSize;
+    }
+
+    // stream->Putc(ev, ':'); // (s=0uv:
+    // stream->Putc(ev, 'c'); // (s=0uv:c
+    stream->Putc(ev, ')');  // end 's' col cell (s=0uv:c)
+    mWriter_LineSize += 1;  // maybe 3 if we add ':' and 'c'
+
+    morkRow* r = ioTable->mTable_MetaRow;
+    if (r) {
+      if (r->IsRow()) {
+        mWriter_SuppressDirtyRowNewline = morkBool_kTrue;
+        this->PutRow(ev, r);
+      } else
+        r->NonRowTypeError(ev);
+    }
+
+    stream->Putc(ev, '}');  // end meta
+    ++mWriter_LineSize;
+
+    if (mWriter_LineSize < mWriter_MaxIndent) {
+      stream->Putc(ev, ' ');  // nice white space
+      ++mWriter_LineSize;
+    }
+  }
+}
+
+void morkWriter::EndTable(morkEnv* ev) {
+  morkStream* stream = mWriter_Stream;
+  stream->Putc(ev, '}');  // end table
+  ++mWriter_LineSize;
+
+  mWriter_TableAtomScope = 'v';  // (a=v)
+}
+
+mork_bool morkWriter::PutRowDict(morkEnv* ev, morkRow* ioRow) {
+  mWriter_RowForm = mWriter_TableForm;
+
+  morkCell* cells = ioRow->mRow_Cells;
+  if (cells) {
+    morkStream* stream = mWriter_Stream;
+    mdbYarn yarn;           // to ref content inside atom
+    char buf[64];           // buffer for staging the dict alias hex ID
+    char* idBuf = buf + 1;  // where the id always starts
+    buf[0] = '(';           // we always start with open paren
+
+    morkCell* end = cells + ioRow->mRow_Length;
+    --cells;  // prepare for preincrement:
+    while (++cells < end && ev->Good()) {
+      morkAtom* atom = cells->GetAtom();
+      if (atom && atom->IsAtomDirty()) {
+        if (atom->IsBook())  // is it possible to write atom ID?
+        {
+          if (!this->DidStartDict()) {
+            this->StartDict(ev);
+            if (ev->Bad()) break;
+          }
+          atom->SetAtomClean();  // neutralize change
+
+          this->IndentAsNeeded(ev, morkWriter_kDictAliasDepth);
+          morkBookAtom* ba = (morkBookAtom*)atom;
+          mork_size size = ev->TokenAsHex(idBuf, ba->mBookAtom_Id);
+          mork_size bytesWritten;
+          stream->Write(ev->AsMdbEnv(), buf, size + 1, &bytesWritten);  // '('
+          mWriter_LineSize += bytesWritten;
+
+          if (morkAtom::AliasYarn(atom, &yarn)) {
+            mork_scope atomScope = atom->GetBookAtomSpaceScope(ev);
+            if (atomScope && atomScope != mWriter_DictAtomScope)
+              this->ChangeDictAtomScope(ev, atomScope);
+
+            if (mWriter_DidStartDict && yarn.mYarn_Form != mWriter_DictForm)
+              this->ChangeDictForm(ev, yarn.mYarn_Form);
+
+            mork_size pending =
+                yarn.mYarn_Fill + morkWriter_kYarnEscapeSlop + 1;
+            this->IndentOverMaxLine(ev, pending,
+                                    morkWriter_kDictAliasValueDepth);
+
+            stream->Putc(ev, '=');  // start value
+            ++mWriter_LineSize;
+
+            this->WriteYarn(ev, &yarn);
+
+            stream->Putc(ev, ')');  // end value
+            ++mWriter_LineSize;
+          } else
+            atom->BadAtomKindError(ev);
+
+          ++mWriter_DoneCount;
+        }
+      }
+    }
+  }
+  return ev->Good();
+}
+
+mork_bool morkWriter::IsYarnAllValue(const mdbYarn* inYarn) {
+  mork_fill fill = inYarn->mYarn_Fill;
+  const mork_u1* buf = (const mork_u1*)inYarn->mYarn_Buf;
+  const mork_u1* end = buf + fill;
+  --buf;  // prepare for preincrement
+  while (++buf < end) {
+    mork_ch c = *buf;
+    if (!morkCh_IsValue(c)) return morkBool_kFalse;
+  }
+  return morkBool_kTrue;
+}
+
+mork_bool morkWriter::PutVerboseCell(morkEnv* ev, morkCell* ioCell,
+                                     mork_bool inWithVal) {
+  morkStream* stream = mWriter_Stream;
+  morkStore* store = mWriter_Store;
+
+  mdbYarn* colYarn = &mWriter_ColYarn;
+
+  morkAtom* atom = (inWithVal) ? ioCell->GetAtom() : (morkAtom*)0;
+
+  mork_column col = ioCell->GetColumn();
+  store->TokenToString(ev, col, colYarn);
+
+  mdbYarn yarn;                      // to ref content inside atom
+  morkAtom::AliasYarn(atom, &yarn);  // works even when atom==nil
+
+  if (yarn.mYarn_Form != mWriter_RowForm)
+    this->ChangeRowForm(ev, yarn.mYarn_Form);
+
+  mork_size pending =
+      yarn.mYarn_Fill + colYarn->mYarn_Fill + morkWriter_kYarnEscapeSlop + 3;
+  this->IndentOverMaxLine(ev, pending, morkWriter_kRowCellDepth);
+
+  stream->Putc(ev, '(');  // start cell
+  ++mWriter_LineSize;
+
+  this->WriteYarn(ev, colYarn);  // column
+
+  pending = yarn.mYarn_Fill + morkWriter_kYarnEscapeSlop;
+  this->IndentOverMaxLine(ev, pending, morkWriter_kRowCellValueDepth);
+  stream->Putc(ev, '=');
+  ++mWriter_LineSize;
+
+  this->WriteYarn(ev, &yarn);  // value
+
+  stream->Putc(ev, ')');  // end cell
+  ++mWriter_LineSize;
+
+  return ev->Good();
+}
+
+mork_bool morkWriter::PutVerboseRowCells(morkEnv* ev, morkRow* ioRow) {
+  morkCell* cells = ioRow->mRow_Cells;
+  if (cells) {
+    morkCell* end = cells + ioRow->mRow_Length;
+    --cells;  // prepare for preincrement:
+    while (++cells < end && ev->Good()) {
+      // note we prefer to avoid writing cells here with no value:
+      if (cells->GetAtom())  // does cell have any value?
+        this->PutVerboseCell(ev, cells, /*inWithVal*/ morkBool_kTrue);
+    }
+  }
+  return ev->Good();
+}
+
+mork_bool morkWriter::PutCell(morkEnv* ev, morkCell* ioCell,
+                              mork_bool inWithVal) {
+  morkStream* stream = mWriter_Stream;
+  char buf[128];          // buffer for staging hex ids
+  char* idBuf = buf + 2;  // where the id always starts
+  buf[0] = '(';           // we always start with open paren
+  buf[1] = '^';           // column is always a hex ID
+
+  mork_size colSize = 0;  // the size of col hex ID
+  mork_size bytesWritten;
+
+  morkAtom* atom = (inWithVal) ? ioCell->GetAtom() : (morkAtom*)0;
+
+  mork_column col = ioCell->GetColumn();
+  char* p = idBuf;
+  colSize = ev->TokenAsHex(p, col);
+  p += colSize;
+
+  mdbYarn yarn;                      // to ref content inside atom
+  morkAtom::AliasYarn(atom, &yarn);  // works even when atom==nil
+
+  if (yarn.mYarn_Form != mWriter_RowForm)
+    this->ChangeRowForm(ev, yarn.mYarn_Form);
+
+  if (atom && atom->IsBook())  // is it possible to write atom ID?
+  {
+    this->IndentAsNeeded(ev, morkWriter_kRowCellDepth);
+    *p++ = '^';
+    morkBookAtom* ba = (morkBookAtom*)atom;
+
+    mork_size valSize = ev->TokenAsHex(p, ba->mBookAtom_Id);
+    mork_fill yarnFill = yarn.mYarn_Fill;
+    mork_bool putImmYarn = (yarnFill <= valSize);
+    if (putImmYarn) putImmYarn = this->IsYarnAllValue(&yarn);
+
+    if (putImmYarn)  // value no bigger than id?
+    {
+      p[-1] = '=';  // go back and clobber '^' with '=' instead
+      if (yarnFill) {
+        MORK_MEMCPY(p, yarn.mYarn_Buf, yarnFill);
+        p += yarnFill;
+      }
+      *p++ = ')';
+      mork_size distance = (mork_size)(p - buf);
+      stream->Write(ev->AsMdbEnv(), buf, distance, &bytesWritten);
+      mWriter_LineSize += bytesWritten;
+    } else {
+      p += valSize;
+      *p = ')';
+      stream->Write(ev->AsMdbEnv(), buf, colSize + valSize + 4, &bytesWritten);
+      mWriter_LineSize += bytesWritten;
+    }
+
+    if (atom->IsAtomDirty()) {
+      atom->SetAtomClean();
+      ++mWriter_DoneCount;
+    }
+  } else  // must write an anonymous atom
+  {
+    mork_size pending =
+        yarn.mYarn_Fill + colSize + morkWriter_kYarnEscapeSlop + 2;
+    this->IndentOverMaxLine(ev, pending, morkWriter_kRowCellDepth);
+
+    mork_size bytesWritten;
+    stream->Write(ev->AsMdbEnv(), buf, colSize + 2, &bytesWritten);
+    mWriter_LineSize += bytesWritten;
+
+    pending -= (colSize + 2);
+    this->IndentOverMaxLine(ev, pending, morkWriter_kRowCellDepth);
+    stream->Putc(ev, '=');
+    ++mWriter_LineSize;
+
+    this->WriteYarn(ev, &yarn);
+    stream->Putc(ev, ')');  // end cell
+    ++mWriter_LineSize;
+  }
+  return ev->Good();
+}
+
+mork_bool morkWriter::PutRowCells(morkEnv* ev, morkRow* ioRow) {
+  morkCell* cells = ioRow->mRow_Cells;
+  if (cells) {
+    morkCell* end = cells + ioRow->mRow_Length;
+    --cells;  // prepare for preincrement:
+    while (++cells < end && ev->Good()) {
+      // note we prefer to avoid writing cells here with no value:
+      if (cells->GetAtom())  // does cell have any value?
+        this->PutCell(ev, cells, /*inWithVal*/ morkBool_kTrue);
+    }
+  }
+  return ev->Good();
+}
+
+mork_bool morkWriter::PutRow(morkEnv* ev, morkRow* ioRow) {
+  if (ioRow && ioRow->IsRow()) {
+    mWriter_RowForm = mWriter_TableForm;
+
+    mork_size bytesWritten;
+    morkStream* stream = mWriter_Stream;
+    char buf[128 + 16];  // buffer for staging hex
+    char* p = buf;
+    mdbOid* roid = &ioRow->mRow_Oid;
+    mork_size ridSize = 0;
+
+    mork_scope tableScope = mWriter_TableRowScope;
+
+    if (ioRow->IsRowDirty()) {
+      if (mWriter_SuppressDirtyRowNewline || !mWriter_LineSize)
+        mWriter_SuppressDirtyRowNewline = morkBool_kFalse;
+      else {
+        if (tableScope)  // in a table?
+          mWriter_LineSize = stream->PutIndent(ev, morkWriter_kRowDepth);
+        else
+          mWriter_LineSize = stream->PutIndent(ev, 0);  // no indent
+      }
+
+      //      mork_rid rid = roid->mOid_Id;
+      *p++ = '[';  // start row punct=1
+      mork_size punctSize =
+          (mWriter_BeVerbose) ? 9 : 1;  // counting "[ /*r=*/ "
+
+      mork_bool rowRewrite = ioRow->IsRowRewrite();
+
+      if (rowRewrite && mWriter_Incremental) {
+        *p++ = '-';
+        ++punctSize;  // counting '-'
+        ++mWriter_LineSize;
+      }
+
+      if (tableScope && roid->mOid_Scope == tableScope)
+        ridSize = ev->TokenAsHex(p, roid->mOid_Id);
+      else
+        ridSize = ev->OidAsHex(p, *roid);
+
+      p += ridSize;
+
+      if (mWriter_BeVerbose) {
+        *p++ = ' ';  // punct=2
+        *p++ = '/';  // punct=3
+        *p++ = '*';  // punct=4
+        *p++ = 'r';  // punct=5
+        *p++ = '=';  // punct=6
+
+        mork_size usesSize = ev->TokenAsHex(p, (mork_token)ioRow->mRow_GcUses);
+        punctSize += usesSize;
+        p += usesSize;
+
+        *p++ = '*';  // punct=7
+        *p++ = '/';  // punct=8
+        *p++ = ' ';  // punct=9
+      }
+      stream->Write(ev->AsMdbEnv(), buf, ridSize + punctSize, &bytesWritten);
+      mWriter_LineSize += bytesWritten;
+
+      // special case situation where row puts exactly one column:
+      if (!rowRewrite && mWriter_Incremental && ioRow->HasRowDelta()) {
+        mork_column col = ioRow->GetDeltaColumn();
+        morkCell dummy(col, morkChange_kNil, (morkAtom*)0);
+        morkCell* cell = 0;
+
+        mork_bool withVal = (ioRow->GetDeltaChange() != morkChange_kCut);
+
+        if (withVal) {
+          mork_pos cellPos = 0;  // dummy pos
+          cell = ioRow->GetCell(ev, col, &cellPos);
+        }
+        if (!cell) cell = &dummy;
+
+        if (mWriter_BeVerbose)
+          this->PutVerboseCell(ev, cell, withVal);
+        else
+          this->PutCell(ev, cell, withVal);
+      } else  // put entire row?
+      {
+        if (mWriter_BeVerbose)
+          this->PutVerboseRowCells(ev, ioRow);  // write all, verbosely
+        else
+          this->PutRowCells(ev, ioRow);  // write all, hex notation
+      }
+
+      stream->Putc(ev, ']');  // end row
+      ++mWriter_LineSize;
+    } else {
+      this->IndentAsNeeded(ev, morkWriter_kRowDepth);
+
+      if (tableScope && roid->mOid_Scope == tableScope)
+        ridSize = ev->TokenAsHex(p, roid->mOid_Id);
+      else
+        ridSize = ev->OidAsHex(p, *roid);
+
+      stream->Write(ev->AsMdbEnv(), buf, ridSize, &bytesWritten);
+      mWriter_LineSize += bytesWritten;
+      stream->Putc(ev, ' ');
+      ++mWriter_LineSize;
+    }
+
+    ++mWriter_DoneCount;
+
+    ioRow->SetRowClean();  // try to do this at the very last
+  } else
+    ioRow->NonRowTypeWarning(ev);
+
+  return ev->Good();
+}
+
+// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789