boolean NamedDrawObj_Create1
(tokentype *Anchor, numtype ClassId,
nametype Nam,
ft F,lt Z,zz *Status, tokentype *Token)
{
numtype DrawId = 0;
if (DeBug || OaBug || ClassBug)
if (sprintf (Msg,
"\n NamedDrawObj:: Create Anchor[%3u:%8u]; ClassId=%4u\n",
Anchor->DbId, Anchor->Handle, ClassId))
TraceMsg (0, Msg);
if (DrawLib01)
DrawId = ++DrawLib01->DrawId;
if (Normal(*Status))
if (Object_Create (Anchor, ClassId, McStat, Token))
if (Attr_ValuePut (Token, Id_Attr, (addrtype )&DrawId, McStat))
if (Attr_ValuePut (Token, Nam_Attr, (addrtype )Nam, McStat))
{
if (DrawObjs_AddInto (&LibTkn010, Token, McStat))
NamedDrawObjs_AddInto (&LibTkn010, Token, McStat);
}
TRACK(TrackBak,"NamedDrawObj_Create1\n");
return (STAT);
}
boolean CoreMoveBytes (addrtype Source, sizeinbytes SourceSize,
sizeinbytes TargetSize,
ft F,lt Z,zz *Status, addrtype *Target )
{
if (SourceSize == 0)
{
*Target = Source;
*Status = Err_NoBytesMoved;
}
if (Normal(*Status))
if (CoreMoreCore (TargetSize, McStat, Target))
memcpy ((char *)*Target, (char *)Source, SourceSize);
if (sprintf (Msg, TraceStr(66),
/* " CoreMoveBytes(%u) @%x to %x NewSize(%u)\n" */
SourceSize, Source, *Target, TargetSize))
SendMsg (0, Msg);
if (Normal(*Status))
CoreFreeCoreSpace (&Source, SourceSize, McStat);
TRACK(TrackBak,"CoreMoveBytes\n");
return(STAT);
}
boolean NamedDrawObj_Create0
(tokentype *Anchor,
ft F,lt Z,zz *Status, tokentype *Token)
{
numtype DrawId = 0;
static
nametype Nam = {"Create0_"};
if (DrawLib01)
DrawId = ++DrawLib01->DrawId;
Ut_IntToStr ((int )DrawId, Nam);
if (DeBug || OaBug || ClassBug)
if (sprintf (Msg, "\n NamedDrawObj:: Create [%3u:%8u] = <%s>\n",
Anchor->DbId, Anchor->Handle, Nam))
TraceMsg (0, Msg);
if (Object_Create (Anchor, NamedDrawObj_Class, McStat, Token))
if (Attr_ValuePut (Token, Id_Attr, (addrtype )&DrawId, McStat))
Attr_ValuePut (Token, Nam_Attr, (addrtype )&Nam, McStat);
if (Normal(*Status))
if (DrawObjs_AddInto (&LibTkn010, Token, McStat))
NamedDrawObjs_AddInto (&LibTkn010, Token, McStat);
TRACK(TrackBak,"NamedDrawObj_Create0\n");
return (STAT);
}
boolean FileGetSomeBytes (blkhdrtype *BlkHdr, farlongtype FileOffset,
unsigned SomeBytes,
ft F,lt Z,zz *Status, addrtype BytesAddr)
{
size_t CheckCount = 0;
int SeekStatus = 0;
SeekStatus = fseek (BlkHdr->BlkFile, FileOffset, SEEK_SET);
if (SeekStatus != 0)
{
sprintf (Msg, TraceStr(9),
/* "***FileGetSomeBytes... SeekStatus= %u\n" */
SeekStatus);
TraceMsg (0, Msg);
*Status = File_BadDiskWrite;
}
CheckCount = fread (BytesAddr, SomeBytes, (size_t )1,
BlkHdr->BlkFile);
if (CheckCount != (int )1)
{
sprintf (Msg, TraceStr(10),
/* "***FileGetSomeBytes... CheckCount= %u\n" */
CheckCount);
TraceMsg (0, Msg);
*Status = File_BadDiskWrite;
}
if (SomeBytes == 0)
*Status = Err_NoBytesMoved;
TRACK(TrackBak,"FileGetSomeBytes\n");
return(STAT);
}
void Sprite32 (short x, short y, short height, const unsigned long *sprite, void *vm_addr, short mode) {
TRACK("Sprite32");
Byte * Dest=(Byte *)vm_addr;
Byte * SpriteData=(Byte *)(void *)sprite;
int SpriteByteNum, ByteNum;
for(int sy=0; sy<height; sy++) {
for(int sx=0; sx<32; sx++) {
if(sizeof(long) == 4)
SpriteByteNum=((sy)*32)+(31-sx);
else /* 8byte long on 64-bit*/
SpriteByteNum=((sy)*64)+(31-sx);
ByteNum=((sy+y)*ScreenState.XMax)+sx+x;
if(GetBit(SpriteData[SpriteByteNum/8], SpriteByteNum%8)!=0) {
if(mode==SPRT_XOR) {
SetBit(&Dest[ByteNum/8], ByteNum%8);
}
if(mode==SPRT_OR) {
SetBit(&Dest[ByteNum/8], ByteNum%8);
}
}
else {
if(mode==SPRT_AND) {
SetBit(&Dest[ByteNum/8], ByteNum%8);
}
}
}
}
}
void Sprite16 (short x, short y, short height, const unsigned short *sprite, void *vm_addr, short mode) {
TRACK("Sprite16");
Byte * Dest=(Byte *)vm_addr;
Byte * SpriteData=(Byte *)(void *)sprite;
int SpriteByteNum, ByteNum;
for(int sy=0; sy<height; sy++) {
for(int sx=0; sx<16; sx++) {
SpriteByteNum=((sy)*16)+(15-sx);
ByteNum=((sy+y)*ScreenState.XMax)+sx+x;
if(GetBit(SpriteData[SpriteByteNum/8], SpriteByteNum%8)!=0) {
if(mode==SPRT_XOR) {
if(GetBit(Dest[ByteNum/8], ByteNum%8)!=0) {
ClearBit(&Dest[ByteNum/8], ByteNum%8);
}
else
SetBit(&Dest[ByteNum/8], ByteNum%8);
}
if(mode==SPRT_OR || mode==SPRT_COPY) {
SetBit(&Dest[ByteNum/8], ByteNum%8);
}
}
else {
if(mode==SPRT_AND) {
SetBit(&Dest[ByteNum/8], ByteNum%8);
}
else if(mode==SPRT_COPY) {
ClearBit(&Dest[ByteNum/8], ByteNum%8);
}
}
}
}
}
boolean NamedDrawObj_ExportFunc
(tokentype *Token, indextype IterNum,
ft F,lt Z,zz *Status)
{
numtype j = IterNum;
NamedDrawObj *r010 = NullPtr;
if (j == 0 || j % QueBug == 0)
{
sprintf (Msg, " Object %4d. Iterate [%3u:%8u]\n",
IterNum, Token->DbId, Token->Handle);
TraceMsg (0, Msg);
}
if (Object_IsA (Token, McStat) == NamedDrawObj_Class)
{
r010 = NamedDrawObj_new2 (Token, McStat);
if (r010)
if (DrawObj_export ((DrawObj *)r010, McStat))
DrawObj_delete ((DrawObj **)&r010, dbFree, McStat);
}
TRACK(TrackBak,"NamedDrawObj_ExportFunc\n");
return (STAT);
}
/*+-----------------------------------------------------------------------+*/
boolean MemCopyOutChunk (numtype Chunk, ft F,lt Z,zz *Status,
vbntype *SwapVbn)
{
TRACK(TrackBak,"MemCopyOutChunk\n");
return(STAT);
}
/* 14.1.1 */
boolean List01_FindListHead
(tokentype *Anchor, char *NameOfList,
ft F,lt Z,zz *Status, tokentype *ListTkn)
{
listheadtype *HeadObj = NullPtr;
tokentype ItorTkn = NullToken;
boolean FOUND = False;
*Status = Iterate_Begin;
while (!FOUND
&& Primal_IterateOnClassObjects
(Anchor, DbListHead_Class, McStat,
&ItorTkn, ListTkn))
{
if (OaGetObject (ListTkn, McStat, (addrtype *)&HeadObj))
if (!strncmp (HeadObj->ListName, NameOfList, sizeof (nametype)))
FOUND = True;
}
if (*Status == Iterate_EndOf)
*Status = Env_Normal;
if (!FOUND)
{
*ListTkn = NullToken;
*Status = List01_NotFound;
}
TRACK(TrackBak,"List01_FindListHead\n");
return(STAT);
}
/*+-----------------------------------------------------------------------+*
~DBM 1->0
*+-----------------------------------------------------------------------+*/
boolean Dbm_FreeDb (tokentype *DbToken, ft F,lt Z,zz *Status)
{
*Status = Err_NotImplemented;
TRACK(TrackBak,"DbmFreeDb\n");
return(STAT);
}
/*+-----------------------------------------------------------------------+*
~L DEBUG
*+-----------------------------------------------------------------------+*/
boolean DbmDumpVchunkVchunk
(tokentype *Token, ft F,lt Z,zz *Status)
{
vchunktkntype VchunkToken;
dbheader *CoreDb = NullPtr;
if (Token->Handle == 0)
{
TraceMsg (0, " *** NULL Handle to Virtual Chunk.\n");
*Status = Oa_VchunkNotExist;
}
if (Token->DbId > CoreDbCount)
{
*Status = Oa_VchunkNotExist;
}
if (Normal(*Status))
if (TmGetCoreDb (Token, McStat, &CoreDb))
if (DbmGetVchunkTkn (Token, McStat, &VchunkToken))
if (Normal(*Status))
if (VchunkToken.InCore)
DumpChunkChunk (0, VchunkToken.InCore);
TRACK(TrackBak,"DbmDumpVchunkVchunk\n");
return (STAT);
}
/* 12.1.4 */
boolean Grp_FreezePacket (tokentype *Anchor, numtype GrpNum,
ft F,lt Z,zz *Status)
{
/* GrpNum is the Packet Index the DbHdr->GrpHdrDir */
dbheader *CoreDb = NullPtr;
grpheader *GrpHdr = NullPtr;
vbntype Vbn = 0;
if (TmGetCoreDb (Anchor, McStat, &CoreDb))
if (MemGetAddr (CoreDb->GrpHdrDir, GrpNum, McStat,(addrtype *)&GrpHdr))
{
if (GrpHdr == NullPtr)
{
if(CoreDb->GrpHdrDirVbn)
if (MemGetVbn (CoreDb->GrpVbnDir, GrpNum,
McStat, &Vbn))
DbmLoadGrpHdr (Anchor, GrpNum, McStat, &GrpHdr);
}
if (GrpHdr)
GrpHdr->FreezePacket = True;
else
*Status = Grp_PacketNotExist;
} else {
*Status = Grp_GrpHdrNotExist;
}
TRACK(TrackBak,"GrpFreezePacket\n");
return (STAT);
}
/* 10.1.15 */
boolean Vchunk_Copy (tokentype *Vtoken0, tokentype *Vtoken1,
ft F,lt Z,zz *Status)
{
vchunktkntype Vchunk0;
vchunktkntype Vchunk1;
vchunkstruc VchunkStruc0;
vchunkstruc VchunkStruc1;
addrtype VchunkAddr0 = NullPtr;
addrtype VchunkAddr1 = NullPtr;
if (DbmInvokeVchunk (Vtoken0, McStat, &Vchunk0))
if (MemGetChunkStruc (Vchunk0.InCore, McStat, &VchunkStruc0))
if (MemGetChunkAddr (Vchunk0.InCore, McStat, &VchunkAddr0))
if (DbmInvokeVchunk (Vtoken1, McStat, &Vchunk1))
if (MemGetChunkStruc (Vchunk1.InCore, McStat, &VchunkStruc1))
if (MemGetChunkAddr (Vchunk1.InCore, McStat, &VchunkAddr1))
if (VchunkStruc0.UnitSize == VchunkStruc1.UnitSize)
{
if (MemPutStackPtr (Vchunk1.InCore, VchunkStruc1.StackPtr, McStat))
MoveBytes (VchunkAddr0, VchunkAddr1,
VchunkStruc0.UnitSize * VchunkStruc0.UnitCount);
} else
*Status = Vchunk_NotSameUnitSize;
TRACK(TrackBak,"Vchunk_Copy\n");
return (STAT);
}
boolean DbmFreeVchunk (tokentype *Vtoken, ft F,lt Z,zz *Status)
{
vchunktkntype Vchunk;
numtype IsCommitted = 0;
#ifdef __FREEZE_VCHUNKS__
dbheader *DbHdr = NullPtr;
#endif /* __FREEZE_VCHUNKS__ */
if (!Vtoken->Handle)
*Status = Oa_VchunkNotExist;
if (Normal(*Status))
if (DbmGetVchunkTkn (Vtoken, McStat, &Vchunk))
if (Normal(*Status))
if (Vchunk.InCore)
#ifdef __FREEZE_VCHUNKS__
if (TmGetCoreDb (Vtoken, McStat, &DbHdr))
if (DbHdr->VchunkCommitDir)
MemGetBit (DbHdr->VchunkCommitDir, Vtoken->Handle,
McStat, &IsCommitted);
#endif /* __FREEZE_VCHUNKS__ */
if (Normal(*Status))
if (IsCommitted == 0)
if (MemFreeChunk (&Vchunk.InCore, McStat))
DbmPutVchunkTkn (Vtoken, &Vchunk, McStat);
TRACK(TrackBak,"DbmFreeVchunk\n");
return (STAT);
}
boolean MemCopyInChunk (numtype Chunk, numtype SwapVbn,
addrtype SwapAddr, ft F,lt Z,zz *Status)
{
TRACK(TrackBak,"MemCopyInChunk\n");
return(STAT);
}
/* 12.1.8 */
boolean Grp_DeletePacket (tokentype *Anchor, numtype GrpNum,
ft F,lt Z,zz *Status)
{
/* GrpNum is the Packet Index the DbHdr->GrpHdrDir */
dbheader *CoreDb = NullPtr;
grpheader *GrpHdr = NullPtr;
numtype Vbn = 0;
if (TmGetCoreDb (Anchor, McStat, &CoreDb))
if (MemGetAddr (CoreDb->GrpHdrDir, GrpNum, McStat,(addrtype *)&GrpHdr))
{
if (GrpHdr == NullPtr)
{
if(CoreDb->GrpHdrDirVbn)
if (MemGetVbn (CoreDb->GrpHdrDirVbn, GrpNum,
McStat, &Vbn))
if (Vbn)
DbmDeleteGrpHdr (Anchor, GrpNum, McStat);
} else
DbmDeleteGrpHdr (Anchor, GrpNum, McStat);
if (Normal(*Status))
GrpFreePacket (Anchor, GrpNum, McStat);
} else {
*Status = Grp_GrpHdrNotExist;
}
TRACK(TrackBak,"GrpDeletePacket\n");
return (STAT);
}
boolean PartLib_Init (ft F,lt Z,zz *Status)
{
/* Initiaize the ClassType */
if (PartLib_Class == 0)
{
/*
ClassBug = True;
*/
if (Env_GetClassId ("PartLib", McStat, &PartLib_Class))
if (Env_GetAttrId ("PartsListHead", McStat, &PartsListHead_Attr))
if (Env_GetAttrId ("VpartsDir", McStat, &VpartsDir_Attr))
if (Env_GetAttrId ("VlinksDir", McStat, &VlinksDir_Attr))
if (Env_GetAttrId ("OwnerTosFroms", McStat, &OwnerTosFroms_Attr))
Env_GetMatrixId ("TosFroms", McStat, &TosFroms_Mtrx);
/*
ClassBug = False;
*/
if (Normal(*Status))
if (Env_InitClassMap (PartLib_Class, sizeof(PartLib),
C_Apl, McStat))
if (Normal(*Status))
Env_InvokeMap (C_Apl, McStat);
if (Normal(*Status))
if (DrawPartPair_InitClass (McStat))
Part_InitClass (McStat);
}
TRACK(TrackBak,"PartLib_Init\n");
return (STAT);
}
static void
track_oper(struct userNode *user, UNUSED_ARG(void *extra)) {
if (!track_cfg.enabled) return;
if (user->uplink->burst && !track_cfg.show_bursts) return;
UPDATE_TIMESTAMP();
TRACK("$bOPER$b %s!%s@%s [%s] on %s", user->nick, user->ident, user->hostname, irc_ntoa(&user->ip), user->uplink->name);
}
/* 10.1.17 */
boolean Vchunk_Free (tokentype *Vtoken, ft F,lt Z,zz *Status)
{
DbmFreeVchunk (Vtoken, McStat);
TRACK(TrackBak,"Vchunk_Free\n");
return (STAT);
}
boolean MemFreeXmemBlk (ft F,lt Z,zz *Status, vbntype *Vbn)
{
*Status = Err_NotImplemented;
TRACK(TrackBak,"MemFreeXmemBlk\n");
return(STAT);
}
/*
call-seq: enabled?() -> bool
Returns true/false depending on if the track is enabled.
*/
static VALUE track_enabled(VALUE obj, VALUE boolean)
{
if (GetTrackEnabled(TRACK(obj)) == TRUE) {
return Qtrue;
} else {
return Qfalse;
}
}
static int
track_join(struct modeNode *mNode, UNUSED_ARG(void *extra)) {
struct userNode *user = mNode->user;
struct chanNode *chan = mNode->channel;
if (!track_cfg.enabled) return 0;
if (user->uplink->burst && !track_cfg.show_bursts) return 0;
if (check_track_join(track_cfg) && check_track_user(user->nick))
{
UPDATE_TIMESTAMP();
if (chan->members.used == 1) {
TRACK("$bCREATE$b %s by %s", chan->name, user->nick);
} else {
TRACK("$bJOIN$b %s by %s", chan->name, user->nick);
}
}
return 0;
}
boolean MemGetFileBlk (bytessize SizeInBytes, blkhdrtype *BlkHdr,
ft F,lt Z,zz *Status,
vbntype *Vbn, lt64 *FileOffset)
{
indextype BlkIndex = 0;
blktkntype BlkTkn;
lt64 TmpXmemSize = XmemSize;
*FileOffset = 0;
XmemFilePtr = BlkHdr->BlkFile;
XmemSize = BlkHdr->EofMark;
XmemHeadFreeVbns = BlkHdr->HeadFreeVbns;
XmemBlkDirChunk = BlkHdr->BlkDirChunk;
XmemHeadFreeBlks = BlkHdr->HeadFreeBlks;
XmemHeadNullBlks = BlkHdr->HeadNullBlks;
XmemBlkTknChunk = BlkHdr->BlkTknChunk;
XmemBlkSizeChunk = BlkHdr->BlkSizeChunk;
if (MemGetChunkAddr (BlkHdr->BlkDirChunk,
McStat, (addrtype *)&XmemBlkDir))
if (MemGetChunkAddr (BlkHdr->BlkTknChunk,
McStat, (addrtype *)&XmemBlkTkn))
if (MemGetChunkAddr (BlkHdr->BlkSizeChunk,
McStat, (addrtype *)&XmemBlkSize))
if (*Vbn)
{
if (MemGetIndex (XmemBlkDirChunk, *Vbn, McStat, &BlkIndex))
if (MemGetSomeBytes (XmemBlkTknChunk, BlkIndex, sizeof (blktkntype),
McStat, (addrtype )&BlkTkn))
*FileOffset = BlkTkn.Offset;
} else {
MemNewXmemBlk (SizeInBytes, McStat, Vbn, FileOffset);
}
BlkHdr->HeadFreeVbns = XmemHeadFreeVbns;
BlkHdr->HeadFreeBlks = XmemHeadFreeBlks;
BlkHdr->HeadNullBlks = XmemHeadNullBlks;
BlkHdr->EofMark = XmemSize;
XmemSize = TmpXmemSize;
XmemFilePtr = MemBlkFile;
XmemHeadFreeVbns = MemHeadFreeVbns;
XmemBlkDirChunk = MemBlkDirChunk;
XmemHeadFreeBlks = MemHeadFreeBlks;
XmemHeadNullBlks = MemHeadNullBlks;
XmemBlkTknChunk = MemBlkTknChunk;
XmemBlkSizeChunk = MemBlkSizeChunk;
XmemBlkDir = MemBlkDir;
XmemBlkTkn = MemBlkTkn;
XmemBlkSize = MemBlkSize;
TRACK(TrackBak,"MemGetFileBlk\n");
return(STAT);
}
/* 10.1.18 */
boolean Vchunk_Commit (tokentype *Vtoken, boolean Release,
ft F,lt Z,zz *Status)
{
DbmCommitVchunk (Vtoken, Release, McStat);
TRACK(TrackBak,"Vchunk_Commit\n");
return (STAT);
}
boolean NamedDrawObjs_AddInto
(tokentype *OwnerTkn, tokentype *MemberTkn,
ft F,lt Z,zz *Status)
{
SetAddInto (NamedDrawObjs_Set, OwnerTkn, MemberTkn, McStat);
TRACK(TrackBak,"NamedDrawObjs_AddInto\n");
return (STAT);
}
boolean Mem_DumpChunkPart
(int MsgLevel, numtype Chunk,
numtype Ilow, numtype Ihigh,
ft F,lt Z,zz *Status)
{
TRACK(TrackBak,"MemDumpChunkPart\n");
return(STAT);
}
boolean MemFreeFileBlk (blkhdrtype *BlkHdr,
ft F,lt Z,zz *Status, vbntype *Vbn)
{
*Status = Err_NotImplemented;
TRACK(TrackBak,"MemFreeFileBlk\n");
return(STAT);
}
/*+-----------------------------------------------------------------------+*/
boolean MemNewXmemBlk (bytessize SizeInBytes, ft F,lt Z,zz *Status,
vbntype *Vbn, lt64 *XmemOffset)
{
*Status = Err_NotImplemented;
TRACK(TrackBak,"MemNewXmemBlk\n");
return(STAT);
}
/* 12.1.11 */
boolean Grp_DumpEntrys (tokentype *Token, numtype GrpNum,
indextype Low, indextype High,
indextype Limit, dumpentryptr DumpEntryPtr,
ft F,lt Z,zz *Status)
{
TRACK(TrackBak,"Grp_DumpEntrys\n");
return (STAT);
}
boolean NamedDrawObj_delete
(NamedDrawObj **This, deletetype DbEvent,
ft F,lt Z,zz *Status)
{
DrawObj_delete ((DrawObj **)This, DbEvent, McStat);
TRACK(TrackBak,"NamedDrawObj_delete\n");
return (STAT);
}
