Index: /orxonox/trunk/src/lib/tinyxml/tinystr.cc
===================================================================
--- /orxonox/trunk/src/lib/tinyxml/tinystr.cc	(revision 4490)
+++ /orxonox/trunk/src/lib/tinyxml/tinystr.cc	(revision 4491)
@@ -37,5 +37,5 @@
 TiXmlString::TiXmlString (const char* instring)
 {
-    unsigned newlen;
+    size_t newlen;
     char * newstring;
 
@@ -47,7 +47,5 @@
         return;
     }
-	//*ME:	warning C4267: convert 'size_t' to 'unsigned int'
-	//*ME:	Use Cast: (unsigned)
-    newlen = (unsigned)strlen (instring) + 1;
+    newlen = strlen (instring) + 1;
     newstring = new char [newlen];
     memcpy (newstring, instring, newlen);
@@ -61,5 +59,5 @@
 TiXmlString::TiXmlString (const TiXmlString& copy)
 {
-    unsigned newlen;
+    size_t newlen;
     char * newstring;
 
@@ -87,5 +85,5 @@
 void TiXmlString ::operator = (const char * content)
 {
-    unsigned newlen;
+    size_t newlen;
     char * newstring;
 
@@ -95,5 +93,5 @@
         return;
     }
-    newlen = (unsigned)strlen (content) + 1;
+    newlen = strlen (content) + 1;
     newstring = new char [newlen];
     // strcpy (newstring, content);
@@ -108,5 +106,5 @@
 void TiXmlString ::operator = (const TiXmlString & copy)
 {
-    unsigned newlen;
+    size_t newlen;
     char * newstring;
 
@@ -128,8 +126,8 @@
 
 // append a const char * to an existing TiXmlString
-void TiXmlString::append( const char* str, int len )
+void TiXmlString::append( const char* str, size_t len )
 {
     char * new_string;
-    unsigned new_alloc, new_size, size_suffix;
+    size_t new_alloc, new_size, size_suffix;
 	
 	// don't use strlen - it can overrun the len passed in!
@@ -192,5 +190,5 @@
 {
     char * new_string;
-    unsigned new_alloc, new_size;
+    size_t new_alloc, new_size;
 
     new_size = length () + strlen (suffix) + 1;
@@ -252,16 +250,11 @@
 unsigned TiXmlString::find (char tofind, unsigned offset) const
 {
-	//*ME:	warning C4244: convert '__w64 int' to 'unsigned'
-	//*ME:	Use Array-Arithmetic instead of Pointer
-	//  char * lookup;
+    char * lookup;
 
     if (offset >= length ())
         return (unsigned) notfound;
-	//  for (lookup = cstring + offset; * lookup; lookup++)
-	//	if (* lookup == tofind)
-	//	    return lookup - cstring;
-    for( unsigned n=offset ; cstring[n] != '\0' ; n++ )
-	if( cstring[n] == tofind )
-	    return  n ;
+    for (lookup = cstring + offset; * lookup; lookup++)
+        if (* lookup == tofind)
+            return (unsigned)(lookup - cstring);
     return (unsigned) notfound;
 }
@@ -276,5 +269,24 @@
 		return ( strcmp( cstring, compare.cstring ) == 0 );
  	}
+	else if ( length() == 0 && compare.length() == 0 )
+	{
+		return true;
+	}
 	return false;
+}
+
+
+bool TiXmlString::operator == (const char* compare) const
+{
+	if ( allocated && compare && *compare )
+	{
+		assert( cstring );
+		return ( strcmp( cstring, compare ) == 0 );
+ 	}
+	else if ( length() == 0 && (!compare || !*compare ) )	// this is a little dubious, but try to duplicate behavior in other operator==
+	{
+		return true;
+	}
+	return false;	
 }
 
Index: /orxonox/trunk/src/lib/tinyxml/tinystr.h
===================================================================
--- /orxonox/trunk/src/lib/tinyxml/tinystr.h	(revision 4490)
+++ /orxonox/trunk/src/lib/tinyxml/tinystr.h	(revision 4491)
@@ -32,5 +32,6 @@
 
 #ifdef _MSC_VER
-#pragma warning( disable : 4786 )	// Debugger truncating names.
+#pragma warning( disable : 4530 )
+#pragma warning( disable : 4786 )
 #endif
 
@@ -47,6 +48,7 @@
 {
   public :
-    // TiXmlString constructor, based on a string
-    TiXmlString (const char * instring);
+    // TiXmlString constructor, based on a string, mark explicit to force
+	// us to find unnecessary casting.
+    explicit TiXmlString (const char * instring);
 
     // TiXmlString empty constructor
@@ -59,5 +61,5 @@
 
     // TiXmlString copy constructor
-    TiXmlString (const TiXmlString& copy);
+    explicit TiXmlString (const TiXmlString& copy);
 
     // TiXmlString destructor
@@ -76,5 +78,5 @@
 
     // Return the length of a TiXmlString
-    unsigned length () const
+    size_t length () const
 	{
 		return ( allocated ) ? current_length : 0;
@@ -108,4 +110,5 @@
     }
     bool operator == (const TiXmlString & compare) const;
+    bool operator == (const char* compare) const;
     bool operator < (const TiXmlString & compare) const;
     bool operator > (const TiXmlString & compare) const;
@@ -159,5 +162,5 @@
             npos = notfound };
 
-    void append (const char *str, int len );
+    void append (const char *str, size_t len );
 
   protected :
@@ -166,11 +169,11 @@
     char * cstring;
     // Number of chars allocated
-    unsigned allocated;
+    size_t allocated;
     // Current string size
-    unsigned current_length;
+    size_t current_length;
 
     // New size computation. It is simplistic right now : it returns twice the amount
     // we need
-    unsigned assign_new_size (unsigned minimum_to_allocate)
+    size_t assign_new_size (size_t minimum_to_allocate)
     {
         return minimum_to_allocate * 2;
@@ -239,4 +242,9 @@
 } ;
 
+#ifdef _MSC_VER
+#pragma warning( default : 4530 )
+#pragma warning( default : 4786 )
+#endif
+
 #endif	// TIXML_STRING_INCLUDED
 #endif	// TIXML_USE_STL
Index: /orxonox/trunk/src/lib/tinyxml/tinyxml.cc
===================================================================
--- /orxonox/trunk/src/lib/tinyxml/tinyxml.cc	(revision 4490)
+++ /orxonox/trunk/src/lib/tinyxml/tinyxml.cc	(revision 4491)
@@ -319,5 +319,5 @@
 	for ( node = firstChild; node; node = node->next )
 	{
-		if ( node->SValue() == TIXML_STRING( _value ))
+		if ( node->SValue() == _value )
 			return node;
 	}
@@ -331,5 +331,5 @@
 	for ( node = firstChild; node; node = node->next )
 	{
-		if ( node->SValue() == TIXML_STRING( _value ))
+		if ( node->SValue() == _value )
 			return node;
 	}
@@ -343,5 +343,5 @@
 	for ( node = lastChild; node; node = node->prev )
 	{
-		if ( node->SValue() == TIXML_STRING (_value))
+		if ( node->SValue() == _value )
 			return node;
 	}
@@ -354,5 +354,5 @@
 	for ( node = lastChild; node; node = node->prev )
 	{
-		if ( node->SValue() == TIXML_STRING (_value))
+		if ( node->SValue() == _value )
 			return node;
 	}
@@ -360,5 +360,5 @@
 }
 
-const TiXmlNode* TiXmlNode::IterateChildren( TiXmlNode* previous ) const
+const TiXmlNode* TiXmlNode::IterateChildren( const TiXmlNode* previous ) const
 {
 	if ( !previous )
@@ -386,5 +386,5 @@
 }
 
-const TiXmlNode* TiXmlNode::IterateChildren( const char * val, TiXmlNode* previous ) const
+const TiXmlNode* TiXmlNode::IterateChildren( const char * val, const TiXmlNode* previous ) const
 {
 	if ( !previous )
@@ -417,5 +417,5 @@
 	for ( node = next; node; node = node->next )
 	{
-		if ( node->SValue() == TIXML_STRING (_value))
+		if ( node->SValue() == _value )
 			return node;
 	}
@@ -428,5 +428,5 @@
 	for ( node = next; node; node = node->next )
 	{
-		if ( node->SValue() == TIXML_STRING (_value))
+		if ( node->SValue() == _value )
 			return node;
 	}
@@ -439,5 +439,5 @@
 	for ( node = prev; node; node = node->prev )
 	{
-		if ( node->SValue() == TIXML_STRING (_value))
+		if ( node->SValue() == _value )
 			return node;
 	}
@@ -450,5 +450,5 @@
 	for ( node = prev; node; node = node->prev )
 	{
-		if ( node->SValue() == TIXML_STRING (_value))
+		if ( node->SValue() == _value )
 			return node;
 	}
@@ -723,5 +723,5 @@
 void TiXmlElement::SetDoubleAttribute( const char * name, double val )
 {	
-	char buf[128];
+	char buf[256];
 	sprintf( buf, "%f", val );
 	SetAttribute( name, buf );
@@ -1141,5 +1141,5 @@
 void TiXmlAttribute::SetDoubleValue( double _value )
 {
-	char buf [64];
+	char buf [256];
 	sprintf (buf, "%lf", _value);
 	SetValue (buf);
@@ -1413,5 +1413,5 @@
 }
 
-const TiXmlAttribute*	TiXmlAttributeSet::Find( const char * name ) const
+const TiXmlAttribute* TiXmlAttributeSet::Find( const char * name ) const
 {
 	const TiXmlAttribute* node;
Index: /orxonox/trunk/src/lib/tinyxml/tinyxml.h
===================================================================
--- /orxonox/trunk/src/lib/tinyxml/tinyxml.h	(revision 4490)
+++ /orxonox/trunk/src/lib/tinyxml/tinyxml.h	(revision 4491)
@@ -73,5 +73,5 @@
 const int TIXML_MAJOR_VERSION = 2;
 const int TIXML_MINOR_VERSION = 3;
-const int TIXML_PATCH_VERSION = 3;
+const int TIXML_PATCH_VERSION = 4;
 
 /*	Internal structure for tracking location of items 
@@ -483,13 +483,13 @@
 		first. IterateChildren will return null when done.
 	*/
-	const TiXmlNode* IterateChildren( TiXmlNode* previous ) const;
+	const TiXmlNode* IterateChildren( const TiXmlNode* previous ) const;
 	TiXmlNode* IterateChildren( TiXmlNode* previous );
 
 	/// This flavor of IterateChildren searches for children with a particular 'value'
-	const TiXmlNode* IterateChildren( const char * value, TiXmlNode* previous ) const;
+	const TiXmlNode* IterateChildren( const char * value, const TiXmlNode* previous ) const;
 	TiXmlNode* IterateChildren( const char * value, TiXmlNode* previous );
 
     #ifdef TIXML_USE_STL
-	const TiXmlNode* IterateChildren( const std::string& _value, TiXmlNode* previous ) const	{	return IterateChildren (_value.c_str (), previous);	}	///< STL std::string form.
+	const TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) const	{	return IterateChildren (_value.c_str (), previous);	}	///< STL std::string form.
 	TiXmlNode* IterateChildren( const std::string& _value, TiXmlNode* previous ) {	return IterateChildren (_value.c_str (), previous);	}	///< STL std::string form.
 	#endif
@@ -1418,5 +1418,9 @@
 };
 
-
+#ifdef _MSC_VER
+#pragma warning( default : 4530 )
+#pragma warning( default : 4786 )
 #endif
 
+#endif
+
Index: /orxonox/trunk/src/lib/tinyxml/tinyxmlparser.cc
===================================================================
--- /orxonox/trunk/src/lib/tinyxml/tinyxmlparser.cc	(revision 4490)
+++ /orxonox/trunk/src/lib/tinyxml/tinyxmlparser.cc	(revision 4491)
@@ -25,4 +25,5 @@
 #include "tinyxml.h"
 #include <ctype.h>
+#include <stddef.h>
 
 //#define DEBUG_PARSER
@@ -50,7 +51,7 @@
 //				ef bf bf 
 
-const char TIXML_UTF_LEAD_0 = (const char)0xef;
-const char TIXML_UTF_LEAD_1 = (const char)0xbb;
-const char TIXML_UTF_LEAD_2 = (const char)0xbf;
+const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
+const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
+const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
 
 const int TiXmlBase::utf8ByteTable[256] = 
@@ -117,5 +118,5 @@
 
 
-/*static*/ int TiXmlBase::IsAlpha( unsigned char anyByte, TiXmlEncoding )
+/*static*/ int TiXmlBase::IsAlpha( unsigned char anyByte, TiXmlEncoding /*encoding*/ )
 {
 	// This will only work for low-ascii, everything else is assumed to be a valid
@@ -138,5 +139,5 @@
 
 
-/*static*/ int TiXmlBase::IsAlphaNum( unsigned char anyByte, TiXmlEncoding )
+/*static*/ int TiXmlBase::IsAlphaNum( unsigned char anyByte, TiXmlEncoding /*encoding*/ )
 {
 	// This will only work for low-ascii, everything else is assumed to be a valid
@@ -202,6 +203,9 @@
 	while ( p < now )
 	{
+		// Treat p as unsigned, so we have a happy compiler.
+		const unsigned char* pU = (const unsigned char*)p;
+
 		// Code contributed by Fletcher Dunn: (modified by lee)
-		switch (*p) {
+		switch (*pU) {
 			case 0:
 				// We *should* never get here, but in case we do, don't
@@ -253,9 +257,9 @@
 						// In these cases, don't advance the column. These are
 						// 0-width spaces.
-						if ( *(p+1)==TIXML_UTF_LEAD_1 && *(p+2)==TIXML_UTF_LEAD_2 )
+						if ( *(pU+1)==TIXML_UTF_LEAD_1 && *(pU+2)==TIXML_UTF_LEAD_2 )
 							p += 3;	
-						else if ( *(p+1)==(char)(0xbf) && *(p+2)==(char)(0xbe) )
+						else if ( *(pU+1)==0xbfU && *(pU+2)==0xbeU )
 							p += 3;	
-						else if ( *(p+1)==(char)(0xbf) && *(p+2)==(char)(0xbf) )
+						else if ( *(pU+1)==0xbfU && *(pU+2)==0xbfU )
 							p += 3;	
 						else
@@ -309,22 +313,24 @@
 		while ( *p )
 		{
+			const unsigned char* pU = (const unsigned char*)p;
+			
 			// Skip the stupid Microsoft UTF-8 Byte order marks
-			if (	*(p+0)==TIXML_UTF_LEAD_0
-				 && *(p+1)==TIXML_UTF_LEAD_1 
-				 && *(p+2)==TIXML_UTF_LEAD_2 )
+			if (	*(pU+0)==TIXML_UTF_LEAD_0
+				 && *(pU+1)==TIXML_UTF_LEAD_1 
+				 && *(pU+2)==TIXML_UTF_LEAD_2 )
 			{
 				p += 3;
 				continue;
 			}
-			else if(*(p+0)==TIXML_UTF_LEAD_0
-				 && *(p+1)==(const char) 0xbf
-				 && *(p+2)==(const char) 0xbe )
+			else if(*(pU+0)==TIXML_UTF_LEAD_0
+				 && *(pU+1)==0xbfU
+				 && *(pU+2)==0xbeU )
 			{
 				p += 3;
 				continue;
 			}
-			else if(*(p+0)==TIXML_UTF_LEAD_0
-				 && *(p+1)==(const char) 0xbf
-				 && *(p+2)==(const char) 0xbf )
+			else if(*(pU+0)==TIXML_UTF_LEAD_0
+				 && *(pU+1)==0xbfU
+				 && *(pU+2)==0xbfU )
 			{
 				p += 3;
@@ -421,7 +427,5 @@
 	{
 		unsigned long ucs = 0;
-		//*ME:	warning C4244: convert '__w64 int' to 'unsigned'
-		//*ME:	Use size_t instead of unsigned (pointer-arithmetic)
-		size_t delta = 0;
+		ptrdiff_t delta = 0;
 		unsigned mult = 1;
 
@@ -708,7 +712,8 @@
 	{
 		// Check for the Microsoft UTF-8 lead bytes.
-		if (	*(p+0) && *(p+0) == TIXML_UTF_LEAD_0
-			 && *(p+1) && *(p+1) == TIXML_UTF_LEAD_1
-			 && *(p+2) && *(p+2) == TIXML_UTF_LEAD_2 )
+		const unsigned char* pU = (const unsigned char*)p;
+		if (	*(pU+0) && *(pU+0) == TIXML_UTF_LEAD_0
+			 && *(pU+1) && *(pU+1) == TIXML_UTF_LEAD_1
+			 && *(pU+2) && *(pU+2) == TIXML_UTF_LEAD_2 )
 		{
 			encoding = TIXML_ENCODING_UTF8;
