trace_visualization 0.0.2 → 0.0.3

data/lib/trace_visualization/preprocessor/hashmap.c

@@ -1,93 +0,0 @@
-#include "hashmap.h"
-#include <stdio.h>
-
-hashmap_t* hashmap_new() {
-	hashmap_t* hashmap = (hashmap_t*)malloc(sizeof(hashmap_t));
-	
-	hashmap->size = 0;
-	hashmap->table = (hashmap_element**)calloc(HASHMAP_SIZE, sizeof(hashmap_element*));
-
-	return hashmap;
-}
-
-void* hashmap_get(hashmap_t* map, long key) {
-	hashmap_element* ptr;
-	int idx = (int)(key % HASHMAP_SIZE);
-	
-	for (ptr = map->table[idx]; ptr != NULL; ptr = ptr->next) {
-		if (ptr->key == key) {
-			return ptr->value;
-		}
-	}
-	
-	return NULL;	
-}
-
-int hashmap_put(hashmap_t* map, long key, void* value) {
-	int result = 1;
-	
-	if (hashmap_get(map, key) == NULL) {
-		hashmap_element* ptr;
-		hashmap_element* element = (hashmap_element*) malloc(sizeof(hashmap_element));
-
-		element->key   = key;
-		element->value = value;
-		element->next  = NULL;
-		
-		int idx = (int)(key % HASHMAP_SIZE);
-		ptr = map->table[idx];
-	
-		if (ptr) {
-			while (ptr->next) ptr = ptr->next;
-			ptr->next = element;
-		} else {
-			map->table[idx] = element;
-		}
-
-		map->size += 1;
-
-		result = 0;
-	} 
-	
-	return result;	
-}
-
-void** hashmap_values(hashmap_t* map) {
-	int i = 0;
-	int j = 0;
-	hashmap_element* ptr;	
-	void** values = (void**)malloc(map->size * sizeof(void*));
-	
-	for (; i < HASHMAP_SIZE; i += 1) {
-		ptr = map->table[i];
-		
-		while (ptr) {
-			values[j] = ptr->value;
-			ptr = ptr->next;
-			j += 1;
-		}
-	}
-	
-	return values;
-}
-
-void hashmap_values_free(void** values) {
-	free(values);
-}
-
-void hashmap_free(hashmap_t* map) {
-	hashmap_element* ptr;
-	hashmap_element* tmp;
-	int i;
-	for (i = 0; i < HASHMAP_SIZE; i++) {
-		for (ptr = map->table[i]; ptr != NULL; ) {
-			tmp = ptr;
-			ptr = (hashmap_element*)ptr->next;
-
-			free(tmp);
-		}
-	}
-	free(map);
-}
-
-

data/lib/trace_visualization/preprocessor/hashmap.h

@@ -1,27 +0,0 @@
-#ifndef __HASHMAP_H__
-#define __HASHMAP_H__
-
-#include <stdlib.h>
-
-#define HASHMAP_SIZE (256)
-
-// typedef struct hashmap_element hashmap_element; 
-struct hashmap_element {
-	long  key;
-	void* value;
-	hashmap_element * next;
-};
-
-struct hashmap_t {
-	hashmap_element** table;
-	int size;
-};
-
-extern hashmap_t* hashmap_new();
-extern int  hashmap_put(hashmap_t* map, long key, void* value);
-extern void* hashmap_get(hashmap_t* map, long key);
-extern void** hashmap_values(hashmap_t* map); 
-extern void hashmap_values_free(void** values);
-extern void  hashmap_free(hashmap_t* map);
-
-#endif

data/lib/trace_visualization/preprocessor/hashmap_test.cpp

