int main(int argc, char *argv[]) {
HashTable ht = newHashTable(65535);
HashTable_put(ht, "1", "two");
HashTable_put(ht, "2", "three");
HashTable_put(ht, "3", "five");
HashTable_put(ht, "4", "seven");
HashTable_put(ht, "5", "eleven");
HashTable_put(ht, "6", "thirteen");
HashTable_put(ht, "7", "seventeen");
HashTable_remove(ht, "1");
HashTable_remove(ht, "2");
HashTable_remove(ht, "6");
HashTable_remove(ht, "7");
HashTable_put(ht, "3", "not allowed");
printf("%s\n", HashTable_get(ht, "1"));
printf("%s\n", HashTable_get(ht, "2"));
printf("%s\n", HashTable_get(ht, "3"));
printf("%s\n", HashTable_get(ht, "4"));
printf("%s\n", HashTable_get(ht, "5"));
printf("%s\n", HashTable_get(ht, "6"));
printf("%s\n", HashTable_get(ht, "7"));
printf("size: %d\n", HashTable_size(ht));
freeHashTable(&ht);
return 0;
}
int main(int argc, char **argv)
{
int i;
struct Hashtable hash_table;
//Allocate memory for a new hash table
newHashTable(&hash_table, HASHTABLE_LENGTH);
printf("New hash table containing no values\n");
//Print the hash table containing no values
for(i=0;i<HASHTABLE_LENGTH;i++){
print_ll(&(hash_table.table[i]));
}
putchar('\n');
//Insert several values into the hash table
insert(&hash_table, "Hello World");
insert(&hash_table, "Hello World");
insert(&hash_table, "Hel World");
insert(&hash_table, "GoodBye");
insert(&hash_table, "GoodBye");
insert(&hash_table, "wangbang");
insert(&hash_table, "Holachola");
insert(&hash_table, "antidis");
printf("Test values inserted printing full hash_table...\n");
//Print the list again
for(i=0;i<HASHTABLE_LENGTH;i++){
print_ll(&(hash_table.table[i]));
}
//Deallocate memory
freeHashTable(&hash_table);
}
void test_phase4(void){
struct pptoken *token;
struct list *source;
struct list *p1;
struct list *p2;
struct list *p3;
struct list *p4;
struct hash_table *macros;
//source = sourceCharsFromFile("tests/trigraphs.c");
//source = sourceCharsFromFile("tests/doubledefine.c");
//source = sourceCharsFromFile("tests/recursivedefine.c");
source = sourceCharsFromFile("tests/functionmacro.c");
p1 = phase1(source);
p2 = phase2(p1);
p3 = phase3(p2);
macros = newHashTable();
assert(macros != NULL);
p4 = phase4(macros, p3);
while(listDequeue(p4, (void**)&token) == 0){
fputs(token->whiteSpace, stdout);
if(token->name != PPTN_EOF){
putchar('{');
printf("\033[35m");
fputs(token->lexeme, stdout);
printf("\033[39m");
putchar('}');
} else {
break;
}
}
}
int main(void){
//initialize stuff
init_zobrist();
srand(time(NULL));
//create a new board
Board_t* goal = newBoard();
//create a new visited cache
HashTable_t* visited = newHashTable(32);
//create a cloned state of the board and scrable it
Board_t* scrabled = cloneBoard(goal);
scramble_times(scrabled, TIMES_TO_SCRAMBLE);
printf("Starting search...\n");
SearchNode_t* root = newSearchNode(scrabled, 0, NULL);
SearchNode_t* result = idf_search(root, goal, visited, 30);
//print out the search
if(result!=NULL){
printf("Search Path:\n");
printSearchNode(result);
}
else
printf("Search failed.\n");
//clean up
deleteSearchNode(root, visited);
assert(TOTAL_SEARCH_NODES==0);
assert(TOTAL_HASH_NODES==0);
deleteHashTable(visited);
deleteBoard(goal);
return 0;
}
vector<ListNode*> rehashing(vector<ListNode*> hashTable) {
int cap = hashTable.size();
vector<ListNode*> newHashTable(cap * 2);
map<int, ListNode*> tailMapper;
for (int i = 0; i < cap; i ++) {
if (hashTable[i] != NULL) {
ListNode *cur = hashTable[i];
while (cur) {
int code = hash(cur->val, cap * 2);
ListNode *newNode = new ListNode(cur->val);
if (newHashTable[code]) {
tailMapper[code]->next = newNode;
} else {
newHashTable[code] = newNode;
}
tailMapper[code] = newNode;
cur = cur->next;
}
}
}
return newHashTable;
}
void test_phase4(void){
struct phase1 p1;
struct phase2 p2;
struct phase3 p3;
struct phase4 p4;
struct pptoken token;
//p1.sourceFile = fopen("phase3.c", "r");
//p1.sourceFile = fopen("tests/defines.c", "r");
p1.sourceFile = fopen("tests/define.c", "r");
phase1Init(&p1);
p2.p1 = &p1;
phase2Init(&p2);
p3.p2 = &p2;
phase3Init(&p3);
p4.p3 = &p3;
p4.symbolTable = newHashTable();
phase4Init(&p4);
token = phase4NextToken(&p4);
while(token.name != PPTN_EOF){
printf("%s", token.whiteSpace);
printf("%s", token.lexeme);
token = phase4NextToken(&p4);
}
}
/**************************************************************************
* public functions
**************************************************************************/
int
initPreload (preloadConfig_t *preloadConfig, rodsEnv *myPreloadRodsEnv, rodsArguments_t *myPreloadRodsArgs) {
rodsLog (LOG_DEBUG, "initPreload: MyPreloadConfig.preload = %d", preloadConfig->preload);
rodsLog (LOG_DEBUG, "initPreload: MyPreloadConfig.clearCache = %d", preloadConfig->clearCache);
rodsLog (LOG_DEBUG, "initPreload: MyPreloadConfig.cachePath = %s", preloadConfig->cachePath);
rodsLog (LOG_DEBUG, "initPreload: MyPreloadConfig.cacheMaxSize = %lld", preloadConfig->cacheMaxSize);
rodsLog (LOG_DEBUG, "initPreload: MyPreloadConfig.preloadMinSize = %lld", preloadConfig->preloadMinSize);
rodsLog (LOG_DEBUG, "initPreload: empty space = %lld", getEmptypSpace(preloadConfig->cachePath));
// copy given configuration
memcpy(&PreloadConfig, preloadConfig, sizeof(preloadConfig_t));
PreloadRodsEnv = myPreloadRodsEnv;
PreloadRodsArgs = myPreloadRodsArgs;
// init hashtables
PreloadThreadTable = newHashTable(NUM_PRELOAD_THREAD_HASH_SLOT);
PreloadFileHandleTable = newHashTable(NUM_PRELOAD_FILEHANDLE_HASH_SLOT);
// init lists
PreloadThreadList = newConcurrentList();
// init lock
INIT_LOCK(PreloadLock);
_preparePreloadCacheDir(preloadConfig->cachePath);
if(preloadConfig->clearCache) {
// clear all cache
_removeAllCaches();
} else {
// remove incomplete preload caches
_removeAllIncompleteCaches();
}
return (0);
}
int main() {
int capacity = 11, i;
HashTablePtr t = newHashTable(capacity, hashInt, compare);
HashNodePtr node;
putIntoHashTable(t, 1, 1);
putIntoHashTable(t, 2, 2);
putIntoHashTable(t, 3, 3);
putIntoHashTable(t, 4, 4);
putIntoHashTable(t, 5, 5);
printHashTable(t);
for(i = 0; i <= 5; i++) {
HashNodePtr node = getFromHashTable(t, i);
if(node) {
printf("key %d values %d\n", node->key, node->value);
} else {
printf("cann't find key %d\n", i);
}
}
for(i = 11; i <= 16; i++) {
HashNodePtr node = getFromHashTable(t, i);
if(node) {
printf("key %d values %d\n", node->key, node->value);
} else {
printf("cann't find key %d\n", i);
}
}
removeFromHashTable(t, 2);
removeFromHashTable(t, 3);
printHashTable(t);
putIntoHashTable(t, 2, 2);
putIntoHashTable(t, 13, 13);
putIntoHashTable(t, 24, 24);
printHashTable(t);
removeFromHashTable(t, 2);
printHashTable(t);
node = getFromHashTable(t, 13);
printf("key %d values %d\n", node->key, node->value);
node = getFromHashTable(t, 24);
printf("key %d values %d\n", node->key, node->value);
putIntoHashTable(t, 35, 35);
printHashTable(t);
freeHashTable(t);
return 0;
}
void
hTabAddItemLong (hTab ** htab, int key, void *pkey, void *item)
{
hashtItem *htip;
hashtItem *last;
if (!(*htab))
*htab = newHashTable (DEFAULT_HTAB_SIZE);
if (key > (*htab)->size)
{
int i;
(*htab)->table = Safe_realloc ((*htab)->table,
(key * 2 + 2) * sizeof (hashtItem *));
for (i = (*htab)->size + 1; i <= (key * 2 + 1); i++)
(*htab)->table[i] = NULL;
(*htab)->size = key * 2 + 1;
}
/* update the key */
if ((*htab)->maxKey < key)
(*htab)->maxKey = key;
if ((*htab)->minKey > key)
(*htab)->minKey = key;
/* create the item */
htip = _newHashtItem (key, pkey, item);
/* if there is a clash then goto end of chain */
if ((last = (*htab)->table[key]))
{
while (last->next)
last = last->next;
last->next = htip;
}
else
/* else just add it */
(*htab)->table[key] = htip;
(*htab)->nItems++;
}
void
rehash(HashTable* h)
{
if (h->outOfMemory==0) {
HashTable* h2 = newHashTable(h->size+h->incrementSize);
HashElement *e,*l;
unsigned long sz,hash,i=0;
if (h2==NULL) {
h->outOfMemory=1;
} else {
sz=h2->size;
// make increment of new table same as old
h2->incrementSize=h->incrementSize;
while (i<h->size) {
l = h->hashArray[i]; // get list from old hash table
h->hashArray[i]=NULL;
while (l!=NULL) { // process every entry from old list
e = l; // process first list element
l = l->next; // get the tail of the list
// hash value for entry to be processed
hash = ((unsigned long) e->value) % sz;
e->next = h2->hashArray[hash]; // append entries to new list
h2->hashArray[hash]=e; // set list in new hash table
}
i++;
}
// swap old and new hash table (to keep pointers to old table valid!)
l=(HashElement*) h->hashArray;
// move new hashArray to old hashTable
h->hashArray = h2->hashArray;
// set temporary hashTable to old hashArray
h2->hashArray= (HashElement**)l;
h2->size = h->size; // set temporary hashTable size to old size
h->size = sz; // set hash table size to new size
h->rehashAt = h->size-(h->size/10); // set new rehash size: 90%
// get rid of temporary table, now holding old hashArray
freeHashTable(h2);
}
}
}
/*-----------------------------------------------------------------*/
hTab *
hTabFromTable (hTab * htab)
{
hTab *nhtab;
hashtItem *htip;
int key;
if (!htab)
return NULL;
nhtab = newHashTable (htab->size);
for (key = htab->minKey; key <= htab->maxKey; key++)
{
for (htip = htab->table[key]; htip; htip = htip->next)
hTabAddItem (&nhtab, htip->key, htip->item);
}
return nhtab;
}
void initMe(void)
{
symbolTable = newHashTable(SYMBOL_TABLE_SIZE);
}
/*
* Restore a Cache struct from buf into a malloc'd buffer.
* This function returns NULL if failed to acquire or release the mutex.
* It first create a local copy of buf's data section and pointer pointers section. This part needs synchronization.
* Then it works on its local copy, which does not need synchronization.
*/
Cache *restoreCache( const char* _inst_name ) {
mutex_type *mutex;
lockReadMutex(_inst_name, &mutex);
unsigned char *buf = prepareNonServerSharedMemory( _inst_name );
if (buf == NULL) {
return NULL;
}
Cache *cache = ( Cache * ) buf;
unsigned char *bufCopy;
unsigned char *pointers;
size_t pointersSize;
unsigned char *bufMapped;
unsigned char *pointersCopy;
unsigned char *pointersMapped;
size_t dataSize;
dataSize = cache->dataSize;
bufCopy = ( unsigned char * )malloc( dataSize );
if ( bufCopy == NULL ) {
rodsLog( LOG_ERROR, "Cannot allocate object buffer of size %lld" , dataSize);
unlockReadMutex(_inst_name, &mutex);
return NULL;
}
memcpy( bufCopy, buf, cache->dataSize );
Cache *cacheCopy = ( Cache * ) bufCopy;
pointersMapped = cacheCopy->pointers;
bufMapped = cacheCopy->address;
pointersSize = bufMapped + SHMMAX - pointersMapped;
pointersCopy = ( unsigned char * )malloc( pointersSize );
if ( pointersCopy == NULL ) {
free( bufCopy );
rodsLog( LOG_ERROR, "Cannot allocate pointer pointer buffer of size %lld", pointersSize);
detachSharedMemory( _inst_name );
unlockReadMutex(_inst_name, &mutex);
return NULL;
}
memcpy( pointersCopy, pointersMapped + ( buf - bufMapped ), pointersSize );
detachSharedMemory( _inst_name );
unlockReadMutex(_inst_name, &mutex);
pointers = pointersCopy;
/* bufCopy = (unsigned char *)malloc(cache->dataSize);
if(bufCopy == NULL) {
return NULL;
}
memcpy(bufCopy, buf, cache->dataSize);
bufMapped = cache->address;
long diffBuf = buf - bufMapped;
pointers = cache->pointers + diffBuf;
pointersSize = pointers - buf; */
long diff = bufCopy - bufMapped;
long pointerDiff = diff;
applyDiff( pointers, pointersSize, diff, pointerDiff );
free( pointersCopy );
#ifdef RE_CACHE_CHECK
Hashtable *objectMap = newHashTable( 100 );
cacheChkEnv( cacheCopy->coreFuncDescIndex, cacheCopy, ( CacheChkFuncType * ) cacheChkNode, objectMap );
cacheChkRuleSet( cacheCopy->coreRuleSet, cacheCopy, objectMap );
#endif
return cacheCopy;
}
/* Copy the data stored in a Cache struct into a continuously allocated memory block in *p.
* All sub structure status are either uninitialized or compressed, which meaning that they are not allocated separately and therefore should not be deallocated.
* Only coreRuleSet and coreFuncDescIndex are copied.
* Starting from *p+size backwards, a list of pointers to pointers in the copied data structures are stored.
* There pointers are used to quickly access all pointers in the stored data structures so that they can be offset when they are copied to a new memory address.
* This function returns NULL if it runs out of memory allocated between in *p and *p+size.
* The rule engine status is also set to uninitialized. */
Cache *copyCache( unsigned char **p, size_t size, Cache *ptr ) {
/* size should be large enough and divisible by ALIGNMENT */
if (size < DEFAULT_BLOCK_SIZE || 0 != size % REGION_ALIGNMENT) {
return NULL;
}
unsigned char *buf = *p;
unsigned char *pointers0 = buf + size;
/* shared objects */
unsigned char **pointers = &pointers0;
int generatePtrDesc = 1;
allocateInBuffer( Cache, ecopy, ptr );
MK_POINTER( &( ecopy->address ) );
MK_POINTER( &( ecopy->pointers ) );
// objectMap will use a hash table size that is twice the number of objects being held (to favor speed).
// Example: The shared memory region has a size of SHMMAX (see shared_memory.hpp). SHMMAX == 30000000.
// The upper bound of the passed-in size is the shared memory region size.
// With an average compiled object size of 75 bytes (taken over sample of 9000 lines of rule code), SHMMAX / 75 = 400000 objects.
// The maximum size of the hash table should be twice the objects that can fit in shared memory (400000 * 2 = 800000).
// The ratio of the shared memory region size to the maximum hash table size is 30000000 / 800000 = 37.5
// Since the calculations are based on an average size, the ratio is rounded to 40 to avoid imbuing too much significance.
// The size of the hash table for a cache of the passed-in size, then, should be the size of the cache divided by the ratio.
// hashtable size upper limit == cache size upper limit / 40 == 30000000 / 40 < 800000
const int SHMEM_TO_MAX_HASHTABLE_SIZE_RATIO{40};
Hashtable *objectMap = newHashTable(size / SHMEM_TO_MAX_HASHTABLE_SIZE_RATIO);
MK_PTR( RuleSet, coreRuleSet );
ecopy->coreRuleSetStatus = COMPRESSED;
ecopy->appRuleSet = NULL;
ecopy->appRuleSetStatus = UNINITIALIZED;
ecopy->extRuleSet = NULL;
ecopy->extRuleSetStatus = UNINITIALIZED;
MK_PTR_TAPP( Env, coreFuncDescIndex, PARAM( Node ) );
ecopy->coreFuncDescIndexStatus = COMPRESSED; /* The coreFuncDescIndex is stored in a continuously allocated memory block in *buf */
ecopy->appFuncDescIndex = NULL;
ecopy->appFuncDescIndexStatus = UNINITIALIZED;
ecopy->extFuncDescIndex = NULL;
ecopy->extFuncDescIndexStatus = UNINITIALIZED;
ecopy->dataSize = ( *p - buf );
ecopy->address = buf;
ecopy->pointers = pointers0;
ecopy->cacheSize = size;
ecopy->cacheStatus = INITIALIZED;
ecopy->appRegion = NULL;
ecopy->appRegionStatus = UNINITIALIZED;
ecopy->coreRegion = NULL;
ecopy->coreRegionStatus = UNINITIALIZED;
ecopy->extRegion = NULL;
ecopy->extRegionStatus = UNINITIALIZED;
ecopy->sysRegion = NULL;
ecopy->sysRegionStatus = UNINITIALIZED;
ecopy->sysFuncDescIndex = NULL;
ecopy->sysFuncDescIndexStatus = UNINITIALIZED;
ecopy->ruleEngineStatus = UNINITIALIZED;
MK_VAR_ARRAY_IN_STRUCT( char, ruleBase );
deleteHashTable( objectMap, nop );
return ecopy;
}
// Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch
int main () {
//Create the hash table we are going to use
HashTable h = newHashTable();
//Open up a dictionary of words to use from the start
FILE * input = fopen("dictionary.txt", "r");
if (input == NULL) return EXIT_FAILURE;
//Malloc some space for the strings we are reading in from the dictionary
char ** temp = malloc(sizeof(char*) * MAX_DICT_SIZE);
int k = 0;
for (k = 0; k < MAX_DICT_SIZE; k++) {
temp[k] = malloc(sizeof(char) * MAX_STRING_LENGTH);
}
//Read in everything from the dictionary
int i = 1;
int j = 0;
temp[j][0] = fgetc(input);
while (temp[j][i-1] != EOF) {
temp[j][i] = fgetc(input);
if (temp[j][i] == '\n') {
temp[j][i] = '\0';
if (hashTableContains(temp[j], h)) {
printf("\nSeen %s\n", temp[j]);
} else {
printf("\nNot seen %s\n", temp[j]);
printf("Adding: %s\n", temp[j]);
put(temp[j], h);
}
assert(hashTableContains(temp[j], h));
i = 0;
j++;
temp[j][0] = fgetc(input);
}
i++;
}
//close the dictionary
fclose(input);
/* TODO: read in some strings from the user using scanf
until they enter an empty string
or until the dictionary is full
*/
//j is each string
//i is each character in a string
while (fgets(temp[j],MAX_STRING_LENGTH,stdin) != NULL && j < MAX_DICT_SIZE) {
//temp[j][i] = *s;
if (temp[j][i] == '\n') {
temp[j][i] = '\0';
if (hashTableContains(temp[j], h)) {
printf("\nSeen %s\n", temp[j]);
} else {
printf("\nNot seen %s\n", temp[j]);
printf("Adding: %s\n", temp[j]);
put(temp[j], h);
}
assert(hashTableContains(temp[j], h));
i = 0;
j++;
//temp[j][0] = *s;
//temp[j][0] = fgets(temp[j][i],MAX_STRING_LENGTH,stdin);
}
i++;
}
/*
tell them if we have ever seen them before
add them to the hash table
*/
//free all the strings we have malloc'ed
for (k=0; k < MAX_DICT_SIZE; k++) {
free(temp[k]);
}
free(temp);
//delete the hash table we used
h = deleteHashTable(h);
//exit
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
char *fname; // name of dictionary file
FILE *wordf; // handle for dictionary file
Item word; // current word from file
int size = 7919; // default size of hash table
HashTable htab; // the hash table
int nwords; // # words read and stored
int nfound; // # words found during search tests
// set up parameters
switch (argc) {
case 2: fname = argv[1]; break;
case 3: fname = argv[1]; size = atoi(argv[2]); break;
default: fname = NULL; usage(argv[0]); break;
}
// access the word file
if (eq(fname,"-")) {
wordf = stdin;
printf("Reading words from stdin\n");
}
else {
wordf = fopen(fname,"r");
if (wordf == NULL) {
printf("Can't open %s\n",fname);
exit(1);
}
printf("Reading words from %s\n",fname);
}
// build hash table, containing all words from file
nwords = 0; nfound = 0;
htab = newHashTable(size);
while ((word = ItemGet(wordf)) != NULL) {
if (eq(word,"")) { dropItem(word); continue; }
HashTableInsert(htab,word);
nwords++;
if (HashTableSearch(htab,word) != NULL)
nfound++;
dropItem(word);
}
// examine hash table
HashTableStats(htab);
// tests
// warning: we are assuming that "!aaaaaa!" etc.
// do not occur in the input; this is not guaranteed
assert(nfound == nwords);
assert(HashTableSearch(htab,"!aaaaaa!") == NULL) ;
assert(HashTableSearch(htab,"!xxxxxx!") == NULL) ;
assert(HashTableSearch(htab,"!yyyyyy!") == NULL) ;
assert(HashTableSearch(htab,"!zzzzzz!") == NULL) ;
printf("Testing completed OK\n");
// clean up
fclose(wordf);
dropHashTable(htab);
return 0;
}
int processXMsg( int streamId, char *readmsg,
RuleEngineEventParam *param, Node *node,
Env *env, ruleExecInfo_t *rei ) {
char myhdr[HEADER_TYPE_LEN];
char mymsg[MAX_NAME_LEN];
char *outStr = NULL;
int i, n;
int iLevel, wCnt;
int ruleInx = 0;
Region *r;
Res *res;
rError_t errmsg;
errmsg.len = 0;
errmsg.errMsg = NULL;
r = make_region( 0, NULL );
ParserContext *context = newParserContext( &errmsg, r );
Pointer *e = newPointer2( readmsg );
int rulegen = 1;
int found;
int grdf[2];
int cmd = 0;
int smallW;
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug:%s", param->actionName );
memset( mymsg, 0, sizeof( mymsg ) );
PARSER_BEGIN( DbgCmd )
TRY( DbgCmd )
TTEXT2( "n", "next" );
cmd = REDEBUG_STEP_OVER;
OR( DbgCmd )
TTEXT2( "s", "step" );
cmd = REDEBUG_NEXT;
OR( DbgCmd )
TTEXT2( "f", "finish" );
cmd = REDEBUG_STEP_OUT;
OR( DbgCmd )
TTEXT2( "b", "break" );
TRY( Param )
TTYPE( TK_TEXT );
int breakPointsInx2;
for ( breakPointsInx2 = 0; breakPointsInx2 < 100; breakPointsInx2++ ) {
if ( breakPoints[breakPointsInx2].actionName == NULL ) {
break;
}
}
if ( breakPointsInx2 == 100 ) {
_writeXMsg( streamId, myhdr, "Maximum breakpoint count reached. Breakpoint not set.\n" );
cmd = REDEBUG_WAIT;
}
else {
breakPoints[breakPointsInx2].actionName = strdup( token->text );
char * base_ptr = NULL;
TRY( loc )
TTYPE( TK_TEXT );
base_ptr = ( char * ) malloc( sizeof( token->text ) + 2 );
base_ptr[0] = 'f';
strcpy( base_ptr + 1, token->text );
TTEXT( ":" );
TTYPE( TK_INT );
breakPoints[breakPointsInx2].base = strdup( base_ptr );
breakPoints[breakPointsInx2].line = atoi( token->text );
rodsLong_t range[2];
char rulesFileName[MAX_NAME_LEN];
getRuleBasePath( base_ptr, rulesFileName );
FILE *file;
/* char errbuf[ERR_MSG_LEN]; */
file = fopen( rulesFileName, "r" );
if ( file == NULL ) {
free( context );
deletePointer( e );
free( base_ptr );
return RULES_FILE_READ_ERROR;
}
Pointer *p = newPointer( file, base_ptr );
if ( getLineRange( p, breakPoints[breakPointsInx2].line, range ) == 0 ) {
breakPoints[breakPointsInx2].start = range[0];
breakPoints[breakPointsInx2].finish = range[1];
}
else {
breakPoints[breakPointsInx2].actionName = NULL;
}
deletePointer( p );
OR( loc )
TTYPE( TK_INT );
if ( node != NULL ) {
breakPoints[breakPointsInx2].base = strdup( node->base );
breakPoints[breakPointsInx2].line = atoi( token->text );
rodsLong_t range[2];
Pointer *p = newPointer2( breakPoints[breakPointsInx2].base );
if ( getLineRange( p, breakPoints[breakPointsInx2].line, range ) == 0 ) {
breakPoints[breakPointsInx2].start = range[0];
breakPoints[breakPointsInx2].finish = range[1];
}
else {
breakPoints[breakPointsInx2].actionName = NULL;
}
deletePointer( p );
}
else {
breakPoints[breakPointsInx2].actionName = NULL;
}
OR( loc )
/* breakPoints[breakPointsInx].base = NULL; */
END_TRY( loc )
free( base_ptr );
if ( breakPoints[breakPointsInx2].actionName != NULL )
snprintf( mymsg, MAX_NAME_LEN, "Breakpoint %i set at %s\n", breakPointsInx2,
breakPoints[breakPointsInx2].actionName );
else {
snprintf( mymsg, MAX_NAME_LEN, "Cannot set breakpoint, source not available\n" );
}
_writeXMsg( streamId, myhdr, mymsg );
if ( breakPointsInx <= breakPointsInx2 ) {
breakPointsInx = breakPointsInx2 + 1;
}
cmd = REDEBUG_WAIT;
}
OR( Param )
NEXT_TOKEN_BASIC;
_writeXMsg( streamId, myhdr, "Unknown parameter type.\n" );
cmd = REDEBUG_WAIT;
OR( Param )
_writeXMsg( streamId, myhdr, "Debugger command \'break\' requires at least one argument.\n" );
cmd = REDEBUG_WAIT;
END_TRY( Param )
OR( DbgCmd )
TRY( Where )
TTEXT2( "w", "where" );
smallW = 1;
OR( Where )
TTEXT2( "W", "Where" );
smallW = 0;
END_TRY( Where )
wCnt = 20;
OPTIONAL_BEGIN( Param )
TTYPE( TK_INT );
wCnt = atoi( token->text );
OPTIONAL_END( Param )
iLevel = 0;
i = reDebugStackCurrPtr - 1;
while ( i >= 0 && wCnt > 0 ) {
if ( !smallW || ( reDebugPCType( ( RuleEngineEvent ) reDebugStackCurr[i].label ) & 1 ) != 0 ) {
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Level %3i", iLevel );
char msg[HEADER_TYPE_LEN - 1];
RuleEngineEventParam param;
param.ruleIndex = 0;
param.actionName = reDebugStackCurr[i].step;
printRuleEngineEventLabel( msg, HEADER_TYPE_LEN - 1, ( RuleEngineEvent ) reDebugStackCurr[i].label, ¶m );
_writeXMsg( streamId, myhdr, msg );
if ( reDebugStackCurr[i].label != EXEC_ACTION_BEGIN ) {
iLevel++;
}
wCnt--;
}
i--;
}
OR( DbgCmd )
TTEXT2( "l", "list" );
TRY( Param )
TTEXT2( "r", "rule" );
TRY( ParamParam )
TTYPE( TK_TEXT );
mymsg[0] = '\n';
mymsg[1] = '\0';
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text );
RuleIndexListNode *node;
found = 0;
while ( findNextRule2( token->text, ruleInx, &node ) != NO_MORE_RULES_ERR ) {
found = 1;
if ( node->secondaryIndex ) {
n = node->condIndex->valIndex->len;
int i;
for ( i = 0; i < n; i++ ) {
Bucket *b = node->condIndex->valIndex->buckets[i];
while ( b != NULL ) {
RuleDesc *rd = getRuleDesc( *( int * )b->value );
char buf[MAX_RULE_LEN];
ruleToString( buf, MAX_RULE_LEN, rd );
snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "%i: %s\n%s\n", node->ruleIndex, rd->node->base[0] == 's' ? "<source>" : rd->node->base + 1, buf );
b = b->next;
}
}
}
else {
RuleDesc *rd = getRuleDesc( node->ruleIndex );
char buf[MAX_RULE_LEN];
ruleToString( buf, MAX_RULE_LEN, rd );
snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "\n %i: %s\n%s\n", node->ruleIndex, rd->node->base[0] == 's' ? "<source>" : rd->node->base + 1, buf );
}
ruleInx ++;
}
if ( !found ) {
snprintf( mymsg, MAX_NAME_LEN, "Rule %s not found\n", token->text );
}
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
OR( ParamParam )
_writeXMsg( streamId, myhdr, "Debugger command \'list rule\' requires one argument.\n" );
cmd = REDEBUG_WAIT;
END_TRY( ParamParam )
OR( Param )
TTEXT2( "b", "breakpoints" );
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text );
mymsg[0] = '\n';
mymsg[1] = '\0';
for ( i = 0; i < breakPointsInx; i++ ) {
if ( breakPoints[i].actionName != NULL ) {
if ( breakPoints[i].base != NULL ) {
snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "Breaking at BreakPoint %i:%s %s:%d\n", i , breakPoints[i].actionName, breakPoints[i].base[0] == 's' ? "<source>" : breakPoints[i].base + 1, breakPoints[i].line );
}
else {
snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "Breaking at BreakPoint %i:%s\n", i , breakPoints[i].actionName );
}
}
}
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
OR( Param )
TTEXT( "*" );
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text );
Env *cenv = env;
mymsg[0] = '\n';
mymsg[1] = '\0';
found = 0;
while ( cenv != NULL ) {
n = cenv->current->size;
for ( i = 0; i < n; i++ ) {
Bucket *b = cenv->current->buckets[i];
while ( b != NULL ) {
if ( b->key[0] == '*' ) { /* skip none * variables */
found = 1;
char typeString[128];
typeToString( ( ( Res * )b->value )->exprType, NULL, typeString, 128 );
snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "%s of type %s\n", b->key, typeString );
}
b = b->next;
}
}
cenv = cenv->previous;
}
if ( !found ) {
snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "<empty>\n" );
}
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
OR( Param )
syncTokenQueue( e, context );
skipWhitespace( e );
ABORT( lookAhead( e, 0 ) != '$' );
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text );
mymsg[0] = '\n';
mymsg[1] = '\0';
Hashtable *vars = newHashTable( 100 );
for ( i = 0; i < coreRuleVarDef .MaxNumOfDVars; i++ ) {
if ( lookupFromHashTable( vars, coreRuleVarDef.varName[i] ) == NULL ) {
snprintf( &mymsg[strlen( mymsg )], MAX_NAME_LEN - strlen( mymsg ), "$%s\n", coreRuleVarDef.varName[i] );
insertIntoHashTable( vars, coreRuleVarDef.varName[i], coreRuleVarDef.varName[i] );
}
}
deleteHashTable( vars, NULL );
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
OR( Param )
NEXT_TOKEN_BASIC;
_writeXMsg( streamId, myhdr, "Unknown parameter type.\n" );
cmd = REDEBUG_WAIT;
OR( Param )
_writeXMsg( streamId, myhdr, "Debugger command \'list\' requires at least one argument.\n" );
cmd = REDEBUG_WAIT;
END_TRY( Param )
OR( DbgCmd )
TTEXT2( "c", "continue" );
cmd = REDEBUG_STEP_CONTINUE;
OR( DbgCmd )
TTEXT2( "C", "Continue" );
cmd = REDEBUG_CONTINUE_VERBOSE;
OR( DbgCmd )
TTEXT2( "del", "delete" );
TRY( Param )
TTYPE( TK_INT );
n = atoi( token->text );
if ( breakPoints[n].actionName != NULL ) {
free( breakPoints[n].actionName );
if ( breakPoints[n].base != NULL ) {
free( breakPoints[n].base );
}
breakPoints[n].actionName = NULL;
breakPoints[n].base = NULL;
snprintf( mymsg, MAX_NAME_LEN, "Breakpoint %i deleted\n", n );
}
else {
snprintf( mymsg, MAX_NAME_LEN, "Breakpoint %i has not been defined\n", n );
}
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
OR( Param )
_writeXMsg( streamId, myhdr, "Debugger command \'delete\' requires one argument.\n" );
cmd = REDEBUG_WAIT;
END_TRY( Param )
OR( DbgCmd )
TTEXT2( "p", "print" );
Node *n = parseTermRuleGen( e, 1, context );
if ( getNodeType( n ) == N_ERROR ) {
errMsgToString( context->errmsg, mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ) );
}
else {
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Printing " );
char * ptr = myhdr + strlen( myhdr );
i = HEADER_TYPE_LEN - 1 - strlen( myhdr );
termToString( &ptr, &i, 0, MIN_PREC, n, 0 );
snprintf( ptr, i, "\n" );
if ( env != NULL ) {
disableReDebugger( grdf );
res = computeNode( n, NULL, regionRegionCpEnv( env, r, ( RegionRegionCopyFuncType * ) regionRegionCpNode ), rei, 0, &errmsg, r );
enableReDebugger( grdf );
outStr = convertResToString( res );
snprintf( mymsg, MAX_NAME_LEN, "%s\n", outStr );
free( outStr );
if ( getNodeType( res ) == N_ERROR ) {
errMsgToString( &errmsg, mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ) );
}
}
else {
snprintf( mymsg, MAX_NAME_LEN, "Runtime environment: <empty>\n" );
}
}
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
OR( DbgCmd )
TTEXT2( "d", "discontinue" );
cmd = REDEBUG_WAIT;
OR( DbgCmd )
snprintf( mymsg, MAX_NAME_LEN, "Unknown Action: %s", readmsg );
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
END_TRY( DbgCmd )
PARSER_END( DbgCmd )
freeRErrorContent( &errmsg );
region_free( r );
deletePointer( e );
free( context );
return cmd;
}
HashTable *newStringHashTable() {
return newHashTable(stringHash, stringEqual);
}
HashTable *newIntHashTable() { return newHashTable(intHash, intEqual); }
