760 lines
24 KiB
C++
760 lines
24 KiB
C++
/*
|
|
www.sourceforge.net/projects/dfhack
|
|
Copyright (c) 2009 Petr Mrázek (peterix), Kenneth Ferland (Impaler[WrG]), dorf
|
|
|
|
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 "Internal.h"
|
|
|
|
#include "dfhack/VersionInfoFactory.h"
|
|
#include "dfhack/VersionInfo.h"
|
|
#include "dfhack/DFError.h"
|
|
#include <algorithm>
|
|
|
|
using namespace DFHack;
|
|
|
|
template<class _T1, class _T2, class _T3>
|
|
struct triple
|
|
{
|
|
typedef _T1 first_type;
|
|
typedef _T2 second_type;
|
|
typedef _T3 third_type;
|
|
|
|
_T1 first;
|
|
_T2 second;
|
|
_T3 third;
|
|
|
|
triple() : first(), second(), third() { }
|
|
|
|
triple(const _T1& __a, const _T2& __b, const _T3& __c) : first(__a), second(__b), third(__c) { }
|
|
|
|
template<class _U1, class _U2, class _U3>
|
|
triple(const triple<_U1, _U2, _U3>& __p) : first(__p.first), second(__p.second), third(__p.third) { }
|
|
|
|
};
|
|
|
|
template<class _T1, class _T2, class _T3>
|
|
inline bool operator==(const triple<_T1, _T2, _T3>& __x, const triple<_T1, _T2, _T3>& __y)
|
|
{
|
|
return __x.first == __y.first && __x.second == __y.second && __x.third == __y.third;
|
|
}
|
|
|
|
template<class _T1, class _T2, class _T3>
|
|
inline bool operator<(const triple<_T1, _T2, _T3>& __x, const triple<_T1, _T2, _T3>& __y)
|
|
{
|
|
return
|
|
__x.first < __y.first ||
|
|
(!(__y.first < __x.first) && __x.second < __y.second) ||
|
|
(!(__y.first < __x.first) && !(__x.second < __y.second) && (__x.third < __y.third));
|
|
}
|
|
|
|
template<class _T1, class _T2, class _T3>
|
|
inline bool operator!=(const triple<_T1, _T2, _T3>& __x, const triple<_T1, _T2, _T3>& __y)
|
|
{
|
|
return !(__x == __y);
|
|
}
|
|
|
|
template<class _T1, class _T2, class _T3>
|
|
inline bool operator>(const triple<_T1, _T2, _T3>& __x, const triple<_T1, _T2, _T3>& __y)
|
|
{
|
|
return __y < __x;
|
|
}
|
|
|
|
template<class _T1, class _T2, class _T3>
|
|
inline bool operator<=(const triple<_T1, _T2, _T3>& __x, const triple<_T1, _T2, _T3>& __y)
|
|
{
|
|
return !(__y < __x);
|
|
}
|
|
|
|
template<class _T1, class _T2, class _T3>
|
|
inline bool operator>=(const triple<_T1, _T2, _T3>& __x, const triple<_T1, _T2, _T3>& __y)
|
|
{
|
|
return !(__x < __y);
|
|
}
|
|
|
|
VersionInfoFactory::VersionInfoFactory(string path_to_xml)
|
|
{
|
|
error = false;
|
|
loadFile(path_to_xml);
|
|
}
|
|
|
|
VersionInfoFactory::~VersionInfoFactory()
|
|
{
|
|
// for each stored version, delete
|
|
for(uint32_t i = 0; i < versions.size();i++)
|
|
{
|
|
delete versions[i];
|
|
}
|
|
versions.clear();
|
|
}
|
|
|
|
VersionInfo * VersionInfoFactory::getVersionInfoByMD5(string hash)
|
|
{
|
|
VersionInfo * vinfo;
|
|
for(uint32_t i = 0; i < versions.size();i++)
|
|
{
|
|
vinfo = versions[i];
|
|
string test_hash;
|
|
if(vinfo->getMD5(test_hash) && hash == test_hash)
|
|
{
|
|
return vinfo;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
VersionInfo * VersionInfoFactory::getVersionInfoByPETimestamp(uint32_t timestamp)
|
|
{
|
|
VersionInfo * vinfo;
|
|
//cout << "lookup size:" << versions.size() << endl;
|
|
for(uint32_t i = 0; i < versions.size();i++)
|
|
{
|
|
vinfo = versions[i];
|
|
uint32_t test_PE;
|
|
//cout << "Testing version: " << hex << vinfo <<" No:" << dec << i << endl;
|
|
//cout << vinfo->getName() << endl;
|
|
if(vinfo->getPE(test_PE) && test_PE == timestamp)
|
|
{
|
|
return vinfo;
|
|
}
|
|
//cout << "LOOP ENDS" << endl;
|
|
}
|
|
//cout << "NOTHING!" << endl;
|
|
return 0;
|
|
}
|
|
|
|
|
|
void VersionInfoFactory::ParseVTable(TiXmlElement* vtable, VersionInfo* mem)
|
|
{
|
|
TiXmlElement* pClassEntry;
|
|
TiXmlElement* pClassSubEntry;
|
|
/*
|
|
// check for rebase, do rebase if check positive
|
|
const char * rebase = vtable->Attribute("rebase");
|
|
if(rebase)
|
|
{
|
|
int32_t rebase_offset = strtol(rebase, NULL, 16);
|
|
mem->RebaseVTable(rebase_offset);
|
|
}
|
|
*/
|
|
// parse vtable entries
|
|
pClassEntry = vtable->FirstChildElement();
|
|
for(;pClassEntry;pClassEntry=pClassEntry->NextSiblingElement())
|
|
{
|
|
string type = pClassEntry->Value();
|
|
const char *cstr_name = pClassEntry->Attribute("name");
|
|
const char *cstr_vtable = pClassEntry->Attribute("vtable");
|
|
uint32_t vtable = 0;
|
|
if(cstr_vtable)
|
|
vtable = strtol(cstr_vtable, NULL, 16);
|
|
// it's a simple class
|
|
if(type== "class")
|
|
{
|
|
mem->setClass(cstr_name, vtable);
|
|
}
|
|
// it's a multi-type class
|
|
else if (type == "multiclass")
|
|
{
|
|
// get offset of the type variable
|
|
const char *cstr_typeoffset = pClassEntry->Attribute("typeoffset");
|
|
uint32_t typeoffset = 0;
|
|
if(cstr_typeoffset)
|
|
typeoffset = strtol(cstr_typeoffset, NULL, 16);
|
|
t_class * mclass = mem->setClass(cstr_name, vtable, typeoffset);
|
|
// parse class sub-entries
|
|
pClassSubEntry = pClassEntry->FirstChildElement();
|
|
for(;pClassSubEntry;pClassSubEntry=pClassSubEntry->NextSiblingElement())
|
|
{
|
|
type = pClassSubEntry->Value();
|
|
if(type== "class")
|
|
{
|
|
// type is a value loaded from type offset
|
|
cstr_name = pClassSubEntry->Attribute("name");
|
|
const char *cstr_value = pClassSubEntry->Attribute("type");
|
|
mem->setClassChild(mclass,cstr_name,cstr_value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct breadcrumb
|
|
{
|
|
TiXmlElement * first;
|
|
OffsetGroup * second;
|
|
};
|
|
|
|
void VersionInfoFactory::ParseOffsets(TiXmlElement * parent, VersionInfo* target, bool initial)
|
|
{
|
|
// we parse the groups iteratively instead of recursively
|
|
// breadcrubs acts like a makeshift stack
|
|
// first pair entry stores the current element of that level
|
|
// second pair entry the group object from OffsetGroup
|
|
typedef triple< TiXmlElement *, OffsetGroup *, INVAL_TYPE> groupTriple;
|
|
vector< groupTriple > breadcrumbs;
|
|
{
|
|
TiXmlElement* pEntry;
|
|
// we get the <Offsets>, look at the children
|
|
pEntry = parent->FirstChildElement();
|
|
const char *cstr_invalid = parent->Attribute("valid");
|
|
INVAL_TYPE parent_inval = NOT_SET;
|
|
if(cstr_invalid)
|
|
{
|
|
if(strcmp(cstr_invalid,"false") == 0)
|
|
parent_inval = IS_INVALID;
|
|
else if(strcmp(cstr_invalid,"true") == 0)
|
|
parent_inval = IS_VALID;
|
|
}
|
|
OffsetGroup * currentGroup = reinterpret_cast<OffsetGroup *> (target);
|
|
currentGroup->setInvalid(parent_inval);
|
|
|
|
// we end here if there are no child tags.
|
|
if(!pEntry)
|
|
return;
|
|
|
|
breadcrumbs.push_back(groupTriple(pEntry,currentGroup, parent_inval));
|
|
}
|
|
|
|
// work variables
|
|
OffsetGroup * currentGroup = 0;
|
|
TiXmlElement * currentElem = 0;
|
|
INVAL_TYPE parent_inval = NOT_SET;
|
|
//cerr << "<Offsets>"<< endl;
|
|
while(1)
|
|
{
|
|
// get current work variables
|
|
currentElem = breadcrumbs.back().first;
|
|
currentGroup = breadcrumbs.back().second;
|
|
parent_inval = breadcrumbs.back().third;
|
|
|
|
// we reached the end of the current group?
|
|
if(!currentElem)
|
|
{
|
|
// go one level up
|
|
breadcrumbs.pop_back();
|
|
// exit if no more work
|
|
if(breadcrumbs.empty())
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
//cerr << "</group>" << endl;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if(!currentGroup)
|
|
{
|
|
groupTriple & gp = breadcrumbs.back();
|
|
gp.first = gp.first->NextSiblingElement();
|
|
continue;
|
|
}
|
|
|
|
// skip non-elements
|
|
if (currentElem->Type() != TiXmlNode::ELEMENT)
|
|
{
|
|
groupTriple & gp = breadcrumbs.back();
|
|
gp.first = gp.first->NextSiblingElement();
|
|
continue;
|
|
}
|
|
|
|
// we have a valid current element and current group
|
|
// get properties
|
|
string type = currentElem->Value();
|
|
std::transform(type.begin(), type.end(), type.begin(), ::tolower);
|
|
const char *cstr_name = currentElem->Attribute("name");
|
|
if(!cstr_name)
|
|
{
|
|
// ERROR, missing attribute
|
|
}
|
|
|
|
// evaluate elements
|
|
const char *cstr_value = currentElem->Attribute("value");
|
|
const char *cstr_invalid = currentElem->Attribute("valid");
|
|
|
|
INVAL_TYPE child_inval = parent_inval;
|
|
if(cstr_invalid)
|
|
{
|
|
if(strcmp(cstr_invalid,"false") == 0)
|
|
child_inval = IS_INVALID;
|
|
else if(strcmp(cstr_invalid,"true") == 0)
|
|
child_inval = IS_VALID;
|
|
}
|
|
if(type == "group")
|
|
{
|
|
// create or get group
|
|
OffsetGroup * og;
|
|
if(initial)
|
|
og = currentGroup->createGroup(cstr_name);
|
|
else
|
|
og = currentGroup->getGroup(cstr_name);
|
|
|
|
// advance this level to the next element
|
|
groupTriple & gp = breadcrumbs.back();
|
|
gp.first = currentElem->NextSiblingElement();
|
|
|
|
if(!og)
|
|
{
|
|
string fullname = currentGroup->getFullName() + cstr_name;
|
|
throw Error::MissingMemoryDefinition("group", fullname);
|
|
}
|
|
|
|
// add a new level that will be processed in the next step
|
|
breadcrumbs.push_back(groupTriple(currentElem->FirstChildElement(), og, child_inval));
|
|
og->setInvalid(child_inval);
|
|
continue;
|
|
}
|
|
else if(type == "address")
|
|
{
|
|
if(child_inval == NOT_SET)
|
|
child_inval = IS_VALID;
|
|
if(initial)
|
|
{
|
|
currentGroup->createAddress(cstr_name);
|
|
}
|
|
else if(cstr_value)
|
|
{
|
|
currentGroup->setAddress(cstr_name, cstr_value, child_inval);
|
|
}
|
|
else
|
|
{
|
|
currentGroup->setAddressValidity(cstr_name, child_inval);
|
|
}
|
|
}
|
|
else if(type == "offset")
|
|
{
|
|
if(child_inval == NOT_SET)
|
|
child_inval = IS_VALID;
|
|
if(initial)
|
|
{
|
|
currentGroup->createOffset(cstr_name);
|
|
}
|
|
else if(cstr_value)
|
|
{
|
|
currentGroup->setOffset(cstr_name, cstr_value, child_inval);
|
|
}
|
|
else
|
|
{
|
|
currentGroup->setOffsetValidity(cstr_name, child_inval);
|
|
}
|
|
}
|
|
else if(type == "string")
|
|
{
|
|
if(child_inval == NOT_SET)
|
|
child_inval = IS_VALID;
|
|
if(initial)
|
|
{
|
|
currentGroup->createString(cstr_name);
|
|
}
|
|
else if(cstr_value)
|
|
{
|
|
currentGroup->setString(cstr_name, cstr_value, child_inval);
|
|
}
|
|
else
|
|
{
|
|
currentGroup->setStringValidity(cstr_name, child_inval);
|
|
}
|
|
}
|
|
else if(type == "hexvalue")
|
|
{
|
|
if(child_inval == NOT_SET)
|
|
child_inval = IS_VALID;
|
|
if(initial)
|
|
{
|
|
currentGroup->createHexValue(cstr_name);
|
|
}
|
|
else if(cstr_value)
|
|
{
|
|
currentGroup->setHexValue(cstr_name, cstr_value, child_inval);
|
|
}
|
|
else
|
|
{
|
|
currentGroup->setHexValueValidity(cstr_name, child_inval);
|
|
}
|
|
}
|
|
|
|
// advance to next element
|
|
groupTriple & gp = breadcrumbs.back();
|
|
gp.first = currentElem->NextSiblingElement();
|
|
continue;
|
|
}
|
|
//cerr << "</Offsets>"<< endl;
|
|
}
|
|
|
|
void VersionInfoFactory::ParseBase (TiXmlElement* entry, VersionInfo* mem)
|
|
{
|
|
TiXmlElement* pElement;
|
|
TiXmlElement* pElement2nd;
|
|
const char *cstr_version = entry->Attribute("name");
|
|
|
|
if (!cstr_version)
|
|
throw Error::MemoryXmlBadAttribute("name");
|
|
|
|
mem->setVersion(cstr_version);
|
|
mem->setOS(OS_BAD);
|
|
|
|
// process additional entries
|
|
pElement = entry->FirstChildElement()->ToElement();
|
|
for(;pElement;pElement=pElement->NextSiblingElement())
|
|
{
|
|
// only elements get processed
|
|
const char *cstr_type = pElement->Value();
|
|
std::string type = cstr_type;
|
|
if(type == "VTable")
|
|
{
|
|
ParseVTable(pElement, mem);
|
|
continue;
|
|
}
|
|
else if(type == "Offsets")
|
|
{
|
|
// we don't care about the descriptions here, do nothing
|
|
ParseOffsets(pElement, mem, true);
|
|
continue;
|
|
}
|
|
else if (type == "Professions")
|
|
{
|
|
pElement2nd = pElement->FirstChildElement("Profession");
|
|
for(;pElement2nd;pElement2nd=pElement2nd->NextSiblingElement("Profession"))
|
|
{
|
|
const char * id = pElement2nd->Attribute("id");
|
|
const char * name = pElement2nd->Attribute("name");
|
|
// FIXME: missing some attributes here
|
|
if(id && name)
|
|
{
|
|
mem->setProfession(id,name);
|
|
}
|
|
else
|
|
{
|
|
// FIXME: this is crap, doesn't tell anything about the error
|
|
throw Error::MemoryXmlUnderspecifiedEntry(name);
|
|
}
|
|
}
|
|
}
|
|
else if (type == "Jobs")
|
|
{
|
|
pElement2nd = pElement->FirstChildElement("Job");
|
|
for(;pElement2nd;pElement2nd=pElement2nd->NextSiblingElement("Job"))
|
|
{
|
|
const char * id = pElement2nd->Attribute("id");
|
|
const char * name = pElement2nd->Attribute("name");
|
|
if(id && name)
|
|
{
|
|
mem->setJob(id,name);
|
|
}
|
|
else
|
|
{
|
|
// FIXME: this is crap, doesn't tell anything about the error
|
|
throw Error::MemoryXmlUnderspecifiedEntry(name);
|
|
}
|
|
}
|
|
}
|
|
else if (type == "Skills")
|
|
{
|
|
pElement2nd = pElement->FirstChildElement("Skill");
|
|
for(;pElement2nd;pElement2nd=pElement2nd->NextSiblingElement("Skill"))
|
|
{
|
|
const char * id = pElement2nd->Attribute("id");
|
|
const char * name = pElement2nd->Attribute("name");
|
|
if(id && name)
|
|
{
|
|
mem->setSkill(id,name);
|
|
}
|
|
else
|
|
{
|
|
// FIXME: this is crap, doesn't tell anything about the error
|
|
throw Error::MemoryXmlUnderspecifiedEntry(name);
|
|
}
|
|
}
|
|
}
|
|
else if (type == "Traits")
|
|
{
|
|
pElement2nd = pElement->FirstChildElement("Trait");
|
|
for(;pElement2nd;pElement2nd=pElement2nd->NextSiblingElement("Trait"))
|
|
{
|
|
const char * id = pElement2nd->Attribute("id");
|
|
const char * name = pElement2nd->Attribute("name");
|
|
const char * lvl0 = pElement2nd->Attribute("level_0");
|
|
const char * lvl1 = pElement2nd->Attribute("level_1");
|
|
const char * lvl2 = pElement2nd->Attribute("level_2");
|
|
const char * lvl3 = pElement2nd->Attribute("level_3");
|
|
const char * lvl4 = pElement2nd->Attribute("level_4");
|
|
const char * lvl5 = pElement2nd->Attribute("level_5");
|
|
if(id && name && lvl0 && lvl1 && lvl2 && lvl3 && lvl4 && lvl5)
|
|
{
|
|
mem->setTrait(id, name, lvl0, lvl1, lvl2, lvl3, lvl4, lvl5);
|
|
}
|
|
else
|
|
{
|
|
// FIXME: this is crap, doesn't tell anything about the error
|
|
throw Error::MemoryXmlUnderspecifiedEntry(name);
|
|
}
|
|
}
|
|
}
|
|
else if (type == "Labors")
|
|
{
|
|
pElement2nd = pElement->FirstChildElement("Labor");
|
|
for(;pElement2nd;pElement2nd=pElement2nd->NextSiblingElement("Labor"))
|
|
{
|
|
const char * id = pElement2nd->Attribute("id");
|
|
const char * name = pElement2nd->Attribute("name");
|
|
if(id && name)
|
|
{
|
|
mem->setLabor(id,name);
|
|
}
|
|
else
|
|
{
|
|
// FIXME: this is crap, doesn't tell anything about the error
|
|
throw Error::MemoryXmlUnderspecifiedEntry(name);
|
|
}
|
|
}
|
|
}
|
|
else if (type == "Levels")
|
|
{
|
|
pElement2nd = pElement->FirstChildElement("Level");
|
|
for(;pElement2nd;pElement2nd=pElement2nd->NextSiblingElement("Level"))
|
|
{
|
|
const char * id = pElement2nd->Attribute("id");
|
|
const char * name = pElement2nd->Attribute("name");
|
|
const char * nextlvl = pElement2nd->Attribute("xpNxtLvl");
|
|
if(id && name && nextlvl)
|
|
{
|
|
mem->setLevel(id, name, nextlvl);
|
|
}
|
|
else
|
|
{
|
|
// FIXME: this is crap, doesn't tell anything about the error
|
|
throw Error::MemoryXmlUnderspecifiedEntry(name);
|
|
}
|
|
}
|
|
}
|
|
else if (type == "Moods")
|
|
{
|
|
pElement2nd = pElement->FirstChildElement("Mood");
|
|
for(;pElement2nd;pElement2nd=pElement2nd->NextSiblingElement("Mood"))
|
|
{
|
|
const char * id = pElement2nd->Attribute("id");
|
|
const char * name = pElement2nd->Attribute("name");
|
|
if(id && name)
|
|
{
|
|
mem->setMood(id, name);
|
|
}
|
|
else
|
|
{
|
|
// FIXME: this is crap, doesn't tell anything about the error
|
|
throw Error::MemoryXmlUnderspecifiedEntry(name);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//FIXME: only log, not hard error
|
|
//throw Error::MemoryXmlUnknownType(type.c_str());
|
|
}
|
|
} // for
|
|
} // method
|
|
|
|
void VersionInfoFactory::EvalVersion(string base, VersionInfo * mem)
|
|
{
|
|
if(knownVersions.find(base) != knownVersions.end())
|
|
{
|
|
v_descr & desc = knownVersions[base];
|
|
if (!desc.second)
|
|
{
|
|
VersionInfo * basemem = new VersionInfo();
|
|
ParseVersion(desc.first, basemem);
|
|
desc.second = basemem;
|
|
}
|
|
mem->copy(desc.second);
|
|
}
|
|
}
|
|
|
|
void VersionInfoFactory::ParseVersion (TiXmlElement* entry, VersionInfo* mem)
|
|
{
|
|
TiXmlElement* pMemEntry;
|
|
const char *cstr_name = entry->Attribute("name");
|
|
const char *cstr_os = entry->Attribute("os");
|
|
const char *cstr_base = entry->Attribute("base");
|
|
const char *cstr_rebase = entry->Attribute("rebase");
|
|
if(cstr_base)
|
|
{
|
|
string base = cstr_base;
|
|
EvalVersion(base, mem);
|
|
}
|
|
|
|
if (!cstr_name)
|
|
throw Error::MemoryXmlBadAttribute("name");
|
|
if (!cstr_os)
|
|
throw Error::MemoryXmlBadAttribute("os");
|
|
|
|
string os = cstr_os;
|
|
mem->setVersion(cstr_name);
|
|
mem->setOS(cstr_os);
|
|
|
|
// offset inherited addresses by 'rebase'.
|
|
int32_t rebase = 0;
|
|
if(cstr_rebase)
|
|
{
|
|
rebase = mem->getBase() + strtol(cstr_rebase, NULL, 16);
|
|
mem->RebaseAddresses(rebase);
|
|
}
|
|
|
|
//set base to default, we're overwriting this because the previous rebase could cause havoc on Vista/7
|
|
if(os == "windows")
|
|
{
|
|
// set default image base. this is fixed for base relocation later
|
|
mem->setBase(0x400000);
|
|
}
|
|
else if(os == "linux")
|
|
{
|
|
// this is wrong... I'm not going to do base image relocation on linux though.
|
|
// users are free to use a sane kernel that doesn't do this kind of **** by default
|
|
mem->setBase(0x0);
|
|
}
|
|
else
|
|
{
|
|
throw Error::MemoryXmlBadAttribute("os");
|
|
}
|
|
|
|
// process additional entries
|
|
//cout << "Entry " << cstr_version << " " << cstr_os << endl;
|
|
pMemEntry = entry->FirstChildElement()->ToElement();
|
|
for(;pMemEntry;pMemEntry=pMemEntry->NextSiblingElement())
|
|
{
|
|
string type, name, value;
|
|
const char *cstr_type = pMemEntry->Value();
|
|
type = cstr_type;
|
|
// check for missing parts
|
|
if(type == "VTable")
|
|
{
|
|
ParseVTable(pMemEntry, mem);
|
|
continue;
|
|
}
|
|
else if(type == "Offsets")
|
|
{
|
|
ParseOffsets(pMemEntry, mem);
|
|
continue;
|
|
}
|
|
else if (type == "MD5")
|
|
{
|
|
const char *cstr_value = pMemEntry->Attribute("value");
|
|
if(!cstr_value)
|
|
throw Error::MemoryXmlUnderspecifiedEntry(cstr_name);
|
|
mem->setMD5(cstr_value);
|
|
}
|
|
else if (type == "PETimeStamp")
|
|
{
|
|
const char *cstr_value = pMemEntry->Attribute("value");
|
|
if(!cstr_value)
|
|
throw Error::MemoryXmlUnderspecifiedEntry(cstr_name);
|
|
mem->setPE(strtol(cstr_value, 0, 16));
|
|
}
|
|
} // for
|
|
} // method
|
|
|
|
// load the XML file with offsets
|
|
bool VersionInfoFactory::loadFile(string path_to_xml)
|
|
{
|
|
TiXmlDocument doc( path_to_xml.c_str() );
|
|
//bool loadOkay = doc.LoadFile();
|
|
if (!doc.LoadFile())
|
|
{
|
|
error = true;
|
|
throw Error::MemoryXmlParse(doc.ErrorDesc(), doc.ErrorId(), doc.ErrorRow(), doc.ErrorCol());
|
|
}
|
|
TiXmlHandle hDoc(&doc);
|
|
TiXmlElement* pElem;
|
|
TiXmlHandle hRoot(0);
|
|
VersionInfo *mem;
|
|
|
|
// block: name
|
|
{
|
|
pElem=hDoc.FirstChildElement().Element();
|
|
// should always have a valid root but handle gracefully if it does
|
|
if (!pElem)
|
|
{
|
|
error = true;
|
|
throw Error::MemoryXmlNoRoot();
|
|
}
|
|
string m_name=pElem->Value();
|
|
if(m_name != "DFHack")
|
|
{
|
|
error = true;
|
|
throw Error::MemoryXmlNoRoot();
|
|
}
|
|
// save this for later
|
|
hRoot=TiXmlHandle(pElem);
|
|
}
|
|
// transform elements
|
|
{
|
|
// trash existing list
|
|
for(uint32_t i = 0; i < versions.size(); i++)
|
|
{
|
|
delete versions[i];
|
|
}
|
|
versions.clear();
|
|
|
|
// For each base version
|
|
TiXmlElement* pMemInfo=hRoot.FirstChild( "Base" ).Element();
|
|
map <string ,TiXmlElement *> map_pNamedEntries;
|
|
vector <string> v_sEntries;
|
|
for( ; pMemInfo; pMemInfo=pMemInfo->NextSiblingElement("Base"))
|
|
{
|
|
const char *name = pMemInfo->Attribute("name");
|
|
if(name)
|
|
{
|
|
string str_name = name;
|
|
mem = new VersionInfo();
|
|
ParseBase( pMemInfo , mem );
|
|
knownVersions[str_name] = v_descr (pMemInfo, mem);
|
|
}
|
|
}
|
|
|
|
// For each derivative version
|
|
pMemInfo=hRoot.FirstChild( "Version" ).Element();
|
|
for( ; pMemInfo; pMemInfo=pMemInfo->NextSiblingElement("Version"))
|
|
{
|
|
const char *name = pMemInfo->Attribute("name");
|
|
if(name)
|
|
{
|
|
string str_name = name;
|
|
knownVersions[str_name] = v_descr (pMemInfo, (VersionInfo *) NULL);
|
|
v_sEntries.push_back(str_name);
|
|
}
|
|
}
|
|
// Parse the versions
|
|
for(uint32_t i = 0; i< v_sEntries.size();i++)
|
|
{
|
|
//FIXME: add a set of entries processed in a step of this cycle, use it to check for infinite loops
|
|
string & name = v_sEntries[i];
|
|
v_descr & desc = knownVersions[name];
|
|
if(!desc.second)
|
|
{
|
|
VersionInfo *version = new VersionInfo();
|
|
ParseVersion( desc.first , version );
|
|
versions.push_back(version);
|
|
}
|
|
}
|
|
}
|
|
error = false;
|
|
return true;
|
|
}
|