Adjust fallen changes

* Restore old map load() used in minimap
* Change tabs to 4 spaces
* Add missing cmake file

src/framework/core/filestream.cpp

@@ -251,26 +251,26 @@ std::string FileStream::getString()
 
 uint8 FileStream::readNode(uint8 &oldNode, uint32 &type)
 {
-	if (!oldNode) {
-		if ((oldNode = getU8()) == 0xFE) {
-			type = getU32();
-			return oldNode;
-		} else {
-			dump << "Failed to read new node.";
-			return 0;
-		}
-	}
+    if (!oldNode) {
+        if ((oldNode = getU8()) == 0xFE) {
+            type = getU32();
+            return oldNode;
+        } else {
+            dump << "Failed to read new node.";
+            return 0;
+        }
+    }
 
-	assert(getU8() == 0xFF);
-	if ((oldNode = getU8()) == 0xFE) {
-		type = getU32();
-		return oldNode;
-	} else {
-		dump << "Failed to read node with old type: " << type;
-		return 0;
-	}
+    assert(getU8() == 0xFF);
+    if ((oldNode = getU8()) == 0xFE) {
+        type = getU32();
+        return oldNode;
+    } else {
+        dump << "Failed to read node with old type: " << type;
+        return 0;
+    }
 
-	return 0;
+    return 0;
 }
 
 void FileStream::addU8(uint8 v)

src/framework/core/filestream.h

@@ -59,7 +59,7 @@ public:
     void addU32(uint8 v);
     void addU64(uint8 v);
 
-	uint8 readNode(uint8 &oldNode, uint32 &type);
+    uint8 readNode(uint8 &oldNode, uint32 &type);
 private:
     std::string m_name;
     PHYSFS_File *m_fileHandle;

src/framework/thirdparty/tinystr.cpp

@@ -36,76 +36,76 @@ TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, { '\0' } };
 
 void TiXmlString::reserve (size_type cap)
 {
-	if (cap > capacity())
-	{
-		TiXmlString tmp;
-		tmp.init(length(), cap);
-		memcpy(tmp.start(), data(), length());
-		swap(tmp);
-	}
+    if (cap > capacity())
+    {
+        TiXmlString tmp;
+        tmp.init(length(), cap);
+        memcpy(tmp.start(), data(), length());
+        swap(tmp);
+    }
 }
 
 
 TiXmlString& TiXmlString::assign(const char* str, size_type len)
 {
-	size_type cap = capacity();
-	if (len > cap || cap > 3*(len + 8))
-	{
-		TiXmlString tmp;
-		tmp.init(len);
-		memcpy(tmp.start(), str, len);
-		swap(tmp);
-	}
-	else
-	{
-		memmove(start(), str, len);
-		set_size(len);
-	}
-	return *this;
+    size_type cap = capacity();
+    if (len > cap || cap > 3*(len + 8))
+    {
+        TiXmlString tmp;
+        tmp.init(len);
+        memcpy(tmp.start(), str, len);
+        swap(tmp);
+    }
+    else
+    {
+        memmove(start(), str, len);
+        set_size(len);
+    }
+    return *this;
 }
 
 
 TiXmlString& TiXmlString::append(const char* str, size_type len)
 {
-	size_type newsize = length() + len;
-	if (newsize > capacity())
-	{
-		reserve (newsize + capacity());
-	}
-	memmove(finish(), str, len);
-	set_size(newsize);
-	return *this;
+    size_type newsize = length() + len;
+    if (newsize > capacity())
+    {
+        reserve (newsize + capacity());
+    }
+    memmove(finish(), str, len);
+    set_size(newsize);
+    return *this;
 }
 
 
 TiXmlString operator + (const TiXmlString & a, const TiXmlString & b)
 {
-	TiXmlString tmp;
-	tmp.reserve(a.length() + b.length());
-	tmp += a;
-	tmp += b;
-	return tmp;
+    TiXmlString tmp;
+    tmp.reserve(a.length() + b.length());
+    tmp += a;
+    tmp += b;
+    return tmp;
 }
 
 TiXmlString operator + (const TiXmlString & a, const char* b)
 {
-	TiXmlString tmp;
-	TiXmlString::size_type b_len = static_cast<TiXmlString::size_type>( strlen(b) );
-	tmp.reserve(a.length() + b_len);
-	tmp += a;
-	tmp.append(b, b_len);
-	return tmp;
+    TiXmlString tmp;
+    TiXmlString::size_type b_len = static_cast<TiXmlString::size_type>( strlen(b) );
+    tmp.reserve(a.length() + b_len);
+    tmp += a;
+    tmp.append(b, b_len);
+    return tmp;
 }
 
 TiXmlString operator + (const char* a, const TiXmlString & b)
 {
-	TiXmlString tmp;
-	TiXmlString::size_type a_len = static_cast<TiXmlString::size_type>( strlen(a) );
-	tmp.reserve(a_len + b.length());
-	tmp.append(a, a_len);
-	tmp += b;
-	return tmp;
+    TiXmlString tmp;
+    TiXmlString::size_type a_len = static_cast<TiXmlString::size_type>( strlen(a) );
+    tmp.reserve(a_len + b.length());
+    tmp.append(a, a_len);
+    tmp += b;
+    return tmp;
 }
 
 
