/*public non-poly*/ void
morkFile::CloseFile(morkEnv* ev) // called by CloseMorkNode();
{
if ( this )
{
if ( this->IsNode() )
{
mFile_Frozen = 0;
mFile_DoTrace = 0;
mFile_IoOpen = 0;
mFile_Active = 0;
if ( mFile_Name )
this->SetFileName(ev, (const char*) 0);
nsIMdbHeap_SlotStrongHeap((nsIMdbHeap*) 0, ev, &mFile_SlotHeap);
nsIMdbFile_SlotStrongFile((nsIMdbFile*) 0, ev, &mFile_Thief);
this->MarkShut();
}
else
this->NonNodeError(ev);
}
else
ev->NilPointerError();
}
/*public non-poly*/
morkArray::morkArray(morkEnv* ev, const morkUsage& inUsage,
nsIMdbHeap* ioHeap, mork_size inSize, nsIMdbHeap* ioSlotHeap)
: morkNode(ev, inUsage, ioHeap)
, mArray_Slots( 0 )
, mArray_Heap( 0 )
, mArray_Fill( 0 )
, mArray_Size( 0 )
, mArray_Seed( (mork_u4)NS_PTR_TO_INT32(this) ) // "random" integer assignment
{
if ( ev->Good() )
{
if ( ioSlotHeap )
{
nsIMdbHeap_SlotStrongHeap(ioSlotHeap, ev, &mArray_Heap);
if ( ev->Good() )
{
if ( inSize < 3 )
inSize = 3;
mdb_size byteSize = inSize * sizeof(void*);
void** block = 0;
ioSlotHeap->Alloc(ev->AsMdbEnv(), byteSize, (void**) &block);
if ( block && ev->Good() )
{
mArray_Slots = block;
mArray_Size = inSize;
MORK_MEMSET(mArray_Slots, 0, byteSize);
if ( ev->Good() )
mNode_Derived = morkDerived_kArray;
}
}
}
else
ev->NilPointerError();
}
}
void morkZone::CloseZone(morkEnv* ev) // called by CloseMorkNode()
{
if ( this )
{
if ( this->IsNode() )
{
nsIMdbHeap* heap = mZone_Heap;
if ( heap )
{
morkHunk* hunk = 0;
nsIMdbEnv* mev = ev->AsMdbEnv();
morkHunk* next = mZone_HunkList;
while ( ( hunk = next ) != 0 )
{
#ifdef morkHunk_USE_TAG_SLOT
if ( !hunk->HunkGoodTag() )
hunk->BadHunkTagWarning(ev);
#endif /* morkHunk_USE_TAG_SLOT */
next = hunk->HunkNext();
heap->Free(mev, hunk);
}
}
nsIMdbHeap_SlotStrongHeap((nsIMdbHeap*) 0, ev, &mZone_Heap);
this->MarkShut();
}
else
this->NonNodeError(ev);
}
else
ev->NilPointerError();
}
// public: // morkMap construction & destruction
morkZone::morkZone(morkEnv* ev, const morkUsage& inUsage,
nsIMdbHeap* ioNodeHeap, nsIMdbHeap* ioZoneHeap)
: morkNode(ev, inUsage, ioNodeHeap)
, mZone_Heap( 0 )
, mZone_HeapVolume( 0 )
, mZone_BlockVolume( 0 )
, mZone_RunVolume( 0 )
, mZone_ChipVolume( 0 )
, mZone_FreeOldRunVolume( 0 )
, mZone_HunkCount( 0 )
, mZone_FreeOldRunCount( 0 )
, mZone_HunkList( 0 )
, mZone_FreeOldRunList( 0 )
, mZone_At( 0 )
, mZone_AtSize( 0 )
// morkRun* mZone_FreeRuns[ morkZone_kBuckets + 1 ];
{
morkRun** runs = mZone_FreeRuns;
morkRun** end = runs + (morkZone_kBuckets + 1); // one past last slot
--runs; // prepare for preincrement
while ( ++runs < end ) // another slot in array?
*runs = 0; // clear all the slots
if ( ev->Good() )
{
if ( ioZoneHeap )
{
nsIMdbHeap_SlotStrongHeap(ioZoneHeap, ev, &mZone_Heap);
if ( ev->Good() )
mNode_Derived = morkDerived_kZone;
}
else
ev->NilPointerError();
}
}
void
morkMap::clear_map(morkEnv* ev, nsIMdbHeap* ioSlotHeap)
{
mMap_Tag = 0;
mMap_Seed = 0;
mMap_Slots = 0;
mMap_Fill = 0;
mMap_Keys = 0;
mMap_Vals = 0;
mMap_Assocs = 0;
mMap_Changes = 0;
mMap_Buckets = 0;
mMap_FreeList = 0;
MORK_MEMSET(&mMap_Form, 0, sizeof(morkMapForm));
mMap_Heap = 0;
if ( ioSlotHeap )
{
nsIMdbHeap_SlotStrongHeap(ioSlotHeap, ev, &mMap_Heap);
}
else
ev->NilPointerError();
}
/*public non-poly*/ void
morkArray::CloseArray(morkEnv* ev) // called by CloseMorkNode();
{
if ( this )
{
if ( this->IsNode() )
{
if ( mArray_Heap && mArray_Slots )
mArray_Heap->Free(ev->AsMdbEnv(), mArray_Slots);
mArray_Slots = 0;
mArray_Size = 0;
mArray_Fill = 0;
++mArray_Seed;
nsIMdbHeap_SlotStrongHeap((nsIMdbHeap*) 0, ev, &mArray_Heap);
this->MarkShut();
}
else
this->NonNodeError(ev);
}
else
ev->NilPointerError();
}
/*public non-poly*/ void
morkParser::CloseParser(morkEnv* ev) // called by CloseMorkNode();
{
if ( this )
{
if ( this->IsNode() )
{
if ( !this->IsShutNode() )
{
mParser_ScopeCoil.CloseCoil(ev);
mParser_ValueCoil.CloseCoil(ev);
mParser_ColumnCoil.CloseCoil(ev);
mParser_StringCoil.CloseCoil(ev);
nsIMdbHeap_SlotStrongHeap((nsIMdbHeap*) 0, ev, &mParser_Heap);
morkStream::SlotStrongStream((morkStream*) 0, ev, &mParser_Stream);
this->MarkShut();
}
}
else
this->NonNodeError(ev);
}
else
ev->NilPointerError();
}
/*public non-poly*/
morkFile::morkFile(morkEnv* ev, const morkUsage& inUsage,
nsIMdbHeap* ioHeap, nsIMdbHeap* ioSlotHeap)
: morkObject(ev, inUsage, ioHeap, morkColor_kNone, (morkHandle*) 0)
, mFile_Frozen( 0 )
, mFile_DoTrace( 0 )
, mFile_IoOpen( 0 )
, mFile_Active( 0 )
, mFile_SlotHeap( 0 )
, mFile_Name( 0 )
, mFile_Thief( 0 )
{
if ( ev->Good() )
{
if ( ioSlotHeap )
{
nsIMdbHeap_SlotStrongHeap(ioSlotHeap, ev, &mFile_SlotHeap);
if ( ev->Good() )
mNode_Derived = morkDerived_kFile;
}
else
ev->NilPointerError();
}
}
/*public non-poly*/
morkParser::morkParser(morkEnv* ev,
const morkUsage& inUsage, nsIMdbHeap* ioHeap,
morkStream* ioStream, mdb_count inBytesPerParseSegment,
nsIMdbHeap* ioSlotHeap)
: morkNode(ev, inUsage, ioHeap)
, mParser_Heap( 0 )
, mParser_Stream( 0 )
, mParser_MoreGranularity( inBytesPerParseSegment )
, mParser_State( morkParser_kStartState )
, mParser_GroupContentStartPos( 0 )
, mParser_TableMid( )
, mParser_RowMid( )
, mParser_CellMid( )
, mParser_InPort( morkBool_kFalse )
, mParser_InDict( morkBool_kFalse )
, mParser_InCell( morkBool_kFalse )
, mParser_InMeta( morkBool_kFalse )
, mParser_InPortRow( morkBool_kFalse )
, mParser_InRow( morkBool_kFalse )
, mParser_InTable( morkBool_kFalse )
, mParser_InGroup( morkBool_kFalse )
, mParser_AtomChange( morkChange_kNil )
, mParser_CellChange( morkChange_kNil )
, mParser_RowChange( morkChange_kNil )
, mParser_TableChange( morkChange_kNil )
, mParser_Change( morkChange_kNil )
, mParser_IsBroken( morkBool_kFalse )
, mParser_IsDone( morkBool_kFalse )
, mParser_DoMore( morkBool_kTrue )
, mParser_Mid()
, mParser_ScopeCoil(ev, ioSlotHeap)
, mParser_ValueCoil(ev, ioSlotHeap)
, mParser_ColumnCoil(ev, ioSlotHeap)
, mParser_StringCoil(ev, ioSlotHeap)
, mParser_ScopeSpool(ev, &mParser_ScopeCoil)
, mParser_ValueSpool(ev, &mParser_ValueCoil)
, mParser_ColumnSpool(ev, &mParser_ColumnCoil)
, mParser_StringSpool(ev, &mParser_StringCoil)
, mParser_MidYarn(ev, morkUsage_kMember, ioSlotHeap)
{
if ( inBytesPerParseSegment < morkParser_kMinGranularity )
inBytesPerParseSegment = morkParser_kMinGranularity;
else if ( inBytesPerParseSegment > morkParser_kMaxGranularity )
inBytesPerParseSegment = morkParser_kMaxGranularity;
mParser_MoreGranularity = inBytesPerParseSegment;
if ( ioSlotHeap && ioStream )
{
nsIMdbHeap_SlotStrongHeap(ioSlotHeap, ev, &mParser_Heap);
morkStream::SlotStrongStream(ioStream, ev, &mParser_Stream);
if ( ev->Good() )
{
mParser_Tag = morkParser_kTag;
mNode_Derived = morkDerived_kParser;
}
}
else
ev->NilPointerError();
}
