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