-#endif	// TIXML_USE_STL
+#endif    // TIXML_USE_STL

src/framework/thirdparty/tinystr.h

@@ -30,18 +30,18 @@ distribution.
 #include <assert.h>
 #include <string.h>
 
-/*	The support for explicit isn't that universal, and it isn't really
-	required - it is used to check that the TiXmlString class isn't incorrectly
-	used. Be nice to old compilers and macro it here:
+/*    The support for explicit isn't that universal, and it isn't really
+    required - it is used to check that the TiXmlString class isn't incorrectly
+    used. Be nice to old compilers and macro it here:
 */
 #if defined(_MSC_VER) && (_MSC_VER >= 1200 )
-	// Microsoft visual studio, version 6 and higher.
-	#define TIXML_EXPLICIT explicit
+    // Microsoft visual studio, version 6 and higher.
+    #define TIXML_EXPLICIT explicit
 #elif defined(__GNUC__) && (__GNUC__ >= 3 )
-	// GCC version 3 and higher.s
-	#define TIXML_EXPLICIT explicit
+    // GCC version 3 and higher.s
+    #define TIXML_EXPLICIT explicit
 #else
-	#define TIXML_EXPLICIT
+    #define TIXML_EXPLICIT
 #endif
 
 
@@ -55,211 +55,211 @@ distribution.
 class TiXmlString
 {
   public :
-	// The size type used
-  	typedef size_t size_type;
+    // The size type used
+      typedef size_t size_type;
 
-	// Error value for find primitive
-	static const size_type npos; // = -1;
+    // Error value for find primitive
+    static const size_type npos; // = -1;
 
 
-	// TiXmlString empty constructor
-	TiXmlString () : rep_(&nullrep_)
-	{
-	}
+    // TiXmlString empty constructor
+    TiXmlString () : rep_(&nullrep_)
+    {
+    }
 
-	// TiXmlString copy constructor
-	TiXmlString ( const TiXmlString & copy) : rep_(0)
-	{
-		init(copy.length());
-		memcpy(start(), copy.data(), length());
-	}
+    // TiXmlString copy constructor
+    TiXmlString ( const TiXmlString & copy) : rep_(0)
+    {
+        init(copy.length());
+        memcpy(start(), copy.data(), length());
+    }
 
-	// TiXmlString constructor, based on a string
-	TIXML_EXPLICIT TiXmlString ( const char * copy) : rep_(0)
-	{
-		init( static_cast<size_type>( strlen(copy) ));
-		memcpy(start(), copy, length());
-	}
+    // TiXmlString constructor, based on a string
+    TIXML_EXPLICIT TiXmlString ( const char * copy) : rep_(0)
+    {
+        init( static_cast<size_type>( strlen(copy) ));
+        memcpy(start(), copy, length());
+    }
 
-	// TiXmlString constructor, based on a string
-	TIXML_EXPLICIT TiXmlString ( const char * str, size_type len) : rep_(0)
-	{
-		init(len);
-		memcpy(start(), str, len);
-	}
+    // TiXmlString constructor, based on a string
+    TIXML_EXPLICIT TiXmlString ( const char * str, size_type len) : rep_(0)
+    {
+        init(len);
+        memcpy(start(), str, len);
+    }
 
-	// TiXmlString destructor
-	~TiXmlString ()
-	{
-		quit();
-	}
+    // TiXmlString destructor
+    ~TiXmlString ()
+    {
+        quit();
+    }
 
-	TiXmlString& operator = (const char * copy)
-	{
-		return assign( copy, (size_type)strlen(copy));
-	}
+    TiXmlString& operator = (const char * copy)
+    {
+        return assign( copy, (size_type)strlen(copy));
+    }
 
-	TiXmlString& operator = (const TiXmlString & copy)
-	{
-		return assign(copy.start(), copy.length());
-	}
+    TiXmlString& operator = (const TiXmlString & copy)
+    {
+        return assign(copy.start(), copy.length());
+    }
 
 
-	// += operator. Maps to append
-	TiXmlString& operator += (const char * suffix)
-	{
-		return append(suffix, static_cast<size_type>( strlen(suffix) ));
-	}
+    // += operator. Maps to append
+    TiXmlString& operator += (const char * suffix)
+    {
+        return append(suffix, static_cast<size_type>( strlen(suffix) ));
+    }
 
-	// += operator. Maps to append
-	TiXmlString& operator += (char single)
-	{
-		return append(&single, 1);
-	}
+    // += operator. Maps to append
+    TiXmlString& operator += (char single)
+    {
+        return append(&single, 1);
+    }
 
-	// += operator. Maps to append
-	TiXmlString& operator += (const TiXmlString & suffix)
-	{
-		return append(suffix.data(), suffix.length());
-	}
+    // += operator. Maps to append
+    TiXmlString& operator += (const TiXmlString & suffix)
+    {
+        return append(suffix.data(), suffix.length());
+    }
 
 
-	// Convert a TiXmlString into a null-terminated char *
-	const char * c_str () const { return rep_->str; }
+    // Convert a TiXmlString into a null-terminated char *
+    const char * c_str () const { return rep_->str; }
 
-	// Convert a TiXmlString into a char * (need not be null terminated).
-	const char * data () const { return rep_->str; }
+    // Convert a TiXmlString into a char * (need not be null terminated).
+    const char * data () const { return rep_->str; }
 
-	// Return the length of a TiXmlString
-	size_type length () const { return rep_->size; }
+    // Return the length of a TiXmlString
+    size_type length () const { return rep_->size; }
 
-	// Alias for length()
-	size_type size () const { return rep_->size; }
+    // Alias for length()
+    size_type size () const { return rep_->size; }
 
-	// Checks if a TiXmlString is empty
-	bool empty () const { return rep_->size == 0; }
+    // Checks if a TiXmlString is empty
+    bool empty () const { return rep_->size == 0; }
 
-	// Return capacity of string
-	size_type capacity () const { return rep_->capacity; }
+    // Return capacity of string
+    size_type capacity () const { return rep_->capacity; }
 
 
-	// single char extraction
-	const char& at (size_type index) const
-	{
-		assert( index < length() );
-		return rep_->str[ index ];
-	}
+    // single char extraction
+    const char& at (size_type index) const
+    {
+        assert( index < length() );
+        return rep_->str[ index ];
+    }
 
-	// [] operator
-	char& operator [] (size_type index) const
-	{
-		assert( index < length() );
-		return rep_->str[ index ];
-	}
+    // [] operator
+    char& operator [] (size_type index) const
+    {
+        assert( index < length() );
+        return rep_->str[ index ];
+    }
 
-	// find a char in a string. Return TiXmlString::npos if not found
-	size_type find (char lookup) const
-	{
-		return find(lookup, 0);
-	}
+    // find a char in a string. Return TiXmlString::npos if not found
+    size_type find (char lookup) const
+    {
+        return find(lookup, 0);
+    }
 
-	// find a char in a string from an offset. Return TiXmlString::npos if not found
-	size_type find (char tofind, size_type offset) const
-	{
-		if (offset >= length()) return npos;
+    // find a char in a string from an offset. Return TiXmlString::npos if not found
+    size_type find (char tofind, size_type offset) const
+    {
+        if (offset >= length()) return npos;
 
-		for (const char* p = c_str() + offset; *p != '\0'; ++p)
-		{
-		   if (*p == tofind) return static_cast< size_type >( p - c_str() );
-		}
-		return npos;
-	}
+        for (const char* p = c_str() + offset; *p != '\0'; ++p)
+        {
+           if (*p == tofind) return static_cast< size_type >( p - c_str() );
+        }
+        return npos;
+    }
 
-	void clear ()
-	{
-		//Lee:
-		//The original was just too strange, though correct:
-		//	TiXmlString().swap(*this);
-		//Instead use the quit & re-init:
-		quit();
-		init(0,0);
-	}
+    void clear ()
+    {
+        //Lee:
+        //The original was just too strange, though correct:
+        //    TiXmlString().swap(*this);
+        //Instead use the quit & re-init:
+        quit();
+        init(0,0);
+    }
 
-	/*	Function to reserve a big amount of data when we know we'll need it. Be aware that this
-		function DOES NOT clear the content of the TiXmlString if any exists.
-	*/
-	void reserve (size_type cap);
+    /*    Function to reserve a big amount of data when we know we'll need it. Be aware that this
+        function DOES NOT clear the content of the TiXmlString if any exists.
+    */
+    void reserve (size_type cap);
 
-	TiXmlString& assign (const char* str, size_type len);
+    TiXmlString& assign (const char* str, size_type len);
 
-	TiXmlString& append (const char* str, size_type len);
+    TiXmlString& append (const char* str, size_type len);
 
-	void swap (TiXmlString& other)
-	{
-		Rep* r = rep_;
-		rep_ = other.rep_;
-		other.rep_ = r;
-	}
+    void swap (TiXmlString& other)
+    {
+        Rep* r = rep_;
+        rep_ = other.rep_;
+        other.rep_ = r;
+    }
 
   private:
 
-	void init(size_type sz) { init(sz, sz); }
-	void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0'; }
-	char* start() const { return rep_->str; }
-	char* finish() const { return rep_->str + rep_->size; }
+    void init(size_type sz) { init(sz, sz); }
+    void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0'; }
+    char* start() const { return rep_->str; }
+    char* finish() const { return rep_->str + rep_->size; }
 
-	struct Rep
-	{
-		size_type size, capacity;
-		char str[1];
-	};
+    struct Rep
+    {
+        size_type size, capacity;
+        char str[1];
+    };
 
-	void init(size_type sz, size_type cap)
-	{
-		if (cap)
-		{
-			// Lee: the original form:
-			//	rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
-			// doesn't work in some cases of new being overloaded. Switching
-			// to the normal allocation, although use an 'int' for systems
-			// that are overly picky about structure alignment.
-			const size_type bytesNeeded = sizeof(Rep) + cap;
-			const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) / sizeof( int ); 
-			rep_ = reinterpret_cast<Rep*>( new int[ intsNeeded ] );
+    void init(size_type sz, size_type cap)
+    {
+        if (cap)
+        {
+            // Lee: the original form:
+            //    rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
+            // doesn't work in some cases of new being overloaded. Switching
+            // to the normal allocation, although use an 'int' for systems
+            // that are overly picky about structure alignment.
+            const size_type bytesNeeded = sizeof(Rep) + cap;
+            const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) / sizeof( int ); 
+            rep_ = reinterpret_cast<Rep*>( new int[ intsNeeded ] );
 
-			rep_->str[ rep_->size = sz ] = '\0';
-			rep_->capacity = cap;
-		}
-		else
-		{
-			rep_ = &nullrep_;
-		}
-	}
+            rep_->str[ rep_->size = sz ] = '\0';
+            rep_->capacity = cap;
+        }
+        else
+        {
+            rep_ = &nullrep_;
+        }
+    }
 
