예제 #1
0
int readDictionary(Dictionary *dict) {
	int row, col;
	//---------------CHANGE DICTIONARY HERE!------//
	FILE *ifp = fopen("dictionary.txt", "r");
	//---------------CHANGE DICTIONARY HERE!------//
	
	//use temp_array to figure out strlen()
	char array[MAX_WORD_LENGTH + 1];
	
	fscanf(ifp, "%d", &dict->size);
	
	//malloc() first dimension of words[][]
	dict->words = malloc(sizeof(char *) * (dict->size));
	
	//return 0 if pointer remains NULL after calling malloc()
	if (dict->words == NULL) {
		return 0;
	}
	
	//malloc() second dimension of words[][]
	for (row = 0; row < dict->size; row++) {
		//set array equal to current line of dictionary.txt
		fscanf(ifp, "%s", array);
		
		//malloc() just enough space on current row of dict->words[][]
		dict->words[row] = malloc(sizeof(char) * (strlen(array) + 1));
		
		//return 0 if pointer remains NULL after calling malloc()
		if (dict->words[row] == NULL) {
			destroyDictionary(dict);
			return 0;
		}
		//read in words from array into dict->words
		strcpy(dict->words[row], array);
	}
	
	//malloc() counts[] array
	dict->counts = malloc(sizeof(int) * dict->size);
	
	//clear memory and return 0 if malloc() fails
	if (dict->counts == NULL) {
		destroyDictionary(dict);
		return 0;
	}
	
	//print dictionary
	if (DEBUG) {
		printf("___________DICTIONARY____________\n");
		for (row = 0; row < dict->size; row++) {
				printf("%s\n", dict->words[row]);
		}
		printf("_________________________________\n\n");
	}
	
	fclose(ifp);
	return 1;
}
void test_LZ78_Compression_Variable_mode_given_input_file_sampleText_forCompresssion_2()
{
    InStream *in = initInStream();
    OutStream *out = initOutStream();
    Dictionary *dictionary = initDictionary(100);
    
    in = openInStream("test/support/Source/sampleText_forCompresssion_2.txt", "rb" , in);
    out = openOutStream("test/support/Compressed/Variable/sampleText_forCompresssion_Compressed_Variable_2.txt", "wb" , out);
      
    LZ78_Compressor(dictionary,in,out,Variable);
    
    TEST_ASSERT_EQUAL_STRING("A",dictionary->Entry[0].data);
    TEST_ASSERT_EQUAL_STRING("AA",dictionary->Entry[1].data);
    TEST_ASSERT_EQUAL_STRING("AAA",dictionary->Entry[2].data);
    TEST_ASSERT_EQUAL_STRING("AAA ",dictionary->Entry[3].data);
    TEST_ASSERT_EQUAL_STRING("B",dictionary->Entry[4].data);
    TEST_ASSERT_EQUAL_STRING("BB",dictionary->Entry[5].data);
    TEST_ASSERT_EQUAL_STRING("BBB",dictionary->Entry[6].data);
    TEST_ASSERT_EQUAL_STRING("BBBB",dictionary->Entry[7].data);
    TEST_ASSERT_EQUAL_STRING("C",dictionary->Entry[8].data);
    TEST_ASSERT_EQUAL_STRING("",dictionary->Entry[9].data);
    
    closeInStream(in);
    closeOutStream(out);
    freeInStream(in);
    freeOutStream(out);
    destroyDictionary(dictionary,100);
}
예제 #3
0
 void resetGlobalRegionDictionary() {
    destroyDictionary();
    if ( _registeredObject != NULL ) {
       _object = NEW GlobalRegionDictionary( *_registeredObject );
       _object->setRegisteredObject( _registeredObject );
       NewNewDirectoryEntryData *entry = getDirectoryEntry( *_object, 1 );
       if ( entry == NULL ) {
          entry = NEW NewNewDirectoryEntryData();
          _object->setRegionData( 1, entry ); //resetGlobalRegionDictionary
       }
    }
 }
