Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#ifndef _MDB_
# include "mdb.h"
#endif
#ifndef _MORK_
# include "mork.h"
#endif
#ifndef _MORKBLOB_
# include "morkBlob.h"
#endif
#ifndef _MORKATOM_
# include "morkAtom.h"
#endif
#ifndef _MORKENV_
# include "morkEnv.h"
#endif
#ifndef _MORKATOMSPACE_
# include "morkAtomSpace.h"
#endif
// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
/* static */
mork_bool morkAtom::GetYarn(const morkAtom* atom, mdbYarn* outYarn) {
const void* source = 0;
mdb_fill fill = 0;
mdb_cscode form = 0;
outYarn->mYarn_More = 0;
if (atom) {
if (atom->IsWeeBook()) {
morkWeeBookAtom* weeBook = (morkWeeBookAtom*)atom;
source = weeBook->mWeeBookAtom_Body;
fill = weeBook->mAtom_Size;
} else if (atom->IsBigBook()) {
morkBigBookAtom* bigBook = (morkBigBookAtom*)atom;
source = bigBook->mBigBookAtom_Body;
fill = bigBook->mBigBookAtom_Size;
form = bigBook->mBigBookAtom_Form;
} else if (atom->IsWeeAnon()) {
morkWeeAnonAtom* weeAnon = (morkWeeAnonAtom*)atom;
source = weeAnon->mWeeAnonAtom_Body;
fill = weeAnon->mAtom_Size;
} else if (atom->IsBigAnon()) {
morkBigAnonAtom* bigAnon = (morkBigAnonAtom*)atom;
source = bigAnon->mBigAnonAtom_Body;
fill = bigAnon->mBigAnonAtom_Size;
form = bigAnon->mBigAnonAtom_Form;
}
}
if (source && fill) // have an atom with nonempty content?
{
// if we have too many bytes, and yarn seems growable:
if (fill > outYarn->mYarn_Size && outYarn->mYarn_Grow) // try grow?
(*outYarn->mYarn_Grow)(outYarn, (mdb_size)fill); // request bigger
mdb_size size = outYarn->mYarn_Size; // max dest size
if (fill > size) // too much atom content?
{
outYarn->mYarn_More = fill - size; // extra atom bytes omitted
fill = size; // copy no more bytes than size of yarn buffer
}
void* dest = outYarn->mYarn_Buf; // where bytes are going
if (!dest) // nil destination address buffer?
fill = 0; // we can't write any content at all
if (fill) // anything to copy?
MORK_MEMCPY(dest, source, fill); // copy fill bytes to yarn
outYarn->mYarn_Fill = fill; // tell yarn size of copied content
} else // no content to put into the yarn
{
outYarn->mYarn_Fill = 0; // tell yarn that atom has no bytes
}
outYarn->mYarn_Form = form; // always update the form slot
return (source != 0);
}
/* static */
mork_bool morkAtom::AliasYarn(const morkAtom* atom, mdbYarn* outYarn) {
outYarn->mYarn_More = 0;
outYarn->mYarn_Form = 0;
if (atom) {
if (atom->IsWeeBook()) {
morkWeeBookAtom* weeBook = (morkWeeBookAtom*)atom;
outYarn->mYarn_Buf = weeBook->mWeeBookAtom_Body;
outYarn->mYarn_Fill = weeBook->mAtom_Size;
outYarn->mYarn_Size = weeBook->mAtom_Size;
} else if (atom->IsBigBook()) {
morkBigBookAtom* bigBook = (morkBigBookAtom*)atom;
outYarn->mYarn_Buf = bigBook->mBigBookAtom_Body;
outYarn->mYarn_Fill = bigBook->mBigBookAtom_Size;
outYarn->mYarn_Size = bigBook->mBigBookAtom_Size;
outYarn->mYarn_Form = bigBook->mBigBookAtom_Form;
} else if (atom->IsWeeAnon()) {
morkWeeAnonAtom* weeAnon = (morkWeeAnonAtom*)atom;
outYarn->mYarn_Buf = weeAnon->mWeeAnonAtom_Body;
outYarn->mYarn_Fill = weeAnon->mAtom_Size;
outYarn->mYarn_Size = weeAnon->mAtom_Size;
} else if (atom->IsBigAnon()) {
morkBigAnonAtom* bigAnon = (morkBigAnonAtom*)atom;
outYarn->mYarn_Buf = bigAnon->mBigAnonAtom_Body;
outYarn->mYarn_Fill = bigAnon->mBigAnonAtom_Size;
outYarn->mYarn_Size = bigAnon->mBigAnonAtom_Size;
outYarn->mYarn_Form = bigAnon->mBigAnonAtom_Form;
} else
atom = 0; // show desire to put empty content in yarn
}
if (!atom) // empty content for yarn?
{
outYarn->mYarn_Buf = 0;
outYarn->mYarn_Fill = 0;
outYarn->mYarn_Size = 0;
// outYarn->mYarn_Grow = 0; // please don't modify the Grow slot
}
return (atom != 0);
}
mork_aid morkAtom::GetBookAtomAid() const // zero or book atom's ID
{
return (this->IsBook()) ? ((morkBookAtom*)this)->mBookAtom_Id : 0;
}
mork_scope morkAtom::GetBookAtomSpaceScope(
morkEnv* ev) const // zero or book's space's scope
{
mork_scope outScope = 0;
if (this->IsBook()) {
const morkBookAtom* bookAtom = (const morkBookAtom*)this;
morkAtomSpace* space = bookAtom->mBookAtom_Space;
if (space->IsAtomSpace())
outScope = space->SpaceScope();
else
space->NonAtomSpaceTypeError(ev);
}
return outScope;
}
void morkAtom::MakeCellUseForever(morkEnv* ev) {
MORK_USED_1(ev);
mAtom_CellUses = morkAtom_kForeverCellUses;
}
mork_u1 morkAtom::AddCellUse(morkEnv* ev) {
MORK_USED_1(ev);
if (mAtom_CellUses < morkAtom_kMaxCellUses) // not already maxed out?
++mAtom_CellUses;
return mAtom_CellUses;
}
mork_u1 morkAtom::CutCellUse(morkEnv* ev) {
if (mAtom_CellUses) // any outstanding uses to cut?
{
if (mAtom_CellUses < morkAtom_kMaxCellUses) // not frozen at max?
--mAtom_CellUses;
} else
this->CellUsesUnderflowWarning(ev);
return mAtom_CellUses;
}
/*static*/ void morkAtom::CellUsesUnderflowWarning(morkEnv* ev) {
ev->NewWarning("mAtom_CellUses underflow");
}
/*static*/ void morkAtom::BadAtomKindError(morkEnv* ev) {
ev->NewError("bad mAtom_Kind");
}
/*static*/ void morkAtom::ZeroAidError(morkEnv* ev) {
ev->NewError("zero atom ID");
}
/*static*/ void morkAtom::AtomSizeOverflowError(morkEnv* ev) {
ev->NewError("atom mAtom_Size overflow");
}
void morkOidAtom::InitRowOidAtom(morkEnv* ev, const mdbOid& inOid) {
MORK_USED_1(ev);
mAtom_CellUses = 0;
mAtom_Kind = morkAtom_kKindRowOid;
mAtom_Change = morkChange_kNil;
mAtom_Size = 0;
mOidAtom_Oid = inOid; // bitwise copy
}
void morkOidAtom::InitTableOidAtom(morkEnv* ev, const mdbOid& inOid) {
MORK_USED_1(ev);
mAtom_CellUses = 0;
mAtom_Kind = morkAtom_kKindTableOid;
mAtom_Change = morkChange_kNil;
mAtom_Size = 0;
mOidAtom_Oid = inOid; // bitwise copy
}
void morkWeeAnonAtom::InitWeeAnonAtom(morkEnv* ev, const morkBuf& inBuf) {
mAtom_Kind = 0;
mAtom_Change = morkChange_kNil;
if (inBuf.mBuf_Fill <= morkAtom_kMaxByteSize) {
mAtom_CellUses = 0;
mAtom_Kind = morkAtom_kKindWeeAnon;
mork_size size = inBuf.mBuf_Fill;
mAtom_Size = (mork_u1)size;
if (size && inBuf.mBuf_Body)
MORK_MEMCPY(mWeeAnonAtom_Body, inBuf.mBuf_Body, size);
mWeeAnonAtom_Body[size] = 0;
} else
this->AtomSizeOverflowError(ev);
}
void morkBigAnonAtom::InitBigAnonAtom(morkEnv* ev, const morkBuf& inBuf,
mork_cscode inForm) {
MORK_USED_1(ev);
mAtom_CellUses = 0;
mAtom_Kind = morkAtom_kKindBigAnon;
mAtom_Change = morkChange_kNil;
mAtom_Size = 0;
mBigAnonAtom_Form = inForm;
mork_size size = inBuf.mBuf_Fill;
mBigAnonAtom_Size = size;
if (size && inBuf.mBuf_Body)
MORK_MEMCPY(mBigAnonAtom_Body, inBuf.mBuf_Body, size);
mBigAnonAtom_Body[size] = 0;
}
/*static*/ void morkBookAtom::NonBookAtomTypeError(morkEnv* ev) {
ev->NewError("non morkBookAtom");
}
mork_u4 morkBookAtom::HashFormAndBody(morkEnv* ev) const {
// This hash is obviously a variation of the dragon book string hash.
// (I won't bother to explain or rationalize this usage for you.)
mork_u4 outHash = 0; // hash value returned
unsigned char c; // next character
const mork_u1* body; // body of bytes to hash
mork_size size = 0; // the number of bytes to hash
if (this->IsWeeBook()) {
size = mAtom_Size;
body = ((const morkWeeBookAtom*)this)->mWeeBookAtom_Body;
} else if (this->IsBigBook()) {
size = ((const morkBigBookAtom*)this)->mBigBookAtom_Size;
body = ((const morkBigBookAtom*)this)->mBigBookAtom_Body;
} else if (this->IsFarBook()) {
size = ((const morkFarBookAtom*)this)->mFarBookAtom_Size;
body = ((const morkFarBookAtom*)this)->mFarBookAtom_Body;
} else {
this->NonBookAtomTypeError(ev);
return 0;
}
const mork_u1* end = body + size;
while (body < end) {
c = *body++;
outHash <<= 4;
outHash += c;
mork_u4 top = outHash & 0xF0000000L; // top four bits
if (top) // any of high four bits equal to one?
{
outHash ^= (top >> 24); // fold down high bits
outHash ^= top; // zero top four bits
}
}
return outHash;
}
mork_bool morkBookAtom::EqualFormAndBody(morkEnv* ev,
const morkBookAtom* inAtom) const {
mork_bool outEqual = morkBool_kFalse;
const mork_u1* body = 0; // body of inAtom bytes to compare
mork_size size; // the number of inAtom bytes to compare
mork_cscode form; // nominal charset for ioAtom
if (inAtom->IsWeeBook()) {
size = inAtom->mAtom_Size;
body = ((const morkWeeBookAtom*)inAtom)->mWeeBookAtom_Body;
form = 0;
} else if (inAtom->IsBigBook()) {
size = ((const morkBigBookAtom*)inAtom)->mBigBookAtom_Size;
body = ((const morkBigBookAtom*)inAtom)->mBigBookAtom_Body;
form = ((const morkBigBookAtom*)inAtom)->mBigBookAtom_Form;
} else if (inAtom->IsFarBook()) {
size = ((const morkFarBookAtom*)inAtom)->mFarBookAtom_Size;
body = ((const morkFarBookAtom*)inAtom)->mFarBookAtom_Body;
form = ((const morkFarBookAtom*)inAtom)->mFarBookAtom_Form;
} else {
inAtom->NonBookAtomTypeError(ev);
return morkBool_kFalse;
}
const mork_u1* thisBody = 0; // body of bytes in this to compare
mork_size thisSize; // the number of bytes in this to compare
mork_cscode thisForm; // nominal charset for this atom
if (this->IsWeeBook()) {
thisSize = mAtom_Size;
thisBody = ((const morkWeeBookAtom*)this)->mWeeBookAtom_Body;
thisForm = 0;
} else if (this->IsBigBook()) {
thisSize = ((const morkBigBookAtom*)this)->mBigBookAtom_Size;
thisBody = ((const morkBigBookAtom*)this)->mBigBookAtom_Body;
thisForm = ((const morkBigBookAtom*)this)->mBigBookAtom_Form;
} else if (this->IsFarBook()) {
thisSize = ((const morkFarBookAtom*)this)->mFarBookAtom_Size;
thisBody = ((const morkFarBookAtom*)this)->mFarBookAtom_Body;
thisForm = ((const morkFarBookAtom*)this)->mFarBookAtom_Form;
} else {
this->NonBookAtomTypeError(ev);
return morkBool_kFalse;
}
// if atoms are empty, form is irrelevant
if (body && thisBody && size == thisSize && (!size || form == thisForm))
outEqual = (MORK_MEMCMP(body, thisBody, size) == 0);
return outEqual;
}
void morkBookAtom::CutBookAtomFromSpace(morkEnv* ev) {
morkAtomSpace* space = mBookAtom_Space;
if (space) {
mBookAtom_Space = 0;
space->mAtomSpace_AtomBodies.CutAtom(ev, this);
space->mAtomSpace_AtomAids.CutAtom(ev, this);
} else
ev->NilPointerError();
}
morkWeeBookAtom::morkWeeBookAtom(mork_aid inAid) {
mAtom_Kind = morkAtom_kKindWeeBook;
mAtom_CellUses = 0;
mAtom_Change = morkChange_kNil;
mAtom_Size = 0;
mBookAtom_Space = 0;
mBookAtom_Id = inAid;
mWeeBookAtom_Body[0] = 0;
}
void morkWeeBookAtom::InitWeeBookAtom(morkEnv* ev, const morkBuf& inBuf,
morkAtomSpace* ioSpace, mork_aid inAid) {
mAtom_Kind = 0;
mAtom_Change = morkChange_kNil;
if (ioSpace) {
if (inAid) {
if (inBuf.mBuf_Fill <= morkAtom_kMaxByteSize) {
mAtom_CellUses = 0;
mAtom_Kind = morkAtom_kKindWeeBook;
mBookAtom_Space = ioSpace;
mBookAtom_Id = inAid;
mork_size size = inBuf.mBuf_Fill;
mAtom_Size = (mork_u1)size;
if (size && inBuf.mBuf_Body)
MORK_MEMCPY(mWeeBookAtom_Body, inBuf.mBuf_Body, size);
mWeeBookAtom_Body[size] = 0;
} else
this->AtomSizeOverflowError(ev);
} else
this->ZeroAidError(ev);
} else
ev->NilPointerError();
}
void morkBigBookAtom::InitBigBookAtom(morkEnv* ev, const morkBuf& inBuf,
mork_cscode inForm,
morkAtomSpace* ioSpace, mork_aid inAid) {
mAtom_Kind = 0;
mAtom_Change = morkChange_kNil;
if (ioSpace) {
if (inAid) {
mAtom_CellUses = 0;
mAtom_Kind = morkAtom_kKindBigBook;
mAtom_Size = 0;
mBookAtom_Space = ioSpace;
mBookAtom_Id = inAid;
mBigBookAtom_Form = inForm;
mork_size size = inBuf.mBuf_Fill;
mBigBookAtom_Size = size;
if (size && inBuf.mBuf_Body)
MORK_MEMCPY(mBigBookAtom_Body, inBuf.mBuf_Body, size);
mBigBookAtom_Body[size] = 0;
} else
this->ZeroAidError(ev);
} else
ev->NilPointerError();
}
void morkFarBookAtom::InitFarBookAtom(morkEnv* ev, const morkBuf& inBuf,
mork_cscode inForm,
morkAtomSpace* ioSpace, mork_aid inAid) {
mAtom_Kind = 0;
mAtom_Change = morkChange_kNil;
if (ioSpace) {
if (inAid) {
mAtom_CellUses = 0;
mAtom_Kind = morkAtom_kKindFarBook;
mAtom_Size = 0;
mBookAtom_Space = ioSpace;
mBookAtom_Id = inAid;
mFarBookAtom_Form = inForm;
mFarBookAtom_Size = inBuf.mBuf_Fill;
mFarBookAtom_Body = (mork_u1*)inBuf.mBuf_Body;
} else
this->ZeroAidError(ev);
} else
ev->NilPointerError();
}
// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789