-	void quit()
-	{
-		if (rep_ != &nullrep_)
-		{
-			// The rep_ is really an array of ints. (see the allocator, above).
-			// Cast it back before delete, so the compiler won't incorrectly call destructors.
-			delete [] ( reinterpret_cast<int*>( rep_ ) );
-		}
-	}
+    void quit()
+    {
+        if (rep_ != &nullrep_)
+        {
+            // The rep_ is really an array of ints. (see the allocator, above).
+            // Cast it back before delete, so the compiler won't incorrectly call destructors.
+            delete [] ( reinterpret_cast<int*>( rep_ ) );
+        }
+    }
 
-	Rep * rep_;
-	static Rep nullrep_;
+    Rep * rep_;
+    static Rep nullrep_;
 
 } ;
 
 
 inline bool operator == (const TiXmlString & a, const TiXmlString & b)
 {
-	return    ( a.length() == b.length() )				// optimization on some platforms
-	       && ( strcmp(a.c_str(), b.c_str()) == 0 );	// actual compare
+    return    ( a.length() == b.length() )                // optimization on some platforms
+           && ( strcmp(a.c_str(), b.c_str()) == 0 );    // actual compare
 }
 inline bool operator < (const TiXmlString & a, const TiXmlString & b)
 {
-	return strcmp(a.c_str(), b.c_str()) < 0;
+    return strcmp(a.c_str(), b.c_str()) < 0;
 }
 
 inline bool operator != (const TiXmlString & a, const TiXmlString & b) { return !(a == b); }
