void DebugInfoXmlWriter::WriteChildProcessEntry(const Debug::DebugeeInfo& debuggeeInfo, const std::multimap<DWORD, DWORD>& mmapChildProcesses, DWORD dwProcessId) { m_spWriter->WriteStartElement(_T("process")); if (dwProcessId == 0) m_spWriter->WriteAttributeString(_T("image-name"), _T("debugger")); else { CString cszText; cszText.Format(_T("0x%08x"), dwProcessId); m_spWriter->WriteAttributeString(_T("pid"), cszText); if (debuggeeInfo.IsProcessInfoAvail(dwProcessId)) { const Debug::ProcessInfo processInfo = debuggeeInfo.GetProcessInfo(dwProcessId); m_spWriter->WriteAttributeString(_T("image-name"), processInfo.ImageName()); } else m_spWriter->WriteAttributeString(_T("image-name"), _T("unknown")); } m_spWriter->WriteStartElementEnd(); // find all child entries std::multimap<DWORD, DWORD>::const_iterator iter = mmapChildProcesses.find(dwProcessId); while (iter != mmapChildProcesses.end() && iter->first == dwProcessId) { WriteChildProcessEntry(debuggeeInfo, mmapChildProcesses, iter->second); ++iter; } m_spWriter->WriteEndElement(); }
void PatternLink::GenerateConnections( const std::multimap<lem::UCString,const Word_Form*> & points, SynPatternResult * cur_result ) const { typedef std::multimap<lem::UCString,const Word_Form*>::const_iterator IT; IT it_from = points.find( from_marker ); if( it_from==points.end() ) { lem::MemFormatter mem; mem.printf( "Can not find node %us.%us to create link head", from_marker.c_str(), from_node.c_str() ); throw lem::E_BaseException( mem.string() ); } const Word_Form * node0 = it_from->second; std::pair<IT,IT> pit = points.equal_range( to_marker ); if( pit.first==points.end() && !optional_to_node ) { lem::MemFormatter mem; mem.printf( "Can not find node %us to create link tail", to_marker.c_str() ); throw lem::E_BaseException( mem.string() ); } for( IT it=pit.first; it!=pit.second; ++it ) { const Solarix::Word_Form * node1 = it->second; PatternLinkEdge new_edge( node0, link_type, node1 ); cur_result->AddLinkageEdge( new_edge ); } return; }
virtual int OnSendSnotice(char &sno, std::string &desc, const std::string &msg) { std::multimap<char, std::string>::const_iterator it = logstreams.find(sno); char buf[MAXBUF]; if (it == logstreams.end()) return 0; snprintf(buf, MAXBUF, "\2%s\2: %s", desc.c_str(), msg.c_str()); while (it != logstreams.end()) { if (it->first != sno) { it++; continue; } Channel *c = ServerInstance->FindChan(it->second); if (c) { c->WriteChannelWithServ(ServerInstance->Config->ServerName, "PRIVMSG %s :%s", c->name.c_str(), buf); ServerInstance->PI->SendChannelPrivmsg(c, 0, buf); } it++; } return 0; }
void PeakMatchingResults::GetMatches(std::vector<int> &vectFeatureIndices, std::vector<int> &vectMassTagIndices, std::vector<int> &vectProteinIndices , const std::vector<MultiAlignEngine::MassTags::Protein>* &vectProteins, const std::vector<MultiAlignEngine::MassTags::MassTag>* &vectMasstags) const { // The mass tag database has stored in it all the proteins and mass tags corresponding to the matches. // So thats where we need to get all the data from. int numMatches = (int) mvectPeakMatches.size(); std::set <int> massTagID; stdext::hash_map <int, int > massTagSeen; // first get all mass tags in the matches into the set of mass tags. for (int matchNum = 0; matchNum < numMatches; matchNum++) { PeakMatch match = mvectPeakMatches[matchNum]; massTagSeen.insert(std::pair<int,int>(match.mintMasstagID, matchNum)); } // copy hash to mass tag vector std::vector<int> vectMassTagIDs; vectMassTagIDs.reserve(massTagSeen.size()); for (stdext::hash_map <int, int >::iterator massTagIter = massTagSeen.begin(); massTagIter != massTagSeen.end(); massTagIter++) { vectMassTagIDs.push_back((*massTagIter).first); } vectMasstags = mobjMasstagDB.GetMassTagVector(); vectProteins = mobjMasstagDB.GetProteinVector(); const std::multimap<int,int> mapMassTagId2ProteinIndex = mobjMasstagDB.GetMassTagId2ProteinIndexMap(); const stdext::hash_map <int, int > hashMapMassTagId2Index = mobjMasstagDB.GetMassTagId2IndexHash(); // now the relevant mass tags are copied, their ids are copied, the protein names are copied. // So lets create the table of matches using the three vectors vectFeatureIndices, vectMassTagIndices and // vectProteinIndices. Basically, vectFeatureIndices will have the index of the ms feature in a peak match. // the vectMassTagIndices will have the corresponding massTagID, and vectProteinIndices will have the corresponding // parent protein. for (std::multimap<int,int>::const_iterator featureIter = mmapFeatureIndex2PeakMatch.begin(); featureIter != mmapFeatureIndex2PeakMatch.end(); featureIter++) { int featureIndex = (*featureIter).first; int peakMatchIndex = (*featureIter).second; PeakMatch pkMatch = mvectPeakMatches[peakMatchIndex]; int massTagID = pkMatch.mintMasstagID; stdext::hash_map <int, int>::const_iterator massTagIterHash = hashMapMassTagId2Index.find(massTagID); int massTagIndex = (*massTagIterHash).second; // now go through each of the parent proteins of this massTagID and push the triplet into their // corresponding vectors for (std::multimap<int,int>::const_iterator massTagIter = mapMassTagId2ProteinIndex.find(massTagID); massTagIter != mapMassTagId2ProteinIndex.end(); massTagIter++) { if ((*massTagIter).first != massTagID) break; vectFeatureIndices.push_back(featureIndex); vectMassTagIndices.push_back(massTagIndex); vectProteinIndices.push_back((*massTagIter).second); } } }
//get the node id for the source operation of this routing node int getRouteSrc(int id) { std::multimap<int, int>::iterator it = in_edge.find(id); if(getNodeType(it->second) != route) return it->second; else getRouteSrc(it->second); }
bool Semantic::search(string name){ for(mi = Symbols.find(name);mi != Symbols.end();mi++){ return true; } return false; }
string Semantic::checkScope(string name, string currScope){ for(mi=Symbols.find(name);mi!= Symbols.end();++mi){ if(mi->second.scope==currScope){ return mi->second.type; } } return "Error"; }
string Semantic::getScope(string name){ mi = Symbols.find(name); if(mi!=Symbols.end()){ return mi->second.scope; } else{ return "Error"; } }
PersistentDataItem World::GetPersistentData(const std::string &key) { if (!BuildPersistentCache()) return PersistentDataItem(); auto it = persistent_index.find(key); if (it != persistent_index.end()) return GetPersistentData(it->second); return PersistentDataItem(); }
static void sort_by_location(std::multimap<std::string, Species> location_map, std::vector<Species>& species, const std::string location="") { std::multimap<std::string, Species>::iterator itr; while ((itr = location_map.find(location)) != location_map.end()) { const Species sp((*itr).second); species.push_back(sp); sort_by_location(location_map, species, sp.serial()); location_map.erase(itr); } }
std::size_t NodeListT::value_of(const std::multimap<UnitID, NodeListT::SuperInfoT> &supersets, const UnitID &train, const NodeListT::times_t &value, bool neg) const { std::size_t length = lengths.find(train)->second; const SuperInfoT& sinf = supersets.find(train)->second; // actually, it's just (value - sinf.station_no % length), // but lenght is added to avoid % on negative numbers // the associate braces avoid getting negative temporaries return (neg) ? (((length + sinf.station_no) - value) % length) : (((length + value) - sinf.station_no) % length); }
static void save_molecular_type_recursively(const Species& location, std::multimap<Species, const MolecularTypeBase*>& location_map, Tspace_& space, H5::Group* root) { std::multimap<Species, const MolecularTypeBase*>::iterator itr; while ((itr = location_map.find(location)) != location_map.end()) { const MolecularTypeBase* mtb((*itr).second); const Species species(mtb->species()); save_molecular_type(mtb, space.list_voxels_exact(species), root); save_molecular_type_recursively(species, location_map, space, root); location_map.erase(itr); } }
//Checks declaration and unicity of variables bool Semantic::search(string name, string scope){ for(mi = Symbols.find(name);mi!= Symbols.end();++mi){ //cout<<mi->first<<":"<<mi->second.scope<<"\n"; if(mi->second.scope==scope){ return true; } } return false; }
string Semantic::getType(string name,string scope){ mi = Symbols.find(name); for(mi=Symbols.begin();mi!= Symbols.end();++mi){ cout<<mi->first<<":"<<mi->second.scope<<"\n"; if(mi->second.scope==scope){ return mi->second.type; } } return "Error"; }
void AudioOutputDeviceManager::addDeviceEventProc( int _card , std::multimap< int, const AudioOutputDevice * > & _devices ) { if( _devices.find( _card ) != _devices.end() ) { return; } DeviceNameHints hints( _card ); const auto & HINTS = hints.get(); for( int i = 0 ; HINTS[ i ] != nullptr ; i++ ) { const auto HINT = HINTS[ i ]; if( isOutputDevice( HINT ) == false ) { continue; } DeviceDescription description( HINT ); DeviceName name( HINT ); const auto DEVICE = new AudioOutputDevice( description.get() , name.get() ); _devices.insert( std::multimap< int, const AudioOutputDevice * >::value_type( _card , DEVICE ) ); this->callConnectEventHandler( *DEVICE ); } }
std::vector<std::pair<ReducedFraction, ReducedFraction> > findMatchedLyricTimes( const std::multimap<ReducedFraction, MidiChord> &chords, const std::multimap<ReducedFraction, std::string> &lyricTrack) { // <chord quantized on time, chord original on time> std::vector<std::pair<ReducedFraction, ReducedFraction> > matchedLyricTimes; for (const auto &chord: chords) { for (const auto ¬e: chord.second.notes) { if (lyricTrack.find(note.origOnTime) != lyricTrack.end()) { matchedLyricTimes.push_back({chord.first, note.origOnTime}); break; } } } return matchedLyricTimes; }
static void dfs_visit(MetaClass *u, const std::multimap<MetaClass*, MetaClass*> &adjacents, std::set<MetaClass*> &visited, std::list<MetaClass*> &sorted) { visited.insert(u); std::multimap<MetaClass*, MetaClass*>::const_iterator iter= adjacents.find(u); while (iter != adjacents.end() && iter->first == u) { MetaClass *v= iter->second; if (visited.find(v) == visited.end()) dfs_visit(v, adjacents, visited, sorted); ++iter; } sorted.push_front(u); }
void WriteComments(int comm_id, bool bInterLine) { itComments = mapComments.find(comm_id); if (itComments == mapComments.end()) // check if we have at least one comment for the xml id return; itRangeComments = mapComments.equal_range(comm_id); for (itComments = itRangeComments.first; itComments != itRangeComments.second;++itComments) { if (bInterLine == itComments->second.bInterLineComment) { WriteLF(pPOTFile); fprintf(pPOTFile,bInterLine ? "#%s\n": "#. %s\n", itComments->second.text.c_str()); } } return; };
__declspec(noinline) void save_stack_trace() { if (!g_mem_alloc_gather_stats) return; if (::Random.randF() >= g_mem_alloc_gather_stats_frequency) return; StackTrace.Count = xrDebug::BuildStackTrace(StackTrace.Frames, StackTrace.Capacity, StackTrace.LineCapacity); const int skipFrames = 2; if (StackTrace.Count <= skipFrames) return; int frameCount = StackTrace.Count - skipFrames; int totalSize = 0; int* lengths = (int*)_alloca(frameCount*sizeof(int)); for (int i = 0; i < frameCount; i++) { lengths[i] = strlen(StackTrace.GetFrame(i + skipFrames)); totalSize += lengths[i]+1; } char* stackTrace = (char*)malloc(totalSize); { auto ptr = stackTrace; for (int i = 0; i < frameCount; i++) { memcpy(ptr, StackTrace.GetFrame(i), lengths[i]); ptr += lengths[i]; *ptr = '\n'; } *ptr = 0; } boost::crc_32_type temp; temp.process_block(stackTrace, stackTrace+totalSize); uint crc = temp.checksum(); for (auto it = stats.find(crc); it != stats.end(); it++) { auto& pair = *it; if (pair.first != crc) break; if (strcmp(pair.second.StackTrace, stackTrace)) continue; pair.second.Calls++; return; } stats.insert({crc, {stackTrace, 1}}); }
virtual int OnPreCommand(std::string &command, std::vector<std::string> ¶meters, User *user, bool validated, const std::string &original_line) { std::multimap<std::string, Alias>::iterator i, upperbound; /* If theyre not registered yet, we dont want * to know. */ if (user->registered != REG_ALL) return 0; /* We dont have any commands looking like this? Stop processing. */ i = Aliases.find(command); if (i == Aliases.end()) return 0; /* Avoid iterating on to different aliases if no patterns match. */ upperbound = Aliases.upper_bound(command); irc::string c = command.c_str(); /* The parameters for the command in their original form, with the command stripped off */ std::string compare = original_line.substr(command.length()); while (*(compare.c_str()) == ' ') compare.erase(compare.begin()); while (i != upperbound) { if (i->second.UserCommand) { if (DoAlias(user, NULL, &(i->second), compare, original_line)) { return 1; } } i++; } // If we made it here, no aliases actually matched. return 0; }
int WfipsData::AssociateHelitack( std::multimap<std::string, CResource*>&resc_map ) { sqlite3_stmt *stmt; int rc; rc = sqlite3_prepare_v2( db, "SELECT heli FROM heli_assign WHERE hel=?", -1, &stmt, NULL ); std::string key; std::multimap<string, CResource*>::iterator it = resc_map.begin(); std::multimap<string, CResource*>::iterator find; for( ; it != resc_map.end(); it++ ) { if( EQUAL( it->second->GetRescType().GetRescType().c_str(), "HELI" ) ) { continue; } sqlite3_bind_text( stmt, 1, it->first.c_str(), -1, SQLITE_TRANSIENT ); while( sqlite3_step( stmt ) == SQLITE_ROW ) { key = (const char*)sqlite3_column_text( stmt, 0 ); find = resc_map.find( key ); if( find == resc_map.end() ) { continue; } CHelicopter* poHelic = dynamic_cast<CHelicopter*>( it->second ); if( poHelic ) { poHelic->AddAttachedCrew( find->second ); } } sqlite3_reset( stmt ); } sqlite3_finalize( stmt ); stmt = NULL; return 0; }
bool CZMQAbstractPublishNotifier::Initialize(void *pcontext) { assert(!psocket); // check if address is being used by other publish notifier std::multimap<std::string, CZMQAbstractPublishNotifier*>::iterator i = mapPublishNotifiers.find(address); if (i==mapPublishNotifiers.end()) { psocket = zmq_socket(pcontext, ZMQ_PUB); if (!psocket) { zmqError("Failed to create socket"); return false; } int rc = zmq_bind(psocket, address.c_str()); if (rc!=0) { zmqError("Failed to bind address"); zmq_close(psocket); return false; } // register this notifier for the address, so it can be reused for other publish notifier mapPublishNotifiers.insert(std::make_pair(address, this)); return true; } else { LogPrint(BCLog::ZMQ, "zmq: Reusing socket for address %s\n", address); psocket = i->second->psocket; mapPublishNotifiers.insert(std::make_pair(address, this)); return true; } }
bool AMQPAbstractPublishNotifier::Initialize() { std::multimap<std::string, AMQPAbstractPublishNotifier*>::iterator i = mapPublishNotifiers.find(address); if (i == mapPublishNotifiers.end()) { try { handler_ = std::make_shared<AMQPSender>(address); thread_ = std::make_shared<std::thread>(&AMQPAbstractPublishNotifier::SpawnProtonContainer, this); } catch (std::exception &e) { LogPrint("amqp", "amqp: initialization error: %s\n", e.what()); return false; } mapPublishNotifiers.insert(std::make_pair(address, this)); } else { // copy the shared ptrs to the message handler and the thread where the proton container is running handler_ = i->second->handler_; thread_ = i->second->thread_; mapPublishNotifiers.insert(std::make_pair(address, this)); } return true; }
BestTrack findBestTrack( const QList<MTrack> &tracks, const std::multimap<ReducedFraction, std::string> &lyricTrack, const std::set<int> &usedTracks) { BestTrack bestTrack; int maxMatches = 0; Q_ASSERT_X(areEqualIndexesSuccessive(tracks), "MidiLyrics::findBestTrack", "Equal indexes of operations are not successive"); for (int i = 0; i != tracks.size(); ++i) { if (tracks[i].mtrack->drumTrack() || usedTracks.find(i) != usedTracks.end()) continue; // due to staff split there can be equal indexes of operation if (i > 0 && tracks[i].indexOfOperation == tracks[i - 1].indexOfOperation) continue; int matches = 0; for (const auto &chord: tracks[i].chords) { for (const auto ¬e: chord.second.notes) { if (lyricTrack.find(note.origOnTime) != lyricTrack.end()) { ++matches; bestTrack.matchedLyricTimes.push_back({chord.first, note.origOnTime}); break; } } } if (matches > maxMatches) { maxMatches = matches; bestTrack.index = tracks[i].indexOfOperation; } } return bestTrack; }
const std::map<Key,Value> MultimapToMap( const std::multimap<Key,Value> m) { std::map<Key,Value> n; const auto end = m.end(); for (auto begin = m.begin(); begin != end; ) { assert(begin != m.end()); const auto key = (*begin).first; assert(m.find(key) != m.end()); //Must the average be calculated? const auto r = m.equal_range(key); assert(r.first != m.end()); if (r.first != r.second ) { Value sum(0.0); int cnt = 0; for (auto i = r.first; i!=r.second; ++i) { sum += (*i).second; ++cnt; } const Value result( sum / static_cast<double>(cnt)); n[ key ] = result; } else { const Value result((*r.first).second); n[ key ] = result; } begin = r.second; } return n; }
void addLyricsToScore( const std::multimap<ReducedFraction, std::string> &lyricTrack, const std::vector<std::pair<ReducedFraction, ReducedFraction>> &matchedLyricTimes, const Staff *staffAddTo) { Score *score = staffAddTo->score(); addTitleIfAny(lyricTrack, score); for (const auto &timePair: matchedLyricTimes) { const auto quantizedTime = timePair.first; const auto originalTime = timePair.second; const auto it = lyricTrack.find(originalTime); Q_ASSERT_X(it != lyricTrack.end(), "MidiLyrics::addLyricsToScore", "Lyric time not found"); QString text = MidiCharset::convertToCharset(it->second); if (originalTime != ReducedFraction(0, 1) || !isTitlePrefix(text)) { // not title score->addLyrics(quantizedTime.ticks(), staffAddTo->idx(), removeSlashes(text).toHtmlEscaped()); } } }
bool AssociatedRelayConsumer::check_authentication(const std::multimap<std::string, std::string> ¶ms) { // Try to find our assoc handle. const std::string *assoc_handle_ptr = lookup_assoc_handle(openid_provider()); if(!assoc_handle_ptr) assoc_handle_ptr = associate(); // If the handle is "DUMB", we have to fall back to the dumb consumer. if(assoc_handle_ptr->compare("DUMB") == 0) { delete assoc_handle_ptr; return DumbRelayConsumer::check_authentication(params); } // Move the string to the stack, so that return can free it. std::string assoc_handle(*assoc_handle_ptr); delete assoc_handle_ptr; // Not possible to be missing the assoc_handle std::multimap<std::string, std::string>::const_iterator assoc_iter = params.find(std::string("openid.assoc_handle")); if(assoc_iter == params.end()) return false; if(assoc_handle.compare(assoc_iter->second) == 0) { // make sure this request was signed. std::multimap<std::string, std::string>::const_iterator sig_iter = params.find(std::string("openid.sig")); if(sig_iter == params.end()) return false; std::string their_signature(sig_iter->second); // Look for the signed fields. sig_iter = params.find(std::string("openid.signed")); if(sig_iter == params.end()) return false; std::string signed_params(sig_iter->second), key; // construct the message that was signed. std::ostringstream message; std::string::const_iterator iter = signed_params.begin(); while(iter != signed_params.end()) { char c = *iter; ++iter; // We hit a non-key character, if(c == '\n' || c == ',' || iter == signed_params.end()) { // store the last char in the string. if(iter == signed_params.end()) key.push_back(c); // look for the param std::string key_to_find("openid."); key_to_find.append(key); sig_iter = params.find(key_to_find); if(sig_iter == params.end()) return false; // add to the message data. message << key << ":" << sig_iter->second << "\n"; // clear the key to start over. key.clear(); } else { key.push_back(c); } } // attempt to recreate the signature. Association *assoc = lookup_association(assoc_handle); if(!assoc) return false; std::string our_signature(create_signature(message.str(), assoc->secret)); delete assoc; // Test that the signature created matches the one given. return (their_signature.compare(our_signature) == 0); } else if(assoc_handle.compare(assoc_iter->second) != 0 && (assoc_iter = params.find("openid.invalidate_handle")) != params.end()) { // Prepare the verification post data. std::ostringstream data; CURL *curl = new_curl_handle(); data << "openid.mode=check_authentication"; for(std::multimap<std::string, std::string>::const_iterator iter = params.begin(); iter != params.end(); ++iter) { if(iter->first.compare("openid.mode") == 0) continue; char *tmp; tmp = curl_easy_escape(curl, iter->first.c_str(), iter->first.size()); data << "&" << tmp << "="; curl_free(tmp); tmp = curl_easy_escape(curl, iter->second.c_str(), iter->second.size()); data << tmp; curl_free(tmp); } // Clean up after curl. curl_easy_cleanup(curl); // execute. std::string content = contact_openid_provider(data.str()); // Check for invalidating the handle. std::string invalidate_substring("\ninvalidate_handle:"); invalidate_substring.append(assoc_iter->second).append("\n"); if(content.find(invalidate_substring) != content.npos) invalidate_assoc_handle(assoc_iter->second); // Test for is_valid. return content.find("\nis_valid:true\n") != content.npos; } // If we didn't match any other cases, return false. return false; }
//This function is responsible for returning the register number that will act //as operand 1 int getReg1Address(int nodeID,PEInputMux LMux,exec_state state) { /* *************Memory Operations******************* if the instruction is ld_add, st_add result = register number this node is mapped to in mem_node_regNum if the instruction is a ld_data result = 0 if the instruction is st_data { get the node id of the operand other than the varname and st_add if they are scheduled more than a cycle apart { reg=get the register that operand writes to result = getRotatingRegNum(reg,operandID,nodeID); } else result = 0 } ***************Alu Operations************** Get the first operand (lets call it op) If(op is Constant) result = 0 if(op is scheduled more than 1 cycle apart) reg=get the register that operand writes to result = getRotatingRegNum(reg,operandID,nodeID); else result =0 *****************Route Operation************ get the source node of the only incoming edge to this node if(src node is scheduled more than 1 cycle apart) reg=get the register that operand writes to result = getRotatingRegNum(reg,operandID,nodeID); else result =0 */ int result = 0; if(LMux == Register) { int opType = getNodeType(nodeID); //there will be atmost 1 incoming edge to the routing node std::multimap<int, int>::iterator it_inedge = in_edge.find(nodeID); vector<int> operands = getOperands(nodeID); switch(opType){ //MEMORY OPERATIONS case ld_add: case st_add: result = mem_node_regNum[nodeID]; return result; break; case ld_data: result = 0; return result; break; case st_data: int op; for(int i=0;i<operands.size();++i) { int type = getNodeType(operands[i]); if(type!=constant && type!=st_add) { op = operands[i]; break; } } if(isScheduledMoreThanACycleApart(nodeID,op)) { int srcReg = getOutputRegisterNumber(op); result = getRotatingRegNum(srcReg,op,nodeID,state); return result; } else { result = 0; return result; } //ROUTING NODE case route: if(isScheduledMoreThanACycleApart(nodeID,it_inedge->second)) { int srcReg = getOutputRegisterNumber(it_inedge->second); result = getRotatingRegNum(srcReg,it_inedge->second,nodeID,state); } else { result = 0; } return result; break; } /* ***************Alu Operations************** Get the first operand (lets call it op) If(op is Constant) result = 0 if(op is scheduled more than 1 cycle apart) reg=get the register that operand writes to result = getRotatingRegNum(reg,operandID,nodeID); else result =0 */ if(operands.size() > 0) { int op1 = operands[0]; int opType = getNodeType(op1); if(opType == constant) result == 0; if(isScheduledMoreThanACycleApart(nodeID,op1)) { int srcReg = getOutputRegisterNumber(op1); result = getRotatingRegNum(srcReg,op1,nodeID,state); } else { result = 0; } return result; } } else { return 0; } }
bool hasExampleHandlers(T eventName) { return map.find(eventName) != map.end(); }
void command_interpreter (CHAR_DATA * ch, char *argument) { char buf[MAX_STRING_LENGTH]; char *command_args, *p, *social_args; int cmd_level = 0; int i = 0, echo = 1; AFFECTED_TYPE *craft_affect = NULL; AFFECTED_TYPE *af; ALIAS_DATA *alias; extern int second_affect_active; if (!ch) return; *buf = '\0'; p = argument; while (*p == ' ') p++; if (strchr (p, '%')) { send_to_char ("Input with the '%' character is not permitted.\n", ch); return; } if (strchr (p, '#') && IS_MORTAL (ch) && strncmp (p, "ge", 2) != 0 && strncmp (p, "buy", 3) != 0) { send_to_char ("Input with the '#' character is not permitted.\n", ch); return; } if (IS_MORTAL (ch) && strchr (p, '$')) { send_to_char ("Input with the '$' character is not permitted.\n", ch); return; } std::multimap<int, room_prog>::iterator it; if (IS_NPC(ch)) it = mob_prog_list.find(ch->mob->nVirtual); if (IS_NPC(ch) && !get_second_affect (ch, SA_DOANYWAY, 0) && it != mob_prog_list.end()) { if (m_prog(ch, p)) { return; } } std::pair<std::multimap<int, room_prog>::iterator, std::multimap<int, room_prog>::iterator> pair; if (ch->right_hand && !get_second_affect (ch, SA_DOANYWAY, 0)) { pair = obj_prog_list.equal_range(ch->right_hand->nVirtual); for (it = pair.first; it != pair.second; it++) { if (it->second.type != 1 && it->second.type != 3 && it->second.type != 5) continue; if (o_prog(ch, p, it->second)) return; } } if (ch->left_hand && !get_second_affect (ch, SA_DOANYWAY, 0)) { pair = obj_prog_list.equal_range(ch->left_hand->nVirtual); for (it = pair.first; it != pair.second; it++) { if (it->second.type != 1 && it->second.type != 3 && it->second.type != 5) continue; if (o_prog(ch, p, it->second)) return; } } for (OBJ_DATA *tobj = ch->equip; tobj; tobj = tobj->next_content) { if (get_second_affect (ch, SA_DOANYWAY, 0)) break; pair = obj_prog_list.equal_range(tobj->nVirtual); for (it = pair.first; it != pair.second; it++) { if (it->second.type != 2 && it->second.type != 3 && it->second.type != 5) continue; if (o_prog(ch, p, it->second)) return; } } /* this is where it crashes on the hour - Grommit */ if (!ch->room ) { std::ostringstream stream; stream << "Error in command_interpreter:commands.cpp. Command \"" << argument << "\" called by \"" << ch->tname << "\" with null room. Previously in " << (ch->last_room) << " entering null room from the " << (dirs[ch->from_dir]) << "."; system_log(stream.str().c_str(),true); return; } /* end grommit diagnostics to avoid segfaulting on the below for loop */ for (OBJ_DATA *tobj = ch->room->contents; tobj; tobj = tobj->next_content) { if (get_second_affect (ch, SA_DOANYWAY, 0)) break; pair = obj_prog_list.equal_range(tobj->nVirtual); for (it = pair.first; it != pair.second; it++) { if (it->second.type != 4 && it->second.type != 5) continue; if (o_prog(ch, p, it->second)) return; } } for (CHAR_DATA *temp_char = ch->room->people; temp_char; temp_char = temp_char->next_in_room) { if (get_second_affect (ch, SA_DOANYWAY, 0)) break; if (temp_char == ch) continue; if (!IS_NPC(temp_char)) continue; pair = mob_prog_list.equal_range(temp_char->mob->nVirtual); for (it = pair.first; it != pair.second; ++it) { if (m_prog(ch, p, it->second)) return; } } if (ch->room && ch->room->prg && !get_second_affect(ch, SA_DOANYWAY, 0) && r_program (ch, p)) { if (!IS_NPC (ch) || (ch->desc && (ch->pc && str_cmp (ch->pc->account_name, "Guest")))) { player_log (ch, "[RPROG]", p); } if (!IS_SET (commands[i].flags, C_NWT)) show_to_watchers (ch, argument); return; } if (get_second_affect(ch, SA_DOANYWAY, 0)) remove_second_affect(get_second_affect(ch, SA_DOANYWAY, 0)); if (!IS_MORTAL (ch) && !str_cmp (argument, "sho wl")) { send_to_char ("Heh heh. Glad I added in this check, aren't we? No shouting for you.\n", ch); return; } if (ch->desc) { last_descriptor = ch->desc; sprintf (full_last_command, "Last Command Issued, by %s [%d]: %s", ch->tname, ch->in_room, argument); sprintf (last_command, "%s", argument); } social_args = argument; command_args = one_argument (argument, buf); if (!*buf) return; while (*command_args == ' ') command_args++; if (ch->pc && !GET_FLAG (ch, FLAG_ALIASING)) { if ((alias = is_alias (ch, buf))) { ch->flags |= FLAG_ALIASING; while (alias) { command_interpreter (ch, alias->line); if (ch->deleted) return; alias = alias->next_line; } ch->flags &= ~FLAG_ALIASING; return; } } for (i = 1; *commands[i].command; i++) if (is_abbrev (buf, commands[i].command)) break; if ((craft_affect = is_craft_command (ch, argument))) i = 0; if (IS_SET (commands[i].flags, C_IMP)) { cmd_level = 6; } else if (IS_SET (commands[i].flags, C_LV5)) { cmd_level = 5; } else if (IS_SET (commands[i].flags, C_LV4)) { cmd_level = 4; } else if (IS_SET (commands[i].flags, C_LV3)) { cmd_level = 3; } else if (IS_SET (commands[i].flags, C_LV2)) { cmd_level = 2; } else if (IS_SET (commands[i].flags, C_LV1)) { cmd_level = 1; } if (IS_SET (commands[i].flags, C_GDE) && (IS_NPC (ch) || (!ch->pc->is_guide && !ch->pc->level))) { send_to_char ("Eh?\n\r", ch); return; } /* Need to pass the CHAR_DATA pointer for the person who made the command and modify the following line to test the commanding char's trust against the trust level for the command. - Methuselah */ if ((!*commands[i].command) || (cmd_level > GET_TRUST (ch))) { if (!social (ch, argument)) { echo = number (1, 9); if (echo == 1) send_to_char ("Eh?\n\r", ch); else if (echo == 2) send_to_char ("Huh?\n\r", ch); else if (echo == 3) send_to_char ("I'm afraid that just isn't possible...\n\r", ch); else if (echo == 4) send_to_char ("I don't recognize that command.\n\r", ch); else if (echo == 5) send_to_char ("What?\n\r", ch); else if (echo == 6) send_to_char ("Perhaps you should try typing it a different way?\n\r", ch); else if (echo == 7) send_to_char ("Try checking your typing - I don't recognize it.\n\r", ch); else if (echo == 8) send_to_char ("That isn't a recognized command, craft, or social.\n\r", ch); else send_to_char ("Hmm?\n\r", ch); } else { if (!IS_SET (commands[i].flags, C_NWT)) show_to_watchers (ch, argument); } return; } if (ch->stun) { send_to_char ("You're still reeling.\n", ch); return; } if (ch->roundtime) { sprintf (buf, "You'll need to wait another %d seconds.\n", ch->roundtime); send_to_char (buf, ch); return; } if (IS_SET (commands[i].flags, C_WLK) && (ch->moves || GET_FLAG (ch, FLAG_LEAVING) || GET_FLAG (ch, FLAG_ENTERING))) { send_to_char ("Stop traveling first.\n\r", ch); return; } if (IS_SET (commands[i].flags, C_MNT) && IS_RIDER (ch)) { send_to_char ("Get off your mount first.\n", ch); return; } if (commands[i].min_position > GET_POS (ch)) { switch (GET_POS (ch)) { case DEAD: if (IS_MORTAL (ch)) { send_to_char ("You are dead. You can't do that.\n\r", ch); return; } case UNCON: case MORT: send_to_char ("You're seriously wounded and unconscious.\n\r", ch); return; case STUN: send_to_char ("You're too stunned to do that.\n\r", ch); return; case SLEEP: send_to_char ("You can't do that while sleeping.\n\r", ch); return; case REST: send_to_char ("You can't do that while lying down.\n\r", ch); return; case SIT: send_to_char ("You can't do that while sitting.\n\r", ch); return; case FIGHT: send_to_char ("No way! You are fighting for your life!\n\r", ch); return; } return; } if (!IS_NPC (ch) && ch->pc->create_state == STATE_DIED && !IS_SET (commands[i].flags, C_DOA)) { send_to_char ("You can't do that when you're dead.\n\r", ch); return; } if (!IS_SET (commands[i].flags, C_BLD) && is_blind (ch)) { if (get_equip (ch, WEAR_BLINDFOLD)) send_to_char ("You can't do that while blindfolded.\n\r", ch); else send_to_char ("You can't do that while blind.\n\r", ch); return; } if ((af = get_affect (ch, MAGIC_AFFECT_PARALYSIS)) && !IS_SET (commands[i].flags, C_PAR) && IS_MORTAL (ch)) { send_to_char ("You can't move.\n", ch); return; } if (IS_SUBDUEE (ch) && !IS_SET (commands[i].flags, C_SUB) && !cmd_level) { act ("$N won't let you.", false, ch, 0, ch->subdue, TO_CHAR); return; } /* Most commands break delays */ if (ch->delay && !IS_SET (commands[i].flags, C_DEL)) break_delay (ch); /* Send this command to the log */ if (!second_affect_active && (!IS_NPC (ch) || ch->desc)) { if (IS_SET (commands[i].flags, C_NLG)) ; else if (i > 0) { /* Log craft commands separately. */ if (!str_cmp (commands[i].command, ".")) player_log (ch, "say", command_args); else if (!str_cmp (commands[i].command, ",")) player_log (ch, "emote", command_args); else if (!str_cmp (commands[i].command, ":")) player_log (ch, "emote", command_args); else if (!str_cmp (commands[i].command, ";")) player_log (ch, "wiznet", command_args); else player_log (ch, commands[i].command, command_args); } } if (IS_MORTAL (ch) && get_affect (ch, MAGIC_HIDDEN) && !IS_SET (commands[i].flags, C_HID) && skill_level (ch, SKILL_SNEAK, 0) < number (1, MAX(100, skill_level(ch, SKILL_SNEAK, 0))) && would_reveal (ch)) { remove_affect_type (ch, MAGIC_HIDDEN); act ("$n reveals $mself.", true, ch, 0, 0, TO_ROOM | _ACT_FORMAT); act ("Your actions have compromised your concealment.", true, ch, 0, 0, TO_CHAR); } /* Execute command */ if (!IS_SET (commands[i].flags, C_NWT)) show_to_watchers (ch, social_args); if (!i) /* craft_command */ craft_command (ch, command_args, craft_affect); else (*commands[i].proc) (ch, command_args, 0); last_descriptor = NULL; }