mirror of
https://github.com/EQEmu/Server.git
synced 2025-12-12 09:31:30 +00:00
Nuke unused TinyXML
This commit is contained in:
Michael Cook (mackal)
parent
4e129ca7b5
commit
ae0eebe043
@ -73,7 +73,6 @@ SET(common_sources
|
||||
textures.cpp
|
||||
timer.cpp
|
||||
unix.cpp
|
||||
xml_parser.cpp
|
||||
platform.cpp
|
||||
json/jsoncpp.cpp
|
||||
net/console_server.cpp
|
||||
@ -104,10 +103,6 @@ SET(common_sources
|
||||
patches/uf.cpp
|
||||
patches/uf_limits.cpp
|
||||
StackWalker/StackWalker.cpp
|
||||
tinyxml/tinystr.cpp
|
||||
tinyxml/tinyxml.cpp
|
||||
tinyxml/tinyxmlerror.cpp
|
||||
tinyxml/tinyxmlparser.cpp
|
||||
util/directory.cpp
|
||||
util/uuid.cpp)
|
||||
|
||||
@ -215,7 +210,6 @@ SET(common_headers
|
||||
unix.h
|
||||
useperl.h
|
||||
version.h
|
||||
xml_parser.h
|
||||
zone_numbers.h
|
||||
event/event_loop.h
|
||||
event/task.h
|
||||
@ -269,8 +263,6 @@ SET(common_headers
|
||||
patches/uf_ops.h
|
||||
patches/uf_structs.h
|
||||
StackWalker/StackWalker.h
|
||||
tinyxml/tinystr.h
|
||||
tinyxml/tinyxml.h
|
||||
util/memory_stream.h
|
||||
util/directory.h
|
||||
util/uuid.h)
|
||||
@ -373,15 +365,6 @@ SOURCE_GROUP(StackWalker FILES
|
||||
StackWalker/StackWalker.cpp
|
||||
)
|
||||
|
||||
SOURCE_GROUP(TinyXML FILES
|
||||
tinyxml/tinystr.h
|
||||
tinyxml/tinyxml.h
|
||||
tinyxml/tinystr.cpp
|
||||
tinyxml/tinyxml.cpp
|
||||
tinyxml/tinyxmlerror.cpp
|
||||
tinyxml/tinyxmlparser.cpp
|
||||
)
|
||||
|
||||
SOURCE_GROUP(Util FILES
|
||||
util/memory_stream.h
|
||||
util/directory.cpp
|
||||
@ -390,7 +373,7 @@ SOURCE_GROUP(Util FILES
|
||||
util/uuid.h
|
||||
)
|
||||
|
||||
INCLUDE_DIRECTORIES(Patches SocketLib StackWalker TinyXML)
|
||||
INCLUDE_DIRECTORIES(Patches SocketLib StackWalker)
|
||||
|
||||
ADD_LIBRARY(common ${common_sources} ${common_headers})
|
||||
|
||||
|
||||
@ -1,318 +0,0 @@
|
||||
/*
|
||||
www.sourceforge.net/projects/tinyxml
|
||||
Original file by Yves Berquin.
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any
|
||||
damages arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any
|
||||
purpose, including commercial applications, and to alter it and
|
||||
redistribute it freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must
|
||||
not claim that you wrote the original software. If you use this
|
||||
software in a product, an acknowledgment in the product documentation
|
||||
would be appreciated but is not required.
|
||||
|
||||
2. Altered source versions must be plainly marked as such, and
|
||||
must not be misrepresented as being the original software.
|
||||
|
||||
3. This notice may not be removed or altered from any source
|
||||
distribution.
|
||||
*/
|
||||
|
||||
#include "tinyxml.h"
|
||||
|
||||
#ifndef TIXML_USE_STL
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#include "tinystr.h"
|
||||
|
||||
// TiXmlString constructor, based on a C string
|
||||
TiXmlString::TiXmlString (const char* instring)
|
||||
{
|
||||
size_t newlen;
|
||||
char * newstring;
|
||||
|
||||
if (!instring)
|
||||
{
|
||||
allocated = 0;
|
||||
cstring = nullptr;
|
||||
current_length = 0;
|
||||
return;
|
||||
}
|
||||
newlen = strlen (instring) + 1;
|
||||
newstring = new char [newlen];
|
||||
memcpy (newstring, instring, newlen);
|
||||
// strcpy (newstring, instring);
|
||||
allocated = newlen;
|
||||
cstring = newstring;
|
||||
current_length = newlen - 1;
|
||||
}
|
||||
|
||||
// TiXmlString copy constructor
|
||||
TiXmlString::TiXmlString (const TiXmlString& copy)
|
||||
{
|
||||
size_t newlen;
|
||||
char * newstring;
|
||||
|
||||
// Prevent copy to self!
|
||||
if ( © == this )
|
||||
return;
|
||||
|
||||
if (! copy . allocated)
|
||||
{
|
||||
allocated = 0;
|
||||
cstring = nullptr;
|
||||
current_length = 0;
|
||||
return;
|
||||
}
|
||||
newlen = copy . length () + 1;
|
||||
newstring = new char [newlen];
|
||||
// strcpy (newstring, copy . cstring);
|
||||
memcpy (newstring, copy . cstring, newlen);
|
||||
allocated = newlen;
|
||||
cstring = newstring;
|
||||
current_length = newlen - 1;
|
||||
}
|
||||
|
||||
// TiXmlString = operator. Safe when assign own content
|
||||
void TiXmlString ::operator = (const char * content)
|
||||
{
|
||||
size_t newlen;
|
||||
char * newstring;
|
||||
|
||||
if (! content)
|
||||
{
|
||||
empty_it ();
|
||||
return;
|
||||
}
|
||||
newlen = strlen (content) + 1;
|
||||
newstring = new char [newlen];
|
||||
// strcpy (newstring, content);
|
||||
memcpy (newstring, content, newlen);
|
||||
empty_it ();
|
||||
allocated = newlen;
|
||||
cstring = newstring;
|
||||
current_length = newlen - 1;
|
||||
}
|
||||
|
||||
// = operator. Safe when assign own content
|
||||
void TiXmlString ::operator = (const TiXmlString & copy)
|
||||
{
|
||||
size_t newlen;
|
||||
char * newstring;
|
||||
|
||||
if (! copy . length ())
|
||||
{
|
||||
empty_it ();
|
||||
return;
|
||||
}
|
||||
newlen = copy . length () + 1;
|
||||
newstring = new char [newlen];
|
||||
// strcpy (newstring, copy . c_str ());
|
||||
memcpy (newstring, copy . c_str (), newlen);
|
||||
empty_it ();
|
||||
allocated = newlen;
|
||||
cstring = newstring;
|
||||
current_length = newlen - 1;
|
||||
}
|
||||
|
||||
|
||||
// append a const char * to an existing TiXmlString
|
||||
void TiXmlString::append( const char* str, size_t len )
|
||||
{
|
||||
char * new_string;
|
||||
size_t new_alloc, new_size, size_suffix;
|
||||
|
||||
// don't use strlen - it can overrun the len passed in!
|
||||
const char* p = str;
|
||||
size_suffix = 0;
|
||||
|
||||
while ( *p && size_suffix < (unsigned)len )
|
||||
{
|
||||
++p;
|
||||
++size_suffix;
|
||||
}
|
||||
if ( !size_suffix)
|
||||
return;
|
||||
|
||||
new_size = length () + size_suffix + 1;
|
||||
// check if we need to expand
|
||||
if (new_size > allocated)
|
||||
{
|
||||
// compute new size
|
||||
new_alloc = assign_new_size (new_size);
|
||||
|
||||
// allocate new buffer
|
||||
new_string = new char [new_alloc];
|
||||
new_string [0] = 0;
|
||||
|
||||
// copy the previous allocated buffer into this one
|
||||
if (allocated && cstring)
|
||||
// strcpy (new_string, cstring);
|
||||
memcpy (new_string, cstring, length ());
|
||||
|
||||
// append the suffix. It does exist, otherwize we wouldn't be expanding
|
||||
// strncat (new_string, str, len);
|
||||
memcpy (new_string + length (),
|
||||
str,
|
||||
size_suffix);
|
||||
|
||||
// return previsously allocated buffer if any
|
||||
if (allocated && cstring)
|
||||
delete [] cstring;
|
||||
|
||||
// update member variables
|
||||
cstring = new_string;
|
||||
allocated = new_alloc;
|
||||
}
|
||||
else
|
||||
{
|
||||
// we know we can safely append the new string
|
||||
// strncat (cstring, str, len);
|
||||
memcpy (cstring + length (),
|
||||
str,
|
||||
size_suffix);
|
||||
}
|
||||
current_length = new_size - 1;
|
||||
cstring [current_length] = 0;
|
||||
}
|
||||
|
||||
|
||||
// append a const char * to an existing TiXmlString
|
||||
void TiXmlString::append( const char * suffix )
|
||||
{
|
||||
char * new_string;
|
||||
size_t new_alloc, new_size;
|
||||
|
||||
new_size = length () + strlen (suffix) + 1;
|
||||
// check if we need to expand
|
||||
if (new_size > allocated)
|
||||
{
|
||||
// compute new size
|
||||
new_alloc = assign_new_size (new_size);
|
||||
|
||||
// allocate new buffer
|
||||
new_string = new char [new_alloc];
|
||||
new_string [0] = 0;
|
||||
|
||||
// copy the previous allocated buffer into this one
|
||||
if (allocated && cstring)
|
||||
memcpy (new_string, cstring, 1 + length ());
|
||||
// strcpy (new_string, cstring);
|
||||
|
||||
// append the suffix. It does exist, otherwize we wouldn't be expanding
|
||||
// strcat (new_string, suffix);
|
||||
memcpy (new_string + length (),
|
||||
suffix,
|
||||
strlen (suffix) + 1);
|
||||
|
||||
// return previsously allocated buffer if any
|
||||
if (allocated && cstring)
|
||||
delete [] cstring;
|
||||
|
||||
// update member variables
|
||||
cstring = new_string;
|
||||
allocated = new_alloc;
|
||||
}
|
||||
else
|
||||
{
|
||||
// we know we can safely append the new string
|
||||
// strcat (cstring, suffix);
|
||||
memcpy (cstring + length (),
|
||||
suffix,
|
||||
strlen (suffix) + 1);
|
||||
}
|
||||
current_length = new_size - 1;
|
||||
}
|
||||
|
||||
// Check for TiXmlString equuivalence
|
||||
//bool TiXmlString::operator == (const TiXmlString & compare) const
|
||||
//{
|
||||
// return (! strcmp (c_str (), compare . c_str ()));
|
||||
//}
|
||||
|
||||
//unsigned TiXmlString::length () const
|
||||
//{
|
||||
// if (allocated)
|
||||
// // return strlen (cstring);
|
||||
// return current_length;
|
||||
// return 0;
|
||||
//}
|
||||
|
||||
|
||||
unsigned TiXmlString::find (char tofind, unsigned offset) const
|
||||
{
|
||||
char * lookup;
|
||||
|
||||
if (offset >= length ())
|
||||
return (unsigned) notfound;
|
||||
for (lookup = cstring + offset; * lookup; lookup++)
|
||||
if (* lookup == tofind)
|
||||
return (unsigned)(lookup - cstring);
|
||||
return (unsigned) notfound;
|
||||
}
|
||||
|
||||
|
||||
bool TiXmlString::operator == (const TiXmlString & compare) const
|
||||
{
|
||||
if ( allocated && compare.allocated )
|
||||
{
|
||||
assert( cstring );
|
||||
assert( compare.cstring );
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
bool TiXmlString::operator < (const TiXmlString & compare) const
|
||||
{
|
||||
if ( allocated && compare.allocated )
|
||||
{
|
||||
assert( cstring );
|
||||
assert( compare.cstring );
|
||||
return ( strcmp( cstring, compare.cstring ) > 0 );
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool TiXmlString::operator > (const TiXmlString & compare) const
|
||||
{
|
||||
if ( allocated && compare.allocated )
|
||||
{
|
||||
assert( cstring );
|
||||
assert( compare.cstring );
|
||||
return ( strcmp( cstring, compare.cstring ) < 0 );
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
#endif // TIXML_USE_STL
|
||||
@ -1,250 +0,0 @@
|
||||
/*
|
||||
www.sourceforge.net/projects/tinyxml
|
||||
Original file by Yves Berquin.
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any
|
||||
damages arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any
|
||||
purpose, including commercial applications, and to alter it and
|
||||
redistribute it freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must
|
||||
not claim that you wrote the original software. If you use this
|
||||
software in a product, an acknowledgment in the product documentation
|
||||
would be appreciated but is not required.
|
||||
|
||||
2. Altered source versions must be plainly marked as such, and
|
||||
must not be misrepresented as being the original software.
|
||||
|
||||
3. This notice may not be removed or altered from any source
|
||||
distribution.
|
||||
*/
|
||||
|
||||
#include "tinyxml.h"
|
||||
|
||||
|
||||
#ifndef TIXML_USE_STL
|
||||
|
||||
#ifndef TIXML_STRING_INCLUDED
|
||||
#define TIXML_STRING_INCLUDED
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning( disable : 4530 )
|
||||
#pragma warning( disable : 4786 )
|
||||
#endif
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
/*
|
||||
TiXmlString is an emulation of the std::string template.
|
||||
Its purpose is to allow compiling TinyXML on compilers with no or poor STL support.
|
||||
Only the member functions relevant to the TinyXML project have been implemented.
|
||||
The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase
|
||||
a string and there's no more room, we allocate a buffer twice as big as we need.
|
||||
*/
|
||||
class TiXmlString
|
||||
{
|
||||
public :
|
||||
// TiXmlString constructor, based on a string, mark explicit to force
|
||||
// us to find unnecessary casting.
|
||||
explicit TiXmlString (const char * instring);
|
||||
|
||||
// TiXmlString empty constructor
|
||||
TiXmlString ()
|
||||
{
|
||||
allocated = 0;
|
||||
cstring = nullptr;
|
||||
current_length = 0;
|
||||
}
|
||||
|
||||
// TiXmlString copy constructor
|
||||
explicit TiXmlString (const TiXmlString& copy);
|
||||
|
||||
// TiXmlString destructor
|
||||
~ TiXmlString ()
|
||||
{
|
||||
empty_it ();
|
||||
}
|
||||
|
||||
// Convert a TiXmlString into a classical char *
|
||||
const char * c_str () const
|
||||
{
|
||||
if (allocated)
|
||||
return cstring;
|
||||
return "";
|
||||
}
|
||||
|
||||
// Return the length of a TiXmlString
|
||||
size_t length () const
|
||||
{
|
||||
return ( allocated ) ? current_length : 0;
|
||||
}
|
||||
|
||||
// TiXmlString = operator
|
||||
void operator = (const char * content);
|
||||
|
||||
// = operator
|
||||
void operator = (const TiXmlString & copy);
|
||||
|
||||
// += operator. Maps to append
|
||||
TiXmlString& operator += (const char * suffix)
|
||||
{
|
||||
append (suffix);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// += operator. Maps to append
|
||||
TiXmlString& operator += (char single)
|
||||
{
|
||||
append (single);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// += operator. Maps to append
|
||||
TiXmlString& operator += (TiXmlString & suffix)
|
||||
{
|
||||
append (suffix);
|
||||
return *this;
|
||||
}
|
||||
bool operator == (const TiXmlString & compare) const;
|
||||
bool operator == (const char* compare) const;
|
||||
bool operator < (const TiXmlString & compare) const;
|
||||
bool operator > (const TiXmlString & compare) const;
|
||||
|
||||
// Checks if a TiXmlString is empty
|
||||
bool empty () const
|
||||
{
|
||||
return length () ? false : true;
|
||||
}
|
||||
|
||||
// single char extraction
|
||||
const char& at (unsigned index) const
|
||||
{
|
||||
assert( index < length ());
|
||||
return cstring [index];
|
||||
}
|
||||
|
||||
// find a char in a string. Return TiXmlString::notfound if not found
|
||||
unsigned find (char lookup) const
|
||||
{
|
||||
return find (lookup, 0);
|
||||
}
|
||||
|
||||
// find a char in a string from an offset. Return TiXmlString::notfound if not found
|
||||
unsigned find (char tofind, unsigned offset) const;
|
||||
|
||||
/* Function to reserve a big amount of data when we know we'll need it. Be aware that this
|
||||
function clears the content of the TiXmlString if any exists.
|
||||
*/
|
||||
void reserve (unsigned size)
|
||||
{
|
||||
empty_it ();
|
||||
if (size)
|
||||
{
|
||||
allocated = size;
|
||||
cstring = new char [size];
|
||||
cstring [0] = 0;
|
||||
current_length = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// [] operator
|
||||
char& operator [] (unsigned index) const
|
||||
{
|
||||
assert( index < length ());
|
||||
return cstring [index];
|
||||
}
|
||||
|
||||
// Error value for find primitive
|
||||
enum { notfound = 0xffffffff,
|
||||
npos = notfound };
|
||||
|
||||
void append (const char *str, size_t len );
|
||||
|
||||
protected :
|
||||
|
||||
// The base string
|
||||
char * cstring;
|
||||
// Number of chars allocated
|
||||
size_t allocated;
|
||||
// Current string size
|
||||
size_t current_length;
|
||||
|
||||
// New size computation. It is simplistic right now : it returns twice the amount
|
||||
// we need
|
||||
size_t assign_new_size (size_t minimum_to_allocate)
|
||||
{
|
||||
return minimum_to_allocate * 2;
|
||||
}
|
||||
|
||||
// Internal function that clears the content of a TiXmlString
|
||||
void empty_it ()
|
||||
{
|
||||
if (cstring)
|
||||
delete [] cstring;
|
||||
cstring = nullptr;
|
||||
allocated = 0;
|
||||
current_length = 0;
|
||||
}
|
||||
|
||||
void append (const char *suffix );
|
||||
|
||||
// append function for another TiXmlString
|
||||
void append (const TiXmlString & suffix)
|
||||
{
|
||||
append (suffix . c_str ());
|
||||
}
|
||||
|
||||
// append for a single char.
|
||||
void append (char single)
|
||||
{
|
||||
if ( cstring && current_length < (allocated-1) )
|
||||
{
|
||||
cstring[ current_length ] = single;
|
||||
++current_length;
|
||||
cstring[ current_length ] = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
char smallstr [2];
|
||||
smallstr [0] = single;
|
||||
smallstr [1] = 0;
|
||||
append (smallstr);
|
||||
}
|
||||
}
|
||||
|
||||
} ;
|
||||
|
||||
/*
|
||||
TiXmlOutStream is an emulation of std::ostream. It is based on TiXmlString.
|
||||
Only the operators that we need for TinyXML have been developped.
|
||||
*/
|
||||
class TiXmlOutStream : public TiXmlString
|
||||
{
|
||||
public :
|
||||
TiXmlOutStream () : TiXmlString () {}
|
||||
|
||||
// TiXmlOutStream << operator. Maps to TiXmlString::append
|
||||
TiXmlOutStream & operator << (const char * in)
|
||||
{
|
||||
append (in);
|
||||
return (* this);
|
||||
}
|
||||
|
||||
// TiXmlOutStream << operator. Maps to TiXmlString::append
|
||||
TiXmlOutStream & operator << (const TiXmlString & in)
|
||||
{
|
||||
append (in . c_str ());
|
||||
return (* this);
|
||||
}
|
||||
} ;
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning( default : 4530 )
|
||||
#pragma warning( default : 4786 )
|
||||
#endif
|
||||
|
||||
#endif // TIXML_STRING_INCLUDED
|
||||
#endif // TIXML_USE_STL
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,51 +0,0 @@
|
||||
/*
|
||||
www.sourceforge.net/projects/tinyxml
|
||||
Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any
|
||||
damages arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any
|
||||
purpose, including commercial applications, and to alter it and
|
||||
redistribute it freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must
|
||||
not claim that you wrote the original software. If you use this
|
||||
software in a product, an acknowledgment in the product documentation
|
||||
would be appreciated but is not required.
|
||||
|
||||
2. Altered source versions must be plainly marked as such, and
|
||||
must not be misrepresented as being the original software.
|
||||
|
||||
3. This notice may not be removed or altered from any source
|
||||
distribution.
|
||||
*/
|
||||
|
||||
#include "tinyxml.h"
|
||||
|
||||
// The goal of the seperate error file is to make the first
|
||||
// step towards localization. tinyxml (currently) only supports
|
||||
// latin-1, but at least the error messages could now be translated.
|
||||
//
|
||||
// It also cleans up the code a bit.
|
||||
//
|
||||
|
||||
const char* TiXmlBase::errorString[ TIXML_ERROR_STRING_COUNT ] =
|
||||
{
|
||||
"No error",
|
||||
"Error",
|
||||
"Failed to open file",
|
||||
"Memory allocation failed.",
|
||||
"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.",
|
||||
};
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,101 +0,0 @@
|
||||
/* EQEMu: Everquest Server Emulator
|
||||
Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; version 2 of the License.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY except by those people which sell it, which
|
||||
are required to give you total support for your newly bought product;
|
||||
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
||||
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
#include "global_define.h"
|
||||
#include "xml_parser.h"
|
||||
|
||||
XMLParser::XMLParser() {
|
||||
ParseOkay = false;
|
||||
}
|
||||
|
||||
bool XMLParser::ParseFile(const char *file, const char *root_ele) {
|
||||
std::map<std::string,ElementHandler>::iterator handler;
|
||||
TiXmlDocument doc( file );
|
||||
if(!doc.LoadFile()) {
|
||||
printf("Unable to load '%s': %s\n", file, doc.ErrorDesc());
|
||||
return(false);
|
||||
}
|
||||
|
||||
TiXmlElement *root = doc.FirstChildElement( root_ele );
|
||||
if(root == nullptr) {
|
||||
printf("Unable to find root '%s' in %s\n",root_ele, file);
|
||||
return(false);
|
||||
}
|
||||
|
||||
ParseOkay=true;
|
||||
|
||||
TiXmlNode *main_element = nullptr;
|
||||
while( (main_element = root->IterateChildren( main_element )) ) {
|
||||
if(main_element->Type() != TiXmlNode::ELEMENT)
|
||||
continue; //skip crap we dont care about
|
||||
TiXmlElement *ele = (TiXmlElement *) main_element;
|
||||
|
||||
handler=Handlers.find(ele->Value());
|
||||
if (handler!=Handlers.end() && handler->second) {
|
||||
ElementHandler h=handler->second;
|
||||
|
||||
/*
|
||||
*
|
||||
* This is kinda a sketchy operation here, since all of these
|
||||
* element handler methods will be functions in child classes.
|
||||
* This essentially causes us to do an un-checkable (and hence
|
||||
* un-handle-properly-able) cast down to the child class. This
|
||||
* WILL BREAK if any children classes do multiple inheritance.
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
(this->*h)(ele);
|
||||
} else {
|
||||
//unhandled element.... do nothing for now
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return(ParseOkay);
|
||||
}
|
||||
|
||||
const char *XMLParser::ParseTextBlock(TiXmlNode *within, const char *name, bool optional) {
|
||||
TiXmlElement * txt = within->FirstChildElement(name);
|
||||
if(txt == nullptr) {
|
||||
if(!optional) {
|
||||
printf("Unable to find a '%s' element on %s element at line %d\n", name, within->Value(), within->Row());
|
||||
ParseOkay=false;
|
||||
}
|
||||
return(nullptr);
|
||||
}
|
||||
TiXmlNode *contents = txt->FirstChild();
|
||||
if(contents == nullptr || contents->Type() != TiXmlNode::TEXT) {
|
||||
if(!optional)
|
||||
printf("Node '%s' was expected to be a text element in %s element at line %d\n", name, txt->Value(), txt->Row());
|
||||
return(nullptr);
|
||||
}
|
||||
return(contents->Value());
|
||||
}
|
||||
|
||||
const char *XMLParser::GetText(TiXmlNode *within, bool optional) {
|
||||
TiXmlNode *contents = within->FirstChild();
|
||||
if(contents == nullptr || contents->Type() != TiXmlNode::TEXT) {
|
||||
if(!optional) {
|
||||
printf("Node was expected to be a text element in %s element at line %d\n", within->Value(), within->Row());
|
||||
ParseOkay=false;
|
||||
}
|
||||
return(nullptr);
|
||||
}
|
||||
return(contents->Value());
|
||||
}
|
||||
|
||||
@ -1,52 +0,0 @@
|
||||
/* EQEMu: Everquest Server Emulator
|
||||
Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; version 2 of the License.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY except by those people which sell it, which
|
||||
are required to give you total support for your newly bought product;
|
||||
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
||||
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
#ifndef XMLParser_H
|
||||
#define XMLParser_H
|
||||
|
||||
#include "global_define.h"
|
||||
#include "tinyxml/tinyxml.h"
|
||||
#include "../common/types.h"
|
||||
|
||||
#include <string>
|
||||
#include <map>
|
||||
|
||||
/*
|
||||
* See note in XMLParser::ParseFile() before inheriting this class.
|
||||
*/
|
||||
class XMLParser {
|
||||
public:
|
||||
typedef void (XMLParser::*ElementHandler)(TiXmlElement *ele);
|
||||
|
||||
XMLParser();
|
||||
virtual ~XMLParser() {}
|
||||
|
||||
bool ParseFile(const char *file, const char *root_ele);
|
||||
bool ParseStatus() const { return ParseOkay; }
|
||||
|
||||
protected:
|
||||
const char *ParseTextBlock(TiXmlNode *within, const char *name, bool optional = false);
|
||||
const char *GetText(TiXmlNode *within, bool optional = false);
|
||||
|
||||
std::map<std::string,ElementHandler> Handlers;
|
||||
|
||||
bool ParseOkay;
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user