bool calc_zero_operand(tree* my_tree)
{
assert(my_tree);
int ret = 0;
if (my_tree -> type == TR_SIGN && (*(int*)(my_tree -> value) == '*' || *(int*)(my_tree -> value) == '/')
&&(
(is_num_leaf(my_tree -> left) && IS_ZERO(*(double*)(my_tree -> left -> value)))
||
(is_num_leaf(my_tree -> right) && IS_ZERO(*(double*)(my_tree -> right -> value)))
))
{
clear_leafs(my_tree);
DBG_FREE fprintf(stdout, "[%08x] tree.cpp, calc_zero_operand, my_tree -> value\n", my_tree -> value);
free(my_tree -> value);
my_tree -> value = calloc(1, sizeof(double));
assert(my_tree -> value);
*(double*)(my_tree -> value) = 0.0;
my_tree -> type = TR_N;
return true;
}
return false;
}
void
WMDeleteTimerWithClientData(void *cdata)
{
TimerHandler *handler, *tmp;
if (!cdata || !timerHandler)
return;
tmp = timerHandler;
if (tmp->clientData==cdata) {
tmp->nextDelay = 0;
if (!IS_ZERO(tmp->when)) {
timerHandler = tmp->next;
wfree(tmp);
}
} else {
while (tmp->next) {
if (tmp->next->clientData==cdata) {
handler = tmp->next;
handler->nextDelay = 0;
if (IS_ZERO(handler->when))
break;
tmp->next = handler->next;
wfree(handler);
break;
}
tmp = tmp->next;
}
}
}
// --[ Method ]---------------------------------------------------------------
//
// - Class : CMatrix
//
// - prototype : void Transform(CPlane* plane)
//
// - Purpose : Transforms a plane.
//
// -----------------------------------------------------------------------------
void CMatrix::Transform(CPlane* plane) const
{
CVector3 planePoint;
// Get a point of the plane:
if(IS_ZERO(plane->A()) == false)
{
planePoint.Set(-plane->D() / plane->A(), 0.0f, 0.0f);
}
else if(IS_ZERO(plane->B()) == false)
{
planePoint.Set(0.0f, -plane->D() / plane->B(), 0.0f);
}
else if(IS_ZERO(plane->C()) == false)
{
planePoint.Set(0.0f, 0.0f, -plane->D() / plane->C());
}
// Transform both point of the plane and plane's normal.
CVector3 normal = plane->Normal();
Transform(&planePoint);
Transform(&normal, true);
plane->Build(planePoint, normal);
}
struct fp_ext *
fp_fsgldiv(struct fp_ext *dest, struct fp_ext *src)
{
int exp;
unsigned long quot, rem;
dprint(PINSTR, "fsgldiv\n");
fp_dyadic_check(dest, src);
/* calculate the correct sign now, as it's necessary for infinities */
dest->sign = src->sign ^ dest->sign;
/* Handle infinities */
if (IS_INF(dest)) {
/* infinity / infinity = NaN (quiet, as always) */
if (IS_INF(src))
fp_set_nan(dest);
/* infinity / anything else = infinity (with approprate sign) */
return dest;
}
if (IS_INF(src)) {
/* anything / infinity = zero (with appropriate sign) */
dest->exp = 0;
dest->mant.m64 = 0;
dest->lowmant = 0;
return dest;
}
/* zeroes */
if (IS_ZERO(dest)) {
/* zero / zero = NaN */
if (IS_ZERO(src))
fp_set_nan(dest);
/* zero / anything else = zero */
return dest;
}
if (IS_ZERO(src)) {
/* anything / zero = infinity (with appropriate sign) */
fp_set_sr(FPSR_EXC_DZ);
dest->exp = 0x7fff;
dest->mant.m64 = 0;
return dest;
}
exp = dest->exp - src->exp + 0x3fff;
dest->mant.m32[0] &= 0xffffff00;
src->mant.m32[0] &= 0xffffff00;
/* do the 32-bit divide */
if (dest->mant.m32[0] >= src->mant.m32[0]) {
fp_sub64(dest->mant, src->mant);
fp_div64(quot, rem, dest->mant.m32[0], 0, src->mant.m32[0]);
dest->mant.m32[0] = 0x80000000 | (quot >> 1);
dest->mant.m32[1] = (quot & 1) | rem; /* only for rounding */
} else {
struct fp_ext *
fp_fsgldiv(struct fp_ext *dest, struct fp_ext *src)
{
int exp;
unsigned long quot, rem;
dprint(PINSTR, "fsgldiv\n");
fp_dyadic_check(dest, src);
/* */
dest->sign = src->sign ^ dest->sign;
/* */
if (IS_INF(dest)) {
/* */
if (IS_INF(src))
fp_set_nan(dest);
/* */
return dest;
}
if (IS_INF(src)) {
/* */
dest->exp = 0;
dest->mant.m64 = 0;
dest->lowmant = 0;
return dest;
}
/* */
if (IS_ZERO(dest)) {
/* */
if (IS_ZERO(src))
fp_set_nan(dest);
/* */
return dest;
}
if (IS_ZERO(src)) {
/* */
fp_set_sr(FPSR_EXC_DZ);
dest->exp = 0x7fff;
dest->mant.m64 = 0;
return dest;
}
exp = dest->exp - src->exp + 0x3fff;
dest->mant.m32[0] &= 0xffffff00;
src->mant.m32[0] &= 0xffffff00;
/* */
if (dest->mant.m32[0] >= src->mant.m32[0]) {
fp_sub64(dest->mant, src->mant);
fp_div64(quot, rem, dest->mant.m32[0], 0, src->mant.m32[0]);
dest->mant.m32[0] = 0x80000000 | (quot >> 1);
dest->mant.m32[1] = (quot & 1) | rem; /* */
} else {
void TimerManager::DumpTimerList(int flag, const char* indent)
{
Timer *timer_ptr;
const char *ptmp;
// we want to allow flag to be "D_FULLDEBUG | D_DAEMONCORE",
// and only have output if _both_ are specified by the user
// in the condor_config. this is a little different than
// what dprintf does by itself ( which is just
// flag & DebugFlags > 0 ), so our own check here:
if ( ! IsDebugCatAndVerbosity(flag) )
return;
if ( indent == NULL)
indent = DEFAULT_INDENT;
dprintf(flag, "\n");
dprintf(flag, "%sTimers\n", indent);
dprintf(flag, "%s~~~~~~\n", indent);
for(timer_ptr = timer_list; timer_ptr != NULL; timer_ptr = timer_ptr->next)
{
if ( timer_ptr->event_descrip )
ptmp = timer_ptr->event_descrip;
else
ptmp = "NULL";
std::string slice_desc;
if( !timer_ptr->timeslice ) {
formatstr(slice_desc, "period = %d, ", timer_ptr->period);
}
else {
formatstr_cat(slice_desc, "timeslice = %.3g, ",
timer_ptr->timeslice->getTimeslice());
if( !IS_ZERO(timer_ptr->timeslice->getDefaultInterval()) ) {
formatstr_cat(slice_desc, "period = %.1f, ",
timer_ptr->timeslice->getDefaultInterval());
}
if( !IS_ZERO(timer_ptr->timeslice->getInitialInterval()) ) {
formatstr_cat(slice_desc, "initial period = %.1f, ",
timer_ptr->timeslice->getInitialInterval());
}
if( !IS_ZERO(timer_ptr->timeslice->getMinInterval()) ) {
formatstr_cat(slice_desc, "min period = %.1f, ",
timer_ptr->timeslice->getMinInterval());
}
if( !IS_ZERO(timer_ptr->timeslice->getMaxInterval()) ) {
formatstr_cat(slice_desc, "max period = %.1f, ",
timer_ptr->timeslice->getMaxInterval());
}
}
dprintf(flag,
"%sid = %d, when = %ld, %shandler_descrip=<%s>\n",
indent, timer_ptr->id, (long)timer_ptr->when,
slice_desc.c_str(),ptmp);
}
dprintf(flag, "\n");
}
struct fp_ext *
fp_fsglmul(struct fp_ext *dest, struct fp_ext *src)
{
int exp;
dprint(PINSTR, "fsglmul\n");
fp_dyadic_check(dest, src);
/* calculate the correct sign now, as it's necessary for infinities */
dest->sign = src->sign ^ dest->sign;
/* Handle infinities */
if (IS_INF(dest)) {
if (IS_ZERO(src))
fp_set_nan(dest);
return dest;
}
if (IS_INF(src)) {
if (IS_ZERO(dest))
fp_set_nan(dest);
else
fp_copy_ext(dest, src);
return dest;
}
/* Of course, as we all know, zero * anything = zero. You may
not have known that it might be a positive or negative
zero... */
if (IS_ZERO(dest) || IS_ZERO(src)) {
dest->exp = 0;
dest->mant.m64 = 0;
dest->lowmant = 0;
return dest;
}
exp = dest->exp + src->exp - 0x3ffe;
/* do a 32-bit multiply */
fp_mul64(dest->mant.m32[0], dest->mant.m32[1],
dest->mant.m32[0] & 0xffffff00,
src->mant.m32[0] & 0xffffff00);
if (exp >= 0x7fff) {
fp_set_ovrflw(dest);
return dest;
}
dest->exp = exp;
if (exp < 0) {
fp_set_sr(FPSR_EXC_UNFL);
fp_denormalize(dest, -exp);
}
return dest;
}
bool CFXRecursiveBlurTexture::DoFrame(CDemo* pDemo, float fEffectTime, float fDemoTime)
{
assert(pDemo);
if(!m_pTexture) return false;
// Evaluate vars
CVarFloat::CValueFloat valueIntensity;
CVarFloat::CValueFloat valueWidth;
CVarFloat::CValueFloat valueHeight;
CVarFloat::CValueFloat valueOriginX;
CVarFloat::CValueFloat valueOriginY;
EvaluateVar("Intensity", fEffectTime, &valueIntensity);
EvaluateVar("Width", fEffectTime, &valueWidth);
EvaluateVar("Height", fEffectTime, &valueHeight);
EvaluateVar("X Origin", fEffectTime, &valueOriginX);
EvaluateVar("Y Origin", fEffectTime, &valueOriginY);
// Compute blur direction
CVector3 v3Vector;
v3Vector.Build(CVector3(valueOriginX.GetValue(), valueOriginY.GetValue(), 0.0f), CVector3(0.5f, 0.5f, 0.0f));
if(!IS_ZERO(v3Vector.X()) || !IS_ZERO(v3Vector.Y()))
{
v3Vector.Normalize();
}
// Accumulate previous blur
float fWidth = valueWidth.GetValue();
float fHeight = valueHeight.GetValue();
UtilGL::Rendering::DrawCenteredQuad(m_pTexture,
0.5f + v3Vector.X() * ((fWidth * 0.5f) - 0.5f),
0.5f + v3Vector.Y() * ((fHeight * 0.5f) - 0.5f),
fWidth, fHeight,
0.0f, CVector4(1.0f, 1.0f, 1.0f, valueIntensity.GetValue()),
UtilGL::States::BLEND_SRCALPHA, UtilGL::States::BLEND_INVSRCALPHA);
// Store accumulation
m_pTexture->CopyFromFramebuffer(0, 0, 0, 0, m_pTexture->GetWidth(), m_pTexture->GetHeight());
// Restore demo viewport
pDemo->SetDemoViewport();
// Clear framebuffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
return true;
}
struct fp_ext *
fp_fsglmul(struct fp_ext *dest, struct fp_ext *src)
{
int exp;
dprint(PINSTR, "fsglmul\n");
fp_dyadic_check(dest, src);
/* */
dest->sign = src->sign ^ dest->sign;
/* */
if (IS_INF(dest)) {
if (IS_ZERO(src))
fp_set_nan(dest);
return dest;
}
if (IS_INF(src)) {
if (IS_ZERO(dest))
fp_set_nan(dest);
else
fp_copy_ext(dest, src);
return dest;
}
/*
*/
if (IS_ZERO(dest) || IS_ZERO(src)) {
dest->exp = 0;
dest->mant.m64 = 0;
dest->lowmant = 0;
return dest;
}
exp = dest->exp + src->exp - 0x3ffe;
/* */
fp_mul64(dest->mant.m32[0], dest->mant.m32[1],
dest->mant.m32[0] & 0xffffff00,
src->mant.m32[0] & 0xffffff00);
if (exp >= 0x7fff) {
fp_set_ovrflw(dest);
return dest;
}
dest->exp = exp;
if (exp < 0) {
fp_set_sr(FPSR_EXC_UNFL);
fp_denormalize(dest, -exp);
}
return dest;
}
struct fp_ext *
fp_fadd(struct fp_ext *dest, struct fp_ext *src)
{
int diff;
dprint(PINSTR, "fadd\n");
fp_dyadic_check(dest, src);
if (IS_INF(dest)) {
/* infinity - infinity == NaN */
if (IS_INF(src) && (src->sign != dest->sign))
fp_set_nan(dest);
return dest;
}
if (IS_INF(src)) {
fp_copy_ext(dest, src);
return dest;
}
if (IS_ZERO(dest)) {
if (IS_ZERO(src)) {
if (src->sign != dest->sign) {
if (FPDATA->rnd == FPCR_ROUND_RM)
dest->sign = 1;
else
dest->sign = 0;
}
} else
fp_copy_ext(dest, src);
return dest;
}
dest->lowmant = src->lowmant = 0;
if ((diff = dest->exp - src->exp) > 0)
fp_denormalize(src, diff);
else if ((diff = -diff) > 0)
fp_denormalize(dest, diff);
if (dest->sign == src->sign) {
if (fp_addmant(dest, src))
if (!fp_addcarry(dest))
return dest;
} else {
if (dest->mant.m64 < src->mant.m64) {
fp_submant(dest, src, dest);
dest->sign = !dest->sign;
} else
fp_submant(dest, dest, src);
}
return dest;
}
CVector3D CVector3D::GetVerticalVector(int m) const
{
if(!IS_ZERO(dx))
return CVector3D(-(m*dy+dz)/dx,m,1);
else
if(!IS_ZERO(dy))
return CVector3D(1,-(dx+m*dz)/dy,m);
else
if(!IS_ZERO(dz))
return CVector3D(m,1,-(m*dx+dy)/dz);
else
return CVector3D(0,0,0);
}
// --[ Method ]---------------------------------------------------------------
//
// - Class : CMatrix
//
// - prototype : CMatrix Inverse()
//
// - Purpose : Returns the inverse transformation matrix.
//
// - Note : IMPORTANT: Algorithm only valid for orthogonal matrices!
//
// -----------------------------------------------------------------------------
CMatrix CMatrix::Inverse() const
{
CMatrix result;
// Transpose rotation submatrix
CVector3 row0(m_fM[0][0], m_fM[1][0], m_fM[2][0]);
CVector3 row1(m_fM[0][1], m_fM[1][1], m_fM[2][1]);
CVector3 row2(m_fM[0][2], m_fM[1][2], m_fM[2][2]);
CVector3 position(m_fM[0][3], m_fM[1][3], m_fM[2][3]);
CVector3 invPosition;
// Solve ecuation system
invPosition.SetX((-row0) * position);
invPosition.SetY((-row1) * position);
invPosition.SetZ((-row2) * position);
// Get scale values
CVector3 scale = Scale();
float sqrSclX = scale.X(); sqrSclX *= sqrSclX;
float sqrSclY = scale.Y(); sqrSclY *= sqrSclY;
float sqrSclZ = scale.Z(); sqrSclZ *= sqrSclZ;
// Shouldn't happen:
assert(!IS_ZERO(sqrSclX));
assert(!IS_ZERO(sqrSclY));
assert(!IS_ZERO(sqrSclZ));
// Normalize axis and multiply by the inverse scale.
row0 = row0 / sqrSclX;
row1 = row1 / sqrSclY;
row2 = row2 / sqrSclZ;
// Insert values
result.SetRow0(row0.X(), row0.Y(), row0.Z(), invPosition.X());
result.SetRow1(row1.X(), row1.Y(), row1.Z(), invPosition.Y());
result.SetRow2(row2.X(), row2.Y(), row2.Z(), invPosition.Z());
result.SetRow3( 0.0f, 0.0f, 0.0f, 1.0f);
return result;
}
unsigned int Math::solveQuadric(DOUBLE coeffs[3], DOUBLE roots[2])
{
/* x^2 + px + q = 0 */
DOUBLE p = coeffs[1] / (2.0 * coeffs[2]);
DOUBLE q = coeffs[0] / coeffs[2];
DOUBLE delta = p * p - q;
if (IS_ZERO(delta))
{
roots[0] = -p;
return (1);
}
else if (delta > 0.0)
{
DOUBLE sqrt_delta = sqrt(delta);
roots[0] = sqrt_delta - p;
roots[1] = -sqrt_delta - p;
return (2);
}
return (0);
}
Ray Fisheye::_getRay(const double x, const double y)
{
double phi, theta;
// TODO: Force into a circle of radius = min(width,height)
// Map x and y to [-1,1]
double _x = 2.0 * x - 1.0;
double _y = 2.0 * y - 1.0;
double r = _x*_x + _y*_y;
if (r > 1.0) {
return Ray();
}
r = sqrt(r);
if (IS_ZERO(r)) {
phi = 0.0;
} else {
phi = asin(_y / r);
if (_x < 0.0) {
phi = M_PI - phi;
}
}
theta = r * getFieldOfView() / 2.0 ;
Vector dir = Vector(sin(theta)*cos(phi), sin(theta)*sin(phi), cos(theta));
dir = basis * dir;
dir.normalize(); // TODO: Necessary?
return Ray(position, dir, 1.0);
}
int solveQuadric(float c[3], float s[2])
{
float p, q, D;
/* normal form: x^2 + px + q = 0 */
p = c[ 1 ] / (2 * c[ 2 ]);
q = c[ 0 ] / c[ 2 ];
D = p * p - q;
if (IS_ZERO(D))
{
s[ 0 ] = - p;
return 1;
}
else if (D > 0)
{
float sqrt_D = sqrt(D);
s[ 0 ] = sqrt_D - p;
s[ 1 ] = - sqrt_D - p;
return 2;
}
else /* if (D < 0) */
return 0;
}
void EV_LightTurnOn(Line *line, float max)
{
iterlist_t *list = P_GetSectorIterListForTag(P_ToXLine(line)->tag, false);
if(!list) return;
float lightLevel = 0;
if(NON_ZERO(max))
lightLevel = max;
IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
IterList_RewindIterator(list);
Sector *sec;
while((sec = (Sector *)IterList_MoveIterator(list)))
{
// If Max = 0 means to search for the highest light level in the
// surrounding sector.
if(IS_ZERO(max))
{
lightLevel = P_GetFloatp(sec, DMU_LIGHT_LEVEL);
float otherLevel = DDMINFLOAT;
P_FindSectorSurroundingHighestLight(sec, &otherLevel);
if(otherLevel > lightLevel)
lightLevel = otherLevel;
}
P_SetFloatp(sec, DMU_LIGHT_LEVEL, lightLevel);
}
}
void
WMDeleteTimerHandler(WMHandlerID handlerID)
{
TimerHandler *tmp, *handler=(TimerHandler*)handlerID;
if (!handler || !timerHandler)
return;
tmp = timerHandler;
handler->nextDelay = 0;
if (IS_ZERO(handler->when))
return;
if (tmp==handler) {
timerHandler = handler->next;
wfree(handler);
} else {
while (tmp->next) {
if (tmp->next==handler) {
tmp->next=handler->next;
wfree(handler);
break;
}
tmp = tmp->next;
}
}
}
inline double solver_second_degree(double a, double b, double c)
{
double res;
double det;
double tmp[4];
det = b * b - 4.0 * a * c;
if (IS_ZERO(det))
{
res = -1.0 * b / (2.0 * a);
res = CHECK_SOLUTION(res);
}
else if (det > 0.0)
{
tmp[2] = sqrt(det);
tmp[3] = 2.0 * a;
tmp[0] = -(b - tmp[2]) / tmp[3];
tmp[1] = -(b + tmp[2]) / tmp[3];
tmp[0] = CHECK_SOLUTION(tmp[0]);
tmp[1] = CHECK_SOLUTION(tmp[1]);
res = check_solution_equation(tmp[0], tmp[1]);
}
else
{
res = NOT_A_SOLUTION;
}
return (res);
}
static void
delayUntilNextTimerEvent(struct timeval *delay)
{
struct timeval now;
TimerHandler *handler;
handler = timerHandler;
while (handler && IS_ZERO(handler->when)) handler = handler->next;
if (!handler) {
/* The return value of this function is only valid if there _are_
timers active. */
delay->tv_sec = 0;
delay->tv_usec = 0;
return;
}
rightNow(&now);
if (IS_AFTER(now, handler->when)) {
delay->tv_sec = 0;
delay->tv_usec = 0;
} else {
delay->tv_sec = handler->when.tv_sec - now.tv_sec;
delay->tv_usec = handler->when.tv_usec - now.tv_usec;
if (delay->tv_usec < 0) {
delay->tv_usec += 1000000;
delay->tv_sec--;
}
}
}
Mat3 inverse(Mat3& o) {
Mat3 r;
float cofactor0 = o.m[4]*o.m[8] - o.m[5]*o.m[7];
float cofactor3 = o.m[2]*o.m[7] - o.m[1]*o.m[8];
float cofactor6 = o.m[1]*o.m[5] - o.m[2]*o.m[4];
float det = o.m[0]*cofactor0 + o.m[3]*cofactor3 + o.m[6]*cofactor6;
if (IS_ZERO(det)) {
printf("Mat3::inverse error: singular matrix\n");
return r;
}
float inv_det = 1.0f / det;
r.m[0] = inv_det*cofactor0;
r.m[1] = inv_det*cofactor3;
r.m[2] = inv_det*cofactor6;
r.m[3] = inv_det*(o.m[5]*o.m[6] - o.m[3]*o.m[8]);
r.m[4] = inv_det*(o.m[0]*o.m[8] - o.m[2]*o.m[6]);
r.m[5] = inv_det*(o.m[2]*o.m[3] - o.m[0]*o.m[5]);
r.m[6] = inv_det*(o.m[3]*o.m[7] - o.m[4]*o.m[6]);
r.m[7] = inv_det*(o.m[1]*o.m[6] - o.m[0]*o.m[7]);
r.m[8] = inv_det*(o.m[0]*o.m[4] - o.m[1]*o.m[3]);
return r;
}
BOOL CVector3D::operator!=( VECTOR3D v ) const
{
CVector3D vect( dx-v.dx, dy-v.dy, dz-v.dz );
if ( IS_ZERO( vect.GetLength() ) )
return FALSE;
else
return TRUE;
}
BOOL CPoint3D::operator!=( POINT3D pos ) const
{
CVector3D vect( x-pos.x, y-pos.y, z-pos.z );
if ( IS_ZERO( vect.GetLength() ) )
return FALSE;
else
return TRUE;
}
bool VectorBase<scalar,index,SizeAtCompileTime>::operator==(const scalar s)const
{
for ( index i = 0 ; i < this->size() ; ++ i )
{
if(!IS_ZERO(std::abs(this->operator[](i)-s)))
return false;
}
return true;
}
//=============================================================================
double matVector2DUnit::get_norm() const
//
// lav 12/10/13 written.
//
{
assert(IS_ZERO(get_squared_norm() - 1));
return 1;
}
/**
This method is used to return the ratio of the weight that is supported by the stance foot.
*/
double SimBiController::getStanceFootWeightRatio(DynamicArray<ContactPoint> *cfs){
Vector3d stanceFootForce = getForceOnFoot(stanceFoot, cfs);
Vector3d swingFootForce = getForceOnFoot(swingFoot, cfs);
double totalYForce = (stanceFootForce + swingFootForce).dotProductWith(SimGlobals::up);
if (IS_ZERO(totalYForce))
return -1;
else
return stanceFootForce.dotProductWith(SimGlobals::up) / totalYForce;
}
void CVector3D::Normalize()
{
double len = GetLength();
if(!IS_ZERO(len))
{
dx /= len;
dy /= len;
dz /= len;
}
}
bool VectorBase<scalar,index,SizeAtCompileTime>::operator==(const VectorBase<scalar,index,S>& vec)const
{
if (this->size() != vec.size() )
return false;
for ( index i = 0 ; i < this->size() ; ++ i ){
if(!IS_ZERO(std::abs(this->operator[](i)-vec[i])))
return false;
}
return true;
}
BOOL _IsInTheSameFace(CPoint3D pt1, CPoint3D pt2, CPoint3D pt3, CPoint3D pt4)
{
CVector3D v1 = pt1 - pt2;
CVector3D v2 = pt2 - pt3;
CVector3D v3 = pt3 - pt4;
if ( IS_ZERO(( ( v1*v2 ) * ( v2*v3 ) ) | ( ( v1*v2 ) * ( v2*v3 ) )) )
return TRUE;
else
return FALSE;
}
//----------------------------------------------------------//
// CPacket::GetMessages
//----------------------------------------------------------//
CPacket::Error::Enum CPacket::GetMessages(TMessageList& tempList)
{
//-- DataBuffer should have exactly m_HeaderV1.m_nMessages inside it.
tempList.clear();
u16 nProcessedMessages = 0;
CPacketSerializer messageDeserializer(ISerializer::Mode::Deserializing, m_DataBuffer.Buffer(), m_DataBuffer.UsedSize());
CPacketSerializer::Error::Enum eSerError = CPacketSerializer::Error::Ok;
while ( (CPacketSerializer::Error::Ok == eSerError)
&& (messageDeserializer.GetOffset() < messageDeserializer.GetSize()) )
{
CMessage::Type nMessageType = CMessage::kTypeUnknown;
if (IS_ZERO(messageDeserializer.SerializeU32(nMessageType, 'type')))
{
return Error::Serializer;
}
CMessage* pMessage = CMessageFactory::CreateType(nMessageType);
if (IS_NULL_PTR(pMessage))
{
return Error::ProtocolMismatch;
}
pMessage->Serialize(messageDeserializer);
eSerError = messageDeserializer.GetError();
if (CPacketSerializer::Error::Ok != eSerError)
{
return Error::Serializer;
}
SysSmartPtr<CMessage> pSmart(pMessage);
tempList.push_back(pSmart);
++nProcessedMessages;
}
//-- Sanity tests
//-- messageSerializer should have consumed all its bytes.
assert(messageDeserializer.GetOffset() == messageDeserializer.GetSize());
if (messageDeserializer.GetOffset() != messageDeserializer.GetSize())
{
return Error::SanityFail;
}
//-- We should have processed exactly the right number of messages.
assert(nProcessedMessages == GetMessageCount());
if (nProcessedMessages != GetMessageCount())
{
return Error::SanityFail;
}
return Error::Ok;
}
static void init_domain_for_ob (object_t * ob)
{
svalue_t *ret;
const char *domain_name;
if (!current_object
#ifdef PACKAGE_UIDS
|| !current_object->uid
#endif
) {
/*
* Only for the master and void object. Note that you can't ask for
* the backbone or root domain here since we're in the process of
* loading the master object.
*/
ob->stats.domain = add_stat_entry("NONAME", &domains);
return;
}
/*
* Ask master object who the creator of this object is.
*/
push_malloced_string(add_slash(ob->obname));
if (master_ob)
ret = apply_master_ob(APPLY_DOMAIN_FILE, 1);
else
ret = apply(applies_table[APPLY_DOMAIN_FILE], ob, 1, ORIGIN_DRIVER);
if (IS_ZERO(ret)) {
ob->stats.domain = current_object->stats.domain;
return;
}
if (ret->type != T_STRING)
error("'domain_file' in the master object must return a string!\n");
domain_name = ret->u.string;
if (strcmp(current_object->stats.domain->name, domain_name) == 0) {
ob->stats.domain = current_object->stats.domain;
return;
}
if (strcmp(backbone_domain->name, domain_name) == 0) {
/*
* The object is loaded from backbone. We give domain ownership to
* the creator rather than backbone.
*/
ob->stats.domain = current_object->stats.domain;
return;
}
/*
* The object isn't loaded from backbone or from the same domain as the
* creator, so we need to lookup the domain, and add it if it isnt
* present.
*/
ob->stats.domain = add_stat_entry(domain_name, &domains);
return;
}
