//------------------------------Insert--------------------------------------- // Insert or replace a key/value pair in the given dictionary. If the // dictionary is too full, it's size is doubled. The prior value being // replaced is returned (NULL if this is a 1st insertion of that key). If // an old value is found, it's swapped with the prior key-value pair on the // list. This moves a commonly searched-for value towards the list head. void *Dict::Insert(void *key, void *val) { uint hash = _hash( key ); // Get hash key uint i = hash & (_size-1); // Get hash key, corrected for size bucket *b = &_bin[i]; // Handy shortcut for( uint j=0; j<b->_cnt; j++ ) if( !_cmp(key,b->_keyvals[j+j]) ) { void *prior = b->_keyvals[j+j+1]; b->_keyvals[j+j ] = key; // Insert current key-value b->_keyvals[j+j+1] = val; return prior; // Return prior } if( ++_cnt > _size ) { // Hash table is full doubhash(); // Grow whole table if too full i = hash & (_size-1); // Rehash b = &_bin[i]; // Handy shortcut } if( b->_cnt == b->_max ) { // Must grow bucket? if( !b->_keyvals ) { b->_max = 2; // Initial bucket size b->_keyvals = (void**)_arena->Amalloc_4(sizeof(void*) * b->_max * 2); } else { b->_keyvals = (void**)_arena->Arealloc(b->_keyvals, sizeof(void*) * b->_max * 2, sizeof(void*) * b->_max * 4); b->_max <<= 1; // Double bucket } } b->_keyvals[b->_cnt+b->_cnt ] = key; b->_keyvals[b->_cnt+b->_cnt+1] = val; b->_cnt++; return NULL; // Nothing found prior }
BSONObjExternalSorter::Data BSONObjExternalSorter::Iterator::next(){ if ( _in ){ Data& d = *_it; ++_it; return d; } Data best; int slot = -1; for ( unsigned i=0; i<_stash.size(); i++ ){ if ( ! _stash[i].second ){ if ( _files[i]->more() ) _stash[i] = pair<Data,bool>( _files[i]->next() , true ); else continue; } if ( slot == -1 || _cmp( best , _stash[i].first ) == 0 ){ best = _stash[i].first; slot = i; } } assert( slot >= 0 ); _stash[slot].second = false; return best; }
bool ProxyData::operator == (const ProxyData &d) const { if (Type.value != d.Type.value) return false; if (Type.value == PROXY_NONE) return true; if ((Port.value != d.Port.value) && !_cmp(Host.ptr, d.Host.ptr)) return false; if (Type.value == PROXY_SOCKS4) return true; if (Auth.bValue != d.Auth.bValue) return false; if (!d.Auth.bValue) return true; return _cmp(User.ptr, d.User.ptr) && _cmp(Password.ptr, d.Password.ptr); }
bool ProxyData::operator == (const ProxyData &d) const { if (Type != d.Type) return false; if (Type == PROXY_NONE) return true; if ((Port != d.Port) && !_cmp(Host, d.Host)) return false; if (Type == PROXY_SOCKS4) return true; if (Auth != d.Auth) return false; if (d.Auth == 0) return true; return _cmp(User, d.User) && _cmp(Password, d.Password); }
//------------------------------FindDict------------------------------------- // Find a key-value pair in the given dictionary. If not found, return NULL. // If found, move key-value pair towards head of list. void *Dict::operator [](const void *key) const { uint i = _hash( key ) & (_size-1); // Get hash key, corrected for size bucket *b = &_bin[i]; // Handy shortcut for( uint j=0; j<b->_cnt; j++ ) if( !_cmp(key,b->_keyvals[j+j]) ) return b->_keyvals[j+j+1]; return NULL; }
void YahooClient::processStatus(unsigned short service, const char *id, const char *_state, const char *_msg, const char *_away, const char *_idle) { Contact *contact; YahooUserData *data = findContact(id, NULL, contact); if (data == NULL) return; unsigned state = 0; unsigned away = 0; unsigned idle = 0; if (_state) state = atol(_state); if (_away) away = atol(_away); if (_idle) idle = atol(_idle); if (service == YAHOO_SERVICE_LOGOFF) state = YAHOO_STATUS_OFFLINE; if ((state != data->Status.value) || ((state == YAHOO_STATUS_CUSTOM) && (((away != 0) != data->bAway.bValue) || _cmp(_msg, data->AwayMessage.ptr)))) { unsigned long old_status = STATUS_UNKNOWN; unsigned style = 0; const char *statusIcon = NULL; contactInfo(data, old_status, style, statusIcon); time_t now; time(&now); now -= idle; if (data->Status.value == YAHOO_STATUS_OFFLINE) data->OnlineTime.value = now; data->Status.value = state; data->bAway.bValue = (away != 0); data->StatusTime.value = now; unsigned long new_status = STATUS_UNKNOWN; contactInfo(data, old_status, style, statusIcon); if (old_status != new_status) { StatusMessage m; m.setContact(contact->id()); m.setClient(dataName(data).c_str()); m.setFlags(MESSAGE_RECEIVED); m.setStatus(STATUS_OFFLINE); Event e(EventMessageReceived, &m); e.process(); if ((new_status == STATUS_ONLINE) && !contact->getIgnore()) { Event e(EventContactOnline, contact); e.process(); } } else { Event e(EventContactStatus, contact); e.process(); } } }
bool CL_GenericBTreeNode::Search (CL_VoidPtr itm, short& index) const { if (!_item) return FALSE; long i; short result; if (_keyCount <= 7) { // Small number of keys, do a linear search if (_keyCount == 0) { index = -1; return FALSE; } for (i = 0; i < _keyCount; i++) { result = _cmp (_item[i], itm); if (result >= 0) break; } if (result == 0) { index = i; return TRUE; } else { index = i-1; return FALSE; } } // Do a binary search long lo = 0, hi = _keyCount-1, mid; while (lo <= hi) { mid = (lo + hi)/2; result = _cmp (_item[mid], itm); if (result == 0) { index = mid; return TRUE; } if (result < 0) lo = mid+1; else hi = mid-1; } index = (result <= 0) ? (mid) : mid-1; return FALSE; }
NOINLINE const char* CmdLineArgs::GetArg( const char* id ) const { typedef char** iterator; for ( iterator it = argv, end = it+argc; it!=end; ++it ) { if ( const char* arg = _cmp( *it, id ) ) return arg; } return nullptr; }
//------------------------------Delete--------------------------------------- // Find & remove a value from dictionary. Return old value. void *Dict::Delete(void *key) { uint i = _hash( key ) & (_size-1); // Get hash key, corrected for size bucket *b = &_bin[i]; // Handy shortcut for( uint j=0; j<b->_cnt; j++ ) if( !_cmp(key,b->_keyvals[j+j]) ) { void *prior = b->_keyvals[j+j+1]; b->_cnt--; // Remove key/value from lo bucket b->_keyvals[j+j ] = b->_keyvals[b->_cnt+b->_cnt ]; b->_keyvals[j+j+1] = b->_keyvals[b->_cnt+b->_cnt+1]; _cnt--; // One less thing in table return prior; } return NULL; }
void DreamGenContext::printchar(const Frame *charSet, uint16* x, uint16 y, uint8 c, uint8 nextChar, uint8 *width, uint8 *height) { if (c == 255) return; push(si); push(di); if (data.byte(kForeignrelease) != 0) y -= 3; uint16 tmp = c - 32 + data.word(kCharshift); showframe(charSet, *x, y, tmp & 0x1ff, (tmp >> 8) & 0xfe, width, height); di = pop(); si = pop(); _cmp(data.byte(kKerning), 0); if (flags.z()) *width = kernchars(c, nextChar, *width); (*x) += *width; }
void DreamGenContext::dosreturn() { _cmp(data.byte(kCommandtype), 250); if (!flags.z()) { data.byte(kCommandtype) = 250; al = 46; commandonly(); } ax = data.word(kMousebutton); _and(ax, 1); if (flags.z()) return; data.word(kMousebutton) = 0; engine->quit(); }
bool BSONIteratorSorted::ElementFieldCmp::operator()(const char* s1, const char* s2) const { // Skip the type byte and compare field names. return _cmp(s1 + 1, s2 + 1); }
static void _verify_get(void) { if (!_cmp(_get, ONES)) { exit(-1); } }
void VMDriver::execute(){ if( this->m_state == STATE_IDLE ){ printf( "Error: state is idle. \n"); return; } assert( this->currentAssembly() ); while( this->isActive() ){ if( this->isBreak() ){ break; } unsigned char content = this->getByte( m_funcAddr , m_pc ); m_pc++; switch( content ){ case EMnemonic::MovPtr : _mov_ptr(); break; case EMnemonic::Mov : _mov(); break; case EMnemonic::Add : _add(); break; case EMnemonic::Sub : _sub(); break; case EMnemonic::Mul : _mul(); break; case EMnemonic::Div : _div(); break; case EMnemonic::Rem : _rem(); break; case EMnemonic::Inc : _inc(); break; case EMnemonic::Dec : _dec(); break; case EMnemonic::Push : _push(); break; case EMnemonic::PushPtr : _push_ptr(); break; case EMnemonic::Pop : _pop(); break; case EMnemonic::Call : _call(); break; case EMnemonic::ST : _st(); break; case EMnemonic::LD : _ld(); break; case EMnemonic::EndFunc : _endFunc(); break; case EMnemonic::CmpGeq : case EMnemonic::CmpG : case EMnemonic::CmpLeq : case EMnemonic::CmpL : case EMnemonic::CmpEq : case EMnemonic::CmpNEq : _cmp( content ); break; case EMnemonic::Not : _not(); break; case EMnemonic::Minus : _minus(); break; case EMnemonic::LogOr : case EMnemonic::LogAnd : _log( content ); break; case EMnemonic::Jmp : _jmp(); break; case EMnemonic::JumpZero : _jumpzero(); break; case EMnemonic::JumpNotZero : _jumpnotzero(); break; case EMnemonic::RET : _ret(); break; } } }