// ============================================================================
// ==============================================================================
bool CalcTransTable(const std::vector<FORMAT_RES_DATA> &vecResData,
std::map<int, int> &mapLookTrans,
std::map<int, int> &mapWeaponMotionTrans)
{
mapLookTrans.clear();
mapWeaponMotionTrans.clear();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
std::vector<FORMAT_RES_DATA>::const_iterator it = vecResData.begin();
std::map<int, std::map<int, int> > mapLookTransCount;
std::map<int, std::map<int, int> > mapWeaponMotionTransCount;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
for (; it != vecResData.end(); ++it) {
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
const FORMAT_RES_DATA &rData = *it;
const std::vector<__int64> &rVecIndex = rData.vecIndex;
__int64 i64IndexRes = ResPathTransIndex(rData.strRes);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (i64IndexRes > 0) {
//~~~~~~~~~~~~~~~~~~~~~
int nResLook = 0;
int nResWeaponMotion = 0;
//~~~~~~~~~~~~~~~~~~~~~
GetIndexInfo(i64IndexRes, nResLook, nResWeaponMotion);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
std::vector<__int64>::const_iterator itIndex = rVecIndex.begin();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
for (; itIndex != rVecIndex.end(); ++itIndex) {
//~~~~~~~~~~~~~~~~~~~~~~~~
int nIndexLook = 0;
int nIndexWeaponMotion = 0;
__int64 i64Index = *itIndex;
//~~~~~~~~~~~~~~~~~~~~~~~~
GetIndexInfo(i64Index, nIndexLook, nIndexWeaponMotion);
++mapLookTransCount[nIndexLook][nResLook];
++mapWeaponMotionTransCount[nIndexWeaponMotion][nResWeaponMotion];
}
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
std::map<int, std::map<int, int> >::const_iterator itMap;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
for (itMap = mapLookTransCount.begin(); itMap != mapLookTransCount.end(); ++itMap) {
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
std::map<int, int>::const_iterator it;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
for (it = itMap->second.begin(); it != itMap->second.end(); ++it) {
mapLookTrans[itMap->first] = CalMapMaxSecondFirst(itMap->second);
}
}
for (itMap = mapWeaponMotionTransCount.begin(); itMap != mapWeaponMotionTransCount.end(); ++itMap) {
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
std::map<int, int>::const_iterator it;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
for (it = itMap->second.begin(); it != itMap->second.end(); ++it) {
mapWeaponMotionTrans[itMap->first] = CalMapMaxSecondFirst(itMap->second);
}
}
return true;
}
// -------------------------------------------------------------------------------------------------------
// Couldn't meet amount exactly, will need to generate change
// returning with a 0 means either too many spends or no change
// Latter should never happen since we should only get here if exact is not possible
// -------------------------------------------------------------------------------------------------------
int calculateChange(
int nMaxNumberOfSpends,
bool fMinimizeChange,
const CAmount nValueTarget,
const std::map<CoinDenomination, CAmount>& mapOfDenomsHeld,
std::map<CoinDenomination, CAmount>& mapOfDenomsUsed)
{
CoinDenomination minDenomOverTarget = ZQ_ERROR;
// Initialize
mapOfDenomsUsed.clear();
for (const auto& denom : zerocoinDenomList)
mapOfDenomsUsed.insert(std::pair<CoinDenomination, CAmount>(denom, 0));
for (const auto& denom : zerocoinDenomList) {
if (nValueTarget < ZerocoinDenominationToAmount(denom) && mapOfDenomsHeld.at(denom)) {
minDenomOverTarget = denom;
break;
}
}
// OK so if != ZQ_ERROR we have a solution using 1 coin
if (minDenomOverTarget != ZQ_ERROR) {
mapOfDenomsUsed.at(minDenomOverTarget) = 1;
// Now find out # of coins in change
CAmount nChangeAmount = ZerocoinDenominationToAmount(minDenomOverTarget) - nValueTarget;
std::map<CoinDenomination, CAmount> mapChange = getChange(nChangeAmount);
int nChangeCount = getNumberOfCoinsUsed(mapChange);
if (fMinimizeChange) {
CoinDenomination nextToMaxDenom = getNextLowerDenomHeld(minDenomOverTarget, mapOfDenomsHeld);
int newChangeCount = minimizeChange(nMaxNumberOfSpends, nChangeCount,
nextToMaxDenom, nValueTarget,
mapOfDenomsHeld, mapOfDenomsUsed);
// Alternative method yields less mints and is less than MaxNumberOfSpends if true
if (newChangeCount < nChangeCount) return newChangeCount;
// Reclear
for (const auto& denom : zerocoinDenomList)
mapOfDenomsUsed.at(denom) = 0;
// Then reset as before previous clearing
mapOfDenomsUsed.at(minDenomOverTarget) = 1;
}
return nChangeCount;
} else {
// Try to meet a different way
for (const auto& denom : zerocoinDenomList)
mapOfDenomsUsed.at(denom) = 0;
CAmount nRemainingValue = nValueTarget;
int nCoinCount = 0;
CAmount AmountUsed = 0;
for (const auto& denom : reverse_iterate(zerocoinDenomList)) {
CAmount nValue = ZerocoinDenominationToAmount(denom);
do {
if (mapOfDenomsHeld.at(denom) && nRemainingValue > 0) {
mapOfDenomsUsed.at(denom)++;
AmountUsed += nValue;
nRemainingValue -= nValue;
nCoinCount++;
}
} while ((nRemainingValue > 0) && (mapOfDenomsUsed.at(denom) < mapOfDenomsHeld.at(denom)));
if (nRemainingValue < 0) break;
}
CAmount nChangeAmount = AmountUsed - nValueTarget;
std::map<CoinDenomination, CAmount> mapChange = getChange(nChangeAmount);
int nMaxChangeCount = getNumberOfCoinsUsed(mapChange);
// Instead get max Denom held
CoinDenomination maxDenomHeld = getMaxDenomHeld(mapOfDenomsHeld);
// Assign for size (only)
std::map<CoinDenomination, CAmount> mapOfMinDenomsUsed = mapOfDenomsUsed;
int nChangeCount = minimizeChange(nMaxNumberOfSpends, nMaxChangeCount,
maxDenomHeld, nValueTarget,
mapOfDenomsHeld, mapOfMinDenomsUsed);
int nNumSpends = getNumberOfCoinsUsed(mapOfMinDenomsUsed);
if (!fMinimizeChange && (nCoinCount < nNumSpends)) {
return nMaxChangeCount;
}
mapOfDenomsUsed = mapOfMinDenomsUsed;
return nChangeCount;
}
}
void CNodeDefManager::clear()
{
m_content_features.clear();
m_name_id_mapping.clear();
m_name_id_mapping_with_aliases.clear();
m_group_to_items.clear();
m_next_id = 0;
resetNodeResolveState();
u32 initial_length = 0;
initial_length = MYMAX(initial_length, CONTENT_UNKNOWN + 1);
initial_length = MYMAX(initial_length, CONTENT_AIR + 1);
initial_length = MYMAX(initial_length, CONTENT_IGNORE + 1);
m_content_features.resize(initial_length);
// Set CONTENT_UNKNOWN
{
ContentFeatures f;
f.name = "unknown";
// Insert directly into containers
content_t c = CONTENT_UNKNOWN;
m_content_features[c] = f;
addNameIdMapping(c, f.name);
}
// Set CONTENT_AIR
{
ContentFeatures f;
f.name = "air";
f.drawtype = NDT_AIRLIKE;
f.param_type = CPT_LIGHT;
f.light_propagates = true;
f.sunlight_propagates = true;
f.walkable = false;
f.pointable = false;
f.diggable = false;
f.buildable_to = true;
f.floodable = true;
f.is_ground_content = true;
// Insert directly into containers
content_t c = CONTENT_AIR;
m_content_features[c] = f;
addNameIdMapping(c, f.name);
}
// Set CONTENT_IGNORE
{
ContentFeatures f;
f.name = "ignore";
f.drawtype = NDT_AIRLIKE;
f.param_type = CPT_NONE;
f.light_propagates = false;
f.sunlight_propagates = false;
f.walkable = false;
f.pointable = false;
f.diggable = false;
f.buildable_to = true; // A way to remove accidental CONTENT_IGNOREs
f.is_ground_content = true;
// Insert directly into containers
content_t c = CONTENT_IGNORE;
m_content_features[c] = f;
addNameIdMapping(c, f.name);
}
}
// *********************************************************************
// * Matlab entry point *
// *********************************************************************
void mexFunction (int nlhs, mxArray **plhs, int nrhs, const mxArray **prhs)
{
int command;
// Cleanup function - register only once
static bool cleanupRegistered = false;
if (!cleanupRegistered) {
// Yay for C++11 lambdas
mexAtExit([] () {
std::cout << "Cleaning up the onyx Linear LaRank MEX wrapper!" << std::endl;
// Clear all the objects to free their memory
objects.clear();
});
}
// We need at least one argument - command
if (nrhs < 1) {
mexErrMsgTxt("Wrapper requires at least one argument!");
}
if (mxGetNumberOfElements(prhs[0]) != 1 || !mxIsNumeric(prhs[0])) {
mexErrMsgTxt("First argument needs to be a numeric command!");
}
command = static_cast<int>(mxGetScalar(prhs[0]));
// Skip the command
nrhs--;
prhs++;
switch (command) {
case CommandCreate: {
return classifier_create(nlhs, plhs, nrhs, prhs);
}
case CommandDelete: {
return classifier_delete(nlhs, plhs, nrhs, prhs);
}
case CommandPredict: {
return classifier_predict(nlhs, plhs, nrhs, prhs);
}
case CommandUpdate: {
return classifier_update(nlhs, plhs, nrhs, prhs);
}
case CommandSerialize: {
return classifier_serialize(nlhs, plhs, nrhs, prhs);
}
case CommandDeserialize: {
return classifier_deserialize(nlhs, plhs, nrhs, prhs);
}
case CommandGetC: {
return classifier_get_c(nlhs, plhs, nrhs, prhs);
}
case CommandSetC: {
return classifier_set_c(nlhs, plhs, nrhs, prhs);
}
case CommandGetTau: {
return classifier_get_tau(nlhs, plhs, nrhs, prhs);
}
case CommandSetTau: {
return classifier_set_tau(nlhs, plhs, nrhs, prhs);
}
case CommandGetNumFeatures: {
return classifier_get_num_features(nlhs, plhs, nrhs, prhs);
}
case CommandGetNumClasses: {
return classifier_get_num_classes(nlhs, plhs, nrhs, prhs);
}
case CommandGetClassLabels: {
return classifier_get_class_labels(nlhs, plhs, nrhs, prhs);
}
case CommandGetNumSeenSamples: {
return classifier_get_num_seen_samples(nlhs, plhs, nrhs, prhs);
}
case CommandGetDecisionFunctionWeights: {
return classifier_get_decision_function_weights(nlhs, plhs, nrhs, prhs);
}
default: {
mexErrMsgTxt("Unrecognized command value!");
}
}
}
///////////////////////////////////////////////////////////////
//
// CPerfStatFunctionTimingImpl::DoPulse
//
//
//
///////////////////////////////////////////////////////////////
void CPerfStatFunctionTimingImpl::DoPulse ( void )
{
// Maybe turn off stats gathering if nobody is watching
if ( m_bIsActive && m_TimeSinceLastViewed.Get () > 15000 )
SetActive ( false );
// Do nothing if not active
if ( !m_bIsActive )
{
m_TimingMap.clear ();
return;
}
// Check if time to cycle the stats
if ( m_TimeSinceUpdate.Get () >= 10000 )
{
m_TimeSinceUpdate.Reset ();
// For each timed function
for ( std::map < SString, SFunctionTimingInfo >::iterator iter = m_TimingMap.begin () ; iter != m_TimingMap.end () ; )
{
SFunctionTimingInfo& item = iter->second;
// Update history
item.iPrevIndex = ( item.iPrevIndex + 1 ) % NUMELMS( item.history );
item.history[ item.iPrevIndex ] = item.now5s;
// Reset accumulator
item.now5s.uiNumCalls = 0;
item.now5s.fTotalMs = 0;
item.now5s.fPeakMs = 0;
item.now5s.fResBiggestMs = 0;
item.now5s.strResBiggestMsName.clear();
item.now5s.uiTotalBytes = 0;
item.now5s.uiPeakBytes = 0;
item.now5s.uiResBiggestBytes = 0;
item.now5s.strResBiggestBytesName.clear();
// Recalculate last 60 second stats
item.prev60s.uiNumCalls = 0;
item.prev60s.fTotalMs = 0;
item.prev60s.fPeakMs = 0;
item.prev60s.fResBiggestMs = 0;
item.prev60s.strResBiggestMsName.clear();
item.prev60s.uiTotalBytes = 0;
item.prev60s.uiPeakBytes = 0;
item.prev60s.uiResBiggestBytes = 0;
item.prev60s.strResBiggestBytesName.clear();
for ( uint i = 0 ; i < NUMELMS( item.history ) ; i++ )
{
const STiming& slot = item.history[i];
item.prev60s.uiNumCalls += slot.uiNumCalls;
item.prev60s.fTotalMs += slot.fTotalMs;
item.prev60s.fPeakMs = Max ( item.prev60s.fPeakMs, slot.fPeakMs );
if ( item.prev60s.fResBiggestMs < slot.fTotalMs )
{
item.prev60s.fResBiggestMs = slot.fTotalMs;
item.prev60s.strResBiggestMsName = slot.strResBiggestMsName;
}
item.prev60s.uiTotalBytes += slot.uiTotalBytes;
item.prev60s.uiPeakBytes = Max ( item.prev60s.uiPeakBytes, slot.uiPeakBytes );
if ( item.prev60s.uiResBiggestBytes < slot.uiTotalBytes )
{
item.prev60s.uiResBiggestBytes = slot.uiTotalBytes;
item.prev60s.strResBiggestBytesName = slot.strResBiggestBytesName;
}
}
// Remove from map if no calls in the last 60s
if ( item.prev60s.uiNumCalls == 0 )
m_TimingMap.erase ( iter++ );
else
++iter;
}
}
//
// Update PeakUs threshold
//
m_PeakUsRequiredHistory.RemoveOlderThan ( 10000 );
ms_PeakUsThresh = m_PeakUsRequiredHistory.GetLowestValue ( DEFAULT_THRESH_MS * 1000 );
}
void mutation_category_trait::reset()
{
mutation_category_traits.clear();
}
/**
* Clears the cache.
*
* Since we don't change the state of the object we're marked const (also
* required since the objects in the cache need to be marked const).
*/
void clear_visibility_cache() const { invisibility_cache_.clear(); }
// return index of error, or -1 on success
int parse_kv(std::string str)
{
keyvals.clear();
_error.str("");
std::vector<char> current_key;
std::vector<char> current_val;
int i = 0;
while(str[i])
{
current_key.clear();
current_val.clear();
while(isspace(str[i])) i++;
while(str[i]) {
if(str[i] == '"') {
_error << "key names are not allowed to contain quotes or be contained in quotes.";
return i;
} else if(isspace(str[i])) {
_error << "unexpected whitespace.";
return i;
} else if(str[i] == '=') {
i++;
break;
} else current_key.push_back(str[i++]);
}
if(!current_key.size()) {
_error << "empty key name.";
return i;
}
bool quoted = false;
if(str[i] == '"') {
quoted = true;
i++;
}
while(str[i]) {
if(str[i] == '"') {
if(quoted) {
quoted = false;
i++;
break;
} else {
_error << "misplaced quotes.";
return i;
}
} else if(str[i] == '=') {
_error << "unexpected '=' char in value token.";
return i;
} else if(!quoted && isspace(str[i])) break;
else current_val.push_back(str[i++]);
}
if(quoted) {
_error << "unterminated quotes.";
return i;
}
if(str[i] && !isspace(str[i])) {
_error << "expected whitespace after value token.";
return i;
}
if(!current_val.size()) {
_error << "empty value string.";
return i;
}
std::string key = std::string(current_key.data(), current_key.size());
std::string val = std::string(current_val.data(), current_val.size());
if(keyvals.find(key) != keyvals.end())
{
_error << "duplicate key encountered: '" << key << "'";
return i;
}
keyvals[key] = val;
}
return -1;
}
/*!
Execute a boost::threadpool::pool task.
\param type Type of task to execute.
\param username Person who is the base of a task.
\param change What value to change as part of their statistic.
*/
void do_task(const Task_Type type, const int id, const int change)
{
boost::shared_lock<boost::shared_mutex> guard(mutex);
switch (type) {
case RESET_TASK:
statistics.clear();
break;
case ADD_TASK:
// Add a player to the player list.
try {
const std::map<int, VTankObject::Statistics>::iterator i = statistics.find(id);
if (i != statistics.end()) {
// Exists already. Do nothing.
return;
}
const tank_ptr tank = Players::tanks.get(id);
VTankObject::Statistics stats = VTankObject::Statistics();
stats.tankName = tank->get_name();
stats.kills = 0;
stats.deaths = 0;
stats.assists = 0;
stats.objectivesCaptured = 0;
stats.objectivesCompleted = 0;
stats.calculatedPoints = 0;
statistics[id] = stats;
}
catch (const TankNotExistException &) {
}
break;
case KILL_TASK:
// Add a kill to the player's record.
statistics[id].kills += change;
break;
case ASSIST_TASK:
// Add an assist to the player's record.
statistics[id].assists += change;
break;
case DEATH_TASK:
// Add a death to the player's record.
statistics[id].deaths += change;
break;
case OBJECTIVE_TASK:
// Add an objective completion to the player's record.
statistics[id].objectivesCompleted += change;
break;
case CAPTURE_TASK:
// Add an objective capture to the player's record.
statistics[id].objectivesCaptured += change;
break;
}
}
void Clear() { histo.clear(); }
void FileFilterIndex::clearIndex(std::map<std::string, int> indexMap)
{
indexMap.clear();
}
int main() {
// freopen("9066in.txt","r",stdin);
// freopen("9066out.txt","w",stdout);
int i, j, nq, root;
memset(pl, 0, sizeof(pl));
memset(B.r, 0, sizeof(B.r));
memset(q, 0, sizeof(q));
scanf("%d", &n);
for (i = 1; i <= n; i++)
scanf("%d", &a[i]);
scanf("%d", &nq);
for (i = 1; i <= nq; i++) {
char buff[2];
scanf("%s%d%d", buff, &q[i].x, &q[i].y);
q[i].tp = buff[0];
q[i].id = i;
}
std::sort(q + 1, q + nq + 1, cmp1);
pos.clear();
pcnt = 0;
newnode(root);
for (j = 1; j <= nq && q[j].tp == 'U'; j++)
;
for (i = 1; i <= n; i++) {
std::set<int>::iterator it;
std::set<int>&th = pos[a[i]];
if (!th.empty()) {
it = th.end();
--it;
refresh(root, 1, n, *it, -a[i]);
refresh(root, 1, n, i, a[i]);
th.insert(i);
} else {
refresh(root, 1, n, i, a[i]);
th.insert(i);
}
while (j <= nq && q[j].y <= i) {
q[j].ans = query(root, 1, n, q[j].x, q[j].y);
j++;
}
}
std::sort(q + 1, q + nq + 1, cmp2);
pcnt = 0;
B.init(n);
for (i = 1; i <= nq; i++) {
if (q[i].tp == 'Q') {
LL del = B.sum(q[i].x, 1, q[i].y);
printf("%lld\n", del + q[i].ans);
} else {
PII range;
getRange(q[i].x, a[q[i].x], range);
B.add(range.AA + 1, q[i].x, q[i].x, range.BB - 1, -a[q[i].x]);
getRange(q[i].x, q[i].y, range);
B.add(range.AA + 1, q[i].x, q[i].x, range.BB - 1, q[i].y);
pos[a[q[i].x]].erase(q[i].x);
pos[q[i].y].insert(q[i].x);
a[q[i].x] = q[i].y;
}
}
return 0;
}
void TexturePack::readTextureList(const char* texturelistfile,
std::vector<Rect>& textures_,
std::map<std::string, int>& filenameMap_,
int* pwidth, int* pheight)
{
G_FILE* fis = g_fopen(texturelistfile, "rt");
if (fis == NULL)
{
throw GiderosException(GStatus(6000, texturelistfile)); // Error #6000: %s: No such file or directory.
return;
}
textures_.clear();
filenameMap_.clear();
int width = 0;
int height = 0;
char line[1024];
while (true)
{
line[0] = line[1023] = 0;
if (g_fgets(line, 1024, fis) == NULL)
break;
char* c;
if ((c = strrchr(line, 0xa)))
*c = '\0';
if ((c = strrchr(line, 0xd)))
*c = '\0';
if (line[0] == '\0')
break;
std::vector<std::string> result;
pystring::split(line, result, ",");
for (std::size_t i = 0; i < result.size(); ++i)
{
if (result[i].empty() == false)
result[i] = pystring::strip(result[i]);
}
if (result.size() >= 9)
{
Rect rect;
rect.x = atoi(result[1].c_str());
rect.y = atoi(result[2].c_str());
rect.width = atoi(result[3].c_str());
rect.height = atoi(result[4].c_str());
rect.dx1 = atoi(result[5].c_str());
rect.dy1 = atoi(result[6].c_str());
rect.dx2 = atoi(result[7].c_str());
rect.dy2 = atoi(result[8].c_str());
filenameMap_[result[0]] = textures_.size();
textures_.push_back(rect);
width += rect.width + rect.dx1 + rect.dx2;
height += rect.height + rect.dy1 + rect.dy2;
}
}
g_fclose(fis);
if (pwidth)
*pwidth = width;
if (pheight)
*pheight = height;
if (textures_.empty() == true)
{
throw GiderosException(GStatus(6008, texturelistfile)); // Error #6008: %s: File does not contain texture region information.
return;
}
}
// ============================================================================
// ==============================================================================
bool AdvanceReduce(const std::map<__int64, std::string> &rMapOrgInfo,
const std::vector<FORMAT_RES_DATA> &vecResData,
std::map<__int64, std::string> &mapNewIndex,
std::map<int, int> &mapLookTrans,
std::map<int, int> &mapWeaponMotionTrans)
{
mapNewIndex.clear();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
std::vector<FORMAT_RES_DATA>::const_iterator it = vecResData.begin();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
for (; it != vecResData.end(); ++it) {
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
const FORMAT_RES_DATA &rData = *it;
const std::vector<__int64> &rVecIndex = rData.vecIndex;
__int64 i64IndexRes = ResPathTransIndex(rData.strRes);
bool bIndexResOk = true;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (i64IndexRes <= 0) {
bIndexResOk = false;
}
if (bIndexResOk) {
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
std::map<__int64, std::string>::const_iterator it = rMapOrgInfo.find(i64IndexRes);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (it == rMapOrgInfo.end() || it->second != rData.strRes) {
bIndexResOk = false;
}
}
if (!bIndexResOk) {
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
std::vector<__int64>::const_iterator itIndex = rVecIndex.begin();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
for (; itIndex != rVecIndex.end(); ++itIndex) {
//~~~~~~~~~~~~~~~~~~~~~~~~
__int64 i64Index = *itIndex;
//~~~~~~~~~~~~~~~~~~~~~~~~
if (REDUCE_VERSION > 1) {
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
__int64 i64IndexRuleTrans = MountRuleTrans(i64Index);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (i64IndexRuleTrans != i64Index) {
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
const std::map<__int64, std::string>::const_iterator itRule = rMapOrgInfo.find(i64IndexRuleTrans);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (itRule != rMapOrgInfo.end() && itRule->second == rData.strRes) {
continue;
}
}
}
mapNewIndex[i64Index] = rData.strRes;
}
} else {
mapNewIndex[i64IndexRes] = rData.strRes;
//~~~~~~~~~~~~~~~~~~~~~
int nResLook = 0;
int nResWeaponMotion = 0;
//~~~~~~~~~~~~~~~~~~~~~
GetIndexInfo(i64IndexRes, nResLook, nResWeaponMotion);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
std::vector<__int64>::const_iterator itIndex = rVecIndex.begin();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
for (; itIndex != rVecIndex.end(); ++itIndex) {
//~~~~~~~~~~~~~~~~~~~~~~~~
int nIndexLook = 0;
int nIndexWeaponMotion = 0;
__int64 i64Index = *itIndex;
//~~~~~~~~~~~~~~~~~~~~~~~~
if (REDUCE_VERSION > 1) {
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
__int64 i64IndexRuleTrans = MountRuleTrans(i64Index);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (i64IndexRuleTrans != i64Index) {
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
const std::map<__int64, std::string>::const_iterator itRule = rMapOrgInfo.find(i64IndexRuleTrans);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (itRule != rMapOrgInfo.end() && itRule->second == rData.strRes) {
continue;
}
}
}
GetIndexInfo(i64Index, nIndexLook, nIndexWeaponMotion);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
std::map<int, int>::const_iterator itFind;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
itFind = mapLookTrans.find(nIndexLook);
if (itFind == mapLookTrans.end()) {
mapLookTrans[nIndexLook] = nResLook;
}
if (mapLookTrans[nIndexLook] != nResLook) {
mapNewIndex[i64Index] = rData.strRes;
continue;
}
itFind = mapWeaponMotionTrans.find(nIndexWeaponMotion);
if (itFind == mapWeaponMotionTrans.end()) {
mapWeaponMotionTrans[nIndexWeaponMotion] = nResWeaponMotion;
}
if (mapWeaponMotionTrans[nIndexWeaponMotion] != nResWeaponMotion) {
mapNewIndex[i64Index] = rData.strRes;
}
}
}
}
printf("ReduceVer %d End %d %d %d\n", REDUCE_VERSION, mapNewIndex.size(), mapLookTrans.size(),
mapWeaponMotionTrans.size());
return true;
}
/* Menu メッセージ処理 */
INT_PTR CPropMainMenu::DispatchEvent(
HWND hwndDlg, // handle to dialog box
UINT uMsg, // message
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter
)
{
WORD wNotifyCode;
WORD wID;
HWND hwndCtl;
NMHDR* pNMHDR;
static HWND hwndComboFunkKind;
static HWND hwndListFunk;
static HWND hwndTreeRes;
int i;
HTREEITEM nIdxMenu;
int nIdxFIdx;
int nIdxFunc;
WCHAR szLabel[256+10];
EFunctionCode eFuncCode;
SMainMenuWork* pFuncWk; // 機能
TCHAR szKey[2];
TV_INSERTSTRUCT tvis; // 挿入用
TV_ITEM tvi; // 取得用
HTREEITEM htiItem;
HTREEITEM htiParent;
HTREEITEM htiTemp;
HTREEITEM htiTemp2;
TV_DISPINFO* ptdi;
CDlgInput1 cDlgInput1;
static bool bInMove;
bool bIsNode;
switch( uMsg ){
case WM_INITDIALOG:
/* ダイアログデータの設定 Menu */
SetData( hwndDlg );
::SetWindowLongPtr( hwndDlg, DWLP_USER, lParam );
/* コントロールのハンドルを取得 */
hwndComboFunkKind = ::GetDlgItem( hwndDlg, IDC_COMBO_FUNCKIND );
hwndListFunk = ::GetDlgItem( hwndDlg, IDC_LIST_FUNC );
hwndTreeRes = ::GetDlgItem( hwndDlg, IDC_TREE_RES );
/* キー選択時の処理 */
::SendMessage( hwndDlg, WM_COMMAND, MAKELONG( IDC_COMBO_FUNCKIND, CBN_SELCHANGE ), (LPARAM)hwndComboFunkKind );
// TreeViewのメッセージ処理（アクセスキー入力用）
m_hwndDlg = hwndDlg;
m_wpTreeView = (WNDPROC)SetWindowLongPtr( hwndTreeRes, GWLP_WNDPROC, (LONG_PTR)TreeViewProc );
::SetTimer( hwndDlg, 1, 300, NULL );
bInMove = false;
return TRUE;
case WM_NOTIFY:
pNMHDR = (NMHDR*)lParam;
ptdi = (TV_DISPINFO*)lParam;
switch( pNMHDR->code ){
case PSN_HELP:
OnHelp( hwndDlg, IDD_PROP_MAINMENU );
return TRUE;
case PSN_KILLACTIVE:
/* ダイアログデータの取得 Menu */
GetData( hwndDlg );
return TRUE;
case PSN_SETACTIVE:
m_nPageNum = ID_PROPCOM_PAGENUM_MAINMENU;
// 表示を更新する（マクロ設定画面でのマクロ名変更を反映）
nIdxFIdx = Combo_GetCurSel( hwndComboFunkKind );
nIdxFunc = List_GetCurSel( hwndListFunk );
if( nIdxFIdx != CB_ERR ){
::SendMessage( hwndDlg, WM_COMMAND, MAKEWPARAM( IDC_COMBO_FUNCKIND, CBN_SELCHANGE ), (LPARAM)hwndComboFunkKind );
if( nIdxFunc != LB_ERR ){
List_SetCurSel( hwndListFunk, nIdxFunc );
}
}
return TRUE;
case TVN_BEGINLABELEDIT: // アイテムの編集開始
if (pNMHDR->hwndFrom == hwndTreeRes) {
HWND hEdit = TreeView_GetEditControl( hwndTreeRes );
if (msMenu[ptdi->item.lParam].m_bIsNode) {
// ノードのみ有効
SetWindowText( hEdit, to_tchar( msMenu[ptdi->item.lParam].m_sName.c_str() ) ) ;
EditCtl_LimitText( hEdit, MAX_MAIN_MENU_NAME_LEN );
// 編集時のメッセージ処理
m_wpEdit = (WNDPROC)SetWindowLongPtr( hEdit, GWLP_WNDPROC, (LONG_PTR)WindowProcEdit );
}
else {
// ノード以外編集不可
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, TRUE);
}
}
return TRUE;
case TVN_ENDLABELEDIT: // アイテムの編集が終了
if (pNMHDR->hwndFrom == hwndTreeRes
&& msMenu[ ptdi->item.lParam ].m_bIsNode) {
// ノード有効
pFuncWk = &msMenu[ptdi->item.lParam];
std::wstring strNameOld = pFuncWk->m_sName;
if (ptdi->item.pszText == NULL) {
// Esc
// 何も設定しない（元のまま）
}
else if (auto_strcmp(ptdi->item.pszText, _T("")) == 0) {
// 空
pFuncWk->m_sName = LSW(STR_PROPCOMMAINMENU_EDIT);
}
else {
pFuncWk->m_sName = to_wchar(ptdi->item.pszText);
}
if( strNameOld != pFuncWk->m_sName ){
// ラベルを編集したらリソースからの文字列取得をやめる 2012.10.14 syat 各国語対応
pFuncWk->m_nFunc = F_NODE;
}
ptdi->item.pszText = const_cast<TCHAR*>( MakeDispLabel( pFuncWk ) );
TreeView_SetItem( hwndTreeRes , &ptdi->item ); // 編集結果を反映
// 編集時のメッセージ処理を戻す
SetWindowLongPtr( TreeView_GetEditControl( hwndTreeRes ), GWLP_WNDPROC, (LONG_PTR)m_wpEdit );
m_wpEdit = NULL;
}
return TRUE;
case TVN_DELETEITEM:
if (!bInMove && !msMenu.empty()
&& pNMHDR->hwndFrom == hwndTreeRes
&& (htiItem = TreeView_GetSelection( hwndTreeRes )) != NULL) {
//付属情報を削除
tvi.mask = TVIF_HANDLE | TVIF_PARAM;
tvi.hItem = htiItem;
if (TreeView_GetItem( hwndTreeRes, &tvi )) {
msMenu.erase( tvi.lParam );
}
return 0;
}
break;
case NM_DBLCLK:
// ダブルクリック時の処理
if (pNMHDR->hwndFrom == hwndTreeRes) {
htiItem = TreeView_GetSelection( hwndTreeRes );
if (htiItem == NULL) {
break;
}
tvi.mask = TVIF_HANDLE | TVIF_PARAM;
tvi.hItem = htiItem;
if (!TreeView_GetItem( hwndTreeRes, &tvi )) {
break;
}
pFuncWk = &msMenu[tvi.lParam];
if (pFuncWk->m_nFunc != F_SEPARATOR) {
auto_sprintf( szKey, _T("%ls"), pFuncWk->m_sKey);
if (!cDlgInput1.DoModal(
G_AppInstance(),
hwndDlg,
LS(STR_PROPCOMMAINMENU_ACCKEY1),
LS(STR_PROPCOMMAINMENU_ACCKEY2),
1,
szKey)) {
return TRUE;
}
auto_sprintf( pFuncWk->m_sKey, L"%ts", szKey);
pFuncWk->m_bDupErr = false;
tvi.mask = TVIF_HANDLE | TVIF_TEXT | TVIF_PARAM;
tvi.pszText = const_cast<TCHAR*>( MakeDispLabel( pFuncWk ) );
TreeView_SetItem( hwndTreeRes, &tvi );
}
}
break;
}
break;
case WM_COMMAND:
wNotifyCode = HIWORD(wParam); /* 通知コード */
wID = LOWORD(wParam); /* 項目ID､ コントロールID､ またはアクセラレータID */
hwndCtl = (HWND) lParam; /* コントロールのハンドル */
if (hwndComboFunkKind == hwndCtl) {
switch( wNotifyCode ){
case CBN_SELCHANGE:
nIdxFIdx = Combo_GetCurSel( hwndComboFunkKind );
if (nIdxFIdx == nSpecialFuncsNum) {
// 機能一覧に特殊機能をセット
List_ResetContent( hwndListFunk );
for (i = 0; i < nsFuncCode::nFuncList_Special_Num; i++) {
List_AddString( hwndListFunk, LS(nsFuncCode::pnFuncList_Special[i]) );
}
}
else {
/* 機能一覧に文字列をセット（リストボックス）*/
m_cLookup.SetListItem( hwndListFunk, nIdxFIdx );
}
return TRUE;
}
}
else{
switch( wNotifyCode ){
/* ボタン／チェックボックスがクリックされた */
case BN_CLICKED:
switch( wID ){
case IDC_BUTTON_IMPORT: /* インポート */
/* カスタムメニュー設定をインポートする */
Import( hwndDlg );
return TRUE;
case IDC_BUTTON_EXPORT: /* エクスポート */
/* カスタムメニュー設定をエクスポートする */
Export( hwndDlg );
return TRUE;
case IDC_BUTTON_CLEAR:
if (IDCANCEL == ::MYMESSAGEBOX( hwndDlg, MB_OKCANCEL | MB_ICONQUESTION, GSTR_APPNAME,
LS(STR_PROPCOMMAINMENU_CLEAR)) ) {
return TRUE;
}
// 内部データ初期化
msMenu.clear();
nMenuCnt = 0;
// TreeView初期化
TreeView_DeleteAllItems( hwndTreeRes );
return TRUE;
case IDC_BUTTON_INITIALIZE:
if (IDCANCEL == ::MYMESSAGEBOX( hwndDlg, MB_OKCANCEL | MB_ICONQUESTION, GSTR_APPNAME,
LS(STR_PROPCOMMAINMENU_INIT))) {
return TRUE;
}
// 初期状態に戻す
{
CDataProfile cProfile;
std::vector<std::wstring> data;
cProfile.SetReadingMode();
cProfile.ReadProfileRes( MAKEINTRESOURCE(IDR_MENU1), MAKEINTRESOURCE(ID_RC_TYPE_INI), &data );
CShareData_IO::IO_MainMenu( cProfile, &data, m_Common.m_sMainMenu, false );
SetData( hwndDlg );
}
return TRUE;
case IDC_BUTTON_DELETE:
htiItem = TreeView_GetSelection( hwndTreeRes );
if (htiItem != NULL) {
if (TreeView_GetChild( hwndTreeRes, htiItem ) != NULL
&& IDCANCEL == ::MYMESSAGEBOX( hwndDlg, MB_OKCANCEL | MB_ICONQUESTION, GSTR_APPNAME,
LS(STR_PROPCOMMAINMENU_DEL))) {
return TRUE;
}
htiTemp = TreeView_GetNextSibling( hwndTreeRes, htiItem );
if (htiTemp == NULL) {
// 末尾ならば、前を取る
htiTemp = TreeView_GetPrevSibling( hwndTreeRes, htiItem );
}
TreeView_DeleteItem( hwndTreeRes, htiItem );
if (htiTemp != NULL) {
TreeView_SelectItem( hwndTreeRes, htiTemp );
}
}
break;
case IDC_BUTTON_INSERT_NODE: // ノード挿入
case IDC_BUTTON_INSERTSEPARATOR: // 区切線挿入
case IDC_BUTTON_INSERT: // 挿入(上)
case IDC_BUTTON_INSERT_A: // 挿入(下)
case IDC_BUTTON_ADD: // 追加
eFuncCode = F_INVALID;
bIsNode = false;
switch (wID) {
case IDC_BUTTON_INSERT_NODE: // ノード挿入
eFuncCode = F_NODE;
bIsNode = true;
auto_strncpy( szLabel , LSW(STR_PROPCOMMAINMENU_EDIT), _countof(szLabel) - 1 );
szLabel[_countof(szLabel) - 1] = L'\0';
break;
case IDC_BUTTON_INSERTSEPARATOR: // 区切線挿入
eFuncCode = F_SEPARATOR;
auto_strncpy( szLabel , LSW(STR_PROPCOMMAINMENU_SEP), _countof(szLabel) - 1 );
szLabel[_countof(szLabel) - 1] = L'\0';
break;
case IDC_BUTTON_INSERT: // 挿入
case IDC_BUTTON_INSERT_A: // 挿入
case IDC_BUTTON_ADD: // 追加
// Function 取得
if (CB_ERR == (nIdxFIdx = Combo_GetCurSel( hwndComboFunkKind ))) {
return FALSE;
}
if (LB_ERR == (nIdxFunc = List_GetCurSel( hwndListFunk ))) {
return FALSE;
}
if (nIdxFIdx == nSpecialFuncsNum) {
// 特殊機能
auto_strcpy( szLabel, LSW(nsFuncCode::pnFuncList_Special[nIdxFunc]) );
eFuncCode = nsFuncCode::pnFuncList_Special[nIdxFunc];
}
else if (m_cLookup.Pos2FuncCode( nIdxFIdx, nIdxFunc ) != 0) {
List_GetText( hwndListFunk, nIdxFunc, szLabel );
eFuncCode = m_cLookup.Pos2FuncCode( nIdxFIdx, nIdxFunc );
}
else {
auto_strcpy( szLabel, L"?" );
eFuncCode = F_SEPARATOR;
}
break;
}
// 挿入位置検索
htiTemp = TreeView_GetSelection( hwndTreeRes );
if (htiTemp == NULL) {
// 取れなかったらRootの末尾
htiParent = TVI_ROOT;
htiTemp = TVI_LAST;
}
else {
if (wID == IDC_BUTTON_ADD) {
// 追加
tvi.mask = TVIF_HANDLE | TVIF_PARAM;
tvi.hItem = htiTemp;
if (!TreeView_GetItem( hwndTreeRes, &tvi )) {
// 取れなかったらRootの末尾
htiParent = TVI_ROOT;
htiTemp = TVI_LAST;
}
else {
if (msMenu[tvi.lParam].m_bIsNode) {
// ノード
htiParent = htiTemp;
htiTemp = TVI_LAST;
}
else {
// 子を付けられないので親に付ける（選択アイテムの下に付く）
htiParent = TreeView_GetParent( hwndTreeRes, htiTemp );
htiTemp = TVI_LAST;
if (htiParent == NULL) {
// 取れなかったらRootの末尾
htiParent = TVI_ROOT;
}
}
}
}
else if (wID == IDC_BUTTON_INSERT_NODE || wID == IDC_BUTTON_INSERT_A) {
// ノード挿入、挿入(下)
// 追加先を探る
htiTemp = TreeView_GetSelection( hwndTreeRes );
if (htiTemp == NULL) {
htiParent = TVI_ROOT;
htiTemp = TVI_LAST;
}
else {
tvi.mask = TVIF_HANDLE | TVIF_PARAM;
tvi.hItem = htiTemp;
if (TreeView_GetItem( hwndTreeRes, &tvi )) {
if (msMenu[tvi.lParam].m_bIsNode) {
// ノード
htiParent = htiTemp;
htiTemp = TVI_FIRST;
}
else {
// 子を付けられないので親に付ける（選択アイテムの下に付く）
htiParent = TreeView_GetParent( hwndTreeRes, htiTemp );
if (htiParent == NULL) {
// 取れなかったらRoot
htiParent = TVI_ROOT;
}
}
}
else {
// 取れなかったらRoot
htiParent = TVI_ROOT;
htiTemp = TVI_LAST;
}
}
}
else {
// 挿入(上)、区切線
// 挿入先を探る
htiParent = TreeView_GetParent( hwndTreeRes, htiTemp );
if (htiParent == NULL) {
// 取れなかったらRootのトップ
htiParent = TVI_ROOT;
htiTemp = TVI_FIRST;
}
else {
// 一つ手前
htiTemp = TreeView_GetPrevSibling( hwndTreeRes, htiTemp );
if (htiTemp == NULL) {
// 取れなかったら親の最初
htiTemp = TVI_FIRST;
}
}
}
}
// TreeViewに挿入
pFuncWk = &msMenu[nMenuCnt];
pFuncWk->m_nFunc = (EFunctionCode)eFuncCode;
pFuncWk->m_sName = szLabel;
pFuncWk->m_bDupErr = false;
pFuncWk->m_bIsNode = bIsNode;
pFuncWk->m_sKey[0] = L'\0';
tvis.item.mask = TVIF_TEXT | TVIF_PARAM | TVIF_CHILDREN;
tvis.hParent = htiParent;
tvis.hInsertAfter = htiTemp;
tvis.item.pszText = const_cast<TCHAR*>(to_tchar(szLabel));
tvis.item.lParam = nMenuCnt++;
tvis.item.cChildren = ( wID == IDC_BUTTON_INSERT_NODE );
htiItem = TreeView_InsertItem( hwndTreeRes, &tvis );
// 展開
if (htiParent != TVI_ROOT) {
TreeView_Expand( hwndTreeRes, htiParent, TVE_EXPAND );
}
TreeView_SelectItem( hwndTreeRes, htiItem );
// リストを1つ進める
switch (wID) {
case IDC_BUTTON_INSERT: // 挿入
case IDC_BUTTON_INSERT_A: // 挿入
case IDC_BUTTON_ADD: // 追加
List_SetCurSel( hwndListFunk, nIdxFunc+1 );
break;
}
break;
case IDC_BUTTON_UP:
htiItem = TreeView_GetSelection( hwndTreeRes );
if (htiItem == NULL) {
break;
}
htiTemp = TreeView_GetPrevSibling( hwndTreeRes, htiItem );
if (htiTemp == NULL) {
// そのエリアで最初
break;
}
// コピー
bInMove = true;
TreeCopy(hwndTreeRes, htiItem, htiTemp, false, true);
// 削除
TreeView_DeleteItem( hwndTreeRes, htiTemp );
bInMove = false;
break;
case IDC_BUTTON_DOWN:
htiItem = TreeView_GetSelection( hwndTreeRes );
if (htiItem == NULL) {
break;
}
htiTemp = TreeView_GetNextSibling( hwndTreeRes, htiItem );
if (htiTemp == NULL) {
// そのエリアで最後
break;
}
// コピー
bInMove = true;
TreeCopy(hwndTreeRes, htiTemp, htiItem, false, true);
// 削除
TreeView_DeleteItem( hwndTreeRes, htiItem );
bInMove = false;
// 選択
htiItem = TreeView_GetNextSibling( hwndTreeRes, htiTemp );
if (htiItem != NULL) {
TreeView_SelectItem( hwndTreeRes, htiItem );
}
break;
case IDC_BUTTON_RIGHT:
htiItem = TreeView_GetSelection( hwndTreeRes );
if (htiItem == NULL) {
break;
}
htiTemp = TreeView_GetPrevSibling( hwndTreeRes, htiItem );
if (htiTemp == NULL) {
// そのエリアで最初
break;
}
// ノード確認
tvi.mask = TVIF_HANDLE | TVIF_PARAM | TVIF_CHILDREN;
tvi.hItem = htiTemp;
i = TreeView_GetItem( hwndTreeRes, &tvi );
if (!TreeView_GetItem( hwndTreeRes, &tvi )) {
// エラー
break;
}
if (tvi.cChildren) {
// 直前がノード
HTREEITEM htiTemp2;
// コピー
bInMove = true;
htiTemp2 = TreeCopy(hwndTreeRes, htiTemp, htiItem, true, true);
// 削除
TreeView_DeleteItem( hwndTreeRes, htiItem );
bInMove = false;
// 選択
TreeView_SelectItem( hwndTreeRes, htiTemp2 );
}
else {
// ノードが無い
break;
}
break;
case IDC_BUTTON_LEFT:
htiItem = TreeView_GetSelection( hwndTreeRes );
if (htiItem == NULL) {
break;
}
htiParent = TreeView_GetParent( hwndTreeRes, htiItem );
if (htiParent == NULL) {
// Root
break;
}
// コピー
bInMove = true;
htiTemp2 = TreeCopy(hwndTreeRes, htiParent, htiItem, false, true);
// 削除
TreeView_DeleteItem( hwndTreeRes, htiItem );
bInMove = false;
// 選択
TreeView_SelectItem( hwndTreeRes, htiTemp2 );
break;
case IDC_BUTTON_CHECK: // メニューの検査
{
wstring sErrMsg;
if (Check_MainMenu( hwndTreeRes, sErrMsg )) {
InfoMessage( hwndDlg, LS(STR_PROPCOMMAINMENU_OK));
}
else {
WarningMessage( hwndDlg, to_tchar(sErrMsg.c_str()) );
}
}
break;
case IDC_BUTTON_EXPAND: // ツリー全開
TreeView_ExpandAll( hwndTreeRes, true );
break;
case IDC_BUTTON_COLLAPSE: // ツリー全閉
TreeView_ExpandAll( hwndTreeRes, false );
break;
}
break;
}
}
break;
case WM_TIMER:
nIdxMenu = TreeView_GetSelection( hwndTreeRes );
nIdxFIdx = Combo_GetCurSel( hwndComboFunkKind );
nIdxFunc = List_GetCurSel( hwndListFunk );
i = List_GetCount( hwndTreeRes );
if (nIdxMenu == NULL) {
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_DELETE ), FALSE );
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_UP ), FALSE );
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_DOWN ), FALSE );
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_RIGHT ), FALSE );
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_LEFT ), FALSE );
}
else{
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_DELETE ), TRUE );
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_UP ), NULL != TreeView_GetPrevSibling( hwndTreeRes, nIdxMenu ) );
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_DOWN ), NULL != TreeView_GetNextSibling( hwndTreeRes, nIdxMenu ) );
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_RIGHT ), NULL != TreeView_GetPrevSibling( hwndTreeRes, nIdxMenu ) );
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_LEFT ), NULL != TreeView_GetParent( hwndTreeRes, nIdxMenu ) );
}
if (LB_ERR == nIdxFunc ||
( CB_ERR != nIdxFIdx && LB_ERR != nIdxFunc &&
(m_cLookup.Pos2FuncCode( nIdxFIdx, nIdxFunc ) == 0 && nIdxFIdx != nSpecialFuncsNum))) {
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_INSERT ), FALSE );
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_INSERT_A ), FALSE );
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_ADD ), FALSE );
}
else{
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_INSERT ), NULL != nIdxMenu );
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_INSERT_A ), NULL != nIdxMenu );
::EnableWindow( ::GetDlgItem( hwndDlg, IDC_BUTTON_ADD ), TRUE );
}
break;
case WM_DESTROY:
::KillTimer( hwndDlg, 1 );
// 編集時のメッセージ処理を戻す
SetWindowLongPtr( hwndTreeRes, GWLP_WNDPROC, (LONG_PTR)m_wpTreeView );
m_wpTreeView = NULL;
// ワークのクリア
msMenu.clear();
nMenuCnt = 0;
break;
case WM_HELP:
{
HELPINFO *p = (HELPINFO *)lParam;
MyWinHelp( (HWND)p->hItemHandle, HELP_WM_HELP, (ULONG_PTR)(LPVOID)p_helpids );
}
return TRUE;
//Context Menu
case WM_CONTEXTMENU:
MyWinHelp( hwndDlg, HELP_CONTEXTMENU, (ULONG_PTR)(LPVOID)p_helpids );
return TRUE;
}
return FALSE;
}
void GazeboConnector::clear() {
tracked.clear();
}
/* ダイアログデータの設定 MainMenu */
void CPropMainMenu::SetData( HWND hwndDlg )
{
CMainMenu* pcMenuTBL = m_Common.m_sMainMenu.m_cMainMenuTbl;
CMainMenu* pcFunc;
HWND hwndCombo;
HWND hwndCheck;
HWND hwndTreeRes;
const int MAX_LABEL_CCH = 256+10;
WCHAR szLabel[MAX_LABEL_CCH];
int nCurLevel;
HTREEITEM htiItem;
HTREEITEM htiParent;
TV_INSERTSTRUCT tvis; // 挿入用
SMainMenuWork* pFuncWk; // 機能(work)
int i;
/* 機能種別一覧に文字列をセット（コンボボックス） */
hwndCombo = ::GetDlgItem( hwndDlg, IDC_COMBO_FUNCKIND );
m_cLookup.SetCategory2Combo( hwndCombo );
// 特別機能追加
nSpecialFuncsNum = Combo_AddString( hwndCombo, LS( STR_SPECIAL_FUNC ) );
/* 種別の先頭の項目を選択（コンボボックス）*/
Combo_SetCurSel( hwndCombo, 0 );
// ワーク、TreeViewの初期化
msMenu.clear();
nMenuCnt = 0;
hwndTreeRes = ::GetDlgItem( hwndDlg, IDC_TREE_RES );
TreeView_DeleteAllItems( hwndTreeRes );
// アクセスキーを( )付で表示
hwndCheck = ::GetDlgItem( hwndDlg, IDC_CHECK_KEY_PARENTHESES );
BtnCtl_SetCheck( hwndCheck, m_Common.m_sMainMenu.m_bMainMenuKeyParentheses );
/* メニュー項目一覧と内部データをセット（TreeView）*/
nCurLevel = 0;
htiParent = TVI_ROOT;
htiItem = TreeView_GetRoot( hwndTreeRes );
for (i = 0; i < m_Common.m_sMainMenu.m_nMainMenuNum; i++) {
pcFunc = &pcMenuTBL[i];
if (pcFunc->m_nLevel < nCurLevel) {
// Level Up
for (; pcFunc->m_nLevel < nCurLevel; nCurLevel--) {
htiParent = (htiParent == TVI_ROOT) ? TVI_ROOT : TreeView_GetParent( hwndTreeRes, htiParent );
if (htiParent == NULL) htiParent = TVI_ROOT;
}
}
else if (pcFunc->m_nLevel > nCurLevel) {
// Level Down
for ( htiParent = htiItem, nCurLevel++; pcFunc->m_nLevel < nCurLevel; nCurLevel++) {
// 実行されることは無いはず（データが正常ならば）
htiParent = TreeView_GetChild( hwndTreeRes, htiItem );
if (htiParent == NULL) htiParent = htiItem;
}
}
// 内部データを作成
pFuncWk = &msMenu[nMenuCnt];
pFuncWk->m_nFunc = pcFunc->m_nFunc;
pFuncWk->m_bIsNode = false;
switch (pcFunc->m_nType) {
case T_LEAF:
m_cLookup.Funccode2Name( pcFunc->m_nFunc, szLabel, MAX_LABEL_CCH );
pFuncWk->m_sName = szLabel;
break;
case T_SEPARATOR:
pFuncWk->m_sName = LSW(STR_PROPCOMMAINMENU_SEP);
break;
case T_SPECIAL:
// 2014.05.04 各国語対応
pFuncWk->m_sName = LSW(pcFunc->m_nFunc);
break;
case T_NODE:
pFuncWk->m_bIsNode = true;
// ラベル編集後のノードはiniから、それ以外はリソースからラベルを取得 2012.10.14 syat 各国語対応
if (pFuncWk->m_nFunc == F_NODE) {
pFuncWk->m_sName = RemoveAmpersand( pcFunc->m_sName );
} else {
pFuncWk->m_sName = LSW( pFuncWk->m_nFunc );
}
break;
}
auto_strcpy(pFuncWk->m_sKey, pcFunc->m_sKey);
pFuncWk->m_bDupErr = false;
// TreeViewに挿入
tvis.item.mask = TVIF_TEXT | TVIF_PARAM | TVIF_CHILDREN;
tvis.hParent = htiParent;
tvis.hInsertAfter = TVI_LAST;
tvis.item.pszText = const_cast<TCHAR*>( MakeDispLabel( pFuncWk ) );
tvis.item.lParam = nMenuCnt++; // 内部データインデックスのインクリメント
tvis.item.cChildren = ( pcFunc->m_nType == T_NODE );
htiItem = TreeView_InsertItem( hwndTreeRes, &tvis );
}
}
static void clear_controlid_list()
{
controlid_lookup.clear();
}
inline void
CommandInterestValidator::reset()
{
m_trustAnchorsForInterest.clear();
m_trustScopeForInterest.clear();
}
void Localization::UnloadAllSets()
{
g_strings.clear();
}
std::string LoadMtl (
std::map<std::string, material_t>& material_map,
std::istream& inStream)
{
material_map.clear();
std::stringstream err;
material_t material;
int maxchars = 8192; // Alloc enough size.
std::vector<char> buf(maxchars); // Alloc enough size.
while (inStream.peek() != -1) {
inStream.getline(&buf[0], maxchars);
std::string linebuf(&buf[0]);
// Trim newline '\r\n' or '\n'
if (linebuf.size() > 0) {
if (linebuf[linebuf.size()-1] == '\n') linebuf.erase(linebuf.size()-1);
}
if (linebuf.size() > 0) {
if (linebuf[linebuf.size()-1] == '\r') linebuf.erase(linebuf.size()-1);
}
// Skip if empty line.
if (linebuf.empty()) {
continue;
}
// Skip leading space.
const char* token = linebuf.c_str();
token += strspn(token, " \t");
assert(token);
if (token[0] == '\0') continue; // empty line
if (token[0] == '#') continue; // comment line
// new mtl
if ((0 == strncmp(token, "newmtl", 6)) && isSpace((token[6]))) {
// flush previous material.
material_map.insert(std::pair<std::string, material_t>(material.name, material));
// initial temporary material
InitMaterial(material);
// set new mtl name
char namebuf[4096];
token += 7;
sscanf(token, "%s", namebuf);
material.name = namebuf;
continue;
}
// ambient
if (token[0] == 'K' && token[1] == 'a' && isSpace((token[2]))) {
token += 2;
float r, g, b;
parseFloat3(r, g, b, token);
material.ambient[0] = r;
material.ambient[1] = g;
material.ambient[2] = b;
continue;
}
// diffuse
if (token[0] == 'K' && token[1] == 'd' && isSpace((token[2]))) {
token += 2;
float r, g, b;
parseFloat3(r, g, b, token);
material.diffuse[0] = r;
material.diffuse[1] = g;
material.diffuse[2] = b;
continue;
}
// specular
if (token[0] == 'K' && token[1] == 's' && isSpace((token[2]))) {
token += 2;
float r, g, b;
parseFloat3(r, g, b, token);
material.specular[0] = r;
material.specular[1] = g;
material.specular[2] = b;
continue;
}
// transmittance
if (token[0] == 'K' && token[1] == 't' && isSpace((token[2]))) {
token += 2;
float r, g, b;
parseFloat3(r, g, b, token);
material.transmittance[0] = r;
material.transmittance[1] = g;
material.transmittance[2] = b;
continue;
}
// ior(index of refraction)
if (token[0] == 'N' && token[1] == 'i' && isSpace((token[2]))) {
token += 2;
material.ior = parseFloat(token);
continue;
}
// emission
if(token[0] == 'K' && token[1] == 'e' && isSpace(token[2])) {
token += 2;
float r, g, b;
parseFloat3(r, g, b, token);
material.emission[0] = r;
material.emission[1] = g;
material.emission[2] = b;
continue;
}
// shininess
if(token[0] == 'N' /*&& token[1] == 's' */&& isSpace(token[1/*2*/])) {
token += 2;
material.shininess = parseFloat(token);
continue;
}
// illum model
if (0 == strncmp(token, "illum", 5) && isSpace(token[5])) {
token += 6;
material.illum = parseInt(token);
continue;
}
// dissolve
if ((token[0] == 'd' && isSpace(token[1]))) {
token += 1;
material.dissolve = parseFloat(token);
continue;
}
if (token[0] == 'T' && token[1] == 'r' && isSpace(token[2])) {
token += 2;
material.dissolve = parseFloat(token);
continue;
}
// ambient texture
if ((0 == strncmp(token, "map_Ka", 6)) && isSpace(token[6])) {
token += 7;
material.ambient_texname = token;
continue;
}
// diffuse texture
if ((0 == strncmp(token, "map_Kd", 6)) && isSpace(token[6])) {
token += 7;
material.diffuse_texname = token;
continue;
}
// specular texture
if ((0 == strncmp(token, "map_Ks", 6)) && isSpace(token[6])) {
token += 7;
material.specular_texname = token;
continue;
}
// normal texture
if ((0 == strncmp(token, "map_Ns", 6)) && isSpace(token[6])) {
token += 7;
material.normal_texname = token;
continue;
}
// unknown parameter
const char* _space = strchr(token, ' ');
if(!_space) {
_space = strchr(token, '\t');
}
if(_space) {
int len = _space - token;
std::string key(token, len);
std::string value = _space + 1;
material.unknown_parameter.insert(std::pair<std::string, std::string>(key, value));
}
}
// flush last material.
material_map.insert(std::pair<std::string, material_t>(material.name, material));
return err.str();
}
static void dumpCXXData(const ObjectFile *Obj) {
struct CompleteObjectLocator {
StringRef Symbols[2];
ArrayRef<little32_t> Data;
};
struct ClassHierarchyDescriptor {
StringRef Symbols[1];
ArrayRef<little32_t> Data;
};
struct BaseClassDescriptor {
StringRef Symbols[2];
ArrayRef<little32_t> Data;
};
struct TypeDescriptor {
StringRef Symbols[1];
uint64_t AlwaysZero;
StringRef MangledName;
};
struct ThrowInfo {
uint32_t Flags;
};
struct CatchableTypeArray {
uint32_t NumEntries;
};
struct CatchableType {
uint32_t Flags;
uint32_t NonVirtualBaseAdjustmentOffset;
int32_t VirtualBasePointerOffset;
uint32_t VirtualBaseAdjustmentOffset;
uint32_t Size;
StringRef Symbols[2];
};
std::map<std::pair<StringRef, uint64_t>, StringRef> VFTableEntries;
std::map<std::pair<StringRef, uint64_t>, StringRef> TIEntries;
std::map<std::pair<StringRef, uint64_t>, StringRef> CTAEntries;
std::map<StringRef, ArrayRef<little32_t>> VBTables;
std::map<StringRef, CompleteObjectLocator> COLs;
std::map<StringRef, ClassHierarchyDescriptor> CHDs;
std::map<std::pair<StringRef, uint64_t>, StringRef> BCAEntries;
std::map<StringRef, BaseClassDescriptor> BCDs;
std::map<StringRef, TypeDescriptor> TDs;
std::map<StringRef, ThrowInfo> TIs;
std::map<StringRef, CatchableTypeArray> CTAs;
std::map<StringRef, CatchableType> CTs;
std::map<std::pair<StringRef, uint64_t>, StringRef> VTableSymEntries;
std::map<std::pair<StringRef, uint64_t>, int64_t> VTableDataEntries;
std::map<std::pair<StringRef, uint64_t>, StringRef> VTTEntries;
std::map<StringRef, StringRef> TINames;
SectionRelocMap.clear();
for (const SectionRef &Section : Obj->sections()) {
section_iterator Sec2 = Section.getRelocatedSection();
if (Sec2 != Obj->section_end())
SectionRelocMap[*Sec2].push_back(Section);
}
uint8_t BytesInAddress = Obj->getBytesInAddress();
std::vector<std::pair<SymbolRef, uint64_t>> SymAddr =
object::computeSymbolSizes(*Obj);
for (auto &P : SymAddr) {
object::SymbolRef Sym = P.first;
uint64_t SymSize = P.second;
ErrorOr<StringRef> SymNameOrErr = Sym.getName();
error(SymNameOrErr.getError());
StringRef SymName = *SymNameOrErr;
ErrorOr<object::section_iterator> SecIOrErr = Sym.getSection();
error(SecIOrErr.getError());
object::section_iterator SecI = *SecIOrErr;
// Skip external symbols.
if (SecI == Obj->section_end())
continue;
const SectionRef &Sec = *SecI;
// Skip virtual or BSS sections.
if (Sec.isBSS() || Sec.isVirtual())
continue;
StringRef SecContents;
error(Sec.getContents(SecContents));
ErrorOr<uint64_t> SymAddressOrErr = Sym.getAddress();
error(SymAddressOrErr.getError());
uint64_t SymAddress = *SymAddressOrErr;
uint64_t SecAddress = Sec.getAddress();
uint64_t SecSize = Sec.getSize();
uint64_t SymOffset = SymAddress - SecAddress;
StringRef SymContents = SecContents.substr(SymOffset, SymSize);
// VFTables in the MS-ABI start with '??_7' and are contained within their
// own COMDAT section. We then determine the contents of the VFTable by
// looking at each relocation in the section.
if (SymName.startswith("??_7")) {
// Each relocation either names a virtual method or a thunk. We note the
// offset into the section and the symbol used for the relocation.
collectRelocationOffsets(Obj, Sec, SecAddress, SecAddress, SecSize,
SymName, VFTableEntries);
}
// VBTables in the MS-ABI start with '??_8' and are filled with 32-bit
// offsets of virtual bases.
else if (SymName.startswith("??_8")) {
ArrayRef<little32_t> VBTableData(
reinterpret_cast<const little32_t *>(SymContents.data()),
SymContents.size() / sizeof(little32_t));
VBTables[SymName] = VBTableData;
}
// Complete object locators in the MS-ABI start with '??_R4'
else if (SymName.startswith("??_R4")) {
CompleteObjectLocator COL;
COL.Data = ArrayRef<little32_t>(
reinterpret_cast<const little32_t *>(SymContents.data()), 3);
StringRef *I = std::begin(COL.Symbols), *E = std::end(COL.Symbols);
collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E);
COLs[SymName] = COL;
}
// Class hierarchy descriptors in the MS-ABI start with '??_R3'
else if (SymName.startswith("??_R3")) {
ClassHierarchyDescriptor CHD;
CHD.Data = ArrayRef<little32_t>(
reinterpret_cast<const little32_t *>(SymContents.data()), 3);
StringRef *I = std::begin(CHD.Symbols), *E = std::end(CHD.Symbols);
collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E);
CHDs[SymName] = CHD;
}
// Class hierarchy descriptors in the MS-ABI start with '??_R2'
else if (SymName.startswith("??_R2")) {
// Each relocation names a base class descriptor. We note the offset into
// the section and the symbol used for the relocation.
collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize,
SymName, BCAEntries);
}
// Base class descriptors in the MS-ABI start with '??_R1'
else if (SymName.startswith("??_R1")) {
BaseClassDescriptor BCD;
BCD.Data = ArrayRef<little32_t>(
reinterpret_cast<const little32_t *>(SymContents.data()) + 1, 5);
StringRef *I = std::begin(BCD.Symbols), *E = std::end(BCD.Symbols);
collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E);
BCDs[SymName] = BCD;
}
// Type descriptors in the MS-ABI start with '??_R0'
else if (SymName.startswith("??_R0")) {
const char *DataPtr = SymContents.drop_front(BytesInAddress).data();
TypeDescriptor TD;
if (BytesInAddress == 8)
TD.AlwaysZero = *reinterpret_cast<const little64_t *>(DataPtr);
else
TD.AlwaysZero = *reinterpret_cast<const little32_t *>(DataPtr);
TD.MangledName = SymContents.drop_front(BytesInAddress * 2);
StringRef *I = std::begin(TD.Symbols), *E = std::end(TD.Symbols);
collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E);
TDs[SymName] = TD;
}
// Throw descriptors in the MS-ABI start with '_TI'
else if (SymName.startswith("_TI") || SymName.startswith("__TI")) {
ThrowInfo TI;
TI.Flags = *reinterpret_cast<const little32_t *>(SymContents.data());
collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize,
SymName, TIEntries);
TIs[SymName] = TI;
}
// Catchable type arrays in the MS-ABI start with _CTA or __CTA.
else if (SymName.startswith("_CTA") || SymName.startswith("__CTA")) {
CatchableTypeArray CTA;
CTA.NumEntries =
*reinterpret_cast<const little32_t *>(SymContents.data());
collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize,
SymName, CTAEntries);
CTAs[SymName] = CTA;
}
// Catchable types in the MS-ABI start with _CT or __CT.
else if (SymName.startswith("_CT") || SymName.startswith("__CT")) {
const little32_t *DataPtr =
reinterpret_cast<const little32_t *>(SymContents.data());
CatchableType CT;
CT.Flags = DataPtr[0];
CT.NonVirtualBaseAdjustmentOffset = DataPtr[2];
CT.VirtualBasePointerOffset = DataPtr[3];
CT.VirtualBaseAdjustmentOffset = DataPtr[4];
CT.Size = DataPtr[5];
StringRef *I = std::begin(CT.Symbols), *E = std::end(CT.Symbols);
collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E);
CTs[SymName] = CT;
}
// Construction vtables in the Itanium ABI start with '_ZTT' or '__ZTT'.
else if (SymName.startswith("_ZTT") || SymName.startswith("__ZTT")) {
collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize,
SymName, VTTEntries);
}
// Typeinfo names in the Itanium ABI start with '_ZTS' or '__ZTS'.
else if (SymName.startswith("_ZTS") || SymName.startswith("__ZTS")) {
TINames[SymName] = SymContents.slice(0, SymContents.find('\0'));
}
// Vtables in the Itanium ABI start with '_ZTV' or '__ZTV'.
else if (SymName.startswith("_ZTV") || SymName.startswith("__ZTV")) {
collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize,
SymName, VTableSymEntries);
for (uint64_t SymOffI = 0; SymOffI < SymSize; SymOffI += BytesInAddress) {
auto Key = std::make_pair(SymName, SymOffI);
if (VTableSymEntries.count(Key))
continue;
const char *DataPtr =
SymContents.substr(SymOffI, BytesInAddress).data();
int64_t VData;
if (BytesInAddress == 8)
VData = *reinterpret_cast<const little64_t *>(DataPtr);
else
VData = *reinterpret_cast<const little32_t *>(DataPtr);
VTableDataEntries[Key] = VData;
}
}
// Typeinfo structures in the Itanium ABI start with '_ZTI' or '__ZTI'.
else if (SymName.startswith("_ZTI") || SymName.startswith("__ZTI")) {
// FIXME: Do something with these!
}
}
for (const auto &VFTableEntry : VFTableEntries) {
StringRef VFTableName = VFTableEntry.first.first;
uint64_t Offset = VFTableEntry.first.second;
StringRef SymName = VFTableEntry.second;
outs() << VFTableName << '[' << Offset << "]: " << SymName << '\n';
}
for (const auto &VBTable : VBTables) {
StringRef VBTableName = VBTable.first;
uint32_t Idx = 0;
for (little32_t Offset : VBTable.second) {
outs() << VBTableName << '[' << Idx << "]: " << Offset << '\n';
Idx += sizeof(Offset);
}
}
for (const auto &COLPair : COLs) {
StringRef COLName = COLPair.first;
const CompleteObjectLocator &COL = COLPair.second;
outs() << COLName << "[IsImageRelative]: " << COL.Data[0] << '\n';
outs() << COLName << "[OffsetToTop]: " << COL.Data[1] << '\n';
outs() << COLName << "[VFPtrOffset]: " << COL.Data[2] << '\n';
outs() << COLName << "[TypeDescriptor]: " << COL.Symbols[0] << '\n';
outs() << COLName << "[ClassHierarchyDescriptor]: " << COL.Symbols[1]
<< '\n';
}
for (const auto &CHDPair : CHDs) {
StringRef CHDName = CHDPair.first;
const ClassHierarchyDescriptor &CHD = CHDPair.second;
outs() << CHDName << "[AlwaysZero]: " << CHD.Data[0] << '\n';
outs() << CHDName << "[Flags]: " << CHD.Data[1] << '\n';
outs() << CHDName << "[NumClasses]: " << CHD.Data[2] << '\n';
outs() << CHDName << "[BaseClassArray]: " << CHD.Symbols[0] << '\n';
}
for (const auto &BCAEntry : BCAEntries) {
StringRef BCAName = BCAEntry.first.first;
uint64_t Offset = BCAEntry.first.second;
StringRef SymName = BCAEntry.second;
outs() << BCAName << '[' << Offset << "]: " << SymName << '\n';
}
for (const auto &BCDPair : BCDs) {
StringRef BCDName = BCDPair.first;
const BaseClassDescriptor &BCD = BCDPair.second;
outs() << BCDName << "[TypeDescriptor]: " << BCD.Symbols[0] << '\n';
outs() << BCDName << "[NumBases]: " << BCD.Data[0] << '\n';
outs() << BCDName << "[OffsetInVBase]: " << BCD.Data[1] << '\n';
outs() << BCDName << "[VBPtrOffset]: " << BCD.Data[2] << '\n';
outs() << BCDName << "[OffsetInVBTable]: " << BCD.Data[3] << '\n';
outs() << BCDName << "[Flags]: " << BCD.Data[4] << '\n';
outs() << BCDName << "[ClassHierarchyDescriptor]: " << BCD.Symbols[1]
<< '\n';
}
for (const auto &TDPair : TDs) {
StringRef TDName = TDPair.first;
const TypeDescriptor &TD = TDPair.second;
outs() << TDName << "[VFPtr]: " << TD.Symbols[0] << '\n';
outs() << TDName << "[AlwaysZero]: " << TD.AlwaysZero << '\n';
outs() << TDName << "[MangledName]: ";
outs().write_escaped(TD.MangledName.rtrim(StringRef("\0", 1)),
/*UseHexEscapes=*/true)
<< '\n';
}
for (const auto &TIPair : TIs) {
StringRef TIName = TIPair.first;
const ThrowInfo &TI = TIPair.second;
auto dumpThrowInfoFlag = [&](const char *Name, uint32_t Flag) {
outs() << TIName << "[Flags." << Name
<< "]: " << (TI.Flags & Flag ? "true" : "false") << '\n';
};
auto dumpThrowInfoSymbol = [&](const char *Name, int Offset) {
outs() << TIName << '[' << Name << "]: ";
auto Entry = TIEntries.find(std::make_pair(TIName, Offset));
outs() << (Entry == TIEntries.end() ? "null" : Entry->second) << '\n';
};
outs() << TIName << "[Flags]: " << TI.Flags << '\n';
dumpThrowInfoFlag("Const", 1);
dumpThrowInfoFlag("Volatile", 2);
dumpThrowInfoSymbol("CleanupFn", 4);
dumpThrowInfoSymbol("ForwardCompat", 8);
dumpThrowInfoSymbol("CatchableTypeArray", 12);
}
for (const auto &CTAPair : CTAs) {
StringRef CTAName = CTAPair.first;
const CatchableTypeArray &CTA = CTAPair.second;
outs() << CTAName << "[NumEntries]: " << CTA.NumEntries << '\n';
unsigned Idx = 0;
for (auto I = CTAEntries.lower_bound(std::make_pair(CTAName, 0)),
E = CTAEntries.upper_bound(std::make_pair(CTAName, UINT64_MAX));
I != E; ++I)
outs() << CTAName << '[' << Idx++ << "]: " << I->second << '\n';
}
for (const auto &CTPair : CTs) {
StringRef CTName = CTPair.first;
const CatchableType &CT = CTPair.second;
auto dumpCatchableTypeFlag = [&](const char *Name, uint32_t Flag) {
outs() << CTName << "[Flags." << Name
<< "]: " << (CT.Flags & Flag ? "true" : "false") << '\n';
};
outs() << CTName << "[Flags]: " << CT.Flags << '\n';
dumpCatchableTypeFlag("ScalarType", 1);
dumpCatchableTypeFlag("VirtualInheritance", 4);
outs() << CTName << "[TypeDescriptor]: " << CT.Symbols[0] << '\n';
outs() << CTName << "[NonVirtualBaseAdjustmentOffset]: "
<< CT.NonVirtualBaseAdjustmentOffset << '\n';
outs() << CTName
<< "[VirtualBasePointerOffset]: " << CT.VirtualBasePointerOffset
<< '\n';
outs() << CTName << "[VirtualBaseAdjustmentOffset]: "
<< CT.VirtualBaseAdjustmentOffset << '\n';
outs() << CTName << "[Size]: " << CT.Size << '\n';
outs() << CTName
<< "[CopyCtor]: " << (CT.Symbols[1].empty() ? "null" : CT.Symbols[1])
<< '\n';
}
for (const auto &VTTPair : VTTEntries) {
StringRef VTTName = VTTPair.first.first;
uint64_t VTTOffset = VTTPair.first.second;
StringRef VTTEntry = VTTPair.second;
outs() << VTTName << '[' << VTTOffset << "]: " << VTTEntry << '\n';
}
for (const auto &TIPair : TINames) {
StringRef TIName = TIPair.first;
outs() << TIName << ": " << TIPair.second << '\n';
}
auto VTableSymI = VTableSymEntries.begin();
auto VTableSymE = VTableSymEntries.end();
auto VTableDataI = VTableDataEntries.begin();
auto VTableDataE = VTableDataEntries.end();
for (;;) {
bool SymDone = VTableSymI == VTableSymE;
bool DataDone = VTableDataI == VTableDataE;
if (SymDone && DataDone)
break;
if (!SymDone && (DataDone || VTableSymI->first < VTableDataI->first)) {
StringRef VTableName = VTableSymI->first.first;
uint64_t Offset = VTableSymI->first.second;
StringRef VTableEntry = VTableSymI->second;
outs() << VTableName << '[' << Offset << "]: ";
outs() << VTableEntry;
outs() << '\n';
++VTableSymI;
continue;
}
if (!DataDone && (SymDone || VTableDataI->first < VTableSymI->first)) {
StringRef VTableName = VTableDataI->first.first;
uint64_t Offset = VTableDataI->first.second;
int64_t VTableEntry = VTableDataI->second;
outs() << VTableName << '[' << Offset << "]: ";
outs() << VTableEntry;
outs() << '\n';
++VTableDataI;
continue;
}
}
}
void __AtracShutdown() {
for (auto it = atracMap.begin(), end = atracMap.end(); it != end; ++it) {
delete it->second;
}
atracMap.clear();
}
void reset_effect_types()
{
effect_types.clear();
}
void Reconstruct()
{
FILE *fo = fopen(output_file, "wb");
int sv, cv, cd, len, pst;
long long num_edges_renet = 0;
double cw, sum;
std::queue<int> node, depth;
std::queue<double> weight;
for (sv = 0; sv != num_vertices; sv++)
{
if (sv % 10 == 0)
{
printf("%cProgress: %.3lf%%", 13, (real)sv / (real)(num_vertices + 1) * 100);
fflush(stdout);
}
while (!node.empty()) node.pop();
while (!depth.empty()) depth.pop();
while (!weight.empty()) weight.pop();
vid2weight.clear();
for (int i = 0; i != num_vertices; i++)
{
rank_list[i].vid = i;
rank_list[i].weight = 0;
}
len = neighbor[sv].size();
if (len > max_k)
{
for (int i = 0; i != len; i++)
fprintf(fo, "%s\t%s\t%lf\n", vertex[sv].name, vertex[neighbor[sv][i].vid].name, neighbor[sv][i].weight);
num_edges_renet += len;
continue;
}
vid2weight[sv] += vertex[sv].degree / 10.0; // Set weights for self-links here!
len = neighbor[sv].size();
sum = vertex[sv].sum_weight;
node.push(sv);
depth.push(0);
weight.push(sum);
while (!node.empty())
{
cv = node.front();
cd = depth.front();
cw = weight.front();
node.pop();
depth.pop();
weight.pop();
if (cd != 0) vid2weight[cv] += cw;
if (cd < max_depth)
{
len = neighbor[cv].size();
sum = vertex[cv].sum_weight;
for (int i = 0; i != len; i++)
{
node.push(neighbor[cv][i].vid);
depth.push(cd + 1);
weight.push(cw * neighbor[cv][i].weight / sum);
}
}
}
pst = 0;
std::map<int, double>::iterator iter;
for (iter = vid2weight.begin(); iter != vid2weight.end(); iter++)
{
rank_list[pst].vid = (iter->first);
rank_list[pst].weight = (iter->second);
pst++;
}
std::sort(rank_list, rank_list + pst);
for (int i = 0; i != max_k; i++)
{
if (i == pst) break;
fprintf(fo, "%s\t%s\t%.6lf\n", vertex[sv].name, vertex[rank_list[i].vid].name, rank_list[i].weight);
num_edges_renet++;
}
}
printf("\n");
fclose(fo);
printf("Number of edges in reconstructed network: %lld\n", num_edges_renet);
return;
}
void requirement_data::reset()
{
requirements_all.clear();
}
/*!
* @brief Clear headers
*/
void clear_headers() {
m_headers.clear();
}
void flush_frames() { frame_builders.clear(); }
void setupBenchmark(size_t iters) {
bmMap.clear();
for (size_t i = 0; i < iters; ++i) {
bmMap[i] = "teststring";
}
}
void initOptions() {
int iNum = 0;
mPage.clear();
mPage["general"] = iNum++;
mPage["interface"] = iNum++;
mPage["debug"] = iNum++;
vPages.clear();
vPages.push_back(_("General"));
vPages.push_back(_("Interface"));
vPages.push_back(_("Debug"));
OPTIONS.clear();
OPTIONS["USE_CELSIUS"] = cOpt(mPage["interface"], _("Use Celsius"),
_("Switch between Celsius and Fahrenheit."),
"Fahrenheit,Celsius", "Fahrenheit"
);
OPTIONS["USE_METRIC_SPEEDS"] = cOpt(mPage["interface"], _("Use Metric Speeds"),
_("Switch between Km/h and mph."),
"mph,km/h", "mph"
);
OPTIONS["USE_METRIC_WEIGHTS"] = cOpt(mPage["interface"], _("Use Metric Weights"),
_("Switch between kg and lbs."),
"lbs,kg", "lbs"
);
OPTIONS["FORCE_CAPITAL_YN"] = cOpt(mPage["interface"], _("Force Y/N in prompts"),
_("If true, Y/N prompts are case- sensitive and y and n are not accepted."),
true
);
OPTIONS["NO_BRIGHT_BACKGROUNDS"] = cOpt(mPage["interface"], _("No Bright Backgrounds"),
_("If true, bright backgrounds are not used--some consoles are not compatible."),
false
);
OPTIONS["24_HOUR"] = cOpt(mPage["interface"], _("24 Hour Time"),
_("12h: AM/PM, eg: 7:31 AM - Military: 24h Military, eg: 0731 - 24h: Normal 24h, eg: 7:31"),
"12h,Military,24h", "12h"
);
OPTIONS["SNAP_TO_TARGET"] = cOpt(mPage["interface"], _("Snap to Target"),
_("If true, automatically follow the crosshair when firing/throwing."),
false
);
OPTIONS["SAFEMODE"] = cOpt(mPage["general"], _("Safemode on by default"),
_("If true, safemode will be on after starting a new game or loading."),
true
);
OPTIONS["SAFEMODEPROXIMITY"] = cOpt(mPage["general"], _("Safemode proximity distance"),
_("If safemode is enabled, distance to hostiles when safemode should show a warning. 0 = Max player viewdistance."),
0, 50, 0
);
OPTIONS["AUTOSAFEMODE"] = cOpt(mPage["general"], _("Auto-Safemode on by default"),
_("If true, auto-safemode will be on after starting a new game or loading."),
false
);
OPTIONS["AUTOSAFEMODETURNS"] = cOpt(mPage["general"], _("Turns to reenable safemode"),
_("Number of turns after safemode is reenabled if no hostiles are in safemodeproximity distance."),
1, 100, 50
);
OPTIONS["AUTOSAVE"] = cOpt(mPage["general"], _("Periodically Autosave"),
_("If true, game will periodically save the map."),
false
);
OPTIONS["AUTOSAVE_TURNS"] = cOpt(mPage["general"], _("Game minutes between autosaves"),
_("Number of game minutes between autosaves"),
0, 30, 5
);
OPTIONS["AUTOSAVE_MINUTES"] = cOpt(mPage["general"], _("Real minutes between autosaves"),
_("Number of real time minutes between autosaves"),
0, 127, 5
);
OPTIONS["GRADUAL_NIGHT_LIGHT"] = cOpt(mPage["interface"], _("Gradual night light"),
_("If true will add nice gradual-lighting should only make a difference during the night."),
true
);
OPTIONS["RAIN_ANIMATION"] = cOpt(mPage["interface"], _("Rain animation"),
_("If true, will display weather animations."),
true
);
OPTIONS["CIRCLEDIST"] = cOpt(mPage["general"], _("Circular distances"),
_("If true, the game will calculate range in a realistic way: light sources will be circles diagonal movement will cover more ground and take longer. If disabled, everything is square: moving to the northwest corner of a building takes as long as moving to the north wall."),
false
);
OPTIONS["QUERY_DISASSEMBLE"] = cOpt(mPage["interface"], _("Query on disassembly"),
_("If true, will query before disassembling items."),
true
);
OPTIONS["DROP_EMPTY"] = cOpt(mPage["general"], _("Drop empty containers"),
_("Set to drop empty containers after use. No: Don't drop any. - Watertight: All except watertight containers. - All: Drop all containers."),
"No,Watertight,All", "No"
);
OPTIONS["SKILL_RUST"] = cOpt(mPage["debug"], _("Skill Rust"),
_("Set the level of skill rust. Vanilla: Vanilla Cataclysm - Capped: Capped at skill levels 2 - Int: Intelligence dependent - IntCap: Intelligence dependent, capped - Off: None at all."),
"Vanilla,Capped,Int,IntCap,Off", "Vanilla"
);
OPTIONS["DELETE_WORLD"] = cOpt(mPage["general"], _("Delete World"),
_("Delete world upon player death."),
"No,Yes,Query", "No"
);
OPTIONS["INITIAL_POINTS"] = cOpt(mPage["debug"], _("Initial points"),
_("Initial points available on character generation."),
0, 25, 6
);
OPTIONS["MAX_TRAIT_POINTS"] = cOpt(mPage["debug"], _("Maximum trait points"),
_("Maximum trait points available for character generation."),
0, 25, 12
);
OPTIONS["INITIAL_TIME"] = cOpt(mPage["debug"], _("Initial time"),
_("Initial starting time of day on character generation."),
0, 23, 8
);
OPTIONS["VIEWPORT_X"] = cOpt(mPage["interface"], _("Viewport width"),
_("SDL ONLY: Set the expansion of the viewport along the X axis. Requires restart. POSIX systems will use terminal size at startup."),
12, 93, 12
);
OPTIONS["VIEWPORT_Y"] = cOpt(mPage["interface"], _("Viewport height"),
_("SDL ONLY: Set the expansion of the viewport along the Y axis. Requires restart. POSIX systems will use terminal size at startup."),
12, 93, 12
);
OPTIONS["SIDEBAR_STYLE"] = cOpt(mPage["interface"], _("Sidebar style"),
_("Switch between the standard or a narrower and taller sidebar. Requires restart."),
"Standard,Narrow", "Standard"
);
OPTIONS["MOVE_VIEW_OFFSET"] = cOpt(mPage["interface"], _("Move view offset"),
_("Move view by how many squares per keypress."),
1, 50, 1
);
OPTIONS["STATIC_SPAWN"] = cOpt(mPage["debug"], _("Static spawn"),
_("Spawn zombies at game start instead of during game. Must reset world directory after changing for it to take effect."),
true
);
OPTIONS["CLASSIC_ZOMBIES"] = cOpt(mPage["debug"], _("Classic zombies"),
_("Only spawn classic zombies and natural wildlife. Requires a reset of save folder to take effect. This disables certain buildings."),
false
);
OPTIONS["REVIVE_ZOMBIES"] = cOpt(mPage["debug"], _("Revive zombies"),
_("Allow zombies to revive after a certain amount of time."),
true
);
OPTIONS["SEASON_LENGTH"] = cOpt(mPage["debug"], _("Season length"),
_("Season length, in days."),
14, 127, 14
);
OPTIONS["STATIC_NPC"] = cOpt(mPage["debug"], _("Static npcs"),
_("If true, the game will spawn static NPC at the start of the game, requires world reset."),
false
);
OPTIONS["RANDOM_NPC"] = cOpt(mPage["debug"], _("Random npcs"),
_("If true, the game will randomly spawn NPC during gameplay."),
false
);
OPTIONS["RAD_MUTATION"] = cOpt(mPage["general"], _("Mutations by radiation"),
_("If true, radiation causes the player to mutate."),
false
);
OPTIONS["SAVE_SLEEP"] = cOpt(mPage["interface"], _("Ask to save before sleeping"),
_("If true, game will ask to save the map before sleeping."),
false
);
OPTIONS["HIDE_CURSOR"] = cOpt(mPage["interface"], _("Hide Mouse Cursor"),
_("Always: Cursor is always shown. Hidden: Cursor is hidden. HiddenKB: Cursor is hidden on keyboard input and unhidden on mouse movement."),
"Always,Hidden,HiddenKB", "Always"
);
OPTIONS["AUTO_PICKUP"] = cOpt(mPage["general"], _("Enable item Auto Pickup"),
_("Enable item auto pickup. Change pickup rules with the Auto Pickup Manager in the Help Menu ?3"),
false
);
OPTIONS["AUTO_PICKUP_ZERO"] = cOpt(mPage["general"], _("Auto Pickup 0 Vol/Weight"),
_("Auto pickup items with 0 Volume or Weight"),
false
);
OPTIONS["AUTO_PICKUP_SAFEMODE"] = cOpt(mPage["general"], _("Auto Pickup Safemode"),
_("Auto pickup is disabled as long as you can see monsters nearby. This is affected by Safemode proximity distance."),
false
);
OPTIONS["DANGEROUS_PICKUPS"] = cOpt(mPage["general"], _("Dangerous pickups"),
_("If false will cause player to drop new items that cause them to exceed the weight limit."),
false
);
OPTIONS["SORT_CRAFTING"] = cOpt(mPage["interface"], _("Sort Crafting menu"),
_("If true, the crafting menus will display recipes that you can craft before other recipes"),
false
);
for (std::map<std::string, cOpt>::iterator iter = OPTIONS.begin(); iter != OPTIONS.end(); ++iter) {
mPageItems[(iter->second).getPage()].push_back(iter->first);
}
}