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, 892 insertions, 0 deletions

diff --git a/comm/mailnews/db/mork/morkBuilder.cpp b/comm/mailnews/db/mork/morkBuilder.cpp
new file mode 100644
index 0000000000..4e96209929
--- /dev/null
+++ b/comm/mailnews/db/mork/morkBuilder.cpp
@@ -0,0 +1,892 @@
+/* -*- 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 _MORKNODE_
+#  include "morkNode.h"
+#endif
+
+#ifndef _MORKMAP_
+#  include "morkMap.h"
+#endif
+
+#ifndef _MORKENV_
+#  include "morkEnv.h"
+#endif
+
+#ifndef _MORKPARSER_
+#  include "morkParser.h"
+#endif
+
+#ifndef _MORKBUILDER_
+#  include "morkBuilder.h"
+#endif
+
+#ifndef _MORKCELL_
+#  include "morkCell.h"
+#endif
+
+#ifndef _MORKSTORE_
+#  include "morkStore.h"
+#endif
+
+#ifndef _MORKTABLE_
+#  include "morkTable.h"
+#endif
+
+#ifndef _MORKROW_
+#  include "morkRow.h"
+#endif
+
+#ifndef _MORKCELL_
+#  include "morkCell.h"
+#endif
+
+#ifndef _MORKATOM_
+#  include "morkAtom.h"
+#endif
+
+#ifndef _MORKATOMSPACE_
+#  include "morkAtomSpace.h"
+#endif
+
+#ifndef _MORKROWSPACE_
+#  include "morkRowSpace.h"
+#endif
+
+// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
+
+// ````` ````` ````` ````` `````
+// { ===== begin morkNode interface =====
+
+/*public virtual*/ void morkBuilder::CloseMorkNode(
+    morkEnv* ev)  // CloseBuilder() only if open
+{
+  if (this->IsOpenNode()) {
+    this->MarkClosing();
+    this->CloseBuilder(ev);
+    this->MarkShut();
+  }
+}
+
+/*public virtual*/
+morkBuilder::~morkBuilder()  // assert CloseBuilder() executed earlier
+{
+  MORK_ASSERT(mBuilder_Store == 0);
+  MORK_ASSERT(mBuilder_Row == 0);
+  MORK_ASSERT(mBuilder_Table == 0);
+  MORK_ASSERT(mBuilder_Cell == 0);
+  MORK_ASSERT(mBuilder_RowSpace == 0);
+  MORK_ASSERT(mBuilder_AtomSpace == 0);
+}
+
+/*public non-poly*/
+morkBuilder::morkBuilder(morkEnv* ev, const morkUsage& inUsage,
+                         nsIMdbHeap* ioHeap, morkStream* ioStream,
+                         mdb_count inBytesPerParseSegment,
+                         nsIMdbHeap* ioSlotHeap, morkStore* ioStore)
+
+    : morkParser(ev, inUsage, ioHeap, ioStream, inBytesPerParseSegment,
+                 ioSlotHeap)
+
+      ,
+      mBuilder_Store(0)
+
+      ,
+      mBuilder_Table(0),
+      mBuilder_Row(0),
+      mBuilder_Cell(0)
+
+      ,
+      mBuilder_RowSpace(0),
+      mBuilder_AtomSpace(0)
+
+      ,
+      mBuilder_OidAtomSpace(0),
+      mBuilder_ScopeAtomSpace(0)
+
+      ,
+      mBuilder_PortForm(0),
+      mBuilder_PortRowScope((mork_scope)'r'),
+      mBuilder_PortAtomScope((mork_scope)'v')
+
+      ,
+      mBuilder_TableForm(0),
+      mBuilder_TableRowScope((mork_scope)'r'),
+      mBuilder_TableAtomScope((mork_scope)'v'),
+      mBuilder_TableKind(0)
+
+      ,
+      mBuilder_TablePriority(morkPriority_kLo),
+      mBuilder_TableIsUnique(morkBool_kFalse),
+      mBuilder_TableIsVerbose(morkBool_kFalse),
+      mBuilder_TablePadByte(0)
+
+      ,
+      mBuilder_RowForm(0),
+      mBuilder_RowRowScope((mork_scope)'r'),
+      mBuilder_RowAtomScope((mork_scope)'v')
+
+      ,
+      mBuilder_CellForm(0),
+      mBuilder_CellAtomScope((mork_scope)'v')
+
+      ,
+      mBuilder_DictForm(0),
+      mBuilder_DictAtomScope((mork_scope)'v')
+
+      ,
+      mBuilder_MetaTokenSlot(0)
+
+      ,
+      mBuilder_DoCutRow(morkBool_kFalse),
+      mBuilder_DoCutCell(morkBool_kFalse),
+      mBuilder_CellsVecFill(0) {
+  if (ev->Good()) {
+    if (ioStore) {
+      morkStore::SlotWeakStore(ioStore, ev, &mBuilder_Store);
+      if (ev->Good()) mNode_Derived = morkDerived_kBuilder;
+    } else
+      ev->NilPointerError();
+  }
+}
+
+/*public non-poly*/ void morkBuilder::CloseBuilder(
+    morkEnv* ev)  // called by CloseMorkNode();
+{
+  if (this->IsNode()) {
+    mBuilder_Row = 0;
+    mBuilder_Cell = 0;
+    mBuilder_MetaTokenSlot = 0;
+
+    morkTable::SlotStrongTable((morkTable*)0, ev, &mBuilder_Table);
+    morkStore::SlotWeakStore((morkStore*)0, ev, &mBuilder_Store);
+
+    morkRowSpace::SlotStrongRowSpace((morkRowSpace*)0, ev, &mBuilder_RowSpace);
+
+    morkAtomSpace::SlotStrongAtomSpace((morkAtomSpace*)0, ev,
+                                       &mBuilder_AtomSpace);
+
+    morkAtomSpace::SlotStrongAtomSpace((morkAtomSpace*)0, ev,
+                                       &mBuilder_OidAtomSpace);
+
+    morkAtomSpace::SlotStrongAtomSpace((morkAtomSpace*)0, ev,
+                                       &mBuilder_ScopeAtomSpace);
+    this->CloseParser(ev);
+    this->MarkShut();
+  } else
+    this->NonNodeError(ev);
+}
+
+// } ===== end morkNode methods =====
+// ````` ````` ````` ````` `````
+
+/*static*/ void morkBuilder::NonBuilderTypeError(morkEnv* ev) {
+  ev->NewError("non morkBuilder");
+}
+
+/*static*/ void morkBuilder::NilBuilderCellError(morkEnv* ev) {
+  ev->NewError("nil mBuilder_Cell");
+}
+
+/*static*/ void morkBuilder::NilBuilderRowError(morkEnv* ev) {
+  ev->NewError("nil mBuilder_Row");
+}
+
+/*static*/ void morkBuilder::NilBuilderTableError(morkEnv* ev) {
+  ev->NewError("nil mBuilder_Table");
+}
+
+/*static*/ void morkBuilder::NonColumnSpaceScopeError(morkEnv* ev) {
+  ev->NewError("column space != 'c'");
+}
+
+void morkBuilder::LogGlitch(morkEnv* ev, const morkGlitch& inGlitch,
+                            const char* inKind) {
+  MORK_USED_2(inGlitch, inKind);
+  ev->NewWarning("parsing glitch");
+}
+
+/*virtual*/ void morkBuilder::MidToYarn(
+    morkEnv* ev,
+    const morkMid& inMid,  // typically an alias to concat with strings
+    mdbYarn* outYarn)
+// The parser might ask that some aliases be turned into yarns, so they
+// can be concatenated into longer blobs under some circumstances.  This
+// is an alternative to using a long and complex callback for many parts
+// for a single cell value.
+{
+  mBuilder_Store->MidToYarn(ev, inMid, outYarn);
+}
+
+/*virtual*/ void morkBuilder::OnNewPort(morkEnv* ev, const morkPlace& inPlace)
+// mp:Start     ::= OnNewPort mp:PortItem* OnPortEnd
+// mp:PortItem  ::= mp:Content | mp:Group | OnPortGlitch
+// mp:Content   ::= mp:PortRow | mp:Dict | mp:Table | mp:Row
+{
+  MORK_USED_2(ev, inPlace);
+  // mParser_InPort = morkBool_kTrue;
+  mBuilder_PortForm = 0;
+  mBuilder_PortRowScope = (mork_scope)'r';
+  mBuilder_PortAtomScope = (mork_scope)'v';
+}
+
+/*virtual*/ void morkBuilder::OnPortGlitch(morkEnv* ev,
+                                           const morkGlitch& inGlitch) {
+  this->LogGlitch(ev, inGlitch, "port");
+}
+
+/*virtual*/ void morkBuilder::OnPortEnd(morkEnv* ev, const morkSpan& inSpan)
+// mp:Start     ::= OnNewPort mp:PortItem* OnPortEnd
+{
+  MORK_USED_2(ev, inSpan);
+  // ev->StubMethodOnlyError();
+  // nothing to do?
+  // mParser_InPort = morkBool_kFalse;
+}
+
+/*virtual*/ void morkBuilder::OnNewGroup(morkEnv* ev, const morkPlace& inPlace,
+                                         mork_gid inGid) {
+  MORK_USED_1(inPlace);
+  mParser_InGroup = morkBool_kTrue;
+  mork_pos startPos = inPlace.mPlace_Pos;
+
+  morkStore* store = mBuilder_Store;
+  if (store) {
+    if (inGid >= store->mStore_CommitGroupIdentity)
+      store->mStore_CommitGroupIdentity = inGid + 1;
+
+    if (!store->mStore_FirstCommitGroupPos)
+      store->mStore_FirstCommitGroupPos = startPos;
+    else if (!store->mStore_SecondCommitGroupPos)
+      store->mStore_SecondCommitGroupPos = startPos;
+  }
+}
+
+/*virtual*/ void morkBuilder::OnGroupGlitch(morkEnv* ev,
+                                            const morkGlitch& inGlitch) {
+  this->LogGlitch(ev, inGlitch, "group");
+}
+
+/*virtual*/ void morkBuilder::OnGroupCommitEnd(morkEnv* ev,
+                                               const morkSpan& inSpan) {
+  MORK_USED_2(ev, inSpan);
+  // mParser_InGroup = morkBool_kFalse;
+  // ev->StubMethodOnlyError();
+}
+
+/*virtual*/ void morkBuilder::OnGroupAbortEnd(morkEnv* ev,
+                                              const morkSpan& inSpan) {
+  MORK_USED_1(inSpan);
+  // mParser_InGroup = morkBool_kFalse;
+  ev->StubMethodOnlyError();
+}
+
+/*virtual*/ void morkBuilder::OnNewPortRow(morkEnv* ev,
+                                           const morkPlace& inPlace,
+                                           const morkMid& inMid,
+                                           mork_change inChange) {
+  MORK_USED_3(inMid, inPlace, inChange);
+  // mParser_InPortRow = morkBool_kTrue;
+  ev->StubMethodOnlyError();
+}
+
+/*virtual*/ void morkBuilder::OnPortRowGlitch(morkEnv* ev,
+                                              const morkGlitch& inGlitch) {
+  this->LogGlitch(ev, inGlitch, "port row");
+}
+
+/*virtual*/ void morkBuilder::OnPortRowEnd(morkEnv* ev,
+                                           const morkSpan& inSpan) {
+  MORK_USED_1(inSpan);
+  // mParser_InPortRow = morkBool_kFalse;
+  ev->StubMethodOnlyError();
+}
+
+/*virtual*/ void morkBuilder::OnNewTable(morkEnv* ev, const morkPlace& inPlace,
+                                         const morkMid& inMid,
+                                         mork_bool inCutAllRows)
+// mp:Table     ::= OnNewTable mp:TableItem* OnTableEnd
+// mp:TableItem ::= mp:Row | mp:MetaTable | OnTableGlitch
+// mp:MetaTable ::= OnNewMeta mp:MetaItem* mp:Row OnMetaEnd
+// mp:Meta      ::= OnNewMeta mp:MetaItem* OnMetaEnd
+// mp:MetaItem  ::= mp:Cell | OnMetaGlitch
+{
+  MORK_USED_1(inPlace);
+  // mParser_InTable = morkBool_kTrue;
+  mBuilder_TableForm = mBuilder_PortForm;
+  mBuilder_TableRowScope = mBuilder_PortRowScope;
+  mBuilder_TableAtomScope = mBuilder_PortAtomScope;
+  mBuilder_TableKind = morkStore_kNoneToken;
+
+  mBuilder_TablePriority = morkPriority_kLo;
+  mBuilder_TableIsUnique = morkBool_kFalse;
+  mBuilder_TableIsVerbose = morkBool_kFalse;
+
+  morkTable* table = mBuilder_Store->MidToTable(ev, inMid);
+  morkTable::SlotStrongTable(table, ev, &mBuilder_Table);
+  if (table) {
+    if (table->mTable_RowSpace)
+      mBuilder_TableRowScope = table->mTable_RowSpace->SpaceScope();
+
+    if (inCutAllRows) table->CutAllRows(ev);
+  }
+}
+
+/*virtual*/ void morkBuilder::OnTableGlitch(morkEnv* ev,
+                                            const morkGlitch& inGlitch) {
+  this->LogGlitch(ev, inGlitch, "table");
+}
+
+/*virtual*/ void morkBuilder::OnTableEnd(morkEnv* ev, const morkSpan& inSpan)
+// mp:Table     ::= OnNewTable mp:TableItem* OnTableEnd
+{
+  MORK_USED_1(inSpan);
+  // mParser_InTable = morkBool_kFalse;
+  if (mBuilder_Table) {
+    mBuilder_Table->mTable_Priority = mBuilder_TablePriority;
+
+    if (mBuilder_TableIsUnique) mBuilder_Table->SetTableUnique();
+
+    if (mBuilder_TableIsVerbose) mBuilder_Table->SetTableVerbose();
+
+    morkTable::SlotStrongTable((morkTable*)0, ev, &mBuilder_Table);
+  } else
+    this->NilBuilderTableError(ev);
+
+  mBuilder_Row = 0;
+  mBuilder_Cell = 0;
+
+  mBuilder_TablePriority = morkPriority_kLo;
+  mBuilder_TableIsUnique = morkBool_kFalse;
+  mBuilder_TableIsVerbose = morkBool_kFalse;
+
+  if (mBuilder_TableKind == morkStore_kNoneToken)
+    ev->NewError("missing table kind");
+
+  mBuilder_CellAtomScope = mBuilder_RowAtomScope = mBuilder_TableAtomScope =
+      mBuilder_PortAtomScope;
+
+  mBuilder_DoCutCell = morkBool_kFalse;
+  mBuilder_DoCutRow = morkBool_kFalse;
+}
+
+/*virtual*/ void morkBuilder::OnNewMeta(morkEnv* ev, const morkPlace& inPlace)
+// mp:Meta      ::= OnNewMeta mp:MetaItem* OnMetaEnd
+// mp:MetaItem  ::= mp:Cell | OnMetaGlitch
+// mp:Cell      ::= OnMinusCell? OnNewCell mp:CellItem? OnCellEnd
+// mp:CellItem  ::= mp:Slot | OnCellForm | OnCellGlitch
+// mp:Slot      ::= OnValue | OnValueMid | OnRowMid | OnTableMid
+{
+  MORK_USED_2(ev, inPlace);
+  // mParser_InMeta = morkBool_kTrue;
+}
+
+/*virtual*/ void morkBuilder::OnMetaGlitch(morkEnv* ev,
+                                           const morkGlitch& inGlitch) {
+  this->LogGlitch(ev, inGlitch, "meta");
+}
+
+/*virtual*/ void morkBuilder::OnMetaEnd(morkEnv* ev, const morkSpan& inSpan)
+// mp:Meta      ::= OnNewMeta mp:MetaItem* OnMetaEnd
+{
+  MORK_USED_2(ev, inSpan);
+  // mParser_InMeta = morkBool_kFalse;
+}
+
+/*virtual*/ void morkBuilder::OnMinusRow(morkEnv* ev) {
+  MORK_USED_1(ev);
+  mBuilder_DoCutRow = morkBool_kTrue;
+}
+
+/*virtual*/ void morkBuilder::OnNewRow(morkEnv* ev, const morkPlace& inPlace,
+                                       const morkMid& inMid,
+                                       mork_bool inCutAllCols)
+// mp:Table     ::= OnNewTable mp:TableItem* OnTableEnd
+// mp:TableItem ::= mp:Row | mp:MetaTable | OnTableGlitch
+// mp:MetaTable ::= OnNewMeta mp:MetaItem* mp:Row OnMetaEnd
+// mp:Row       ::= OnMinusRow? OnNewRow mp:RowItem* OnRowEnd
+// mp:RowItem   ::= mp:Cell | mp:Meta | OnRowGlitch
+// mp:Cell      ::= OnMinusCell? OnNewCell mp:CellItem? OnCellEnd
+// mp:CellItem  ::= mp:Slot | OnCellForm | OnCellGlitch
+// mp:Slot      ::= OnValue | OnValueMid | OnRowMid | OnTableMid
+{
+  MORK_USED_1(inPlace);
+  // mParser_InRow = morkBool_kTrue;
+
+  mBuilder_CellForm = mBuilder_RowForm = mBuilder_TableForm;
+  mBuilder_CellAtomScope = mBuilder_RowAtomScope = mBuilder_TableAtomScope;
+  mBuilder_RowRowScope = mBuilder_TableRowScope;
+  morkStore* store = mBuilder_Store;
+
+  if (!inMid.mMid_Buf && !inMid.mMid_Oid.mOid_Scope) {
+    morkMid mid(inMid);
+    mid.mMid_Oid.mOid_Scope = mBuilder_RowRowScope;
+    mBuilder_Row = store->MidToRow(ev, mid);
+  } else {
+    mBuilder_Row = store->MidToRow(ev, inMid);
+  }
+  morkRow* row = mBuilder_Row;
+  if (row && inCutAllCols) {
+    row->CutAllColumns(ev);
+  }
+
+  morkTable* table = mBuilder_Table;
+  if (table) {
+    if (row) {
+      if (mParser_InMeta) {
+        morkRow* metaRow = table->mTable_MetaRow;
+        if (!metaRow) {
+          table->mTable_MetaRow = row;
+          table->mTable_MetaRowOid = row->mRow_Oid;
+          row->AddRowGcUse(ev);
+        } else if (metaRow != row)  // not identical?
+          ev->NewError("duplicate table meta row");
+      } else {
+        if (mBuilder_DoCutRow)
+          table->CutRow(ev, row);
+        else
+          table->AddRow(ev, row);
+      }
+    }
+  }
+  // else // it is now okay to have rows outside a table:
+  //  this->NilBuilderTableError(ev);
+
+  mBuilder_DoCutRow = morkBool_kFalse;
+}
+
+/*virtual*/ void morkBuilder::OnRowPos(morkEnv* ev, mork_pos inRowPos) {
+  if (mBuilder_Row && mBuilder_Table && !mParser_InMeta) {
+    mork_pos hintFromPos = 0;  // best hint when we don't know position
+    mBuilder_Table->MoveRow(ev, mBuilder_Row, hintFromPos, inRowPos);
+  }
+}
+
+/*virtual*/ void morkBuilder::OnRowGlitch(morkEnv* ev,
+                                          const morkGlitch& inGlitch) {
+  this->LogGlitch(ev, inGlitch, "row");
+}
+
+void morkBuilder::FlushBuilderCells(morkEnv* ev) {
+  if (mBuilder_Row) {
+    morkPool* pool = mBuilder_Store->StorePool();
+    morkCell* cells = mBuilder_CellsVec;
+    mork_fill fill = mBuilder_CellsVecFill;
+    mBuilder_Row->TakeCells(ev, cells, fill, mBuilder_Store);
+
+    morkCell* end = cells + fill;
+    --cells;  // prepare for preincrement
+    while (++cells < end) {
+      if (cells->mCell_Atom) cells->SetAtom(ev, (morkAtom*)0, pool);
+    }
+    mBuilder_CellsVecFill = 0;
+  } else
+    this->NilBuilderRowError(ev);
+}
+
+/*virtual*/ void morkBuilder::OnRowEnd(morkEnv* ev, const morkSpan& inSpan)
+// mp:Row       ::= OnMinusRow? OnNewRow mp:RowItem* OnRowEnd
+{
+  MORK_USED_1(inSpan);
+  // mParser_InRow = morkBool_kFalse;
+  if (mBuilder_Row) {
+    this->FlushBuilderCells(ev);
+  } else
+    this->NilBuilderRowError(ev);
+
+  mBuilder_Row = 0;
+  mBuilder_Cell = 0;
+
+  mBuilder_DoCutCell = morkBool_kFalse;
+  mBuilder_DoCutRow = morkBool_kFalse;
+}
+
+/*virtual*/ void morkBuilder::OnNewDict(morkEnv* ev, const morkPlace& inPlace)
+// mp:Dict      ::= OnNewDict mp:DictItem* OnDictEnd
+// mp:DictItem  ::= OnAlias | OnAliasGlitch | mp:Meta | OnDictGlitch
+{
+  MORK_USED_2(ev, inPlace);
+  // mParser_InDict = morkBool_kTrue;
+
+  mBuilder_CellForm = mBuilder_DictForm = mBuilder_PortForm;
+  mBuilder_CellAtomScope = mBuilder_DictAtomScope = mBuilder_PortAtomScope;
+}
+
+/*virtual*/ void morkBuilder::OnDictGlitch(morkEnv* ev,
+                                           const morkGlitch& inGlitch) {
+  this->LogGlitch(ev, inGlitch, "dict");
+}
+
+/*virtual*/ void morkBuilder::OnDictEnd(morkEnv* ev, const morkSpan& inSpan)
+// mp:Dict      ::= OnNewDict mp:DictItem* OnDictEnd
+{
+  MORK_USED_2(ev, inSpan);
+  // mParser_InDict = morkBool_kFalse;
+
+  mBuilder_DictForm = 0;
+  mBuilder_DictAtomScope = 0;
+}
+
+/*virtual*/ void morkBuilder::OnAlias(morkEnv* ev, const morkSpan& inSpan,
+                                      const morkMid& inMid) {
+  MORK_USED_1(inSpan);
+  if (mParser_InDict) {
+    morkMid mid = inMid;  // local copy for modification
+    mid.mMid_Oid.mOid_Scope = mBuilder_DictAtomScope;
+    mBuilder_Store->AddAlias(ev, mid, mBuilder_DictForm);
+  } else
+    ev->NewError("alias not in dict");
+}
+
+/*virtual*/ void morkBuilder::OnAliasGlitch(morkEnv* ev,
+                                            const morkGlitch& inGlitch) {
+  this->LogGlitch(ev, inGlitch, "alias");
+}
+
+morkCell* morkBuilder::AddBuilderCell(morkEnv* ev, const morkMid& inMid,
+                                      mork_change inChange) {
+  morkCell* outCell = 0;
+  mork_column column = inMid.mMid_Oid.mOid_Id;
+
+  if (ev->Good()) {
+    if (mBuilder_CellsVecFill >= morkBuilder_kCellsVecSize)
+      this->FlushBuilderCells(ev);
+    if (ev->Good()) {
+      if (mBuilder_CellsVecFill < morkBuilder_kCellsVecSize) {
+        mork_fill indx = mBuilder_CellsVecFill++;
+        outCell = mBuilder_CellsVec + indx;
+        outCell->SetColumnAndChange(column, inChange);
+        outCell->mCell_Atom = 0;
+      } else
+        ev->NewError("out of builder cells");
+    }
+  }
+  return outCell;
+}
+
+/*virtual*/ void morkBuilder::OnMinusCell(morkEnv* ev) {
+  MORK_USED_1(ev);
+  mBuilder_DoCutCell = morkBool_kTrue;
+}
+
+/*virtual*/ void morkBuilder::OnNewCell(morkEnv* ev, const morkPlace& inPlace,
+                                        const morkMid* inMid,
+                                        const morkBuf* inBuf)
+// Exactly one of inMid and inBuf is nil, and the other is non-nil.
+// When hex ID syntax is used for a column, then inMid is not nil, and
+// when a naked string names a column, then inBuf is not nil.
+
+// mp:Cell      ::= OnMinusCell? OnNewCell mp:CellItem? OnCellEnd
+// mp:CellItem  ::= mp:Slot | OnCellForm | OnCellGlitch
+// mp:Slot      ::= OnValue | OnValueMid | OnRowMid | OnTableMid
+{
+  MORK_USED_1(inPlace);
+  // mParser_InCell = morkBool_kTrue;
+
+  mork_change cellChange =
+      (mBuilder_DoCutCell) ? morkChange_kCut : morkChange_kAdd;
+
+  mBuilder_DoCutCell = morkBool_kFalse;
+
+  mBuilder_CellAtomScope = mBuilder_RowAtomScope;
+
+  mBuilder_Cell = 0;  // nil until determined for a row
+  morkStore* store = mBuilder_Store;
+  mork_scope scope = morkStore_kColumnSpaceScope;
+  morkMid tempMid;              // space for local and modifiable cell mid
+  morkMid* cellMid = &tempMid;  // default to local if inMid==0
+
+  if (inMid)  // mid parameter is actually provided?
+  {
+    *cellMid = *inMid;  // bitwise copy for modifiable local mid
+
+    if (!cellMid->mMid_Oid.mOid_Scope) {
+      if (cellMid->mMid_Buf) {
+        scope = store->BufToToken(ev, cellMid->mMid_Buf);
+        cellMid->mMid_Buf = 0;  // don't do scope lookup again
+        ev->NewWarning("column mids need column scope");
+      }
+      cellMid->mMid_Oid.mOid_Scope = scope;
+    }
+  } else if (inBuf)  // buf points to naked column string name?
+  {
+    cellMid->ClearMid();
+    cellMid->mMid_Oid.mOid_Id = store->BufToToken(ev, inBuf);
+    cellMid->mMid_Oid.mOid_Scope = scope;  // kColumnSpaceScope
+  } else
+    ev->NilPointerError();  // either inMid or inBuf must be non-nil
+
+  mork_column column = cellMid->mMid_Oid.mOid_Id;
+
+  if (mBuilder_Row && ev->Good())  // this cell must be inside a row
+  {
+    // mBuilder_Cell = this->AddBuilderCell(ev, *cellMid, cellChange);
+
+    if (mBuilder_CellsVecFill >= morkBuilder_kCellsVecSize)
+      this->FlushBuilderCells(ev);
+    if (ev->Good()) {
+      if (mBuilder_CellsVecFill < morkBuilder_kCellsVecSize) {
+        mork_fill ix = mBuilder_CellsVecFill++;
+        morkCell* cell = mBuilder_CellsVec + ix;
+        cell->SetColumnAndChange(column, cellChange);
+
+        cell->mCell_Atom = 0;
+        mBuilder_Cell = cell;
+      } else
+        ev->NewError("out of builder cells");
+    }
+  }
+
+  else if (mParser_InMeta && ev->Good())  // cell is in metainfo structure?
+  {
+    if (scope == morkStore_kColumnSpaceScope) {
+      if (mParser_InTable)  // metainfo for table?
+      {
+        if (column == morkStore_kKindColumn)
+          mBuilder_MetaTokenSlot = &mBuilder_TableKind;
+        else if (column == morkStore_kStatusColumn)
+          mBuilder_MetaTokenSlot = &mBuilder_TableStatus;
+        else if (column == morkStore_kRowScopeColumn)
+          mBuilder_MetaTokenSlot = &mBuilder_TableRowScope;
+        else if (column == morkStore_kAtomScopeColumn)
+          mBuilder_MetaTokenSlot = &mBuilder_TableAtomScope;
+        else if (column == morkStore_kFormColumn)
+          mBuilder_MetaTokenSlot = &mBuilder_TableForm;
+      } else if (mParser_InDict)  // metainfo for dict?
+      {
+        if (column == morkStore_kAtomScopeColumn)
+          mBuilder_MetaTokenSlot = &mBuilder_DictAtomScope;
+        else if (column == morkStore_kFormColumn)
+          mBuilder_MetaTokenSlot = &mBuilder_DictForm;
+      } else if (mParser_InRow)  // metainfo for row?
+      {
+        if (column == morkStore_kAtomScopeColumn)
+          mBuilder_MetaTokenSlot = &mBuilder_RowAtomScope;
+        else if (column == morkStore_kRowScopeColumn)
+          mBuilder_MetaTokenSlot = &mBuilder_RowRowScope;
+        else if (column == morkStore_kFormColumn)
+          mBuilder_MetaTokenSlot = &mBuilder_RowForm;
+      }
+    } else
+      ev->NewWarning("expected column scope");
+  }
+}
+
+/*virtual*/ void morkBuilder::OnCellGlitch(morkEnv* ev,
+                                           const morkGlitch& inGlitch) {
+  this->LogGlitch(ev, inGlitch, "cell");
+}
+
+/*virtual*/ void morkBuilder::OnCellForm(morkEnv* ev,
+                                         mork_cscode inCharsetFormat) {
+  morkCell* cell = mBuilder_Cell;
+  if (cell) {
+    mBuilder_CellForm = inCharsetFormat;
+  } else
+    this->NilBuilderCellError(ev);
+}
+
+/*virtual*/ void morkBuilder::OnCellEnd(morkEnv* ev, const morkSpan& inSpan)
+// mp:Cell      ::= OnMinusCell? OnNewCell mp:CellItem? OnCellEnd
+{
+  MORK_USED_2(ev, inSpan);
+  // mParser_InCell = morkBool_kFalse;
+
+  mBuilder_MetaTokenSlot = 0;
+  mBuilder_CellAtomScope = mBuilder_RowAtomScope;
+}
+
+/*virtual*/ void morkBuilder::OnValue(morkEnv* ev, const morkSpan& inSpan,
+                                      const morkBuf& inBuf)
+// mp:CellItem  ::= mp:Slot | OnCellForm | OnCellGlitch
+// mp:Slot      ::= OnValue | OnValueMid | OnRowMid | OnTableMid
+{
+  MORK_USED_1(inSpan);
+  morkStore* store = mBuilder_Store;
+  morkCell* cell = mBuilder_Cell;
+  if (cell) {
+    mdbYarn yarn;
+    yarn.mYarn_Buf = inBuf.mBuf_Body;
+    yarn.mYarn_Fill = yarn.mYarn_Size = inBuf.mBuf_Fill;
+    yarn.mYarn_More = 0;
+    yarn.mYarn_Form = mBuilder_CellForm;
+    yarn.mYarn_Grow = 0;
+    morkAtom* atom = store->YarnToAtom(ev, &yarn, true /* create */);
+    cell->SetAtom(ev, atom, store->StorePool());
+  } else if (mParser_InMeta) {
+    mork_token* metaSlot = mBuilder_MetaTokenSlot;
+    if (metaSlot) {
+      if (metaSlot == &mBuilder_TableStatus)  // table status?
+      {
+        if (mParser_InTable && mBuilder_Table) {
+          const char* body = (const char*)inBuf.mBuf_Body;
+          mork_fill bufFill = inBuf.mBuf_Fill;
+          if (body && bufFill) {
+            const char* bodyEnd = body + bufFill;
+            while (body < bodyEnd) {
+              int c = *body++;
+              switch (c) {
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                  mBuilder_TablePriority = (mork_priority)(c - '0');
+                  break;
+
+                case 'u':
+                case 'U':
+                  mBuilder_TableIsUnique = morkBool_kTrue;
+                  break;
+
+                case 'v':
+                case 'V':
+                  mBuilder_TableIsVerbose = morkBool_kTrue;
+                  break;
+              }
+            }
+          }
+        }
+      } else {
+        mork_token token = store->BufToToken(ev, &inBuf);
+        if (token) {
+          *metaSlot = token;
+          if (metaSlot == &mBuilder_TableKind)  // table kind?
+          {
+            if (mParser_InTable && mBuilder_Table)
+              mBuilder_Table->mTable_Kind = token;
+          }
+        }
+      }
+    }
+  } else
+    this->NilBuilderCellError(ev);
+}
+
+/*virtual*/ void morkBuilder::OnValueMid(morkEnv* ev, const morkSpan& inSpan,
+                                         const morkMid& inMid)
+// mp:CellItem  ::= mp:Slot | OnCellForm | OnCellGlitch
+// mp:Slot      ::= OnValue | OnValueMid | OnRowMid | OnTableMid
+{
+  MORK_USED_1(inSpan);
+  morkStore* store = mBuilder_Store;
+  morkCell* cell = mBuilder_Cell;
+
+  morkMid valMid;                     // local mid for modifications
+  mdbOid* valOid = &valMid.mMid_Oid;  // ref to oid inside mid
+  *valOid = inMid.mMid_Oid;           // bitwise copy inMid's oid
+
+  if (inMid.mMid_Buf) {
+    if (!valOid->mOid_Scope) store->MidToOid(ev, inMid, valOid);
+  } else if (!valOid->mOid_Scope)
+    valOid->mOid_Scope = mBuilder_CellAtomScope;
+
+  if (cell) {
+    morkBookAtom* atom = store->MidToAtom(ev, valMid);
+    if (atom)
+      cell->SetAtom(ev, atom, store->StorePool());
+    else
+      ev->NewError("undefined cell value alias");
+  } else if (mParser_InMeta) {
+    mork_token* metaSlot = mBuilder_MetaTokenSlot;
+    if (metaSlot) {
+      mork_scope valScope = valOid->mOid_Scope;
+      if (!valScope || valScope == morkStore_kColumnSpaceScope) {
+        if (ev->Good() && valMid.HasSomeId()) {
+          *metaSlot = valOid->mOid_Id;
+          if (metaSlot == &mBuilder_TableKind)  // table kind?
+          {
+            if (mParser_InTable && mBuilder_Table) {
+              mBuilder_Table->mTable_Kind = valOid->mOid_Id;
+            } else
+              ev->NewWarning("mBuilder_TableKind not in table");
+          } else if (metaSlot == &mBuilder_TableStatus)  // table status?
+          {
+            if (mParser_InTable && mBuilder_Table) {
+              // $$ what here??
+            } else
+              ev->NewWarning("mBuilder_TableStatus not in table");
+          }
+        }
+      } else
+        this->NonColumnSpaceScopeError(ev);
+    }
+  } else
+    this->NilBuilderCellError(ev);
+}
+
+/*virtual*/ void morkBuilder::OnRowMid(morkEnv* ev, const morkSpan& inSpan,
+                                       const morkMid& inMid)
+// mp:CellItem  ::= mp:Slot | OnCellForm | OnCellGlitch
+// mp:Slot      ::= OnValue | OnValueMid | OnRowMid | OnTableMid
+{
+  MORK_USED_1(inSpan);
+  morkStore* store = mBuilder_Store;
+  morkCell* cell = mBuilder_Cell;
+  if (cell) {
+    mdbOid rowOid = inMid.mMid_Oid;
+    if (inMid.mMid_Buf) {
+      if (!rowOid.mOid_Scope) store->MidToOid(ev, inMid, &rowOid);
+    } else if (!rowOid.mOid_Scope)
+      rowOid.mOid_Scope = mBuilder_RowRowScope;
+
+    if (ev->Good()) {
+      morkPool* pool = store->StorePool();
+      morkAtom* atom = pool->NewRowOidAtom(ev, rowOid, &store->mStore_Zone);
+      if (atom) {
+        cell->SetAtom(ev, atom, pool);
+        morkRow* row = store->OidToRow(ev, &rowOid);
+        if (row)  // found or created such a row?
+          row->AddRowGcUse(ev);
+      }
+    }
+  } else
+    this->NilBuilderCellError(ev);
+}
+
+/*virtual*/ void morkBuilder::OnTableMid(morkEnv* ev, const morkSpan& inSpan,
+                                         const morkMid& inMid)
+// mp:CellItem  ::= mp:Slot | OnCellForm | OnCellGlitch
+// mp:Slot      ::= OnValue | OnValueMid | OnRowMid | OnTableMid
+{
+  MORK_USED_1(inSpan);
+  morkStore* store = mBuilder_Store;
+  morkCell* cell = mBuilder_Cell;
+  if (cell) {
+    mdbOid tableOid = inMid.mMid_Oid;
+    if (inMid.mMid_Buf) {
+      if (!tableOid.mOid_Scope) store->MidToOid(ev, inMid, &tableOid);
+    } else if (!tableOid.mOid_Scope)
+      tableOid.mOid_Scope = mBuilder_RowRowScope;
+
+    if (ev->Good()) {
+      morkPool* pool = store->StorePool();
+      morkAtom* atom = pool->NewTableOidAtom(ev, tableOid, &store->mStore_Zone);
+      if (atom) {
+        cell->SetAtom(ev, atom, pool);
+        morkTable* table = store->OidToTable(ev, &tableOid,
+                                             /*optionalMetaRowOid*/ (mdbOid*)0);
+        if (table)  // found or created such a table?
+          table->AddTableGcUse(ev);
+      }
+    }
+  } else
+    this->NilBuilderCellError(ev);
+}
+
+// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789