static int RemoveHashFunction( struct FunctionDefinition *fdPtr) { struct FunctionHash *fhPtr, *lastPtr = NULL; int hashValue; hashValue = HashSymbol(ValueToString(fdPtr->callFunctionName),SIZE_FUNCTION_HASH); for (fhPtr = FunctionHashtable[hashValue]; fhPtr != NULL; fhPtr = fhPtr->next) { if (fhPtr->fdPtr == fdPtr) { if (lastPtr == NULL) { FunctionHashtable[hashValue] = fhPtr->next; } else { lastPtr->next = fhPtr->next; } rtn_struct(FunctionHash,fhPtr); return(TRUE); } lastPtr = fhPtr; } return(FALSE); }
static int RemoveHashFunction( void *theEnv, struct FunctionDefinition *fdPtr) { struct FunctionHash *fhPtr, *lastPtr = NULL; unsigned hashValue; hashValue = HashSymbol(ValueToString(fdPtr->callFunctionName),SIZE_FUNCTION_HASH); for (fhPtr = ExternalFunctionData(theEnv)->FunctionHashtable[hashValue]; fhPtr != NULL; fhPtr = fhPtr->next) { if (fhPtr->fdPtr == fdPtr) { if (lastPtr == NULL) { ExternalFunctionData(theEnv)->FunctionHashtable[hashValue] = fhPtr->next; } else { lastPtr->next = fhPtr->next; } rtn_struct(theEnv,FunctionHash,fhPtr); return(TRUE); } lastPtr = fhPtr; } return(FALSE); }
int HashFact( struct fact *theFact) { int count = 0; int hashValue; /*============================================*/ /* Get a hash value for the deftemplate name. */ /*============================================*/ count += HashSymbol(ValueToString(theFact->whichDeftemplate->header.name), SIZE_FACT_HASH); /*=================================================*/ /* Add in the hash value for the rest of the fact. */ /*=================================================*/ count += (int) HashMultifield(&theFact->theProposition,SIZE_FACT_HASH); /*================================*/ /* Make sure the hash value falls */ /* in the appropriate range. */ /*================================*/ hashValue = (int) (count % SIZE_FACT_HASH); if (hashValue < 0) hashValue = - hashValue; /*========================*/ /* Return the hash value. */ /*========================*/ return(hashValue); }
static void AddHashFunction( struct FunctionDefinition *fdPtr) { struct FunctionHash *newhash, *temp; int hashValue; if (FunctionHashtable == NULL) InitializeFunctionHashTable(); newhash = get_struct(FunctionHash); newhash->fdPtr = fdPtr; hashValue = HashSymbol(fdPtr->callFunctionName->contents,SIZE_FUNCTION_HASH); temp = FunctionHashtable[hashValue]; FunctionHashtable[hashValue] = newhash; newhash->next = temp; }
static void AddHashFunction( void *theEnv, struct FunctionDefinition *fdPtr) { struct FunctionHash *newhash, *temp; unsigned hashValue; if (ExternalFunctionData(theEnv)->FunctionHashtable == NULL) InitializeFunctionHashTable(theEnv); newhash = get_struct(theEnv,FunctionHash); newhash->fdPtr = fdPtr; hashValue = HashSymbol(fdPtr->callFunctionName->contents,SIZE_FUNCTION_HASH); temp = ExternalFunctionData(theEnv)->FunctionHashtable[hashValue]; ExternalFunctionData(theEnv)->FunctionHashtable[hashValue] = newhash; newhash->next = temp; }
SYMBOL * StoreSymbol(SYMBOL *NewSym,char *string) { SYMBOL *Sym = FreeSymbol(); char *ThisName; // Location of PTR to name int StringLen; int entry; StringLen = strlen(string) + 1; // Get length of string // if there was not Symbol space quit if (Sym == NULL) return NULL; // if there was no name space quit ThisName = (char *) NewPtr((int) StringLen); // Copy the name to the NamesList memcpy(ThisName,string,StringLen); memcpy(Sym,NewSym,sizeof(SYMBOL)); // Set the Symbol data ptr Sym->Name = ThisName; Sym->Len = StringLen-1; Sym->Flags = 0; // Add symbol to hash table #ifdef USE_HASHING entry = HashSymbol(Sym->Name, Sym->LocalScope, Sym->Section); BucketArrayAdd(&SymbolHash, entry, (int) Sym); #endif // Carry forward the names pointer return Sym; }
globle int ItemHashValue( int theType, void *theValue, int theRange) { switch(theType) { case FLOAT: return(HashFloat(ValueToDouble(theValue),theRange)); case INTEGER: return(HashInteger(ValueToLong(theValue),theRange)); case SYMBOL: case STRING: #if OBJECT_SYSTEM case INSTANCE_NAME: #endif return(HashSymbol(ValueToString(theValue),theRange)); case MULTIFIELD: return(HashMultifield((struct multifield *) theValue,theRange)); #if DEFTEMPLATE_CONSTRUCT case FACT_ADDRESS: return(HashFact((struct fact *) theValue) % theRange); #endif case EXTERNAL_ADDRESS: #if OBJECT_SYSTEM case INSTANCE_ADDRESS: #endif return(((int) theValue) % theRange); default: SystemError("UTILITY",1); return(-1L); } return(-1L); }
globle struct FunctionDefinition *FindFunction( char *functionName) { struct FunctionHash *fhPtr; int hashValue; SYMBOL_HN *findValue; hashValue = HashSymbol(functionName,SIZE_FUNCTION_HASH); findValue = (SYMBOL_HN *) FindSymbol(functionName); for (fhPtr = FunctionHashtable[hashValue]; fhPtr != NULL; fhPtr = fhPtr->next) { if (fhPtr->fdPtr->callFunctionName == findValue) { return(fhPtr->fdPtr); } } return(NULL); }
SYMBOL * FindSymbols(char *string,int sectionStart,int sectionEnd, int scope) { SYMBOL *Sym; int elem, entry; int len; len = strlen(string); entry = HashSymbol(string, scope, sectionStart); elem = -1; while(1) { elem = BucketArraySearch(&SymbolHash, entry, elem, (uint*) &Sym); if (Sym == 0) return NULL; if (elem == -1) return NULL; if ( (Sym->LocalScope == scope) && (Sym->Len == len) && (Sym->Section != 0) && (Sym->Section >= sectionStart) && (Sym->Section <= sectionEnd) && (strcmp(string,Sym->Name) == 0) ) { // LastSymCount = n; return Sym; } if (elem == 0) return NULL; } return NULL; }
globle struct FunctionDefinition *FindFunction( void *theEnv, const char *functionName) { struct FunctionHash *fhPtr; unsigned hashValue; SYMBOL_HN *findValue; if (ExternalFunctionData(theEnv)->FunctionHashtable == NULL) return(NULL); hashValue = HashSymbol(functionName,SIZE_FUNCTION_HASH); findValue = (SYMBOL_HN *) FindSymbolHN(theEnv,functionName); for (fhPtr = ExternalFunctionData(theEnv)->FunctionHashtable[hashValue]; fhPtr != NULL; fhPtr = fhPtr->next) { if (fhPtr->fdPtr->callFunctionName == findValue) { return(fhPtr->fdPtr); } } return(NULL); }
globle unsigned long HashMultifield( struct multifield *theSegment, unsigned long theRange) { unsigned long length, i; unsigned long tvalue; unsigned long count; struct field *fieldPtr; union { double fv; void *vv; unsigned long liv; } fis; /*================================================*/ /* Initialize variables for computing hash value. */ /*================================================*/ count = 0; length = theSegment->multifieldLength; fieldPtr = theSegment->theFields; /*====================================================*/ /* Loop through each value in the multifield, compute */ /* its hash value, and add it to the running total. */ /*====================================================*/ for (i = 0; i < length; i++) { switch(fieldPtr[i].type) { case MULTIFIELD: count += HashMultifield((struct multifield *) fieldPtr[i].value,theRange); break; case FLOAT: fis.liv = 0; fis.fv = ValueToDouble(fieldPtr[i].value); count += (fis.liv * (i + 29)) + (unsigned long) ValueToDouble(fieldPtr[i].value); break; case INTEGER: count += (((unsigned long) ValueToLong(fieldPtr[i].value)) * (i + 29)) + ((unsigned long) ValueToLong(fieldPtr[i].value)); break; case FACT_ADDRESS: #if OBJECT_SYSTEM case INSTANCE_ADDRESS: #endif fis.liv = 0; fis.vv = fieldPtr[i].value; count += (unsigned long) (fis.liv * (i + 29)); break; case EXTERNAL_ADDRESS: fis.liv = 0; fis.vv = ValueToExternalAddress(fieldPtr[i].value); count += (unsigned long) (fis.liv * (i + 29)); break; case SYMBOL: case STRING: #if OBJECT_SYSTEM case INSTANCE_NAME: #endif tvalue = (unsigned long) HashSymbol(ValueToString(fieldPtr[i].value),theRange); count += (unsigned long) (tvalue * (i + 29)); break; } } /*========================*/ /* Return the hash value. */ /*========================*/ return(count); }