void test_LZ78_Compression_Variable_mode_given_input_file_libjansson_4_dll_()
{
    InStream *in = initInStream();
    OutStream *out = initOutStream();
    Dictionary *dictionary = initDictionary(4096);
    
    in = openInStream("test/support/Source/libjansson-4.dll", "rb" , in);
    out = openOutStream("test/support/Compressed/Variable/libjansson-4_Compressed_Variable.dll", "wb" , out);
      
    LZ78_Compressor(dictionary,in,out,Variable);

    closeInStream(in);
    closeOutStream(out);
    freeInStream(in);
    freeOutStream(out);
    destroyDictionary(dictionary,4096);
}
예제 #5
0
int main (void) {
	int row, col, i, max;
	char *str = malloc(sizeof(char) * (MAX_WORD_LENGTH + 1));
	char temp[2];
	Dictionary *dict = malloc(sizeof(Dictionary));
	WordSearchPuzzle *puzzle = malloc(sizeof(WordSearchPuzzle));
	
	readDictionary(dict);
	
	readPuzzle(puzzle);
	
	//set bigger dimension of puzzle, use for determining
	//length of diagonal for() loops
	if (puzzle->height > puzzle->width) {
		max = puzzle->height;
	} else {
		max = puzzle->width;
	}
	
	temp[1] = '\0';
	
	for (row = 0; row < puzzle->height; row++) {
		for (col = 0; col < puzzle->width; col++) {
			
			//clear array, except for char at index 0
			for (i = 1; i < MAX_WORD_LENGTH + 1; i++) {
				str[i] = '\0';
			}
			
			//single char strings
			*str = puzzle->grid[row][col];
			checkString(dict, str);
			
			//build strings horizontally-right
			for (i = 1; i < puzzle->width; i++) {
				//make sure not to go too far!
				if (col + i < puzzle->width) {
					temp[0] = puzzle->grid[row][col + i];
					str = strcat(str, temp);
					checkString(dict, str);
				}
			}
			
			//clear array, except for char at index 0
			for (i = 1; i < MAX_WORD_LENGTH + 1; i++) {
				str[i] = '\0';
			}
			
			//build strings horizontally-left
			for (i = 1; i < puzzle->width; i++) {
				//make sure not to go too far!
				if (col - i > 0) {
					temp[0] = puzzle->grid[row][col - i];
					str = strcat(str, temp);
					checkString(dict, str);
				}
			}
			
			//clear array, except for char at index 0
			for (i = 1; i < MAX_WORD_LENGTH + 1; i++) {
				str[i] = '\0';
			}
			
			//build strings vertically-down
			for (i = 1; i < puzzle->height; i++) {
				if (row + i < puzzle->height) {
					temp[0] = puzzle->grid[row + i][col];
					str = strcat(str, temp);
					checkString(dict, str);
				}
			}
			
			//clear array, except for char at index 0
			for (i = 1; i < MAX_WORD_LENGTH + 1; i++) {
				str[i] = '\0';
			}
			
			//build strings vertically-up
			for (i = 1; i < puzzle->height; i++) {
				//why is this >=? top row of puzzle (height/width ints) hindering correct reading?
				if (row - i >= 0) {
					temp[0] = puzzle->grid[row - i][col];
					str = strcat(str, temp);
					checkString(dict, str);
				}
			}
			
			//clear array, except for char at index 0
			for (i = 1; i < MAX_WORD_LENGTH + 1; i++) {
				str[i] = '\0';
			}
			
			//build string diagonally up-left
			for (i = 1; i <= max; i++) {
				if (row - i >= 0 && col - i >= 0) {
					temp[0] = puzzle->grid[row - i][col - i];
					str = strcat(str, temp);
					checkString(dict, str);
				}
			}
			
			//clear array, except for char at index 0
			for (i = 1; i < MAX_WORD_LENGTH + 1; i++) {
				str[i] = '\0';
			}
			
			//build string diagonally up-right
			for (i = 1; i < max; i++) {
				if (row - i >= 0 && col + i < puzzle->width) {
					temp[0] = puzzle->grid[row - i][col + i];
					str = strcat(str, temp);
					checkString(dict, str);
				}
			}
			
			//clear array, except for char at index 0
			for (i = 1; i < MAX_WORD_LENGTH + 1; i++) {
				str[i] = '\0';
			}
			
			//build string diagonally down-left
			for (i = 1; i < max; i++) {
				if (row + i < puzzle->height && col - i >= 0) {
					temp[0] = puzzle->grid[row + i][col - i];
					str = strcat(str, temp);
					checkString(dict, str);
				}
			}
			
			//clear array, except for char at index 0
			for (i = 1; i < MAX_WORD_LENGTH + 1; i++) {
				str[i] = '\0';
			}
			//build string diagonally down-right
			for (i = 1; i < max; i++) {
				if (row + i < puzzle->height && col + i < puzzle->width) {
					temp[0] = puzzle->grid[row + i][col + i];
					str = strcat(str, temp);
					checkString(dict, str);
				}
			}
		}//end [col] for loop
	}//end [row] for loop
	
	for (i = 0; i < dict->size; i++) {
		if (dict->counts[i] > 0) {
			printf("%s (%d)\n", dict->words[i], dict->counts[i]);
		}
	}
	
	destroyDictionary(dict);
	destroyPuzzle(puzzle);
	
	free(str);
	str = NULL;
	
	return 0;
}
예제 #6
0
 ~Object() {
    destroyDictionary();
    delete _registeredObject;
 }