@@ -1,90 +0,0 @@
-#include <cppunit/extensions/HelperMacros.h>
-#include <iostream>
-#include "hashmap.h"
-
-using namespace std;
-
-class hashmap_test : public CPPUNIT_NS::TestFixture {
-	CPPUNIT_TEST_SUITE(hashmap_test);
-	CPPUNIT_TEST(smoke_test);
-	CPPUNIT_TEST(complex_test);	
-	CPPUNIT_TEST(hashmap_values_test);	
-	CPPUNIT_TEST_SUITE_END();
-public:
-	void smoke_test(void);
-	void complex_test(void);
-	void hashmap_values_test(void);
-};
-
-CPPUNIT_TEST_SUITE_REGISTRATION(hashmap_test);
-
-void hashmap_test::smoke_test() {
-	hashmap_t* map = hashmap_new();
-	
-	const char* value = "value";
-	hashmap_put(map, 12345, (char*)value);
-	
-	void* ptr = hashmap_get(map, 1);
-	CPPUNIT_ASSERT(ptr == NULL);
-	
-	ptr = hashmap_get(map, 12345);
-	CPPUNIT_ASSERT(ptr != NULL);
-	CPPUNIT_ASSERT(strcmp((char*)ptr, value) == 0);
-
-	hashmap_free(map);
-}
-
-void hashmap_test::complex_test() {
-	hashmap_t* map = hashmap_new();
-	
-	CPPUNIT_ASSERT(map != NULL);
-	
-	for (long i = 0; i < HASHMAP_SIZE << 3; i += HASHMAP_SIZE >> 2) {
-		hashmap_put(map, i, (void*)i);
-	}
-
-	for (int i = 0; i < HASHMAP_SIZE; i++) {
-		if (i % (HASHMAP_SIZE >> 2) == 0) {
-			CPPUNIT_ASSERT(map->table[i] != NULL);
-		} else {
-			CPPUNIT_ASSERT(map->table[i] == NULL);
-		}
-	}
-
-	for (long i = 0; i < HASHMAP_SIZE << 3; i += HASHMAP_SIZE >> 2) {
-		void* ptr = hashmap_get(map, i);
-		CPPUNIT_ASSERT(ptr == (void*)i);
-		
-		CPPUNIT_ASSERT(hashmap_get(map, i + 1) == NULL);
-		CPPUNIT_ASSERT(hashmap_get(map, i - 1) == NULL);		
-	}
-	
-	hashmap_free(map);
-}
-
-void hashmap_test::hashmap_values_test() {
-	hashmap_t* map = hashmap_new();
-	
-	CPPUNIT_ASSERT(map != NULL);
-	
-	int k = 2;
-	
-	for (long i = 0; i < HASHMAP_SIZE * k; i += 1) {
-		hashmap_put(map, i, (void*)i);
-	}
-	
-	CPPUNIT_ASSERT(map->size == HASHMAP_SIZE * k);
-	
-	void** values = hashmap_values(map);
-	CPPUNIT_ASSERT(values != NULL);
-	
-	for (int i = 0; i < map->size; i++) {
-		void* value = values[i];
-		
-		int int_value = (i % k) * HASHMAP_SIZE + i / k;
-		CPPUNIT_ASSERT(value == (void*)int_value);
-	}
-
-	hashmap_values_free(values);
-	hashmap_free(map);	
-}

data/lib/trace_visualization/preprocessor/lexeme.h

@@ -1,11 +0,0 @@
-#ifndef __LEXEME_H__
-#define __LEXEME_H__
-
-struct lexeme_t {
-	const char* name;
-	const char* source;
-	long        numeric;
-	int         ord;
-};
-
-#endif

data/lib/trace_visualization/preprocessor/lexeme_table.c

