void morkPool::ZapCells(morkEnv* ev, morkCell* ioVector, mork_size inSize,
                        morkZone* ioZone) {
  MORK_USED_1(inSize);

  if (ioVector) {
#ifdef morkZone_CONFIG_ARENA
    // a zone 'run' knows its size, and can indeed be deallocated:
    ioZone->ZoneZapRun(ev, ioVector);
#else  /*morkZone_CONFIG_ARENA*/
    MORK_USED_1(ioZone);
    mPool_Heap->Free(ev->AsMdbEnv(), ioVector);
#endif /*morkZone_CONFIG_ARENA*/
  }
}

/*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;
}

mork_bool morkFactory::CanOpenMorkTextFile(morkEnv* ev,
                                           // const mdbYarn* inFirst512Bytes,
                                           nsIMdbFile* ioFile) {
  MORK_USED_1(ev);
  mork_bool outBool = morkBool_kFalse;
  mork_size headSize = strlen(morkWriter_kFileHeader);

  char localBuf[256 + 4];  // for extra for sloppy safety
  mdbYarn localYarn;
  mdbYarn* y = &localYarn;
  y->mYarn_Buf = localBuf;  // space to hold content
  y->mYarn_Fill = 0;        // no logical content yet
  y->mYarn_Size = 256;      // physical capacity is 256 bytes
  y->mYarn_More = 0;
  y->mYarn_Form = 0;
  y->mYarn_Grow = 0;

  if (ioFile) {
    nsIMdbEnv* menv = ev->AsMdbEnv();
    mdb_size actualSize = 0;
    ioFile->Get(menv, y->mYarn_Buf, y->mYarn_Size, /*pos*/ 0, &actualSize);
    y->mYarn_Fill = actualSize;

    if (y->mYarn_Buf && actualSize >= headSize && ev->Good()) {
      mork_u1* buf = (mork_u1*)y->mYarn_Buf;
      outBool = (MORK_MEMCMP(morkWriter_kFileHeader, buf, headSize) == 0);
    }
  } else
    ev->NilPointerError();

  return outBool;
}

void
morkRow::OnZeroRowGcUse(morkEnv* ev)
// OnZeroRowGcUse() is called when CutRowGcUse() returns zero.
{
  MORK_USED_1(ev);
  // ev->NewWarning("need to implement OnZeroRowGcUse");
}

NS_IMETHODIMP
morkFactory::OpenFilePort(
    nsIMdbEnv* mev, // context
    nsIMdbHeap* ioHeap, // can be nil to cause ev's heap attribute to be used
    // const char* inFilePath, // the file to open for readonly import
    nsIMdbFile* ioFile, // db abstract file interface
    const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
    nsIMdbThumb** acqThumb)
{
    NS_ASSERTION(false, "this doesn't look implemented");
    MORK_USED_1(ioHeap);
    mdb_err outErr = NS_OK;
    nsIMdbThumb* outThumb = 0;
    morkEnv* ev = morkEnv::FromMdbEnv(mev);
    if ( ev )
    {
        if ( ioFile && inOpenPolicy && acqThumb )
        {
        }
        else
            ev->NilPointerError();

        outErr = ev->AsErr();
    }
    if ( acqThumb )
        *acqThumb = outThumb;
    return outErr;
}

/*protected non-poly*/ void
morkParser::StartParse(morkEnv* ev)
{
  MORK_USED_1(ev);
  mParser_InCell = morkBool_kFalse;
  mParser_InMeta = morkBool_kFalse;
  mParser_InDict = morkBool_kFalse;
  mParser_InPortRow = morkBool_kFalse;
  
  mParser_RowMid.ClearMid();
  mParser_TableMid.ClearMid();
  mParser_CellMid.ClearMid();
  
  mParser_GroupId = 0;
  mParser_InPort = morkBool_kTrue;

  mParser_GroupSpan.ClearSpan();
  mParser_DictSpan.ClearSpan();
  mParser_AliasSpan.ClearSpan();
  mParser_MetaSpan.ClearSpan();
  mParser_TableSpan.ClearSpan();
  mParser_RowSpan.ClearSpan();
  mParser_CellSpan.ClearSpan();
  mParser_ColumnSpan.ClearSpan();
  mParser_SlotSpan.ClearSpan();

   mParser_PortSpan.ClearSpan();
}

/*virtual*/ void
morkBuilder::OnPortRowEnd(morkEnv* ev, const morkSpan& inSpan)
{
  MORK_USED_1(inSpan);
  // mParser_InPortRow = morkBool_kFalse;
  ev->StubMethodOnlyError();
}

// { ===== begin morkMap poly interface =====
/*virtual*/ mork_bool // 
morkRowMap::Equal(morkEnv* ev, const void* inKeyA,
  const void* inKeyB) const
{
  MORK_USED_1(ev);
  return (*(const morkRow**) inKeyA)->EqualRow(*(const morkRow**) inKeyB);
}

