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