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; }