// alloc and free individual instances of handles (inside hand frames):
morkHandleFace* morkPool::NewHandle(morkEnv* ev, mork_size inSize,
                                    morkZone* ioZone) {
  void* newBlock = 0;
  if (inSize <= sizeof(morkHandleFrame)) {
    morkLink* firstLink = mPool_FreeHandleFrames.RemoveFirst();
    if (firstLink) {
      newBlock = firstLink;
      if (mPool_FreeFramesCount)
        --mPool_FreeFramesCount;
      else
        ev->NewWarning("mPool_FreeFramesCount underflow");
    } else
      mPool_Heap->Alloc(ev->AsMdbEnv(), sizeof(morkHandleFrame),
                        (void**)&newBlock);
  } else {
    ev->NewWarning("inSize > sizeof(morkHandleFrame)");
    mPool_Heap->Alloc(ev->AsMdbEnv(), inSize, (void**)&newBlock);
  }
#ifdef morkZone_CONFIG_ARENA
#else  /*morkZone_CONFIG_ARENA*/
  MORK_USED_1(ioZone);
#endif /*morkZone_CONFIG_ARENA*/

  return (morkHandleFace*)newBlock;
}

mork_u2
morkTable::AddTableGcUse(morkEnv* ev)
{
  MORK_USED_1(ev); 
  if ( mTable_GcUses < morkTable_kMaxTableGcUses ) // not already maxed out?
    ++mTable_GcUses;
    
  return mTable_GcUses;
}

/*virtual*/ nsresult morkHandle::Handle_IsOpenMdbObject(nsIMdbEnv* mev,
                                                        mdb_bool* outOpen) {
  MORK_USED_1(mev);
  nsresult outErr = NS_OK;

  MORK_ASSERT(outOpen);
  if (outOpen) *outOpen = this->IsOpenNode();

  return outErr;
}

// alloc & free individual instances of atoms (lots of atom subclasses):
void morkPool::ZapAtom(morkEnv* ev, morkAtom* ioAtom,
                       morkZone* ioZone)  // any subclass (by kind)
{
#ifdef morkZone_CONFIG_ARENA
  if (!ioAtom) ev->NilPointerWarning();  // a zone 'chip' cannot be freed
#else                                    /*morkZone_CONFIG_ARENA*/
  MORK_USED_1(ioZone);
  if (ioAtom) mPool_Heap->Free(ev->AsMdbEnv(), ioAtom);
#endif                                   /*morkZone_CONFIG_ARENA*/
}

mork_bool
morkPool::CutRowCells(morkEnv* ev, morkRow* ioRow,
  mork_size inNewSize,
  morkZone* ioZone)
{
  MORK_USED_1(ioZone);
#ifdef morkZone_CONFIG_ARENA
#else /*morkZone_CONFIG_ARENA*/
#endif /*morkZone_CONFIG_ARENA*/

  mork_fill fill = ioRow->mRow_Length;
  if ( ev->Good() && fill > inNewSize ) // need fewer cells?
  {
    if ( inNewSize ) // want any row cells at all?
    {
      morkCell* newCells = this->NewCells(ev, inNewSize, ioZone);
      if ( newCells )
      {
        morkCell* saveNewCells = newCells; // Keep newcell pos
        morkCell* oldCells = ioRow->mRow_Cells;
        morkCell* oldEnd = oldCells + fill; // one past all old cells
        morkCell* newEnd = oldCells + inNewSize; // copy only kept old cells
        while ( oldCells < newEnd )
        {
          *newCells++ = *oldCells++; // bitwise copy each old cell struct
        }
        while ( oldCells < oldEnd )
        {
          if ( oldCells->mCell_Atom ) // need to unref old cell atom?
            oldCells->SetAtom(ev, (morkAtom*) 0, this); // unref cell atom
          ++oldCells;
        }
        oldCells = ioRow->mRow_Cells;
        ioRow->mRow_Cells = saveNewCells;
        ioRow->mRow_Length = (mork_u2) inNewSize;
        ++ioRow->mRow_Seed;
        
        if ( oldCells )
          this->ZapCells(ev, oldCells, fill, ioZone);
      }
    }
    else // get rid of all row cells
    {
      morkCell* oldCells = ioRow->mRow_Cells;
      ioRow->mRow_Cells = 0;
      ioRow->mRow_Length = 0;
      ++ioRow->mRow_Seed;
      
      if ( oldCells )
        this->ZapCells(ev, oldCells, fill, ioZone);
    }
  }
  return ( ev->Good() && ioRow->mRow_Length <= inNewSize );
}

/*virtual*/ mork_test  // hit(a,b) implies hash(a) == hash(b)
morkRowProbeMap::MapTest(morkEnv* ev, const void* inMapKey,
                         const void* inAppKey) const {
  MORK_USED_1(ev);
  const morkRow* key = *(const morkRow**)inMapKey;
  if (key) {
    mork_bool hit = key->EqualRow(*(const morkRow**)inAppKey);
    return (hit) ? morkTest_kHit : morkTest_kMiss;
  } else
    return morkTest_kVoid;
}

void
morkMapIter::CloseMapIter(morkEnv* ev)
{
  MORK_USED_1(ev);
  mMapIter_Map = 0;
  mMapIter_Seed = 0;
  
  mMapIter_Bucket = 0;
  mMapIter_AssocRef = 0;
  mMapIter_Assoc = 0;
  mMapIter_Next = 0;
}

nsIMdbFile*
morkFile::AcquireFileHandle(morkEnv* ev)
{
  nsIMdbFile* outFile = 0;

#ifdef MORK_CONFIG_USE_ORKINFILE
  return this;
#endif /*MORK_CONFIG_USE_ORKINFILE*/
  MORK_USED_1(ev);
    
  return outFile;
}