Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-06 00:55:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
b5974e51e9
gecko-dev/lib/libaddr/abenv.cpp
spider 1b162ad28f Adding libaddr as part of Normandy merge
1998-06-22 21:46:46 +00:00

1095 lines
27 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
/* file: abenv.cpp
** Most portions derive from public domain IronDoc code and interfaces.
**
** Changes:
** <1> 05Feb1998 first implementation
** <0> 23Dec1997 first interface draft
*/
#ifndef _ABTABLE_
#include "abtable.h"
#endif
#ifndef _ABMODEL_
#include "abmodel.h"
#endif
#include "xp_mem.h"
/*3456789_123456789_123456789_123456789_123456789_123456789_123456789_12345678*/
/* ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- */
#if AB_CONFIG_TRACE_orDEBUG_orPRINT
static const char* ab_Env_kClassName /*i*/ = "ab_Env";
#endif /* end AB_CONFIG_TRACE_orDEBUG_orPRINT*/
#if AB_CONFIG_TRACE_orDEBUG_orPRINT
static const char* AB_Env_kClassName /*i*/ = "AB_Env";
#endif /* end AB_CONFIG_TRACE_orDEBUG_orPRINT*/
// ````` ````` ````` ````` ````` ````` ````` `````
// virtual ab_Object methods
char* ab_Env::ObjectAsString(ab_Env* ev, char* outXmlBuf) const /*i*/
{
AB_USED_PARAMS_1(ev);
#if AB_CONFIG_TRACE_orDEBUG_orPRINT
// copied from public domain IronDoc:
char debugFlags[ 5 ];
char printFlags[ 5 ];
debugFlags[ 0 ] = (mEnv_Self.sEnv_DoTrace)? 'T' : 't';
debugFlags[ 1 ] = (mEnv_Self.sEnv_DoDebug)? 'D' : 'd';
debugFlags[ 2 ] = (mEnv_Self.sEnv_DoErrBreak)? 'E' : 'e';
debugFlags[ 3 ] = (mEnv_Self.sEnv_BeParanoid)? 'P' : 'p';
debugFlags[ 4 ] = '\0';
printFlags[ 0 ] = (mEnv_BeShallow)? 'S' : 's';
printFlags[ 1 ] = (mEnv_BeComplete)? 'C' : 'c';
printFlags[ 2 ] = (mEnv_BeConcise)? 'I' : 'i';
printFlags[ 3 ] = (mEnv_BeVerbose)? 'V' : 'v';
printFlags[ 4 ] = '\0';
XP_SPRINTF(outXmlBuf,
"<ab_Env:str me=\"^%lX\" d:t=\"^%lX:^%lX\" d:p=\"%.4s:%.4s\" fc=\"%lu\" sr=\"^%lX\" md=\"%lu\" rc=\"%lu\" a=\"%.9s\" u=\"%.9s\"/>",
(long) this, // me=\"^%lX\"
(long) mEnv_Debugger, // d:t=\"^%lX:
(long) mEnv_Tracer, // :^%lX\"
debugFlags, // d:p=\"%.4s
printFlags, // :%.4s\"
(long) mEnv_Self.sEnv_FaultCount, // fc=\"%lu\"
(long) mEnv_StackRef, // sr=\"^%lX\"
(long) mEnv_MaxRefDelta, // md=\"%lu\"
(unsigned long) mObject_RefCount, // rc=\"%lu\"
this->GetObjectAccessAsString(), // ac=\"%.9s\"
this->GetObjectUsageAsString() // us=\"%.9s\"
);
#else
*outXmlBuf = 0; /* empty string */
#endif /*AB_CONFIG_TRACE_orDEBUG_orPRINT*/
return outXmlBuf;
}
void ab_Env::CloseObject(ab_Env* ev) /*i*/
{
if ( this->IsOpenObject() )
{
this->MarkClosing();
this->CloseEnv(ev);
this->MarkShut();
}
}
void ab_Env::PrintObject(ab_Env* ev, ab_Printer* ioPrinter) const /*i*/
{
#ifdef AB_CONFIG_PRINT
ioPrinter->PutString(ev, "<ab_Env>");
char xmlBuf[ ab_Object_kXmlBufSize + 2 ];
if ( this->IsOpenObject() )
{
ioPrinter->PushDepth(ev); // indent all objects in the list
ioPrinter->NewlineIndent(ev, /*count*/ 1);
ioPrinter->PutString(ev, this->ObjectAsString(ev, xmlBuf));
if ( mEnv_Debugger )
{
ioPrinter->NewlineIndent(ev, /*count*/ 1);
mEnv_Debugger->PrintObject(ev, ioPrinter);
}
if ( mEnv_Tracer )
{
ioPrinter->NewlineIndent(ev, /*count*/ 1);
mEnv_Tracer->PrintObject(ev, ioPrinter);
}
ab_num stackTop = mEnv_StackTop;
if ( stackTop )
{
ioPrinter->Print(ev, "<ab_Env:faults top=\"%lu\">",
(long) stackTop);
ioPrinter->PushDepth(ev); // indent all objects in the list
if ( stackTop > ab_Env_kFaultMaxStackTop )
{
#ifdef AB_CONFIG_DEBUG
this->BreakObject(ev);
#endif /*AB_CONFIG_DEBUG*/
stackTop = ab_Env_kFaultMaxStackTop;
}
const AB_Fault* bottom = mEnv_FaultStack;
const AB_Fault* top = mEnv_FaultStack + stackTop;
while ( --top >= bottom )
{
ioPrinter->NewlineIndent(ev, /*count*/ 1);
ioPrinter->PutString(ev,
AB_Fault_AsXmlString(top, ev->AsSelf(), xmlBuf));
}
ioPrinter->PopDepth(ev); // stop indentation
ioPrinter->NewlineIndent(ev, /*count*/ 1);
ioPrinter->PutString(ev, "</ab_Env:faults>");
}
ioPrinter->PopDepth(ev); // stop indentation
}
else // use ab_Object::ObjectAsString() for non-objects:
{
ioPrinter->PutString(ev, this->ab_Object::ObjectAsString(ev, xmlBuf));
}
ioPrinter->NewlineIndent(ev, /*count*/ 1);
ioPrinter->PutString(ev, "</ab_Env>");
#endif /*AB_CONFIG_PRINT*/
}
ab_Env::~ab_Env()
{
AB_ASSERT(mEnv_Debugger==0);
AB_ASSERT(mEnv_Tracer==0);
#if AB_CONFIG_TRACE_orDEBUG_orPRINT
ab_Object* obj = mEnv_Debugger;
if ( obj )
obj->ObjectNotReleasedPanic(ab_Env_kClassName);
obj = mEnv_Tracer;
if ( obj )
obj->ObjectNotReleasedPanic(ab_Env_kClassName);
#endif /*AB_CONFIG_TRACE_orDEBUG_orPRINT*/
}
// ````` ````` ````` ````` ````` ````` ````` `````
// virtual ab_Env methods
ab_error_count ab_Env::CutAllFaults() /*i*/
{
ab_error_count outCount = 0;
ab_Env* ev = this;
ab_Env_BeginMethod(ev, ab_Env_kClassName, "CutAllFaults")
mEnv_Self.sEnv_FaultCount = 0;
mEnv_StackTop = 0;
ab_num stackSize = ab_Env_kFaultStackSlots * sizeof(AB_Fault);
AB_MEMSET(mEnv_FaultStack, 0, stackSize);
ab_Env_EndMethod(ev)
return outCount;
}
ab_error_count ab_Env::GetAllFaults(AB_Fault* outVector, /*i*/
ab_error_count inSize, ab_error_count* outLength) const
{
ab_error_count outCount = 0;
const ab_Env* ev = this;
ab_Env_BeginMethod(ev, ab_Env_kClassName, "GetAllFaults")
outCount = mEnv_StackTop + 1;
if ( outCount > ab_Env_kFaultStackSlots )
outCount = ab_Env_kFaultStackSlots;
if ( inSize && outVector ) // any space to receive output?
{
if ( inSize > outCount ) // more than enough space?
inSize = outCount; // copy no more than have on hand
ab_num copySize = inSize * sizeof(AB_Fault);
AB_MEMCPY(outVector, mEnv_FaultStack, copySize);
if ( outLength ) // caller wants actual number copied?
*outLength = inSize;
}
ab_Env_EndMethod(ev)
return outCount;
}
#define abEnv_kStackDepthSlop 1024
ab_bool ab_Env::is_stack_depth_okay() const /*i*/
{
// copied from public domain IronDoc:
ab_bool outDepthOkay = AB_kTrue; /* default in case check is disabled */
if ( this->IsOpenObject() )
{
ab_num maxDelta = mEnv_MaxRefDelta;
if ( maxDelta && mEnv_StackRef ) /* stack checking enabled? */
{
long delta = ((ab_u1*) mEnv_StackRef) - ((ab_u1*) &maxDelta);
if ( delta < 0 ) /* need to convert to absolute value? */
delta = -delta;
// add slop so to be more forgiving than abEnv::DefaultCheckStack(),
// so it is possible to notify of errors on soft stack overflow.
outDepthOkay = ( delta <= (maxDelta + abEnv_kStackDepthSlop) );
}
}
else
{
outDepthOkay = AB_kFalse; /* for a bad env, the stack is too deep */
this->ObjectPanic("is_stack_depth_okay env not open");
}
return outDepthOkay;
}
void ab_Env::error_notify(const AB_Fault* inFault) /*i*/
{
ab_Env* ev = this;
// copied from public domain IronDoc:
if ( this->IsOpenObject() )
{
if ( this->is_stack_depth_okay() )
{
ab_Env_BeginMethod(ev, ab_Env_kClassName, "error_notify")
char buf[ AB_Fault_kXmlBufSize + 2 ];
AB_Fault_AsXmlString(inFault, ev->AsSelf(), buf);
#ifdef AB_CONFIG_DEBUG
if ( mEnv_Debugger && ev->DoErrorBreak() )
mEnv_Debugger->BreakString(ev, buf);
#endif /*AB_CONFIG_DEBUG*/
#ifdef AB_CONFIG_TRACE
if ( mEnv_Tracer && ev->DoTrace() )
mEnv_Tracer->TraceString(ev, buf);
#endif /*AB_CONFIG_TRACE*/
ab_Env_EndMethod(ev)
}
}
else
{
#if AB_CONFIG_TRACE_orDEBUG_orPRINT
AB_Env* cev = this->AsSelf();
char buf[ AB_Fault_kXmlBufSize + 2 ];
this->ObjectPanic(AB_Fault_AsXmlString(inFault, cev, buf));
#endif /* end AB_CONFIG_TRACE_orDEBUG_orPRINT*/
}
}
void ab_Env::push_error(ab_error_uid inCode, ab_u4 inSpace) /*i*/
{
if ( this->IsOpenObject() )
{
// note: first fault is written on stack top without bumping pointer
ab_num top = mEnv_StackTop;
if ( mEnv_Self.sEnv_FaultCount ) // not the first recorded error?
++top;
++mEnv_Self.sEnv_FaultCount; // another error has occurred
if ( top < ab_Env_kFaultMaxStackTop ) // room for another error?
{
mEnv_StackTop = top;
AB_Fault* fault = mEnv_FaultStack + top;
AB_Fault_Init(fault, inCode, inSpace);
}
else
{
#ifdef AB_CONFIG_DEBUG
ab_Env* ev = this;
ab_Env_BeginMethod(ev, ab_Env_kClassName, "push_error")
ev->BreakString("dropping one error too many");
ab_Env_EndMethod(ev)
#endif /*AB_CONFIG_DEBUG*/
}
}
else this->ObjectPanic("ev not open");
}
ab_error_uid ab_Env::NewFault(ab_error_uid inCode, ab_u4 inSpace) /*i*/
{
AB_Fault fault;
AB_Fault_Init(&fault, inCode, inSpace);
this->error_notify(&fault);
this->push_error(inCode, inSpace); // untouched by ErrorNotify()
return inCode;
}
void ab_Env::BreakString(const char* inMessage) /*i*/
{
#ifdef AB_CONFIG_DEBUG
if ( this->IsOpenObject() )
{
ab_Env* ev = this;
if ( mEnv_Debugger )
mEnv_Debugger->BreakString(ev, inMessage);
}
#endif /*AB_CONFIG_DEBUG*/
}
void ab_Env::TraceString(const char* inMessage) /*i*/
{
#ifdef AB_CONFIG_TRACE
if ( this->IsOpenObject() )
{
ab_Env* ev = this;
ab_Tracer* tracer = mEnv_Tracer;
if ( mEnv_Tracer && ev->DoTrace() )
mEnv_Tracer->TraceString(ev, inMessage);
}
#endif /*AB_CONFIG_TRACE*/
}
// ````` ````` ````` ````` ````` ````` ````` `````
// public non-poly ab_Env methods
// ````` construction `````
ab_Env::ab_Env(const ab_Usage& inUsage) /*i*/
: ab_Object(inUsage),
mEnv_Debugger( 0 ),
mEnv_Tracer( 0 )
{
AB_MEMSET(&mEnv_Self, 0, sizeof(AB_Env));
}
ab_Env::ab_Env(const ab_Usage& inUsage, const ab_Env& other) /*i*/
: ab_Object(inUsage),
mEnv_Debugger( 0 ),
mEnv_Tracer( 0 )
{
ab_Env* ev = this;
// copy the flags from other's C struct AB_Env...
AB_MEMCPY(&mEnv_Self, &other.mEnv_Self, sizeof(AB_Env));
mEnv_Self.sEnv_FaultCount = 0; // ...but keep error count equal to zero
ab_Tracer* tracer = other.mEnv_Tracer;
if ( tracer && tracer->AcquireObject(ev) )
mEnv_Tracer = tracer;
ab_Debugger* debugger = other.mEnv_Debugger;
if ( ev->Good() && debugger && debugger->AcquireObject(ev) )
mEnv_Debugger = debugger;
}
ab_Env::ab_Env(const ab_Usage& inUsage, ab_Debugger* ioDebugger, /*i*/
ab_Tracer* ioTracer)
: ab_Object(inUsage),
mEnv_Debugger( 0 ),
mEnv_Tracer( 0 )
{
ab_Env* ev = this;
AB_MEMSET(&mEnv_Self, 0, sizeof(AB_Env)); // zero embedded C struct
if ( ioTracer && ioTracer->AcquireObject(ev) )
mEnv_Tracer = ioTracer;
if ( ev->Good() && ioDebugger && ioDebugger->AcquireObject(ev) )
mEnv_Debugger = ioDebugger;
}
// ````` standard logging env `````
static ab_Env* ab_Env_g_simple_env = 0; // for ab_Env::GetSimpleEnv() use
/*static*/
ab_Env* ab_Env::GetSimpleEnv() /*i*/
// This env just has a debugger instance installed. It is used
// when instantiating the standard session log file objects. This
// env is installed as the top panic env when first instantiated.
// (Please, never close this env instance.)
{
ab_Env* outEnv = ab_Env_g_simple_env;
if ( !outEnv )
{
ab_Env* nullEnv = 0; // note operator new() accounts
outEnv = new(*nullEnv) ab_Env(ab_Usage::GetHeap());
}
if ( outEnv && outEnv->Bad() )
outEnv->CutAllFaults();
if ( outEnv && !outEnv->mEnv_Debugger )
{
ab_Debugger* debugger = new(*outEnv) ab_Debugger(ab_Usage::GetHeap());
if ( debugger )
{
if ( outEnv->Good() )
{
outEnv->mEnv_Debugger = debugger;
#ifdef AB_CONFIG_DEBUG
outEnv->mEnv_Self.sEnv_DoDebug = AB_kTrue;
outEnv->mEnv_Self.sEnv_DoErrBreak = AB_kTrue;
outEnv->mEnv_Self.sEnv_BeParanoid = AB_kTrue;
#endif /*AB_CONFIG_DEBUG*/
}
else
debugger->ReleaseObject(outEnv);
}
}
if ( outEnv && !ab_Env_g_simple_env )
{
ab_Env_g_simple_env = outEnv;
outEnv->AcquireObject(outEnv);
ab_Object::PushPanicEnv(outEnv, outEnv);
}
return outEnv;
}
static ab_Env* ab_Env_g_log_file_env = 0; // for ab_Env::GetLogFileEnv() use
/*static*/
ab_Env* ab_Env::GetLogFileEnv() /*i*/
// standard session log env (uses ab_StdioFile::GetLogStdioFile()).
// This uses standard session debugger, tracer, printer, etc.
// (Please, never close this env instance.)
{
ab_Env* outEnv = ab_Env_g_log_file_env;
if ( !outEnv )
{
ab_Env* simpleEv = ab_Env::GetSimpleEnv();
if ( simpleEv )
{
ab_Debugger* d = ab_Debugger::GetLogFileDebugger(simpleEv);
if ( d )
{
ab_Tracer* t = ab_FileTracer::GetLogFileTracer(simpleEv);
if ( t )
{
outEnv = new(*simpleEv) ab_Env(ab_Usage::GetHeap(), d, t);
if ( outEnv )
outEnv->AcquireObject(outEnv);
}
}
}
if ( outEnv )
{
int localVar = 0; // lives somewhere on stack
outEnv->SetStackControl(&localVar, ab_Env_kDefaultMaxRefDelta);
#if AB_CONFIG_TRACE_andLOGGING
outEnv->mEnv_Self.sEnv_DoTrace = AB_kTrue;
#endif /*AB_CONFIG_TRACE_andLOGGING*/
#ifdef AB_CONFIG_DEBUG
outEnv->mEnv_Self.sEnv_DoDebug = AB_kTrue;
outEnv->mEnv_Self.sEnv_DoErrBreak = AB_kTrue;
outEnv->mEnv_Self.sEnv_BeParanoid = AB_kTrue;
#endif /*AB_CONFIG_DEBUG*/
ab_Env_g_log_file_env = outEnv;
outEnv->AcquireObject(outEnv);
ab_Object::PushPanicEnv(outEnv, outEnv);
#if AB_CONFIG_TRACE_andLOGGING
if ( outEnv->DoTrace() )
outEnv->TraceObject(outEnv);
#endif /*AB_CONFIG_TRACE_andLOGGING*/
#ifdef AB_CONFIG_PRINT
ab_Printer* printer = ab_FilePrinter::GetLogFilePrinter(outEnv);
if ( printer )
{
outEnv->PrintObject(outEnv, printer);
printer->Flush(outEnv);
}
#ifdef AB_CONFIG_DEBUG
else outEnv->Break("no log printer");
#endif /*AB_CONFIG_DEBUG*/
#endif /*AB_CONFIG_PRINT*/
}
}
return outEnv;
}
// ````` ````` begin class to statically make log class instances ````` `````
#if AB_CONFIG_TRACE_orDEBUG_orPRINT && defined(USE_STATIC_TWIDDLER)
class ab_EnvStaticTwiddler {
public:
ab_Env* mEnvStaticTwiddler_LogEnv;
public:
ab_EnvStaticTwiddler();
~ab_EnvStaticTwiddler();
};
ab_EnvStaticTwiddler::ab_EnvStaticTwiddler()
{
mEnvStaticTwiddler_LogEnv = ab_Env::GetLogFileEnv();
if ( mEnvStaticTwiddler_LogEnv )
{
ab_Env* simple = ab_Env::GetSimpleEnv();
mEnvStaticTwiddler_LogEnv->AcquireObject(simple);
}
}
ab_EnvStaticTwiddler::~ab_EnvStaticTwiddler()
{
mEnvStaticTwiddler_LogEnv = 0;
ab_Env* ev = ab_Object::TopPanicEnv();
if ( ev && ev->IsOpenObject() )
{
ab_Env_BeginMethod(ev, "ab_EnvStaticTwiddler", "~ab_EnvStaticTwiddler")
#ifdef AB_CONFIG_TRACE
if ( ev->DoTrace() )
ev->TraceObject(ev);
#endif /*AB_CONFIG_TRACE*/
ab_Env_EndMethod(ev)
ab_Printer* printer = ab_FilePrinter::GetLogFilePrinter(ev);
if ( printer )
{
#ifdef AB_CONFIG_TRACE
if ( ev->DoTrace() )
printer->TraceObject(ev);
#endif /*AB_CONFIG_TRACE*/
printer->Flush(ev);
}
ab_Tracer* tracer = ab_FileTracer::GetLogFileTracer(ev);
if ( tracer )
{
#ifdef AB_CONFIG_TRACE
if ( ev->DoTrace() )
tracer->TraceObject(ev);
#endif /*AB_CONFIG_TRACE*/
tracer->Flush(ev);
}
}
}
ab_EnvStaticTwiddler ab_EnvStaticTwiddler_gStaticInstance;
#endif /* end AB_CONFIG_TRACE_orDEBUG_orPRINT && use-static-twiddler */
// ````` ````` end class to statically make log class instances ````` `````
// ````` destruction `````
void ab_Env::CloseEnv(ab_Env* ev) /*i*/
{
ab_Env_BeginMethod(ev, ab_Env_kClassName, "CloseEnv")
ab_Object*obj = mEnv_Debugger;
if ( obj )
{
mEnv_Debugger = 0;
obj->ReleaseObject(ev);
}
obj = mEnv_Tracer;
if ( obj )
{
mEnv_Tracer = 0;
obj->ReleaseObject(ev);
}
ab_Env_EndMethod(ev)
}
// ````` tagged memory management `````
void* ab_Env::HeapSafeTagAlloc(ab_num inSize) /*i*/
{
void* outAddress = 0;
ab_Env* ev = this;
ab_Env_BeginMethod(ev, ab_Env_kClassName, "HeapSafeTagAlloc")
if ( !inSize )
inSize = 1;
ab_u4* tag = (ab_u4*) XP_ALLOC(inSize + sizeof(ab_u4));
if ( tag )
{
*tag = ab_Env_kHeapSafeTag; // install magic tag for later use
outAddress = tag + 1; // slot after tag slot
}
else
ev->NewAbookFault(AB_Table_kFaultOutOfMemory);
#ifdef AB_CONFIG_TRACE
if ( ev->DoTrace() )
ev->Trace("<ab_Env::HeapSafeTagAlloc at=\"^%lX\" sz=\"%lu\"/>",
(long) outAddress, (long) inSize);
#endif /*AB_CONFIG_TRACE*/
ab_Env_EndMethod(ev)
return outAddress;
}
void ab_Env::HeapSafeTagFree(void* ioAddress) /*i*/
{
ab_Env* ev = this;
ab_Env_BeginMethod(ev, ab_Env_kClassName, "HeapSafeTagFree")
#ifdef AB_CONFIG_TRACE
if ( ev->DoTrace() )
ev->Trace("<ab_Env::HeapSafeTagFree at=\"^%lX\" />",
(long) ioAddress);
#endif /*AB_CONFIG_TRACE*/
if ( ioAddress )
{
ab_u4* tag = ((ab_u4*) ioAddress) - 1; // u4 slot before address
if ( *tag == ab_Env_kHeapSafeTag ) // has expected leading tag?
{
XP_FREE(tag); // only free when the tag is correct
}
else
ev->Break("<ab_Env::HeapSafeTagFree tag=\"%.4s\"/>", (char*) tag);
}
ab_Env_EndMethod(ev)
}
/*static*/
ab_bool ab_Env::GoodHeapSafeTag(void* ioAddress)
{
if ( ioAddress )
{
// take care not to act upon an illegally aligned address for a u4:
ab_u4 expected = ab_Env_kHeapSafeTag;
ab_u1* want = (ab_u1*) &expected;
ab_u1* actual = (ab_u1*) (((ab_u4*) ioAddress) - 1);
return ( want[ 0 ] == actual[ 0 ] &&
want[ 1 ] == actual[ 1 ] &&
want[ 2 ] == actual[ 2 ] &&
want[ 3 ] == actual[ 3 ] );
}
return AB_kFalse;
}
// ````` memory management `````
void* ab_Env::HeapAlloc(ab_num inSize) /*i*/
{
void* outAddress = 0;
ab_Env* ev = this;
ab_Env_BeginMethod(ev, ab_Env_kClassName, "HeapAlloc")
if ( !inSize )
inSize = 1;
outAddress = XP_ALLOC(inSize);
if ( !outAddress )
ev->NewAbookFault(AB_Table_kFaultOutOfMemory);
#ifdef AB_CONFIG_TRACE
if ( ev->DoTrace() )
ev->Trace("<ab_Env::HeapAlloc at=\"^%lX\" sz=\"%lu\"/>",
(long) outAddress, (long) inSize);
#endif /*AB_CONFIG_TRACE*/
ab_Env_EndMethod(ev)
return outAddress;
}
void ab_Env::HeapFree(void* ioAddress) /*i*/
{
ab_Env* ev = this;
ab_Env_BeginMethod(ev, ab_Env_kClassName, "HeapFree")
#ifdef AB_CONFIG_TRACE
if ( ev->DoTrace() )
ev->Trace("<ab_Env::HeapFree at=\"^%lX\" />",
(long) ioAddress);
#endif /*AB_CONFIG_TRACE*/
if ( ioAddress )
XP_FREE(ioAddress);
ab_Env_EndMethod(ev)
}
char* ab_Env::CopyString(const char* inStringToCopy) /*i*/
{
char* outString = 0;
ab_Env* ev = this;
ab_Env_BeginMethod(ev, ab_Env_kClassName, "CopyString")
if ( !inStringToCopy )
inStringToCopy = "";
ab_num length = XP_STRLEN(inStringToCopy);
outString = (char*) XP_ALLOC(length + 1);
if ( outString )
{
XP_STRCPY(outString, inStringToCopy);
}
else ev->NewAbookFault(AB_Table_kFaultOutOfMemory);
#ifdef AB_CONFIG_TRACE
if ( ev->DoTrace() )
ev->Trace(
"<ab_Env::CopyString at=\"^%lX\" in=\"%.128s\" len=\"%lu\"/>",
(long) outString, inStringToCopy, (long) length);
#endif /*AB_CONFIG_TRACE*/
ab_Env_EndMethod(ev)
return outString;
}
void ab_Env::FreeString(char* ioStringToFree) /*i*/
{
ab_Env* ev = this;
ab_Env_BeginMethod(ev, ab_Env_kClassName, "FreeString")
if ( ioStringToFree )
{
#ifdef AB_CONFIG_TRACE
if ( ev->DoTrace() )
ev->Trace("<ab_Env::FreeString at=\"^%lX\" io=\"%.128s\"/>",
(long) ioStringToFree, ioStringToFree);
#endif /*AB_CONFIG_TRACE*/
XP_FREE(ioStringToFree);
}
ab_Env_EndMethod(ev)
}
// ````` fault creation covers `````
void ab_Env::NewAbookFault(ab_error_uid faultCode) /*i*/
{
this->NewFault(faultCode, /*space*/ AB_Fault_kAbookSpace);
}
// ````` fault access `````
ab_error_count ab_Env::GetAllErrors(ab_error_uid* outVector, /*i*/
ab_error_count inSize, ab_error_count* outLength)
{
ab_num outCount = mEnv_Self.sEnv_FaultCount;
if ( outCount > ab_Env_kFaultStackSlots )
outCount = ab_Env_kFaultStackSlots;
ab_num copyCount = outCount;
if ( copyCount > inSize )
copyCount = inSize;
if ( copyCount && outVector )
{
AB_MEMCPY(outVector, mEnv_FaultStack, copyCount * sizeof(AB_Fault));
}
if ( outLength )
*outLength = copyCount;
return outCount;
}
// ````` debugging covers `````
void ab_Env::Break(const char* inFormat, ...) /*i*/
{
#ifdef AB_CONFIG_DEBUG
// copied from public domain IronDoc
ab_Env* ev = this;
if ( this->IsOpenObject() )
{
ab_Debugger* debugger = mEnv_Debugger;
if ( debugger )
{
char buf[ AB_Env_kFormatBufferSize ];
va_list args;
va_start(args,inFormat);
PR_vsnprintf(buf, AB_Env_kFormatBufferSize, inFormat, args);
va_end(args);
debugger->BreakString(ev, buf);
}
}
#endif /*AB_CONFIG_DEBUG*/
}
// ````` tracing covers `````
#ifdef AB_CONFIG_TRACE
void ab_Env::Trace(const char* inFormat, ...) /*i*/
{
// copied from public domain IronDoc
ab_Env* ev = this;
if ( this->IsOpenObject() )
{
ab_Tracer* tracer = mEnv_Tracer;
if ( tracer && ev->DoTrace() )
{
char buf[ AB_Env_kFormatBufferSize ];
va_list args;
va_start(args,inFormat);
PR_vsnprintf(buf, AB_Env_kFormatBufferSize, inFormat, args);
va_end(args);
tracer->TraceString(ev, buf);
}
}
}
#endif /*AB_CONFIG_TRACE*/
void ab_Env::TraceBeginMethod(const char* inClass,
const char* inMethod) const /*i*/
{
ab_Env* ev = (ab_Env*) this; // cast away const
// copied from public domain IronDoc
if ( this->IsOpenObject() )
{
ab_Tracer* tracer = mEnv_Tracer;
if ( tracer && ev->DoTrace() )
{
tracer->BeginMethod(ev, inClass, inMethod);
}
}
}
void ab_Env::TraceEndMethod() const /*i*/
{
ab_Env* ev = (ab_Env*) this; // cast away const
// copied from public domain IronDoc
if ( this->IsOpenObject() )
{
ab_Tracer* tracer = mEnv_Tracer;
if ( tracer && ev->DoTrace() )
{
tracer->EndMethod(ev);
}
}
}
// ````` member access `````
void ab_Env::ChangeDebugger(ab_Debugger* ioDebugger) /*i*/
{
ab_Env* ev = this;
ab_Env_BeginMethod(ev, ab_Env_kClassName, "ChangeDebugger")
if ( ev->Good() && ev->IsOpenObject() )
{
if ( ioDebugger )
ioDebugger->AcquireObject(ev);
if ( ev->Good() )
{
if ( mEnv_Debugger )
mEnv_Debugger->ReleaseObject(ev);
mEnv_Debugger = ioDebugger;
}
}
ab_Env_EndMethod(ev)
}
void ab_Env::ChangeTracer(ab_Tracer* ioTracer) /*i*/
{
ab_Env* ev = this;
ab_Env_BeginMethod(ev, ab_Env_kClassName, "ChangeTracer")
if ( ev->Good() && this->IsOpenObject() )
{
if ( ioTracer )
ioTracer->AcquireObject(ev);
if ( ev->Good() )
{
if ( mEnv_Tracer )
mEnv_Tracer->ReleaseObject(ev);
mEnv_Tracer = ioTracer;
}
}
ab_Env_EndMethod(ev)
}
/* ----- ----- ----- ----- C Env ----- ----- ----- ----- */
/* ----- ----- creation / ref counting ----- ----- */
AB_API_IMPL(AB_Env*) /* abenv.cpp */
AB_Env_New() /*i*/
{
AB_Env* outEnv = 0;
#ifdef AB_CONFIG_LOGGING
ab_Env* ev = ab_Env::GetLogFileEnv();
#else /*AB_CONFIG_LOGGING*/
ab_Env* ev = ab_Env::GetSimpleEnv();
#endif /*AB_CONFIG_LOGGING*/
if ( ev )
{
ab_Env_BeginMethod(ev, AB_Env_kClassName, "New")
ab_Env* copyEnv = new(*ev) ab_Env(ab_Usage::GetHeap(), *ev);
if ( copyEnv )
{
outEnv = copyEnv->AsSelf();
#ifdef AB_CONFIG_TRACE
if ( ev->DoTrace() )
copyEnv->TraceObject(ev);
#endif /*AB_CONFIG_TRACE*/
}
ab_Env_EndMethod(ev)
}
return outEnv;
}
AB_API_IMPL(AB_Env*) /* abenv.cpp */
AB_Env_GetLogFileEnv() /*i*/
{
AB_Env* outEnv = 0;
ab_Env* ev = ab_Env::GetLogFileEnv();
if ( ev )
{
outEnv = ev->AsSelf();
}
return outEnv;
}
AB_API_IMPL(ab_ref_count) /* abenv.cpp */
AB_Env_Acquire(AB_Env* self) /*i*/
{
ab_Env* ev = ab_Env::AsThis(self);
return ev->AcquireObject(ev);
}
AB_API_IMPL(ab_ref_count) /* abenv.cpp */
AB_Env_Release(AB_Env* self) /*i*/
{
ab_Env* ev = ab_Env::AsThis(self);
return ev->ReleaseObject(ev);
}
/* ----- ----- error access ----- ----- */
AB_API_IMPL(ab_error_count) /* abenv.cpp */
AB_Env_ForgetErrors(AB_Env* self) /*i*/
/*- Discard all error information. -*/
{
ab_Env* ev = ab_Env::AsThis(self);
return ev->CutAllFaults();
}
AB_API_IMPL(ab_error_count) /* abenv.cpp */
AB_Env_ErrorCount(const AB_Env* self) /*i*/
/*- Number of errors since last forget/reset. -*/
{
AB_Env* mutableSelf = (AB_Env*) self; // cast away const
ab_Env* ev = ab_Env::AsThis(mutableSelf);
return ev->ErrorCount();
}
AB_API_IMPL(ab_error_uid) /* abenv.cpp */
AB_Env_GetError(const AB_Env* self) /*i*/
/*- Last error since forget/reset, otherwise zero. -*/
{
AB_Env* mutableSelf = (AB_Env*) self; // cast away const
ab_Env* ev = ab_Env::AsThis(mutableSelf);
return ev->GetError();
}
AB_API_IMPL(ab_error_count) /* abenv.cpp */
AB_Env_GetAllErrors(const AB_Env* self, ab_error_uid* outVector, /*i*/
ab_error_count inSize, ab_error_count* outLength)
/*- All errors (up to inSize) since forget/reset. -*/
{
AB_Env* mutableSelf = (AB_Env*) self; // cast away const
ab_Env* ev = ab_Env::AsThis(mutableSelf);
return ev->GetAllErrors(outVector, inSize, outLength);
}
AB_API_IMPL(ab_error_uid) /* abenv.cpp */
AB_Env_NewFault(AB_Env* self, ab_error_uid inFaultCode, /*i*/
ab_u4 inFaultSpace)
{
ab_Env* ev = ab_Env::AsThis(self);
return ev->NewFault(inFaultCode, inFaultSpace);
}
/* ----- ----- static dispatching methods ----- ----- */
AB_API_IMPL(ab_error_uid) /* abenv.cpp */
AB_Env_NewAbookFault(AB_Env* self, ab_error_uid inFaultCode) /*i*/
{
ab_Env* ev = ab_Env::AsThis(self);
ev->NewAbookFault(inFaultCode);
return inFaultCode;
}
AB_API_IMPL(void) /* abenv.cpp */
AB_Env_Break(AB_Env* self, const char* inFormat, ...) /*i*/
{
#ifdef AB_CONFIG_DEBUG
ab_Env* ev = ab_Env::AsThis(self);
ab_Env_BeginMethod(ev, AB_Env_kClassName, "Break")
if ( ev->IsOpenObject() )
{
char buf[ AB_Env_kFormatBufferSize ];
va_list args;
va_start(args,inFormat);
PR_vsnprintf(buf, AB_Env_kFormatBufferSize, inFormat, args);
va_end(args);
ev->BreakString(buf);
}
ab_Env_EndMethod(ev)
#endif /*AB_CONFIG_DEBUG*/
}
AB_API_IMPL(void) /* abenv.cpp */
AB_Env_Trace(AB_Env* self, const char* inFormat, ...) /*i*/
{
#ifdef AB_CONFIG_TRACE
ab_Env* ev = ab_Env::AsThis(self);
ab_Env_BeginMethod(ev, AB_Env_kClassName, "Trace")
if ( ev->IsOpenObject() )
{
char buf[ AB_Env_kFormatBufferSize ];
va_list args;
va_start(args,inFormat);
PR_vsnprintf(buf, AB_Env_kFormatBufferSize, inFormat, args);
va_end(args);
ev->TraceString(buf);
}
ab_Env_EndMethod(ev)
#endif /*AB_CONFIG_TRACE*/
}
AB_API_IMPL(void) /* abenv.cpp */
AB_Env_TraceBeginMethod(const AB_Env* self, const char* inClass, /*i*/
const char* inMethod)
{
AB_Env* mutableSelf = (AB_Env*) self; // cast away const
ab_Env* ev = ab_Env::AsThis(mutableSelf);
ev->TraceBeginMethod(inClass, inMethod);
}
AB_API_IMPL(void) /* abenv.cpp */
AB_Env_TraceEndMethod(const AB_Env* self) /*i*/
{
AB_Env* mutableSelf = (AB_Env*) self; // cast away const
ab_Env* ev = ab_Env::AsThis(mutableSelf);
ev->TraceEndMethod();
}
Reference in New Issue View Git Blame Copy Permalink