hashCode.c

/*
 * hashCode.c : Implementation to get int value from a node
 * Part of the compiler project for LSD10 language
 * Gaudry Stéphane
 * More information on http://www.gaudry.be/langages-table-des-symboles.html
 * **********************************************************
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if(VERBOSE_LEVEL<=DEB_E)
	#include <errno.h>
#endif
#include "common.h"
 
/*
 * **********************************************************
 * Internal business declarations
 * **********************************************************
 */
 
int maxVal = -1;
 
/*
 * **********************************************************
 * Internal business
 * **********************************************************
 */
void checkMaxVal(char *file, int line)
{
	if(maxVal==-1)
	{
		#if(VERBOSE_LEVEL<=DEB_E)
		{
			printMsg(DEB_E,"Upper boundary undefined, you must call \"setHashUpperBoundary\" before", file, line);
			printMsg(DEB_E, (char *)strerror(errno), file, line);
		}
		#endif
		//Failure of the compiler behavior, independent of the parsed code
		exit(EXIT_FAILURE);
	}
}
 
/*
 * **********************************************************
 * Internal business hashcode algorithms alternatives
 * **********************************************************
 */
 
int getDragonHash(const char *cle)
{
//	printf("\n;  Compute hash for %s (%s,%d)", cle, __FILE__, __LINE__);
	const char *ptr = cle;
	int val = 0;
	while(*ptr!='\0')
	{
		int tmp;
		val = (val<<4)+(*ptr);
		if(tmp = (val & 0xF0000000))
		{
			val = val ^ (tmp >>24);
			val = val ^ tmp;
		}
		ptr++;
	}
//	printf("\n;  Hash for %s = %d(%s,%d)", cle, val, __FILE__ ,__LINE__);
	return val;//%maxVal; don't use % because this is an internal function and the % is called once on the result
}
unsigned long getBernsteinHash(unsigned char *str)
{
	unsigned long hash = 5381;
	while(*str!='\0')
	{
		int c = *str;
		hash = (hash << 5 ) + c;
		str++;
	}
	return hash;
}
//unsigned int getDJBHash(const char *str)
//{
//	unsigned int hash = 5381; // DJB Hash
//	const char *s;
//	for (s = str; *s; s++) {
//		hash = ((hash << 5) + hash) + tolower(*s);
//	}
//	return (hash & 0x7FFFFFFF)%maxVal;
//}
 
/*
 * **********************************************************
 * Implementation of the header exposed items
 * See hashCode.h for these functions comments
 * **********************************************************
 */
void setHashUpperBoundary(int _maxVal)
{
	if(_maxVal==-1)
	{
		#if(VERBOSE_LEVEL<=DEB_E)
		{
			printMsg(DEB_E,"Upper boundary must be > 0", __FILE__, __LINE__);
			printMsg(DEB_E, (char *)strerror(errno), __FILE__, __LINE__);
		}
		#endif
		//Failure of the compiler behavior, independent of the parsed code
		exit(EXIT_FAILURE);
	}
	maxVal = _maxVal;
}
int getHashCode(char *identifier)
{
	checkMaxVal(__FILE__, __LINE__);
	return getDragonHash(identifier)%maxVal;
}
int getASTHashCode(AstNode *astNodePtr)
{
	checkMaxVal(__FILE__, __LINE__);
	int hash =  getDragonHash(astNodePtr->info->name);
	switch(astNodePtr->type)
	{
		/* functions overloading is not allowed for LSD010
		 * ref: LSD010_7.2.6
		 * otherwise, we may use something like that:
		 * for each argument, add the int value of the argument type
		 * astNodePtr =
		 * fctHash +=  astNodePtr->info->type;
		 */
 
		/*
		 * The only one allowed case of same names is the set of {function, var} for {declarationNode, existingNode}
		 * ref: LSD010_7.2.5
		 * Thus, adding 1 to the result produces different hash for vars and functions
		 */
		case NODE_TYPE_FUNCTION:
		case NODE_TYPE_FUNCTION_CALL:
			hash+=1;
			break;
	}
	#if(VERBOSE_LEVEL<=DEB_SYM)
		printf(
			"\n;Hash for %s=%d[final %d] (compiler %s, %d)",
			astNodePtr->info->name,
			hash,
			(hash<0)?(maxVal-hash)%maxVal:hash%maxVal,
			__FILE__,
			__LINE__
			);
	#endif
	if(hash<0)
	{
		hash=maxVal-hash;
	}
	return hash%maxVal;
}