dfhack/library/VersionInfoFactory.cpp

631 lines
20 KiB
C++

2009-09-13 18:02:46 -06:00
/*
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"
2010-05-25 22:48:23 -06:00
#include "dfhack/DFError.h"
#include <algorithm>
2010-04-04 16:48:19 -06:00
2009-11-13 20:46:56 -07:00
using namespace DFHack;
2009-09-13 18:02:46 -06:00
VersionInfoFactory::~VersionInfoFactory()
{
2010-08-22 17:29:55 -06:00
// for each stored version, delete
for(uint32_t i = 0; i < versions.size();i++)
{
2010-08-22 17:29:55 -06:00
delete versions[i];
}
2010-08-22 17:29:55 -06:00
versions.clear();
}
void VersionInfoFactory::ParseVTable(TiXmlElement* vtable, VersionInfo* mem)
2009-09-13 18:02:46 -06:00
{
TiXmlElement* pClassEntry;
TiXmlElement* pClassSubEntry;
2010-08-22 17:29:55 -06:00
/*
2009-09-15 14:46:45 -06:00
// check for rebase, do rebase if check positive
2009-09-13 18:02:46 -06:00
const char * rebase = vtable->Attribute("rebase");
if(rebase)
{
int32_t rebase_offset = strtol(rebase, NULL, 16);
mem->RebaseVTable(rebase_offset);
2009-09-13 18:02:46 -06:00
}
2010-08-22 17:29:55 -06:00
*/
2009-09-15 14:46:45 -06:00
// parse vtable entries
2009-09-13 18:02:46 -06:00
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);
2009-09-15 14:46:45 -06:00
// it's a simple class
2009-09-13 18:02:46 -06:00
if(type== "class")
{
mem->setClass(cstr_name, vtable);
2009-09-13 18:02:46 -06:00
}
2009-09-15 14:46:45 -06:00
// it's a multi-type class
2009-09-13 18:02:46 -06:00
else if (type == "multiclass")
{
2009-09-15 14:46:45 -06:00
// get offset of the type variable
2009-09-13 18:02:46 -06:00
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);
2009-09-15 14:46:45 -06:00
// parse class sub-entries
2009-09-13 18:02:46 -06:00
pClassSubEntry = pClassEntry->FirstChildElement();
for(;pClassSubEntry;pClassSubEntry=pClassSubEntry->NextSiblingElement())
{
type = pClassSubEntry->Value();
if(type== "class")
{
2009-09-15 14:46:45 -06:00
// type is a value loaded from type offset
2009-09-13 18:02:46 -06:00
cstr_name = pClassSubEntry->Attribute("name");
const char *cstr_value = pClassSubEntry->Attribute("type");
mem->setClassChild(mclass,cstr_name,cstr_value);
2009-09-13 18:02:46 -06:00
}
}
}
}
}
// FIXME: this is ripe for replacement with a more generic approach
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 pair < TiXmlElement *, OffsetGroup * > groupPair;
vector< groupPair > breadcrumbs;
{
TiXmlElement* pEntry;
// we get the <Offsets>, look at the children
pEntry = parent->FirstChildElement();
if(!pEntry)
return;
OffsetGroup * currentGroup = reinterpret_cast<OffsetGroup *> (target);
breadcrumbs.push_back(groupPair(pEntry,currentGroup));
}
// work variables
OffsetGroup * currentGroup = 0;
TiXmlElement * currentElem = 0;
//cerr << "<Offsets>"<< endl;
while(1)
{
// get current work variables
currentElem = breadcrumbs.back().first;
currentGroup = breadcrumbs.back().second;
// 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)
{
groupPair & gp = breadcrumbs.back();
gp.first = gp.first->NextSiblingElement();
continue;
}
// skip non-elements
if (currentElem->Type() != TiXmlNode::ELEMENT)
{
groupPair & 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");
if(type == "group")
{
// FIXME: possibly use setGroup always, with the initial flag as parameter?
// create or get group
OffsetGroup * og;
if(initial)
og = currentGroup->createGroup(cstr_name);
else
og = currentGroup->getGroup(cstr_name);
//cerr << "<group name=\"" << cstr_name << "\">" << endl;
// advance this level to the next element
groupPair & 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 next
breadcrumbs.push_back(groupPair(currentElem->FirstChildElement(), og));
continue;
}
else if(type == "address")
{
if(initial)
{
currentGroup->createAddress(cstr_name);
}
else if(cstr_value)
{
currentGroup->setAddress(cstr_name, cstr_value);
}
else
{
// ERROR, missing attribute
}
}
else if(type == "offset")
{
if(initial)
{
currentGroup->createOffset(cstr_name);
}
else if(cstr_value)
{
currentGroup->setOffset(cstr_name, cstr_value);
}
else
{
// ERROR, missing attribute
}
}
else if(type == "string")
{
if(initial)
{
currentGroup->createString(cstr_name);
}
else if(cstr_value)
{
currentGroup->setString(cstr_name, cstr_value);
}
else
{
// ERROR, missing attribute
}
}
else if(type == "hexvalue")
{
if(initial)
{
currentGroup->createHexValue(cstr_name);
}
else if(cstr_value)
{
currentGroup->setHexValue(cstr_name, cstr_value);
}
else
{
// ERROR, missing attribute
}
}
// advance to next element
groupPair & gp = breadcrumbs.back();
gp.first = currentElem->NextSiblingElement();
continue;
}
//cerr << "</Offsets>"<< endl;
}
2010-08-22 17:29:55 -06:00
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(VersionInfo::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);
2010-08-22 17:29:55 -06:00
continue;
}
else if (type == "Professions")
{
2010-08-30 22:52:03 -06:00
pElement2nd = pElement->FirstChildElement("Profession");
2010-08-22 17:29:55 -06:00
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")
{
2010-08-30 22:52:03 -06:00
pElement2nd = pElement->FirstChildElement("Job");
2010-08-22 17:29:55 -06:00
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")
{
2010-08-30 22:52:03 -06:00
pElement2nd = pElement->FirstChildElement("Skill");
2010-08-22 17:29:55 -06:00
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")
{
2010-08-30 22:52:03 -06:00
pElement2nd = pElement->FirstChildElement("Trait");
2010-08-22 17:29:55 -06:00
for(;pElement2nd;pElement2nd=pElement2nd->NextSiblingElement("Trait"))
{
const char * id = pElement2nd->Attribute("id");
const char * name = pElement2nd->Attribute("name");
2010-08-30 22:52:03 -06:00
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");
2010-08-22 17:29:55 -06:00
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")
{
2010-08-30 22:52:03 -06:00
pElement2nd = pElement->FirstChildElement("Labor");
2010-08-22 17:29:55 -06:00
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")
{
2010-08-30 22:52:03 -06:00
pElement2nd = pElement->FirstChildElement("Level");
2010-08-22 17:29:55 -06:00
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")
{
2010-08-30 22:52:03 -06:00
pElement2nd = pElement->FirstChildElement("Mood");
2010-08-22 17:29:55 -06:00
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 * newmem = new VersionInfo();
ParseVersion(desc.first, newmem);
desc.second = newmem;
}
mem->copy(desc.second);
}
}
void VersionInfoFactory::ParseVersion (TiXmlElement* entry, VersionInfo* mem)
2009-09-13 18:02:46 -06:00
{
TiXmlElement* pMemEntry;
2010-08-22 17:29:55 -06:00
const char *cstr_name = entry->Attribute("name");
2009-09-13 18:02:46 -06:00
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;
2010-08-22 17:29:55 -06:00
EvalVersion(base, mem);
2009-09-13 18:02:46 -06:00
}
2010-02-28 13:44:14 -07:00
2010-08-22 17:29:55 -06:00
if (!cstr_name)
throw Error::MemoryXmlBadAttribute("name");
2010-02-28 13:44:14 -07:00
if (!cstr_os)
throw Error::MemoryXmlBadAttribute("os");
2009-09-13 18:02:46 -06:00
string os = cstr_os;
2010-08-22 17:29:55 -06:00
mem->setVersion(cstr_name);
mem->setOS(cstr_os);
2009-09-13 18:02:46 -06:00
// offset inherited addresses by 'rebase'.
int32_t rebase = 0;
if(cstr_rebase)
{
rebase = mem->getBase() + strtol(cstr_rebase, NULL, 16);
mem->RebaseAddresses(rebase);
2009-09-13 18:02:46 -06:00
}
2009-09-13 18:02:46 -06:00
//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);
2009-09-13 18:02:46 -06:00
}
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);
2009-09-13 18:02:46 -06:00
}
else
{
2010-02-28 13:44:14 -07:00
throw Error::MemoryXmlBadAttribute("os");
2009-09-13 18:02:46 -06:00
}
2009-09-13 18:02:46 -06:00
// process additional entries
//cout << "Entry " << cstr_version << " " << cstr_os << endl;
pMemEntry = entry->FirstChildElement()->ToElement();
for(;pMemEntry;pMemEntry=pMemEntry->NextSiblingElement())
{
string type, name, value;
2010-08-22 17:29:55 -06:00
const char *cstr_type = pMemEntry->Value();
2009-09-13 18:02:46 -06:00
type = cstr_type;
2010-08-22 17:29:55 -06:00
// check for missing parts
2009-09-13 18:02:46 -06:00
if(type == "VTable")
{
ParseVTable(pMemEntry, mem);
continue;
}
2010-08-22 17:29:55 -06:00
else if(type == "Offsets")
{
ParseOffsets(pMemEntry, mem);
2010-08-22 17:29:55 -06:00
continue;
}
2010-08-22 17:29:55 -06:00
else if (type == "MD5")
2010-06-10 09:53:25 -06:00
{
2010-08-22 17:29:55 -06:00
const char *cstr_value = pMemEntry->Attribute("value");
if(!cstr_value)
throw Error::MemoryXmlUnderspecifiedEntry(cstr_name);
mem->setMD5(cstr_value);
}
2010-08-22 17:29:55 -06:00
else if (type == "PETimeStamp")
2009-09-13 18:02:46 -06:00
{
2010-08-22 17:29:55 -06:00
const char *cstr_value = pMemEntry->Attribute("value");
if(!cstr_value)
throw Error::MemoryXmlUnderspecifiedEntry(cstr_name);
mem->setPE(strtol(cstr_value, 0, 16));
2009-09-13 18:02:46 -06:00
}
} // for
} // method
VersionInfoFactory::VersionInfoFactory(string path_to_xml)
{
error = false;
loadFile(path_to_xml);
}
2009-09-13 18:02:46 -06:00
// load the XML file with offsets
bool VersionInfoFactory::loadFile(string path_to_xml)
2009-09-13 18:02:46 -06:00
{
TiXmlDocument doc( path_to_xml.c_str() );
2010-02-28 13:44:14 -07:00
//bool loadOkay = doc.LoadFile();
if (!doc.LoadFile())
{
error = true;
throw Error::MemoryXmlParse(doc.ErrorDesc(), doc.ErrorId(), doc.ErrorRow(), doc.ErrorCol());
}
TiXmlHandle hDoc(&doc);
2009-09-15 14:46:45 -06:00
TiXmlElement* pElem;
TiXmlHandle hRoot(0);
2010-08-22 17:29:55 -06:00
VersionInfo *mem;
2010-02-28 13:44:14 -07:00
// block: name
2009-09-13 18:02:46 -06:00
{
2010-02-28 13:44:14 -07:00
pElem=hDoc.FirstChildElement().Element();
// should always have a valid root but handle gracefully if it does
if (!pElem)
2009-09-13 18:02:46 -06:00
{
2010-02-28 13:44:14 -07:00
error = true;
throw Error::MemoryXmlNoRoot();
2009-09-13 18:02:46 -06:00
}
2010-02-28 13:44:14 -07:00
string m_name=pElem->Value();
if(m_name != "DFHack")
2009-09-13 18:02:46 -06:00
{
2010-02-28 13:44:14 -07:00
error = true;
throw Error::MemoryXmlNoRoot();
2009-09-13 18:02:46 -06:00
}
2010-02-28 13:44:14 -07:00
// save this for later
hRoot=TiXmlHandle(pElem);
2009-09-13 18:02:46 -06:00
}
2010-02-28 13:44:14 -07:00
// transform elements
2009-09-13 18:02:46 -06:00
{
2010-02-28 13:44:14 -07:00
// trash existing list
2010-08-22 17:29:55 -06:00
for(uint32_t i = 0; i < versions.size(); i++)
2010-02-28 13:44:14 -07:00
{
2010-08-22 17:29:55 -06:00
delete versions[i];
2010-02-28 13:44:14 -07:00
}
2010-08-22 17:29:55 -06:00
versions.clear();
// For each base version
TiXmlElement* pMemInfo=hRoot.FirstChild( "Base" ).Element();
2010-02-28 13:44:14 -07:00
map <string ,TiXmlElement *> map_pNamedEntries;
2010-08-22 17:29:55 -06:00
vector <string> v_sEntries;
for( ; pMemInfo; pMemInfo=pMemInfo->NextSiblingElement("Base"))
2010-02-28 13:44:14 -07:00
{
2010-08-22 17:29:55 -06:00
const char *name = pMemInfo->Attribute("name");
if(name)
2010-02-28 13:44:14 -07:00
{
2010-08-22 17:29:55 -06:00
string str_name = name;
VersionInfo *base = new VersionInfo();
mem = new VersionInfo();
2010-08-22 17:29:55 -06:00
ParseBase( pMemInfo , mem );
knownVersions[str_name] = v_descr (pMemInfo, mem);
2010-02-28 13:44:14 -07:00
}
}
2010-08-22 17:29:55 -06:00
// 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;
2010-09-20 19:18:34 -06:00
knownVersions[str_name] = v_descr (pMemInfo, (VersionInfo *) NULL);
2010-08-22 17:29:55 -06:00
v_sEntries.push_back(str_name);
}
}
// Parse the versions
for(uint32_t i = 0; i< v_sEntries.size();i++)
2010-02-28 13:44:14 -07:00
{
//FIXME: add a set of entries processed in a step of this cycle, use it to check for infinite loops
2010-08-22 17:29:55 -06:00
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);
}
2010-02-28 13:44:14 -07:00
}
2010-08-22 17:29:55 -06:00
2010-02-28 13:44:14 -07:00
// process found things here
2009-09-13 18:02:46 -06:00
}
2010-02-28 13:44:14 -07:00
error = false;
return true;
}