@@ -1,50 +0,0 @@
-#include "lexeme_table.h"
-#include <stdlib.h>
-
-hashmap_t* lexeme_table_new() {
-	return hashmap_new();
-}
-
-lexeme_t* install_lexeme(hashmap_t* lexeme_table, const char* name, const char* source, long numeric) {
-	lexeme_t* lexeme = NULL;
-
-	void* ptr = hashmap_get(lexeme_table, numeric);
-
-	if (ptr == NULL) {
-		lexeme = (lexeme_t*)malloc(sizeof(lexeme_t));
-		
-		lexeme->name = name;
-		lexeme->source = source;
-		lexeme->numeric = numeric;
-		
-		hashmap_put(lexeme_table, numeric, lexeme);
-	} else {
-		lexeme = (lexeme_t*)ptr;
-	}
-
-	return lexeme;
-}
-
-int compare_lexeme(const void* a, const void* b) {
-	return ((lexeme_t*)*(void**)a)->numeric - ((lexeme_t*)*(void**)b)->numeric;
-}
-
-void reorder_lexemes(hashmap_t* lexeme_table) {
-	void** values = hashmap_values(lexeme_table);
-	
-	qsort(values, lexeme_table->size, sizeof(void*), compare_lexeme);
-	
-	int  ord  = 0;
-	long prev = -1;
-
-	for (int i = 0; i < lexeme_table->size; i++) {
-		int numeric = ((lexeme_t*)values[i])->numeric;
-		
-		if (numeric != prev) {
-			ord += 1;
-			prev = numeric;
-		}
-		
-		((lexeme_t*)values[i])->ord = ord;
-	}
-}

data/lib/trace_visualization/preprocessor/lexeme_table.h

@@ -1,13 +0,0 @@
-#ifndef __LEXEME_TABLE_H__
-#define __LEXEME_TABLE_H__
-
-#include "lexeme.h"
-#include "hashmap.h"
-
-extern hashmap_t* lexeme_table_new();
-
-extern lexeme_t* install_lexeme(hashmap_t* lexeme_table, const char* name, const char* source, long numeric);
-
-extern void reorder_lexemes(hashmap_t* lexeme_table);
-
-#endif

data/lib/trace_visualization/preprocessor/lexeme_table_cpp.h

@@ -1,61 +0,0 @@
-#ifndef __LEXEME_TABLE_H__
-#define __LEXEME_TABLE_H__
-
-#include <map>
-#include <vector>
-#include <algorithm>
-#include "lexeme.h"
-
-class lexeme_table {
-public:
-	
-	~lexeme_table() {
-		for (std::map<long, lexeme_t*>::iterator iter = lexeme_table.begin(); iter != lexeme_table.end(); iter++) {
-			delete iter->second;
-		}
-	}
-	
-	lexeme_t* install_lexeme(const char* name, const char* source, long numeric) {
-		std::map<long, lexeme_t*>::iterator iter = lexeme_table.find(numeric);
-	
-		lexeme_t* lexeme = NULL;
-	
-		if (iter == lexeme_table.end()) {
-			lexeme = new lexeme_t(name, source, numeric);
-			lexeme_table[numeric] = lexeme;
-		} else {
-			lexeme = iter->second;
-		}
-	
-		return lexeme;
-	}
-	
-	void reorder() {
-		std::vector<lexeme_t*> tmp; 
-		for (std::map<long, lexeme_t*>::iterator iter = lexeme_table.begin(); iter != lexeme_table.end(); iter++) {
-			tmp.push_back(iter->second);
-		}
-		
-		std::sort(tmp.begin(), tmp.end(), reorder_function);
-		
-		int  ord  = 0;
-		long prev = -1;
-		for (std::vector<lexeme_t*>::iterator iter = tmp.begin(); iter != tmp.end(); iter++) {
-			if (prev != (*iter)->numeric) {
-				ord += 1;
-				prev = (*iter)->numeric;
-			}
-			
-			(*iter)->ord = ord;
-		}
-	}
-	
-private:
-	std::map<long, lexeme_t*> lexeme_table;
-	
-	static bool reorder_function(lexeme_t* a, lexeme_t* b) {
-		return a->numeric < b->numeric;
-	}
-};
-
-#endif

data/lib/trace_visualization/preprocessor/parser_functions.c

