static void objRemove(void **objReturn, objectTable table, void *logObj, size_t size) { Bool found; Res ires; void *obj; void *end; void *logEnd; found = TableLookup(&obj, table->startTable, (Word)logObj); if (found) { ires = TableRemove(table->startTable, (Word)logObj); verify(ires == ResOK); if (table->endTable != NULL) { ires = TableRemove(table->endTable, (Word)PointerAdd(logObj, size)); verify(ires == ResOK); } *objReturn = obj; return; } /* Must be a truncation. */ verify(table->endTable != NULL); logEnd = PointerAdd(logObj, size); found = TableLookup(&end, table->endTable, (Word)logEnd); verify(found); obj = PointerSub(end, size); /* Remove the old end and insert the new one. */ ires = TableRemove(table->endTable, (Word)logEnd); verify(ires == ResOK); ires = TableDefine(table->endTable, (Word)logObj, obj); verify(ires == ResOK); *objReturn = obj; return; }
//------------------------------------------------------------------------------ void CPlateThermistor::ReadTemp() { digitalWrite(SLAVESELECT, LOW); //read data while(digitalRead(m_pin_plate_thermistor)) {} uint8_t spiBuf[4]; memset(spiBuf, 0, sizeof(spiBuf)); digitalWrite(SLAVESELECT, LOW); for(int i = 0; i < 4; i++) spiBuf[i] = SPITransfer(0xFF); unsigned long conv = (((unsigned long)spiBuf[3] >> 7) & 0x01) + ((unsigned long)spiBuf[2] << 1) + ((unsigned long)spiBuf[1] << 9) + (((unsigned long)spiBuf[0] & 0x1F) << 17); //((spiBuf[0] & 0x1F) << 16) + (spiBuf[1] << 8) + spiBuf[2]; unsigned long adcDivisor = 0x1FFFFF; float voltage = (float)conv * 5.0 / adcDivisor; //unsigned int convHigh = (conv >> 16); digitalWrite(SLAVESELECT, HIGH); unsigned long voltage_mv = voltage * 1000; unsigned long resistance = voltage_mv * 22000 / (5000 - voltage_mv); // in hecto ohms iTemp = TableLookup(PLATE_RESISTANCE_TABLE, sizeof(PLATE_RESISTANCE_TABLE) / sizeof(PLATE_RESISTANCE_TABLE[0]),-40, resistance); }
static piXping * piFindXping ( PEER peer, const char * nick1, const char * nick2 ) { piXping xpingMatch; PEER_CONNECTION; assert(nick1); assert(nick1[0]); assert(piGetPlayer(peer, nick1)); assert(nick2); assert(nick2[0]); assert(piGetPlayer(peer, nick2)); // Setup the xping match. ///////////////////////// strzcpy(xpingMatch.nicks[0], nick1, PI_NICK_MAX_LEN); _strlwr(xpingMatch.nicks[0]); strzcpy(xpingMatch.nicks[1], nick2, PI_NICK_MAX_LEN); _strlwr(xpingMatch.nicks[0]); // Find the xping. ////////////////// return (piXping *)TableLookup(connection->xpings, &xpingMatch); }
static void piCleanseGlobalCacheMap ( void * elem, void * clientData ) { piPlayer * player; int roomType; piCacheKey * cacheKey = (piCacheKey *)elem; PEER peer = (PEER)clientData; piConnection * connection = (piConnection *)peer; piWatchKey watchKeyTemp; watchKeyTemp.key = cacheKey->key; player = piGetPlayer(peer, cacheKey->nick); if(player) { for(roomType = 0 ; roomType < NumRooms ; roomType++) { if(player->inRoom[roomType]) { if(TableLookup(connection->globalWatchKeys[roomType], &watchKeyTemp)) return; } } } TableRemove(connection->globalWatchCache, cacheKey); }
static const unsigned short * piGetWatchKeyW ( const unsigned short * nick, const unsigned short * key, HashTable watchCache ) { #ifndef GSI_UNICODE GSI_UNUSED(nick); GSI_UNUSED(key); GSI_UNUSED(watchCache); return NULL; // can't use this function unless in GSI_UNICODE mode #else piCacheKey keyTemp; piCacheKey * cacheKey; char* nick_A = UCS2ToUTF8StringAlloc(nick); char* key_A = UCS2ToUTF8StringAlloc(key); keyTemp.nick = (char *)nick_A; keyTemp.key = (char *)key_A; cacheKey = (piCacheKey *)TableLookup(watchCache, &keyTemp); gsifree(nick_A); gsifree(key_A); if (!cacheKey) return NULL; if(cacheKey->value_W) return cacheKey->value_W; return L""; #endif }
//------------------------------------------------------------------------------ void CLidThermistor::ReadTemp() { unsigned long voltage_mv = (unsigned long)analogRead(m_pin_lid_thermistor) * 5000 / 1024; unsigned long resistance = voltage_mv * 2200 / (5000 - voltage_mv); iTemp = TableLookup(LID_RESISTANCE_TABLE, sizeof(LID_RESISTANCE_TABLE) / sizeof(LID_RESISTANCE_TABLE[0]), 0, resistance); }
static void printAddr(ulongest_t addr, const char *ident) { ulongest_t label; void *alias; printf("%s:%0*" PRIXLONGEST, ident, hexWordWidth, addr); if (TableLookup(&alias, labelTable, addr)) { label = *(ulongest_t*)alias; putchar('['); if (TableLookup(&alias, internTable, label)) printStr((char *)alias); else printf("unknown label %" PRIuLONGEST, label); putchar(']'); } putchar(' '); }
TableLookup Variant::toTableLookup(void) const { const TableLookupVariantData* data = mData->toTableLookupVariant(); if (data) return data->mData; return TableLookup(); }
static bucket_t *DoFind(bucketset_t set, char *name) { bucket_t tbucket; if (set == NULL) set = g_buckets; assert(set); tbucket.name = name; return (bucket_t *)TableLookup(set->buckets,&tbucket); }
const char *SBServerGetStringValueA(SBServer server, const char *keyname, const char *def) { SBKeyValuePair kv, *ptr; // 11-03-2004 : Saad Nader // Check if we are getting a valid server // before doing anything! /////////////////////////////////////////// assert(server); if (!server) return NULL; kv.key = keyname; ptr = (SBKeyValuePair *)TableLookup(server->keyvals, &kv); if (ptr == NULL) return def; return ptr->value; }
const unsigned short *SBServerGetStringValueW(SBServer server, const unsigned short *keyname, const unsigned short *def) { char* keyname_A = UCS2ToUTF8StringAlloc(keyname); const char* value = SBServerGetStringValueA(server, keyname_A, NULL); if (value == NULL) return def; else { // Since we need the unicode version, we have to dig down to the // reference counted string structure SBRefString ref, *val; ref.str = value; val = (SBRefString *)TableLookup(SBRefStrHash(NULL), &ref); if (val == NULL) return def; // this shouldn't happen return val->str_W; } }
static const char * piGetWatchKeyA ( const char * nick, const char * key, HashTable watchCache ) { piCacheKey keyTemp; piCacheKey * cacheKey; keyTemp.nick = (char *)nick; keyTemp.key = (char *)key; cacheKey = (piCacheKey *)TableLookup(watchCache, &keyTemp); if(!cacheKey) return NULL; if(cacheKey->value) return cacheKey->value; return ""; }
static piXping * piAddXping ( PEER peer, const char * nick1, const char * nick2 ) { piXping xpingMatch; piXping * xping; PEER_CONNECTION; assert(nick1); assert(nick1[0]); assert(piGetPlayer(peer, nick1)); assert(nick2); assert(nick2[0]); assert(piGetPlayer(peer, nick2)); // Setup the one to add. //////////////////////// xping = &xpingMatch; strzcpy(xping->nicks[0], nick1, PI_NICK_MAX_LEN); _strlwr(xping->nicks[0]); strzcpy(xping->nicks[1], nick2, PI_NICK_MAX_LEN); _strlwr(xping->nicks[1]); // Add it. ////////// TableEnter(connection->xpings, xping); // Get it. ////////// xping = (piXping *)TableLookup(connection->xpings, &xpingMatch); // Return it. ///////////// return xping; }
const unsigned short *SBServerGetTeamStringValueW(SBServer server, int teamnum, const unsigned short *key, const unsigned short *sdefault) { char keyname_A[UKEY_LENGTH_MAX]; char default_A[UKEY_LENGTH_MAX]; const char* value_A = NULL; UCS2ToUTF8String(key, keyname_A); UCS2ToUTF8String(sdefault, default_A); value_A = SBServerGetTeamStringValueA(server, teamnum, keyname_A, default_A); if (value_A == NULL) return sdefault; else { // Since we need the unicode version, we have to dig down to the SBRefString structure SBRefString ref, *val; ref.str = value_A; val = (SBRefString *)TableLookup(SBRefStrHash(NULL), &ref); if (val == NULL) return sdefault; return val->str_W; } }
static void piCleanseRoomCacheMap ( void * elem, void * clientData ) { piPlayer * player; piCacheKey * cacheKey = (piCacheKey *)elem; piCleanseRoomCacheMapData * data = (piCleanseRoomCacheMapData *)clientData; piConnection * connection = (piConnection *)data->peer; piWatchKey watchKeyTemp; watchKeyTemp.key = cacheKey->key; player = piGetPlayer(data->peer, cacheKey->nick); if(player && player->inRoom[data->roomType]) { if(TableLookup(connection->roomWatchKeys[data->roomType], &watchKeyTemp)) return; } TableRemove(connection->globalWatchCache, cacheKey); }
static PEERBool piKeyChanged ( PEER peer, const char * nick, const char * key, const char * value, HashTable watchKeys, HashTable watchCache, PEERBool inRoom, RoomType roomType ) { piWatchKey watchKeyTemp; piCacheKey cacheKey; assert(key && key[0]); // We don't track anything for rooms. ///////////////////////////////////// if(!nick || !nick[0]) return PEERTrue; // No NULL values. ////////////////// if(!value) value = ""; // Is this a username (IP and Profile ID)? ////////////////////////////////////////// if(strcasecmp(key, "username") == 0) { piPlayer * player; if(strcmp(nick, "(END)") == 0) { // // If <nick> is "(END)", this is the final message from // a GETCKEYS list. Call straight into the PlayerInfo // callback with zeroed arguments (09mar01/bgw). // assert(inRoom); piAddPlayerInfoCallback(peer, roomType, NULL, 0, 0); return PEERFalse; } // Get the player. ////////////////// player = piGetPlayer(peer, nick); if(player && !player->gotIPAndProfileID) { int profileID; unsigned int IP; // Get the info. //////////////// if(piDemangleUser(value, &IP, &profileID)) { // Cache the info. ////////////////// piSetPlayerIPAndProfileID(peer, nick, IP, profileID); } } // If this was in a room, call the callback. //////////////////////////////////////////// if(inRoom) { if(player && player->gotIPAndProfileID) piAddPlayerInfoCallback(peer, roomType, nick, player->IP, player->profileID); else piAddPlayerInfoCallback(peer, roomType, nick, 0, 0); } } // Is this flags? ///////////////// if(inRoom && strcasecmp(key, "b_flags") == 0) piSetPlayerRoomFlags(peer, nick, roomType, value); // Check if this is a watch key. //////////////////////////////// watchKeyTemp.key = (char *)key; if(!TableLookup(watchKeys, &watchKeyTemp)) { // Is it a broadcast key? ///////////////////////// if(inRoom && (strncmp(key, "b_", 2) == 0)) return PEERTrue; return PEERFalse; } // Cache it. //////////// memset(&cacheKey, 0, sizeof(piCacheKey)); cacheKey.nick = goastrdup(nick); cacheKey.key = goastrdup(key); cacheKey.value = goastrdup(value); #ifdef GSI_UNICODE cacheKey.value_W = UTF8ToUCS2StringAlloc(cacheKey.value); #endif TableEnter(watchCache, &cacheKey); return PEERTrue; }
static void piKeyCacheRefresh ( PEER peer, RoomType roomType, const char * nick ) { int num; piSetupKeysMapData data; PEERBool getIP; PEERBool getFlags; piWatchKey watchKey; PEER_CONNECTION; assert(IN_ROOM || ENTERING_ROOM); if(!IN_ROOM && !ENTERING_ROOM) return; // Get the IP if we're pinging this room. ///////////////////////////////////////// if(!nick) getIP = (connection->pingRoom[roomType] || connection->alwaysRequestPlayerInfo)?PEERTrue:PEERFalse; else getIP = PEERFalse; // Check if we're already getting the IP. ///////////////////////////////////////// if(getIP) { watchKey.key = "username"; getIP = (PEERBool)(!TableLookup(connection->roomWatchKeys[roomType], &watchKey)); } // Don't get flags on a player - he just joined, and will set them. /////////////////////////////////////////////////////////////////// getFlags = (PEERBool)(nick == NULL); // Check for a b_flags watch key. ///////////////////////////////// if(getFlags) { watchKey.key = "b_flags"; getFlags = (PEERBool)(!(TableLookup(connection->globalWatchKeys[roomType], &watchKey) || TableLookup(connection->roomWatchKeys[roomType], &watchKey))); } data.next = 0; num = TableCount(connection->globalWatchKeys[roomType]); if(num) { data.keys = (char **)gsimalloc(sizeof(char *) * num); if(!data.keys) return; TableMap(connection->globalWatchKeys[roomType], piSetupKeysMap, &data); assert(data.next == num); chatGetGlobalKeysA(connection->chat, nick?nick:ROOM, num, (const char **)data.keys, piGetGlobalKeysCallback, peer, CHATFalse); gsifree(data.keys); } if(!nick) { data.next = 0; num = TableCount(connection->roomWatchKeys[roomType]); if(getIP) num++; if(getFlags) num++; if(num) { data.keys = (char **)gsimalloc(sizeof(char *) * num); if(!data.keys) return; TableMap(connection->roomWatchKeys[roomType], piSetupKeysMap, &data); if(getIP) data.keys[data.next++] = "username"; if(getFlags) data.keys[data.next++] = "b_flags"; assert(data.next == num); chatGetChannelKeysA(connection->chat, ROOM, nick?nick:"*", num, (const char **)data.keys, piGetRoomKeysCallback, peer, CHATFalse); gsifree(data.keys); } } }
/* poolRecreate -- create and record a pool */ static void poolRecreate(void *logPool, void *logArena, mps_class_t class, poolSupport support, int bufferClassLevel, ...) { va_list args; mps_pool_t pool; mps_res_t eres; poolRep rep; Res ires; void *entry; Bool found; found = TableLookup(&entry, arenaTable, (Word)logArena); verify(found); va_start(args, bufferClassLevel); eres = mps_pool_create_v(&pool, (mps_arena_t)entry, class, args); verifyMPS(eres); va_end(args); rep = malloc(sizeof(poolRepStruct)); verify(rep != NULL); rep->pool = pool; rep->objects = objectTableCreate(support); rep->bufferClassLevel = bufferClassLevel; ires = TableDefine(poolTable, (Word)logPool, (void *)rep); verify(ires == ResOK); }