void load(uint32 offset) {
byte *item = getData(offset);
id = offset;
// Only save the hashes instead of the full names
bgFilename1 = calcHash(getStringP(READ_LE_UINT32(item + 0)));
bgFilename2 = calcHash(getStringP(READ_LE_UINT32(item + 4)));
txFilename = calcHash(getStringP(READ_LE_UINT32(item + 8)));
bgFilename3 = calcHash(getStringP(READ_LE_UINT32(item + 12)));
xPosIndex = item[16];
count = item[17];
}
STATIC bool calcHMac(const SecureStorageS *storage, unsigned char *caData) {
unsigned char tmpHash[SHA256_LEN], hash[SHA256_LEN];
int16_t len = 0;
int16_t secretLen = 0;
if (storage == NULL) {
assert(LIB_NAME "Storage structure must not be NULL" && (false || Storage_TestMode));
return false;
}
memset(hash, 0, SHA256_LEN);
calcHash(storage, hash);
if (SECURE_DEBUG) {
Utils_PrintHexStr(stderr, "Base hash:", hash, SHA256_LEN);
}
Utils_GetCharArrayLen(storage->caSalt, &len, MIN_SALT_LEN, KEY_VAL_MAX_STR_LEN);
if (Utils_GetCharArrayLen(storage->caSecret, &secretLen, KEY_VAL_MIN_STR_LEN, KEY_VAL_MAX_STR_LEN) == false) {
return false;
}
if (Crypto_CalcHmac(&(storage->caSecret[UTILS_STR_LEN_SIZE]), secretLen, storage->caSalt, len + UTILS_STR_LEN_SIZE, tmpHash) == false)
return false;
calcHashXor(hash, tmpHash, SHA256_LEN);
memcpy(caData + UTILS_STR_LEN_SIZE, hash, SHA256_LEN);
Utils_SetCharArrayLen(caData, SHA256_LEN);
caData[SIGN_LEN] = 0;
return true;
}
int arrayAtIdentityHashInPairs(PyrObject *array, PyrSlot *key)
{
PyrSlot *slots, *test;
unsigned int i, start, end, hash, maxHash;
hash = calcHash(key);
maxHash = array->size >> 1;
start = (hash % maxHash) << 1;
end = array->size;
slots = array->slots;
for (i=start; i<end; i+=2) {
test = slots + i;
if (IsNil(test) || (test->utag == key->utag && test->ui == key->ui)) {
return i;
}
}
end = start - 2;
for (i=0; i<=end; i+=2) {
test = slots + i;
if (IsNil(test) || (test->utag == key->utag && test->ui == key->ui)) {
return i;
}
}
return -2;
}
Palette::Palette(NeverhoodEngine *vm, const char *filename) : Entity(vm, 0) {
PaletteResource paletteResource(_vm);
init();
paletteResource.load(calcHash(filename));
paletteResource.copyPalette(_palette);
SetUpdateHandler(&Palette::update);
}
void AsScene1308JaggyDoor::stCloseDoor() {
startAnimation(0xBA0AE050, -1, -1);
_playBackwards = true;
setVisible(true);
playSound(0, calcHash("fxDoorClose38"));
NextState(&AsScene1308JaggyDoor::stCloseDoorDone);
}
void AsScene2101Door::stCloseDoor() {
startAnimation(0xC222A8D4, 0, -1);
_newStickFrameIndex = STICK_LAST_FRAME;
setVisible(true);
playSound(0, calcHash("fxDoorClose32"));
NextState(&AsScene2101Door::stCloseDoorDone);
}
long find(float * const &vertex, const unsigned int &size, float * const &vertices, unsigned int * const &hashes, const unsigned int &count) {
const unsigned int hash = calcHash(vertex, size);
for (unsigned int i = 0; i < count; i++)
if (hashes[i] == hash && compare(&vertices[i*size], vertex, size))
return (long)i;
return -1;
}
void insert(IntHashMap* m, int32_t value, u_int64_t count)
{
u_int32_t hash = calcHash(m->module, value);
u_int32_t c;
u_int32_t h = hash;
for(c = 0; c < m->maxDups; c++, h += m->module)
{
if(m->hash2count[h] == 0)
{
if(c == 0)
{
m->idx2hash[m->numPlaces] = hash;
m->numPlaces++;
}
m->numEntries++;
m->hash2value[h] = value;
}
if(m->hash2value[h] == value)
{
m->hash2count[h] += count;
return;
}
}
int x = 3;
int y = 0;
printf("%d\n", x/y);
err(-1, "No more places left to store inserted value %d with hash %d!\n", value, hash);
}
StringValue *StringTable::lookup(const char *s, size_t length)
{
const hash_t hash = calcHash(s, length);
const size_t i = findSlot(hash, s, length);
// printf("lookup %.*s %p\n", (int)length, s, table[i].value ?: NULL);
return getValue(table[i].vptr);
}
QString BD::calcHash(QString nomeImagem) const
{
QImage imagem(nomeImagem);
if (imagem.isNull())
return QString();
else
return calcHash(imagem);
}
void insertFile(char name[], struct linknode **hashTable)
{
int hash;
char init;
init = name[0];
hash = calcHash(init);
hashTable[hash] = insertNode(hashTable[hash], name);
}
void deleteFile(char name[], struct linknode **hashTable)
{
int hash;
char init;
init = name[0];
hash = calcHash(init);
hashTable[hash] = deleteNode(hashTable[hash], name);
}
StringEntry *StringEntry::alloc(const char *s, size_t len)
{
StringEntry *se;
se = (StringEntry *) mem.calloc(1,sizeof(StringEntry) + len + 1);
se->value.ctor(s, len);
se->hash = calcHash(s,len);
return se;
}
static void run() {
int lineN;
scanf("%d", &lineN);
for (int line = 0; line < lineN; ++line) {
int command;
int parentId, childId, elementId;
int height, width;
int hash, resultHash;
Element element;
scanf("%d", &command);
switch (command) {
case INIT:
scanf("%d", &expected);
init();
break;
case CREATE:
scanf("%d %d", &elementId, &(element.type));
readElement(&element);
id[elementId] = create(&element);
break;
case ADD:
scanf("%d %d", &parentId, &childId);
add(id[parentId], id[childId]);
break;
case SHOW:
scanf("%d %d %d %d", &elementId, &height, &width, &hash);
show(id[elementId], screen);
resultHash = calcHash(screen, height, width);
#if 0
printf ("Expected W %d H %d\n", width, height);
for (int y = 0; y < height; ++y)
{
for (int x = 0; x < width; ++x)
printf("%c", screen[y][x]);
printf("\n");
}
#endif
if (resultHash == hash)
{
point++;
// printf ("%d \n", point);
}
else
{
printf("FAILED %d %d\n", hash, resultHash);
exit (0);
return;
}
break;
}
}
}
uint Utils::calcHash(const QString &str)
{
if(str.isNull()) // handle null string as "", prevents crash
return calcHash("");
const char *s = str.ascii();
uint hash = 5381;
int c;
while((c = *s++)) hash = ((hash << 5) + hash) + c; // hash*33 + c
return hash;
}
unsigned int DocumentSource::hash() const
{
if (!d->calculatedHash)
{
d->hash = calcHash(d->array);
d->calculatedHash = true;
}
return d->hash;
}
int prEvent_IsRest(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *dictslots = slotRawObject(g->sp)->slots;
PyrSlot *arraySlot = dictslots + ivxIdentDict_array;
if (isKindOfSlot(arraySlot, class_array)) {
PyrSlot key, typeSlot;
static PyrSymbol *s_type = getsym("type");
static PyrSymbol *s_rest = getsym("rest");
PyrSymbol *typeSym;
// test 'this[\type] == \rest' first
SetSymbol(&key, s_type);
identDict_lookup(slotRawObject(g->sp), &key, calcHash(&key), &typeSlot);
if(!slotSymbolVal(&typeSlot, &typeSym) && typeSym == s_rest) {
SetBool(g->sp, 1);
return errNone;
} else {
PyrObject *array = slotRawObject(arraySlot);
PyrSymbol *slotSym;
static PyrSymbol *s_empty = getsym("");
static PyrSymbol *s_r = getsym("r");
static PyrClass *class_rest = getsym("Rest")->u.classobj;
static PyrClass *class_metarest = getsym("Meta_Rest")->u.classobj;
PyrSlot *slot;
int32 size = array->size;
int32 i;
slot = array->slots + 1; // scan only the odd items
for (i = 1; i < size; i += 2, slot += 2) {
if (isKindOfSlot(slot, class_rest)
|| isKindOfSlot(slot, class_metarest)
) {
SetBool(g->sp, 1);
return errNone;
} else if(!slotSymbolVal(slot, &slotSym)) {
if(slotSym == s_empty
|| slotSym == s_r
|| slotSym == s_rest
) {
SetBool(g->sp, 1);
return errNone;
}
} // why no 'else'?
// slotSymbolVal nonzero return = not a symbol;
// non-symbols don't indicate rests, so, ignore them.
}
}
} else {
return errWrongType;
}
SetBool(g->sp, 0);
return errNone;
}
void AsScene2402Door::update() {
if (_isOpen && _countdown != 0 && (--_countdown) == 0) {
_isOpen = false;
setVisible(true);
startAnimation(0x80495831, -1, -1);
_playBackwards = true;
playSound(0, calcHash("fxDoorClose38"));
NextState(&AsScene2402Door::stDoorClosingFinished);
}
AnimatedSprite::update();
}
void AsScene2401Door::update() {
if (_isOpen && _countdown != 0 && (--_countdown) == 0) {
_isOpen = false;
setVisible(true);
startAnimation(0x44687810, -1, -1);
_newStickFrameIndex = 0;
_playBackwards = true;
playSound(0, calcHash("fxDoorClose38"));
}
AnimatedSprite::update();
}
inline Hvl calcHash(C const * theCs)
{
WatchError
Hvl tHvl = 0;
while(*theCs)
{
tHvl = mixHash(tHvl, calcHash(*theCs));
++theCs;
}
return tHvl;
CatchError
}
void clear()
{
for(auto i : myElements) delete i;
myElements.clear();
// myMeta.clear();
myTemp = 294.15; // Kelvins = 21c
myPressure = 101325; // pascals
myVolume = 0;
myGeneratedFlag = false;
mySeenFlag = false;
myCachedHash = calcHash();
}
int prEvent_Delta(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a, key, dur, stretch, delta;
double fdur, fstretch;
int err;
a = g->sp; // dict
SetSymbol(&key, s_delta);
identDict_lookup(slotRawObject(a), &key, calcHash(&key), &delta);
if (NotNil(&delta)) {
slotCopy(a,&delta);
} else {
SetSymbol(&key, s_dur);
identDict_lookup(slotRawObject(a), &key, calcHash(&key), &dur);
err = slotDoubleVal(&dur, &fdur);
if (err) {
if (NotNil(&dur)) return err;
SetNil(a);
return errNone;
}
SetSymbol(&key, s_stretch);
identDict_lookup(slotRawObject(a), &key, calcHash(&key), &stretch);
err = slotDoubleVal(&stretch, &fstretch);
if (err) {
if (NotNil(&stretch)) return err;
SetFloat(a, fdur);
return errNone;
}
SetFloat(a, fdur * fstretch );
}
return errNone;
}
void load(uint32 offset) {
byte *item = getData(offset);
id = offset;
// Only save the hashes instead of the full names
bgFilename = calcHash(getStringP(READ_LE_UINT32(item + 0)));
class437Filename = calcHash(getStringP(READ_LE_UINT32(item + 4)));
dataResourceFilename = calcHash(getStringP(READ_LE_UINT32(item + 8)));
pointListName = calcHash(getStringP(READ_LE_UINT32(item + 12)));
rectListName = calcHash(getStringP(READ_LE_UINT32(item + 16)));
exPaletteFilename2 = calcHash(getStringP(READ_LE_UINT32(item + 20)));
exPaletteFilename1 = calcHash(getStringP(READ_LE_UINT32(item + 24)));
mouseCursorFilename = calcHash(getStringP(READ_LE_UINT32(item + 28)));
which1 = READ_LE_UINT16(item + 32);
which2 = READ_LE_UINT16(item + 34);
}
void Particles::Update()
{
assert(initFlag);
float *dPos;
dPos = (float *)mapGLBufferObject(&m_cuda_posvbo_resource);
setParameters(&mparams);
integrateSystem(dPos, velGpu, mparams.timeStep, numParticles);
calcHash(gridParticleHash, gridParticleIndex,dPos,numParticles);
sortParticles(gridParticleHash,gridParticleIndex,numParticles);
reorderDataAndFindCellStart(cellStart,cellEnd,sortedPos,sortedVel,gridParticleHash,gridParticleIndex,dPos,velGpu,numParticles,mparams.wholeNumCells);
simFluid(velGpu, sortedPos, sortedVel, gridParticleIndex, cellStart, cellEnd, numParticles, solidPosGpu, solidVelGpu, buoyancyGpu, buoyancyAngGpu);
unmapGLBufferObject(m_cuda_posvbo_resource);
}
u_int64_t get(IntHashMap* m, int32_t value)
{
u_int32_t c;
u_int32_t h = calcHash(m->module, value);
for(c = 0; c < m->maxDups; c++, h+= m->module)
{
if(m->hash2count[h] == 0)
return 0;
if(m->hash2value[h] == value)
return m->hash2count[h];
}
return 0;
}
void Worm::move(const WormPart& destiny, const bool& moveHead){
if(moveHead){
if(--posHead < 0) {
posHead = length -1;
}
wormparts[posHead] = destiny;
} else{
wormparts[posHead] = destiny;
posHead++;
posHead %= length;
}
calcHash();
}
int prEvent_IsRest(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *dictslots = slotRawObject(g->sp)->slots;
PyrSlot *arraySlot = dictslots + ivxIdentDict_array;
static int isRestCount = 0;
if (!isKindOfSlot(arraySlot, class_array)) {
return errWrongType;
}
PyrSlot key, typeSlot;
PyrSymbol *typeSym;
// easy tests first: 'this[\type] == \rest'
SetSymbol(&key, s_type);
identDict_lookup(slotRawObject(g->sp), &key, calcHash(&key), &typeSlot);
if(!slotSymbolVal(&typeSlot, &typeSym) && typeSym == s_rest) {
SetBool(g->sp, 1);
return errNone;
}
// and, 'this[\isRest] == true'
SetSymbol(&key, s_isRest);
identDict_lookup(slotRawObject(g->sp), &key, calcHash(&key), &typeSlot);
if(IsTrue(&typeSlot)) {
if (isRestCount == 0)
post("\nWARNING: Setting isRest to true in an event is deprecated. See the Rest helpfile for supported ways to specify rests.\n\n");
isRestCount = (isRestCount + 1) % 100;
SetBool(g->sp, 1);
return errNone;
}
// failing those, scan slot values for something rest-like
PyrObject *array = slotRawObject(arraySlot);
SetBool(g->sp, dictHasRestlikeValue(array) ? 1 : 0);
return errNone;
}
StringValue *StringTable::insert(const char *s, size_t length)
{
const hash_t hash = calcHash(s, length);
size_t i = findSlot(hash, s, length);
if (table[i].vptr)
return NULL; // already in table
if (++count > tabledim * loadFactor)
{
grow();
i = findSlot(hash, s, length);
}
table[i].hash = hash;
table[i].vptr = allocValue(s, length);
// printf("insert %.*s %p\n", (int)length, s, table[i].value ?: NULL);
return getValue(table[i].vptr);
}
StringValue *StringTable::update(const char *s, size_t length)
{
const hash_t hash = calcHash(s, length);
size_t i = findSlot(hash, s, length);
if (!table[i].vptr)
{
if (++count > tabledim * loadFactor)
{
grow();
i = findSlot(hash, s, length);
}
table[i].hash = hash;
table[i].vptr = allocValue(s, length);
}
// printf("update %.*s %p\n", (int)length, s, table[i].value ?: NULL);
return getValue(table[i].vptr);
}
void StringID::construct(T const& name)
{
assert(StringIDUtil<T>::size(name) <= STRING_SIZE);
UINT32 hash = calcHash(name) & (sizeof(mStringHashTable) / sizeof(mStringHashTable[0]) - 1);
InternalData* existingEntry = mStringHashTable[hash];
while (existingEntry != nullptr)
{
if (StringIDUtil<T>::compare(name, existingEntry->chars))
{
mData = existingEntry;
return;
}
existingEntry = existingEntry->next;
}
ScopedSpinLock lock(mSync);
// Search for the value again in case other thread just added it
existingEntry = mStringHashTable[hash];
InternalData* lastEntry = nullptr;
while (existingEntry != nullptr)
{
if (StringIDUtil<T>::compare(name, existingEntry->chars))
{
mData = existingEntry;
return;
}
lastEntry = existingEntry;
existingEntry = existingEntry->next;
}
mData = allocEntry();
StringIDUtil<T>::copy(name, mData->chars);
if (lastEntry == nullptr)
mStringHashTable[hash] = mData;
else
lastEntry->next = mData;
}