@@ -1,42 +0,0 @@
-#include <stdio.h>
-#include <time.h>
-
-/**
- * When flex finds a match, yytext points to the first character of the match 
- * in the input buffer. The string itself is part of the input buffer, and is 
- * NOT allocated separately
- */
-extern const char* yytext;
-
-/**
- * Implements in two ways: (f)lex and unit-tests
- */
-extern void output_lexeme(const char* name, const char* source, int value);
-
-//-----------------------------------------------------------------------------
-void parse_identifier() {
-	int id;
-	sscanf(yytext, "[%d]", &id);
-	output_lexeme("ID", yytext, id);
-}
-
-//-----------------------------------------------------------------------------
-void parse_ip() {
-	unsigned ips[4];
-	sscanf(yytext, "%d.%d.%d.%d", ips, ips + 1, ips + 2, ips + 3);
-	unsigned result = (((ips[0] << 24) & 0xFF000000) | ((ips[1] << 16) & 0xFF0000) | ((ips[2] << 8) & 0xFF00) | (ips[3] & 0xFF));
-	output_lexeme("IP", yytext, result);
-}
-
-//-----------------------------------------------------------------------------
-void parse_date() {
-	struct tm tm;
-	time_t t;
-	
-	if (strptime(yytext, "[%d %b %Y %H:%M:%S]", &tm) == NULL) 
-		/* handle error */ ;
-		
-	t = mktime(&tm);
-	
-	output_lexeme("TIME", yytext, t);
-}

data/lib/trace_visualization/preprocessor/parser_test.cpp

@@ -1,71 +0,0 @@
-#include <cppunit/extensions/HelperMacros.h>
-#include <iostream>
-#include "lexeme.h"
-#include "lexeme_table.h"
-
-const char* yytext;
-
-void output_lexeme(const char* name, long value);
-
-extern void parse_identifier();
-extern void parse_ip();
-extern void parse_date();
-
-using namespace std;
-
-class parser_test : public CPPUNIT_NS::TestFixture {
-	CPPUNIT_TEST_SUITE(parser_test);
-	CPPUNIT_TEST(identifier_parser_test);
-	CPPUNIT_TEST(lexeme_table_test);	
-	CPPUNIT_TEST_SUITE_END();
-public:
-	void identifier_parser_test(void);
-	void lexeme_table_test(void);
-};
-
-CPPUNIT_TEST_SUITE_REGISTRATION(parser_test);
-
-lexeme_t lexeme;
-// lexeme.name = "";
-// lexeme.source = "";
-// lexeme.numeric = -1;
-// lexeme.ord = -1;
-
-void output_lexeme(const char* name, long value) {
-	lexeme.name    = name;
-	lexeme.numeric = value;
-}
-
-//-----------------------------------------------------------------------------
-void parser_test::identifier_parser_test(void) {
-	yytext = "[123]";
-	
-	parse_identifier();
-	
-	CPPUNIT_ASSERT(strcmp("ID", lexeme.name) == 0);
-}
-
-
-//-----------------------------------------------------------------------------
-void parser_test::lexeme_table_test(void) {
-	hashmap_t* table = lexeme_table_new();
-	
-	lexeme_t* lexeme         = install_lexeme(table, "id", "[123]", 123);
-	lexeme_t* another_lexeme = install_lexeme(table, "id", "[124]", 124);
-	lexeme_t* repeat_lexeme  = install_lexeme(table, "id", "[123]", 123);
-
-	CPPUNIT_ASSERT(lexeme         != NULL);	
-	CPPUNIT_ASSERT(another_lexeme != NULL);	
-	CPPUNIT_ASSERT(repeat_lexeme  != NULL);	
-	
-	CPPUNIT_ASSERT_EQUAL(lexeme, repeat_lexeme);	
-
-	reorder_lexemes(table);
-
-	CPPUNIT_ASSERT_EQUAL(1, lexeme->ord);
-	CPPUNIT_ASSERT_EQUAL(2, another_lexeme->ord);
-}
-
-
-
-