@@ -285,21 +285,21 @@ class TiXmlOutStream : public TiXmlString
 {
 public :
 
-	// TiXmlOutStream << operator.
-	TiXmlOutStream & operator << (const TiXmlString & in)
-	{
-		*this += in;
-		return *this;
-	}
+    // TiXmlOutStream << operator.
+    TiXmlOutStream & operator << (const TiXmlString & in)
+    {
+        *this += in;
+        return *this;
+    }
 
-	// TiXmlOutStream << operator.
-	TiXmlOutStream & operator << (const char * in)
-	{
-		*this += in;
-		return *this;
-	}
+    // TiXmlOutStream << operator.
+    TiXmlOutStream & operator << (const char * in)
+    {
+        *this += in;
+        return *this;
+    }
 
 } ;
 
-#endif	// TIXML_STRING_INCLUDED
-#endif	// TIXML_USE_STL
+#endif    // TIXML_STRING_INCLUDED
+#endif    // TIXML_USE_STL

src/framework/thirdparty/tinyxmlerror.cpp

@@ -33,20 +33,20 @@ distribution.
 
 const char* TiXmlBase::errorString[ TiXmlBase::TIXML_ERROR_STRING_COUNT ] =
 {
-	"No error",
-	"Error",
-	"Failed to open file",
-	"Error parsing Element.",
-	"Failed to read Element name",
-	"Error reading Element value.",
-	"Error reading Attributes.",
-	"Error: empty tag.",
-	"Error reading end tag.",
-	"Error parsing Unknown.",
-	"Error parsing Comment.",
-	"Error parsing Declaration.",
-	"Error document empty.",
-	"Error null (0) or unexpected EOF found in input stream.",
-	"Error parsing CDATA.",
-	"Error when TiXmlDocument added to document, because TiXmlDocument can only be at the root.",
+    "No error",
+    "Error",
+    "Failed to open file",
+    "Error parsing Element.",
+    "Failed to read Element name",
+    "Error reading Element value.",
+    "Error reading Attributes.",
+    "Error: empty tag.",
+    "Error reading end tag.",
+    "Error parsing Unknown.",
+    "Error parsing Comment.",
+    "Error parsing Declaration.",
+    "Error document empty.",
+    "Error null (0) or unexpected EOF found in input stream.",
+    "Error parsing CDATA.",
+    "Error when TiXmlDocument added to document, because TiXmlDocument can only be at the root.",
 };