Whitespacing fixes

svn-id: r31330

common/hashmap.h

@@ -107,19 +107,19 @@ public:
 
 
 #ifdef USE_HASHMAP_MEMORY_POOL
-        MemoryPool _nodePool;
+	MemoryPool _nodePool;
 
 	Node *allocNode(const Key& key) {
-	  void* mem = _nodePool.malloc();
+		void* mem = _nodePool.malloc();
-	  return new (mem) Node(key);
+		return new (mem) Node(key);
 	} 
 
 	void freeNode(Node* node) {
-	  node->~Node();
+		node->~Node();
-	  _nodePool.free(node);
+		_nodePool.free(node);
 	}
 #else
-        Node* allocNode(const Key& key) {
+	Node* allocNode(const Key& key) {
 		return new Node(key);
 	} 
 
@@ -352,9 +352,9 @@ public:
 template <class Key, class Val, class HashFunc, class EqualFunc>
 HashMap<Key, Val, HashFunc, EqualFunc>::HashMap() :
 #ifdef USE_HASHMAP_MEMORY_POOL
- _nodePool(sizeof(Node)),
+	_nodePool(sizeof(Node)),
 #endif
- _defaultVal() {
+	_defaultVal() {
 	_arrsize = nextTableSize(0);
 	_arr = new Node *[_arrsize];
 	assert(_arr != NULL);
@@ -376,9 +376,9 @@ HashMap<Key, Val, HashFunc, EqualFunc>::HashMap() :
 template <class Key, class Val, class HashFunc, class EqualFunc>
 HashMap<Key, Val, HashFunc, EqualFunc>::HashMap(const HM_t& map) : 
 #ifdef USE_HASHMAP_MEMORY_POOL
- _nodePool(sizeof(Node)),
+	_nodePool(sizeof(Node)),
 #endif
-         _defaultVal()  {
+	_defaultVal()  {
 	assign(map);
 }
 

common/memorypool.cpp

@@ -32,92 +32,91 @@ namespace Common
 static const size_t CHUNK_PAGE_SIZE = 32;
 
 void* MemoryPool::allocPage() {
-  void* result = ::malloc(CHUNK_PAGE_SIZE * _chunkSize);
+	void* result = ::malloc(CHUNK_PAGE_SIZE * _chunkSize);
-  _pages.push_back(result);
+	_pages.push_back(result);
-  void* current = result;
+	void* current = result;
-  for(size_t i=1; i<CHUNK_PAGE_SIZE; ++i)
+	for(size_t i=1; i<CHUNK_PAGE_SIZE; ++i) {
-  {
+		void* next    = ((char*)current + _chunkSize);
-    void* next    = ((char*)current + _chunkSize);
+		*(void**)current = next;
-    *(void**)current = next;
+
-    
+		current = next;
-    current = next;
+	}
-  }
+	*(void**)current = NULL;
-  *(void**)current = NULL;
+	return result;
-  return result;
 }
 
 MemoryPool::MemoryPool(size_t chunkSize) {
-   // You must at least fit the pointer in the node (technically unneeded considering the next rounding statement)
+	// You must at least fit the pointer in the node (technically unneeded considering the next rounding statement)
-  _chunkSize = MAX(chunkSize, sizeof(void*));
+	_chunkSize = MAX(chunkSize, sizeof(void*));
-  // There might be an alignment problem on some platforms when trying to load a void* on a non natural boundary
+	// There might be an alignment problem on some platforms when trying to load a void* on a non natural boundary
-  // so we round to the next sizeof(void*)
+	// so we round to the next sizeof(void*)
-  _chunkSize = (_chunkSize + sizeof(void*) - 1) & (~(sizeof(void*) - 1));
+	_chunkSize = (_chunkSize + sizeof(void*) - 1) & (~(sizeof(void*) - 1));
 
-  _next = NULL;
+	_next = NULL;
 }
 
 MemoryPool::~MemoryPool() {
-  for(size_t i=0; i<_pages.size(); ++i)
+	for(size_t i=0; i<_pages.size(); ++i)
-    ::free(_pages[i]);
+	::free(_pages[i]);
 }
 
 void* MemoryPool::malloc() {
 #if 1
-  if(!_next)
+	if(!_next)
-    _next = allocPage();
+		_next = allocPage();
 
-  void* result = _next;
+	void* result = _next;
-  _next = *(void**)result;
+	_next = *(void**)result;
-  return result;
+	return result;
 #else
-  return ::malloc(_chunkSize);
+	return ::malloc(_chunkSize);
 #endif
 }
 
 void MemoryPool::free(void* ptr) {
 #if 1
-  *(void**)ptr = _next;
+	*(void**)ptr = _next;
-  _next = ptr;
+	_next = ptr;
 #else
-  ::free(ptr);
+	::free(ptr);
 #endif
 }
 
 // Technically not compliant C++ to compare unrelated pointers. In practice...
 bool MemoryPool::isPointerInPage(void* ptr, void* page) {
-    return (ptr >= page) && (ptr < (char*)page + CHUNK_PAGE_SIZE * _chunkSize);
+	return (ptr >= page) && (ptr < (char*)page + CHUNK_PAGE_SIZE * _chunkSize);
 }
 
 void MemoryPool::freeUnusedPages() {
-  //std::sort(_pages.begin(), _pages.end());
+	//std::sort(_pages.begin(), _pages.end());
-  Array<size_t> numberOfFreeChunksPerPage;
+	Array<size_t> numberOfFreeChunksPerPage;
-  numberOfFreeChunksPerPage.resize(_pages.size());
+	numberOfFreeChunksPerPage.resize(_pages.size());
-  for(size_t i=0; i<numberOfFreeChunksPerPage.size(); ++i) {
+	for(size_t i=0; i<numberOfFreeChunksPerPage.size(); ++i) {
-      numberOfFreeChunksPerPage[i] = 0;
+		numberOfFreeChunksPerPage[i] = 0;
-  }
+	}
-  
-  void* iterator = _next;
-  while(iterator) {
-    // This should be a binary search
-    for(size_t i=0; i<_pages.size(); ++i) {
-      if(isPointerInPage(iterator, _pages[i])) {
-	++numberOfFreeChunksPerPage[i];
-	break;
-      }
-    }
-    iterator = *(void**)iterator;
-  }
 
-  size_t freedPagesCount = 0;
+	void* iterator = _next;
-  for(size_t i=0; i<_pages.size(); ++i) {
+	while(iterator) {
-    if(numberOfFreeChunksPerPage[i] == CHUNK_PAGE_SIZE) {
+		// This should be a binary search
-      ::free(_pages[i]);
+		for(size_t i=0; i<_pages.size(); ++i) {
-      _pages[i] = NULL; // TODO : Remove NULL values
+			if(isPointerInPage(iterator, _pages[i])) {
-      ++freedPagesCount;
+				++numberOfFreeChunksPerPage[i];
-    }
+				break;
-  }
+			}
+		}
+		iterator = *(void**)iterator;
+	}
 
-  //printf("%d freed pages\n", freedPagesCount); 
+	size_t freedPagesCount = 0;
+	for(size_t i=0; i<_pages.size(); ++i) {
+		if(numberOfFreeChunksPerPage[i] == CHUNK_PAGE_SIZE) {
+			::free(_pages[i]);
+			_pages[i] = NULL; // TODO : Remove NULL values
+			++freedPagesCount;
+		}
+	}
+
+	//printf("%d freed pages\n", freedPagesCount); 
 }
 
 }

common/memorypool.h

@@ -26,7 +26,7 @@
 #ifndef COMMON_MEMORYPOOL_H
 #define COMMON_MEMORYPOOL_H
 
-#include <string.h>
+#include "common/scummsys.h"
 #include "common/array.h"
 
 namespace Common
@@ -34,24 +34,24 @@ namespace Common
 
 class MemoryPool
 {
- private:
+private:
-  MemoryPool(const MemoryPool&);
+	MemoryPool(const MemoryPool&);
-  MemoryPool& operator=(const MemoryPool&);
+	MemoryPool& operator=(const MemoryPool&);
 
-  size_t       _chunkSize;
+	size_t			_chunkSize;
-  Array<void*> _pages;
+	Array<void*>	_pages;
-  void*        _next;
+	void*			_next;
 
-  void* allocPage();
+	void*	allocPage();
-  bool  isPointerInPage(void* ptr, void* page);
+	bool	isPointerInPage(void* ptr, void* page);
- public:
+public:
-  MemoryPool(size_t chunkSize);
+	MemoryPool(size_t chunkSize);
-  ~MemoryPool();
+	~MemoryPool();
 
-  void* malloc();
+	void*	malloc();
-  void  free(void* ptr);
+	void 	free(void* ptr);
 
-  void freeUnusedPages();
+	void	freeUnusedPages();
 };
 
 }