void PHPEntityVariable::Store(wxSQLite3Database& db) { // we keep only the function arguments in the databse and globals if(IsFunctionArg() || IsMember()) { try { wxSQLite3Statement statement = db.PrepareStatement("INSERT OR REPLACE INTO VARIABLES_TABLE VALUES (NULL, " ":SCOPE_ID, :FUNCTION_ID, :NAME, :FULLNAME, :SCOPE, :TYPEHINT, " ":FLAGS, :DOC_COMMENT, :LINE_NUMBER, :FILE_NAME)"); statement.Bind(statement.GetParamIndex(":SCOPE_ID"), IsMember() ? Parent()->GetDbId() : wxLongLong(-1)); statement.Bind(statement.GetParamIndex(":FUNCTION_ID"), IsFunctionArg() ? Parent()->GetDbId() : wxLongLong(-1)); statement.Bind(statement.GetParamIndex(":NAME"), GetShortName()); statement.Bind(statement.GetParamIndex(":FULLNAME"), GetFullName()); statement.Bind(statement.GetParamIndex(":SCOPE"), GetScope()); statement.Bind(statement.GetParamIndex(":TYPEHINT"), GetTypeHint()); statement.Bind(statement.GetParamIndex(":FLAGS"), (int)GetFlags()); statement.Bind(statement.GetParamIndex(":DOC_COMMENT"), GetDocComment()); statement.Bind(statement.GetParamIndex(":LINE_NUMBER"), GetLine()); statement.Bind(statement.GetParamIndex(":FILE_NAME"), GetFilename().GetFullPath()); statement.ExecuteUpdate(); SetDbId(db.GetLastRowId()); } catch(wxSQLite3Exception& exc) { wxUnusedVar(exc); } } }
// // This file contains the C++ code from Program 12.20 of // "Data Structures and Algorithms // with Object-Oriented Design Patterns in C++" // by Bruno R. Preiss. // // Copyright (c) 1998 by Bruno R. Preiss, P.Eng. All rights reserved. // // http://www.pads.uwaterloo.ca/Bruno.Preiss/books/opus4/programs/pgm12_20.cpp // void PartitionAsForest::CheckArguments ( PartitionTree const& s, PartitionTree const& t) { if (!IsMember (s) || s.parent != 0 || !IsMember (t) || t.parent != 0 || s == t) throw invalid_argument ("incompatible sets"); }
BOOL CParty::NewMember( u_long uPlayerId, LONG nLevel, LONG nJob, BYTE nSex, LPSTR szName ) #endif // __SYS_PLAYER_DATA { #if __VER < 11 // __SYS_PLAYER_DATA if( szName == NULL ) return FALSE; #endif // __SYS_PLAYER_DATA if( IsMember( uPlayerId ) == FALSE && m_nSizeofMember < MAX_PTMEMBER_SIZE ) { m_aMember[m_nSizeofMember].m_uPlayerId = uPlayerId; #if __VER < 11 // __SYS_PLAYER_DATA m_aMember[m_nSizeofMember].m_nLevel = nLevel; m_aMember[m_nSizeofMember].m_nJob = nJob; m_aMember[m_nSizeofMember].m_nSex = nSex; #endif // __SYS_PLAYER_DATA m_aMember[m_nSizeofMember].m_bRemove = FALSE; #if __VER < 11 // __SYS_PLAYER_DATA strcpy( m_aMember[m_nSizeofMember].m_szName, szName ); #endif // __SYS_PLAYER_DATA m_nSizeofMember++; return TRUE; } return FALSE; }
BOOL CNBLogicalDevice::UnitDeviceAdd(CNBUnitDevice *pUnitDevice) { UINT32 iSequence; if(pUnitDevice->IsGroup()) { if(m_mapUnitDevices.size() && !IsMember(pUnitDevice)) { ATLASSERT(FALSE); return FALSE; } iSequence = pUnitDevice->m_DIB.iSequence; } else { iSequence = 0; } m_mapUnitDevices[iSequence] = pUnitDevice; ATLTRACE(_T("CNBLogicalDevice(%p).m_mapUnitDevices[%d] = (%p) : %s\n"), this, iSequence, pUnitDevice, pUnitDevice->GetName()); pUnitDevice->m_pLogicalDevice = this; return TRUE; }
void PHPEntityVariable::PrintStdout(int indent) const { wxString indentString(' ', indent); wxPrintf("%s%s: %s", indentString, IsMember() ? "Member" : "Variable", GetShortName()); if(!GetTypeHint().IsEmpty()) { wxPrintf(", TypeHint: %s", GetTypeHint()); } if(!GetExpressionHint().IsEmpty()) { wxPrintf(", ExpressionHint: %s", GetExpressionHint()); } if(IsReference()) { wxPrintf(", Reference"); } if(!GetDefaultValue().IsEmpty()) { wxPrintf(", Default: %s", GetDefaultValue()); } wxPrintf(", Ln. %d", GetLine()); wxPrintf("\n"); PHPEntityBase::List_t::const_iterator iter = m_children.begin(); for(; iter != m_children.end(); ++iter) { (*iter)->PrintStdout(indent + 4); } }
/* * safelist_one_channel() * * inputs - client pointer and channel pointer * outputs - none * side effects - a channel is listed if it meets the * requirements */ static void safelist_one_channel(struct Client *source_p, struct Channel *chptr) { struct ListClient *safelist_data = source_p->localClient->safelist_data; int visible; visible = !SecretChannel(chptr) || IsMember(source_p, chptr); if (!visible && !safelist_data->operspy) return; if ((unsigned int)chptr->members.length < safelist_data->users_min || (unsigned int)chptr->members.length > safelist_data->users_max) return; if (safelist_data->topic_min && chptr->topic_time < safelist_data->topic_min) return; /* If a topic TS is provided, don't show channels without a topic set. */ if (safelist_data->topic_max && (chptr->topic_time > safelist_data->topic_max || chptr->topic_time == 0)) return; if (safelist_data->created_min && chptr->channelts < safelist_data->created_min) return; if (safelist_data->created_max && chptr->channelts > safelist_data->created_max) return; list_one_channel(source_p, chptr, visible); }
/* * safelist_channel_named() * * inputs - client pointer, channel name, operspy * outputs - none * side effects - a named channel is listed */ static void safelist_channel_named(struct Client *source_p, const char *name, int operspy) { struct Channel *chptr; char *p; int visible; sendto_one(source_p, form_str(RPL_LISTSTART), me.name, source_p->name); if ((p = strchr(name, ','))) *p = '\0'; if (*name == '\0') { sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), name); sendto_one(source_p, form_str(RPL_LISTEND), me.name, source_p->name); return; } chptr = find_channel(name); if (chptr == NULL) { sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), name); sendto_one(source_p, form_str(RPL_LISTEND), me.name, source_p->name); return; } visible = !SecretChannel(chptr) || IsMember(source_p, chptr); if (visible || operspy) list_one_channel(source_p, chptr, visible); sendto_one(source_p, form_str(RPL_LISTEND), me.name, source_p->name); return; }
/* PState: parse state and add all matches in models to ilist */ static void PState(ILink models, ILink *ilist, char *type, HMMSet *hset) { IntSet states; int j; HMMDef *hmm; ILink h; states = CreateSet(maxStates); PIndex(states); SkipSpaces(); if (ch == '.') { ReadCh(); PStatecomp(models,ilist,type,states,hset); } else { ChkType('s',type); for (h=models; h!=NULL; h=h->next) { hmm = h->owner; for (j=2; j<hmm->numStates; j++) if (IsMember(states,j)) { /* tie ->info */ if (trace & T_ITM) printf(" %12s.state[%d]\n", HMMPhysName(hset,hmm),j); AddItem(hmm,hmm->svec+j,ilist); } } } FreeSet(states); }
static char *first_visible_channel(aClient *sptr, aClient *acptr, int *flg) { Membership *lp; *flg = 0; for (lp = acptr->user->channel; lp; lp = lp->next) { aChannel *chptr = lp->chptr; int cansee = ShowChannel(sptr, chptr); if (cansee && (acptr->umodes & UMODE_HIDEWHOIS) && !IsMember(sptr, chptr)) cansee = 0; if (!cansee) { if (OPCanSeeSecret(sptr)) *flg |= FVC_HIDDEN; else continue; } return chptr->chname; } /* no channels that they can see */ return "*"; }
void SimulationOutput::DoRecord(const ComponentFrame* frame, const Bunch* bunch) { if(frame->IsComponent()) { string id = (*frame).GetComponent().GetQualifiedName(); if(output_all || IsMember(id)) { Record(frame,bunch); } } }
wxString PHPEntityVariable::GetScope() const { PHPEntityBase* parent = Parent(); if(parent && parent->Is(kEntityTypeFunction) && IsFunctionArg()) { return parent->Cast<PHPEntityFunction>()->GetScope(); } else if(parent && parent->Is(kEntityTypeClass) && IsMember()) { return parent->GetFullName(); } else { return ""; } }
int WordSet::operator==(const WordSet &rhs) const { //----------------------------------------- // false if sets have different cardinality //----------------------------------------- if (rhs.NumberOfEntries() != NumberOfEntries()) return 0; //----------------------------------------- // false if some word in rhs is not in lhs //----------------------------------------- WordSetIterator words(&rhs); unsigned long *word; for (; (word = words.Current()); words++) if (IsMember(*word) == 0) return 0; return 1; // equal otherwise }
static int eb_channel(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type) { struct Channel *chptr2; (void)chptr; (void)mode_type; if (data == NULL) return EXTBAN_INVALID; chptr2 = find_channel(data); if (chptr2 == NULL) return EXTBAN_INVALID; /* privacy! don't allow +s/+p channels to influence another channel */ if (!PubChannel(chptr2)) return EXTBAN_INVALID; return IsMember(client_p, chptr2) ? EXTBAN_MATCH : EXTBAN_NOMATCH; }
static int eb_channel(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type) { struct Channel *chptr2; (void)chptr; (void)mode_type; if (data == NULL) return EXTBAN_INVALID; chptr2 = find_channel(data); if (chptr2 == NULL) return EXTBAN_INVALID; /* require consistent target */ if (chptr->chname[0] == '#' && data[0] == '&') return EXTBAN_INVALID; return IsMember(client_p, chptr2) ? EXTBAN_MATCH : EXTBAN_NOMATCH; }
/* * list_all_channels * inputs - pointer to client requesting list * output - 0/1 * side effects - list all channels to source_p */ static int list_all_channels(struct Client *source_p) { struct Channel *chptr; sendto_one(source_p, form_str(source_p,RPL_LISTSTART), me.name, source_p->name); for ( chptr = GlobalChannelList; chptr; chptr = chptr->nextch ) { if ( !source_p->user || (SecretChannel(chptr) && !IsMember(source_p, chptr))) continue; list_one_channel(source_p,chptr); } sendto_one(source_p, form_str(source_p,RPL_LISTEND), me.name, source_p->name); return 0; }
void Group::UpdatePlayerOnlineStatus(Player* player, bool online /*= true*/) { if (!player) return; const ObjectGuid guid = player->GetObjectGuid(); if (!IsMember(guid)) return; SendUpdate(); if (online) { player->SetGroupUpdateFlag(GROUP_UPDATE_FULL); UpdatePlayerOutOfRange(player); } else if (IsLeader(guid)) m_leaderLastOnline = time(nullptr); }
void CBotSquad::AddMember ( edict_t *pEdict ) { if ( !IsMember(pEdict) ) { MyEHandle newh; //CBot *pBot; newh = pEdict; m_theSquad.Push(newh); /*if ( (pBot=CBots::getBotPointer(pEdict))!=NULL ) { pBot->clearSquad(); pBot->setSquad(this); }*/ } }
static void do_channel_who(aClient *sptr, aChannel *channel, char *mask) { Member *cm = channel->members; if (IsMember(sptr, channel) || IsNetAdmin(sptr)) who_flags |= WF_ONCHANNEL; for (cm = channel->members; cm; cm = cm->next) { aClient *acptr = cm->cptr; char status[20]; int cansee; if ((cansee = can_see(sptr, acptr, channel)) & WHO_CANTSEE) continue; make_who_status(sptr, acptr, channel, cm, status, cansee); send_who_reply(sptr, acptr, channel->chname, status, ""); } }
ResultType WinGroup::CloseAndGoToNext(bool aStartWithMostRecent) // If the foreground window is a member of this group, close it and activate // the next member. { if (IsEmpty()) return OK; // OK since this is the expected behavior in this case. // Otherwise: // Don't call Update(), let (De)Activate() do that. HWND fore_win = GetForegroundWindow(); // Even if it's NULL, don't return since the legacy behavior is to continue on to the final part below. WindowSpec *win_spec = IsMember(fore_win, *g); if ( (mIsModeActivate && win_spec) || (!mIsModeActivate && !win_spec) ) { // If the user is using a GroupActivate hotkey, we don't want to close // the foreground window if it's not a member of the group. Conversely, // if the user is using GroupDeactivate, we don't want to close a // member of the group. This precaution helps prevent accidental closing // of windows that suddenly pop up to the foreground just as you've // realized (too late) that you pressed the "close" hotkey. // MS Visual Studio/C++ gets messed up when it is directly sent a WM_CLOSE, // probably because the wrong window (it has two mains) is being sent the close. // But since that's the only app I've ever found that doesn't work right, // it seems best not to change our close method just for it because sending // keys is a fairly high overhead operation, and not without some risk due to // not knowing exactly what keys the user may have physically held down. // Also, we'd have to make this module dependent on the keyboard module, // which would be another drawback. // Try to wait for it to close, otherwise the same window may be activated // again before it has been destroyed, defeating the purpose of the // "ActivateNext" part of this function's job: // SendKeys("!{F4}"); if (fore_win) { WinClose(fore_win, 500); DoWinDelay; } } //else do the activation below anyway, even though no close was done. return mIsModeActivate ? Activate(aStartWithMostRecent, win_spec) : Deactivate(aStartWithMostRecent); }
static int eb_channel(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type) { struct Channel *chptr2; (void)chptr; (void)mode_type; if (data == NULL) return EXTBAN_INVALID; chptr2 = find_channel(data); if (chptr2 == NULL) return EXTBAN_INVALID; /* require consistent target */ if (chptr->chname[0] == '#' && data[0] == '&') return EXTBAN_INVALID; /* privacy! don't allow +s/+p channels to influence another channel */ if (!PubChannel(chptr2) && chptr2 != chptr) return EXTBAN_INVALID; return IsMember(client_p, chptr2) ? EXTBAN_MATCH : EXTBAN_NOMATCH; }
static int has_common_channels(aClient *c1, aClient *c2) { Membership *lp; for (lp = c1->user->channel; lp; lp = lp->next) { if (IsMember(c2, lp->chptr)) { if (c1 == c2) return 1; /* We must ensure that c1 is allowed to "see" c2 */ if ((lp->chptr->mode.mode & MODE_AUDITORIUM) && !is_chan_op(c2, lp->chptr) && !is_chan_op(c1, lp->chptr)) break; return 1; } } return 0; }
ResultType WinGroup::Activate(bool aStartWithMostRecent, WindowSpec *aWinSpec, Label **aJumpToLabel) { if (aJumpToLabel) // Initialize early in case of early return. *aJumpToLabel = NULL; if (IsEmpty()) return OK; // OK since this is the expected behavior in this case. // Otherwise: if (!Update(true)) // Update our private member vars. return FAIL; // It already displayed the error for us. WindowSpec *win, *win_to_activate_next = aWinSpec; bool group_is_active = false; // Set default. HWND activate_win, active_window = GetForegroundWindow(); // This value is used in more than one place. if (win_to_activate_next) { // The caller told us which WindowSpec to start off trying to activate. // If the foreground window matches that WindowSpec, do nothing except // marking it as visited, because we want to stay on this window under // the assumption that it was newly revealed due to a window on top // of it having just been closed: if (win_to_activate_next == IsMember(active_window, *g)) { group_is_active = true; MarkAsVisited(active_window); return OK; } // else don't mark as visited even if it's a member of the group because // we're about to attempt to activate a different window: the next // unvisited member of this same WindowSpec. If the below doesn't // find any of those, it continue on through the list normally. } else // Caller didn't tell us which, so determine it. { if (win_to_activate_next = IsMember(active_window, *g)) // Foreground window is a member of this group. { // Set it to activate this same WindowSpec again in case there's // more than one that matches (e.g. multiple notepads). But first, // mark the current window as having been visited if it hasn't // already by marked by a prior iteration. Update: This method // doesn't work because if a unvisted matching window became the // foreground window by means other than using GroupActivate // (e.g. launching a new instance of the app: now there's another // matching window in the foreground). So just call it straight // out. It has built-in dupe-checking which should prevent the // list from filling up with dupes if there are any special // situations in which that might otherwise happen: //if (!sAlreadyVisitedCount) group_is_active = true; MarkAsVisited(active_window); } else // It's not a member. { win_to_activate_next = mFirstWindow; // We're starting fresh, so start at the first window. // Reset the list of visited windows: sAlreadyVisitedCount = 0; } } // Activate any unvisited window that matches the win_to_activate_next spec. // If none, activate the next window spec in the series that does have an // existing window: // If the spec we're starting at already has some windows marked as visited, // set this variable so that we know to retry the first spec again in case // a full circuit is made through the window specs without finding a window // to activate. Note: Using >1 vs. >0 might protect against any infinite-loop // conditions that may be lurking: bool retry_starting_win_spec = (sAlreadyVisitedCount > 1); bool retry_is_in_effect = false; for (win = win_to_activate_next;;) { // Call this in the mode to find the last match, which makes things nicer // because when the sequence wraps around to the beginning, the windows will // occur in the same order that they did the first time, rather than going // backwards through the sequence (which is counterintuitive for the user): if ( activate_win = WinActivate(*g, win->mTitle, win->mText, win->mExcludeTitle, win->mExcludeText // This next line is whether to find last or first match. We always find the oldest // (bottommost) match except when the user has specifically asked to start with the // most recent. But it only makes sense to start with the most recent if the // group isn't currently active (i.e. we're starting fresh), because otherwise // windows would be activated in an order different from what was already shown // the first time through the enumeration, which doesn't seem to be ever desirable: , !aStartWithMostRecent || group_is_active , sAlreadyVisited, sAlreadyVisitedCount) ) { // We found a window to activate, so we're done. // Probably best to do this before WinDelay in case another hotkey fires during the delay: MarkAsVisited(activate_win); DoWinDelay; //MsgBox(win->mText, 0, win->mTitle); break; } // Otherwise, no window was found to activate. if (retry_is_in_effect) // This was the final attempt because we've already gone all the // way around the circular linked list of WindowSpecs. This check // must be done, otherwise an infinite loop might result if the windows // that formed the basis for determining the value of // retry_starting_win_spec have since been destroyed: break; // Otherwise, go onto the next one in the group: win = win->mNextWindow; // Even if the above didn't change the value of <win> (because there's only // one WinSpec in the list), it's still correct to reset this count because // we want to start the fresh again after all the windows have been // visited. Note: The only purpose of sAlreadyVisitedCount as used by // this function is to indicate which windows in a given WindowSpec have // been visited, not which windows altogether (i.e. it's not necessary to // remember which windows have been visited once we move on to a new // WindowSpec). sAlreadyVisitedCount = 0; if (win == win_to_activate_next) { // We've made one full circuit of the circular linked list without // finding an existing window to activate. At this point, the user // has pressed a hotkey to do a GroupActivate, but nothing has happened // yet. We always want something to happen unless there's absolutely // no existing windows to activate, or there's only a single window in // the system that matches the group and it's already active. if (retry_starting_win_spec) { // Mark the foreground window as visited so that it won't be // mistakenly activated again by the next iteration: MarkAsVisited(active_window); retry_is_in_effect = true; // Now continue with the next iteration of the loop so that it // will activate a different instance of this WindowSpec rather // than getting stuck on this one. } else { if (aJumpToLabel && mJumpToLabel) { // Caller asked us to return in this case, so that it can // use this value to execute a user-specified Gosub: *aJumpToLabel = mJumpToLabel; // Set output param for the caller. } return FAIL; // Let GroupActivate set ErrorLevel to indicate what happened. } } } return OK; }
/* mo_ojoin() * parv[0] = sender prefix * parv[1] = channels separated by commas (#ifdef OJOIN_MULTIJOIN) */ static void mo_ojoin(struct Client *client_p, struct Client *source_p, int parc, char *parv[]) { struct Channel *chptr; char *name = parv[1], modeletter; #ifdef OJOIN_MULTIJOIN char *t; #endif short move_me = 1; unsigned int tmp_flags; /* admins only */ if (!IsAdmin(source_p)) { sendto_one(source_p, form_str(ERR_NOPRIVILEGES), me.name, source_p->name); return; } #ifdef OJOIN_MULTIJOIN for (name = strtoken (&t, name, ","); name; name = strtoken (&t, NULL, ",")) { #endif move_me = 1; switch (*name) { #ifndef DISABLE_CHAN_OWNER case '!': tmp_flags = CHFL_CHANOWNER; modeletter = 'u'; name++; break; #endif case '@': tmp_flags = CHFL_CHANOP; modeletter = 'o'; name++; break; case '+': tmp_flags = CHFL_VOICE; modeletter = 'v'; name++; break; case '%': tmp_flags = CHFL_HALFOP; modeletter = 'h'; name++; break; case '#': case '&': tmp_flags = 0; modeletter = '\0'; break; /* We're not joining a channel, or we don't know the mode, * what ARE we joining? */ default: sendto_one (source_p, form_str(ERR_NOSUCHCHANNEL), me.name, source_p->name, name); #ifdef OJOIN_MULTIJOIN continue; #else return; #endif } /* Error checking here */ if ((chptr = hash_find_channel(name)) == NULL) { sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL), me.name, source_p->name, name); } else if (IsMember(source_p, chptr)) { sendto_one(source_p, ":%s NOTICE %s :Please part %s before using OJOIN", me.name, source_p->name, name); } else { if (move_me == 1) name--; add_user_to_channel(chptr, source_p, tmp_flags); if (chptr->chname[0] == '#') { sendto_server(client_p, CAP_TS6, NOCAPS, ":%s SJOIN %lu %s + :%c%s", me.id, (unsigned long)chptr->channelts, chptr->chname, (modeletter != '\0') ? *name : ' ', source_p->id); sendto_server(client_p, NOCAPS, CAP_TS6, ":%s SJOIN %lu %s + :%c%s", me.name, (unsigned long)chptr->channelts, chptr->chname, (modeletter != '\0') ? *name : ' ', source_p->name); } sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%s@%s JOIN %s", source_p->name, source_p->username, GET_CLIENT_HOST(source_p), chptr->chname); if (modeletter != '\0') { sendto_channel_local(ALL_MEMBERS, chptr, ":%s MODE %s +%c %s", me.name, chptr->chname, modeletter, source_p->name); } /* send the topic... */ if (chptr->topic != NULL) { sendto_one(source_p, form_str(RPL_TOPIC), me.name, source_p->name, chptr->chname, chptr->topic); sendto_one(source_p, form_str(RPL_TOPICWHOTIME), me.name, source_p->name, chptr->chname, chptr->topic_info, chptr->topic_time); } source_p->localClient->last_join_time = CurrentTime; channel_member_names(source_p, chptr, 1); } #ifdef OJOIN_MULTIJOIN } #endif }
/* PStatecomp: parse a statecomp */ static void PStatecomp(ILink models, ILink *ilist, char *type, IntSet states, HMMSet *hset) { HMMDef *hmm; ILink h; int s,j; IntSet streams; Keyword kw; switch(kw=GetKey()) { case MIX_KEY: case STREAM_KEY: if (hset->hsKind==TIEDHS || hset->hsKind==DISCRETEHS) HError(7231,"PStatecomp: Cannot specify streams or mixes unless continuous"); streams = CreateSet(SMAX); if(kw==STREAM_KEY) { PIndex(streams); SkipSpaces(); if (ch != '.') EdError(". expected after stream spec"); ReadCh(); if (GetKey() != MIX_KEY) EdError("Mix expected after Stream index"); } else AddMember(streams,1); SkipSpaces(); if (ch=='[') PMix(models,ilist,type,states,streams,hset); else { ChkType('p',type); for (h=models; h!=NULL; h=h->next) { hmm = h->owner; for (j=2; j<hmm->numStates; j++) if (IsMember(states,j)) for (s=1; s<=hset->swidth[0];s++) if (IsMember(streams,s)) { /* tie -> spdf */ if (trace & T_ITM) printf(" %12s.state[%d].stream[%d]\n", HMMPhysName(hset,hmm),j,s); AddItem(hmm,hmm->svec[j].info->pdf+s,ilist); } } } FreeSet(streams); break; case DUR_KEY: ChkType('d',type); for (h=models; h!=NULL; h=h->next) { hmm = h->owner; for (j=2; j<hmm->numStates; j++) if (IsMember(states,j)) { /* tie ->dur */ if (trace & T_ITM) printf(" %12s.state[%d].dur\n", HMMPhysName(hset,hmm),j); AddItem(hmm,hmm->svec[j].info,ilist); } } break; case WEIGHTS_KEY: ChkType('w',type); for (h=models; h!=NULL; h=h->next) { hmm = h->owner; for (j=2; j<hmm->numStates; j++) if (IsMember(states,j)) { /* tie ->stream weights */ if (trace & T_ITM) printf(" %12s.state[%d].weights\n", HMMPhysName(hset,hmm),j); AddItem(hmm,hmm->svec[j].info,ilist); } } break; default: EdError("dur, weight, stream or mix expected"); } }
/* PMix: parse a mixture spec */ static void PMix(ILink models, ILink *ilist, char *type, IntSet states, IntSet streams,HMMSet *hset) { IntSet mixes; HMMDef *hmm; ILink h; int s,j,m; MixtureElem *me; StreamElem *ste; enum {TMIX, TMEAN, TCOV} what; mixes = CreateSet(maxMixes); PIndex(mixes); SkipSpaces(); what = TMIX; if (ch == '.') { ReadCh(); switch(GetKey()) { case MEAN_KEY: what = TMEAN; ChkType('u',type); break; case COV_KEY: what = TCOV; ChkType('a',type); break; default: EdError("Mean or Cov expected"); } } else ChkType('m',type); for (h=models; h!=NULL; h=h->next) { hmm = h->owner; for (j=2; j<hmm->numStates; j++) if (IsMember(states,j)) { ste = hmm->svec[j].info->pdf+1; for (s=1; s<=hset->swidth[0]; s++,ste++) if (IsMember(streams,s)) { me = ste->spdf.cpdf+1; for (m=1; m<=ste->nMix; m++,me++) if (me->weight>MINMIX && IsMember(mixes,m)) { switch (what) { case TMIX: /* tie ->mpdf */ if (trace & T_ITM) printf(" %12s.state[%d].stream[%d].mix[%d]\n", HMMPhysName(hset,hmm),j,s,m); AddItem(hmm,me,ilist); break; case TMEAN: /* tie ->mean */ ChkType('u',type); if (trace & T_ITM) printf(" %12s.state[%d].stream[%d].mix[%d].mean\n", HMMPhysName(hset,hmm),j,s,m); AddItem(hmm,me->mpdf,ilist); break; case TCOV: /* tie ->cov */ switch (me->mpdf->ckind) { case INVDIAGC: case DIAGC: ChkType('v',type); break; case FULLC: ChkType('i',type); break; case LLTC: ChkType('c',type); break; case XFORMC: ChkType('x',type); break; } if (trace & T_ITM) printf(" %12s.state[%d].stream[%d].mix[%d].%c\n", HMMPhysName(hset,hmm),j,s,m,*type); AddItem(hmm,me->mpdf,ilist); break; } } } } } FreeSet(mixes); }
/* * m_lljoin * parv[0] = sender prefix * parv[1] = channel * parv[2] = nick ("!nick" == cjoin) * parv[3] = vchan/key (optional) * parv[4] = key (optional) * * If a lljoin is received, from our uplink, join * the requested client to the given channel, or ignore it * if there is an error. * * Ok, the way this works. Leaf client tries to join a channel, * it doesn't exist so the join does a cburst request on behalf of the * client, and aborts that join. The cburst sjoin's the channel if it * exists on the hub, and sends back an LLJOIN to the leaf. Thats where * this is now.. * */ static void ms_lljoin(struct Client *client_p, struct Client *source_p, int parc, char *parv[]) { char *chname = NULL; char *nick = NULL; char *key = NULL; char *vkey = NULL; int flags; int i; struct Client *target_p; struct Channel *chptr, *vchan_chptr, *root_vchan; #ifdef VCHANS int cjoin = 0; int vc_ts; char *pvc = NULL; #endif if(uplink && !IsCapable(uplink,CAP_LL)) { sendto_realops_flags(FLAGS_ALL, L_ALL, "*** LLJOIN requested from non LL server %s", client_p->name); return; } chname = parv[1]; if(chname == NULL) return; nick = parv[2]; if(nick == NULL) return; #ifdef VCHANS if (nick[0] == '!') { cjoin = 1; nick++; } if(parc > 4) { key = parv[4]; vkey = parv[3]; } #endif else if(parc >3) { key = vkey = parv[3]; } flags = 0; target_p = find_client(nick); if( !target_p || !target_p->user ) return; if( !MyClient(target_p) ) return; chptr = hash_find_channel(chname); #ifdef VCHANS if (cjoin) { if(!chptr) /* Uhm, bad! */ { sendto_realops_flags(FLAGS_ALL, L_ALL, "LLJOIN %s %s called by %s, but root chan doesn't exist!", chname, nick, client_p->name); return; } flags = CHFL_CHANOP; if(! (vchan_chptr = cjoin_channel(chptr, target_p, chname))) return; root_vchan = chptr; chptr = vchan_chptr; } else #endif { #ifdef VCHANS if (chptr) { vchan_chptr = select_vchan(chptr, target_p, vkey, chname); } else #endif { chptr = vchan_chptr = get_or_create_channel(target_p, chname, NULL); flags = CHFL_CHANOP; } #ifdef VCHANS if (vchan_chptr != chptr) { root_vchan = chptr; chptr = vchan_chptr; } else #endif root_vchan = chptr; if(!chptr || !root_vchan) return; if (chptr->users == 0) flags = CHFL_CHANOP; else flags = 0; /* XXX in m_join.c :( */ /* check_spambot_warning(target_p, chname); */ /* They _could_ join a channel twice due to lag */ if(chptr) { if (IsMember(target_p, chptr)) /* already a member, ignore this */ return; } else { sendto_one(target_p, form_str(ERR_UNAVAILRESOURCE), me.name, nick, root_vchan->chname); return; } if( (i = can_join(target_p, chptr, key)) ) { sendto_one(target_p, form_str(i), me.name, nick, root_vchan->chname); return; } } if ((target_p->user->joined >= ConfigChannel.max_chans_per_user) && (!IsOper(target_p) || (target_p->user->joined >= ConfigChannel.max_chans_per_user*3))) { sendto_one(target_p, form_str(ERR_TOOMANYCHANNELS), me.name, nick, root_vchan->chname ); return; } if(flags == CHFL_CHANOP) { chptr->channelts = CurrentTime; /* * XXX - this is a rather ugly hack. * * Unfortunately, there's no way to pass * the fact that it is a vchan through SJOIN... */ /* Prevent users creating a fake vchan */ #ifdef VCHANS if (chname[0] == '#' && chname[1] == '#') { if ((pvc = strrchr(chname+3, '_'))) { /* * OK, name matches possible vchan: * ##channel_blah */ pvc++; /* point pvc after last _ */ vc_ts = atol(pvc); /* * if blah is the same as the TS, up the TS * by one, to prevent this channel being * seen as a vchan */ if (vc_ts == CurrentTime) chptr->channelts++; } } #endif sendto_one(uplink, ":%s SJOIN %lu %s + :@%s", me.name, (unsigned long) chptr->channelts, chptr->chname, nick); } /* a user can create a channel with halfops..? */ #if 0 else if ((flags == CHFL_HALFOP) && (IsCapable(uplink, CAP_HOPS))) { sendto_one(uplink, ":%s SJOIN %lu %s + :%%%s", me.name, (unsigned long) chptr->channelts, chptr->chname, nick); } #endif else { sendto_one(uplink, ":%s SJOIN %lu %s + :%s", me.name, (unsigned long) chptr->channelts, chptr->chname, nick); } add_user_to_channel(chptr, target_p, flags); #ifdef VCHANS if ( chptr != root_vchan ) add_vchan_to_client_cache(target_p,root_vchan,chptr); #endif sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%s@%s JOIN :%s", target_p->name, target_p->username, target_p->host, root_vchan->chname); if( flags & CHFL_CHANOP ) { chptr->mode.mode |= MODE_TOPICLIMIT; chptr->mode.mode |= MODE_NOPRIVMSGS; sendto_channel_local(ALL_MEMBERS,chptr, ":%s MODE %s +nt", me.name, root_vchan->chname); sendto_one(uplink, ":%s MODE %s +nt", me.name, chptr->chname); } channel_member_names(target_p, chptr, chname, 1); }
// apply a team buff for the main and affected zones void OutdoorPvP::BuffTeam(Team team, uint32 spellId, bool remove /*= false*/, bool onlyMembers /*= true*/, uint32 area /*= 0*/) { for (GuidZoneMap::iterator itr = m_zonePlayers.begin(); itr != m_zonePlayers.end(); ++itr) { Player* player = sObjectMgr.GetPlayer(itr->first); if (!player) continue; if (player && (team == TEAM_NONE || player->GetTeam() == team) && (!onlyMembers || IsMember(player->GetObjectGuid()))) { if (!area || area == player->GetAreaId()) { if (remove) player->RemoveAurasDueToSpell(spellId); else player->CastSpell(player, spellId, true); } } } }
ResultType WinGroup::Deactivate(bool aStartWithMostRecent) { if (IsEmpty()) return OK; // OK since this is the expected behavior in this case. // Otherwise: if (!Update(false)) // Update our private member vars. return FAIL; // It already displayed the error for us. HWND active_window = GetForegroundWindow(); if (IsMember(active_window, *g)) sAlreadyVisitedCount = 0; // Activate the next unvisited non-member: WindowSearch ws; ws.mFindLastMatch = !aStartWithMostRecent || sAlreadyVisitedCount; ws.mAlreadyVisited = sAlreadyVisited; ws.mAlreadyVisitedCount = sAlreadyVisitedCount; ws.mFirstWinSpec = mFirstWindow; EnumWindows(EnumParentFindAnyExcept, (LPARAM)&ws); if (ws.mFoundParent) { // If the window we're about to activate owns other visble parent windows, it can // never truly be activated because it must always be below them in the z-order. // Thus, instead of activating it, activate the first (and usually the only?) // visible window that it owns. Doing this makes things nicer for some apps that // have a pair of main windows, such as MS Visual Studio (and probably many more), // because it avoids activating such apps twice in a row as the user progresses // through the sequence: HWND first_visible_owned = WindowOwnsOthers(ws.mFoundParent); if (first_visible_owned) { MarkAsVisited(ws.mFoundParent); // Must mark owner as well as the owned window. // Activate the owned window instead of the owner because it usually // (probably always, given the comments above) is the real main window: ws.mFoundParent = first_visible_owned; } SetForegroundWindowEx(ws.mFoundParent); // Probably best to do this before WinDelay in case another hotkey fires during the delay: MarkAsVisited(ws.mFoundParent); DoWinDelay; } else // No window was found to activate (they have all been visited). { if (sAlreadyVisitedCount) { bool wrap_around = (sAlreadyVisitedCount > 1); sAlreadyVisitedCount = 0; if (wrap_around) { // The user pressed a hotkey to do something, yet nothing has happened yet. // We want something to happen every time if there's a qualifying // "something" that we can do. And in this case there is: we can start // over again through the list, excluding the foreground window (which // the user has already had a chance to review): MarkAsVisited(active_window); // Make a recursive call to self. This can't result in an infinite // recursion (stack fault) because the called layer will only // recurse a second time if sAlreadyVisitedCount > 1, which is // impossible with the current logic: Deactivate(false); // Seems best to ignore aStartWithMostRecent in this case? } } } // Even if a window wasn't found, we've done our job so return OK: return OK; }
/* * m_topic * parv[0] = sender prefix * parv[1] = channel name * parv[2] = new topic, if setting topic */ static int m_topic(struct Client *client_p, struct Client *source_p, int parc, const char *parv[]) { struct Channel *chptr = NULL; struct membership *msptr; char *p = NULL; if((p = strchr(parv[1], ','))) *p = '\0'; if(MyClient(source_p) && !IsFloodDone(source_p)) flood_endgrace(source_p); if(!IsChannelName(parv[1])) { sendto_one_numeric(source_p, ERR_NOSUCHCHANNEL, form_str(ERR_NOSUCHCHANNEL), parv[1]); return 0; } chptr = find_channel(parv[1]); if(chptr == NULL) { sendto_one_numeric(source_p, ERR_NOSUCHCHANNEL, form_str(ERR_NOSUCHCHANNEL), parv[1]); return 0; } /* setting topic */ if(parc > 2) { msptr = find_channel_membership(chptr, source_p); if(msptr == NULL) { sendto_one_numeric(source_p, ERR_NOTONCHANNEL, form_str(ERR_NOTONCHANNEL), parv[1]); return 0; } if((chptr->mode.mode & MODE_TOPICLIMIT) == 0 || is_chanop(msptr) || !MyClient(source_p)) { char topic_info[USERHOST_REPLYLEN]; ircsprintf(topic_info, "%s!%s@%s", source_p->name, source_p->username, source_p->host); set_channel_topic(chptr, parv[2], topic_info, CurrentTime); sendto_server(client_p, chptr, CAP_TS6, NOCAPS, ":%s TOPIC %s :%s", use_id(source_p), chptr->chname, chptr->topic == NULL ? "" : chptr->topic); sendto_server(client_p, chptr, NOCAPS, CAP_TS6, ":%s TOPIC %s :%s", source_p->name, chptr->chname, chptr->topic == NULL ? "" : chptr->topic); sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%s@%s TOPIC %s :%s", source_p->name, source_p->username, source_p->host, chptr->chname, chptr->topic == NULL ? "" : chptr->topic); } else sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED), me.name, source_p->name, parv[1]); } else if(MyClient(source_p)) { if(!IsMember(source_p, chptr) && SecretChannel(chptr)) { sendto_one_numeric(source_p, ERR_NOTONCHANNEL, form_str(ERR_NOTONCHANNEL), parv[1]); return 0; } if(chptr->topic == NULL) sendto_one(source_p, form_str(RPL_NOTOPIC), me.name, source_p->name, parv[1]); else { sendto_one(source_p, form_str(RPL_TOPIC), me.name, source_p->name, chptr->chname, chptr->topic); sendto_one(source_p, form_str(RPL_TOPICWHOTIME), me.name, source_p->name, chptr->chname, chptr->topic_info, chptr->topic_time); } } return 0; }
/* ** m_list ** parv[0] = sender prefix ** parv[1] = channel */ int m_list(struct Client *cptr, struct Client *sptr, int parc, char *parv[]) { struct Channel *chptr; char *name, *p = NULL; /* anti flooding code, * I did have this in parse.c with a table lookup * but I think this will be less inefficient doing it in each * function that absolutely needs it * * -Dianora */ static time_t last_used=0L; int i,j,minusers; minusers = HasUmode(sptr,UMODE_USER_AUSPEX) ? 0 : MIN_USERS_FOR_LIST; /* throw away non local list requests that do get here -Dianora */ if(!MyConnect(sptr)) return 0; if(!NoFloodProtection(sptr)) { if(IsHoneypot(sptr) || (((last_used + PACE_WAIT) > CurrentTime) && (!IsDoingList(sptr)))) { sendto_one(sptr,form_str(RPL_LOAD2HI),me.name,parv[0],"LIST"); sendto_one(sptr,form_str(RPL_LISTEND),me.name,parv[0]); return 0; } else last_used = CurrentTime; } /* right.. if we are already involved in a "blocked" /list, we will simply continue where we left off */ if (IsDoingList(sptr)) { if (sptr->listprogress != -1) { for (i=sptr->listprogress; i<CH_MAX; i++) { int progress2 = sptr->listprogress2; for (j=0, chptr=(struct Channel*)(hash_get_channel_block(i).list); (chptr) && (j<hash_get_channel_block(i).links); chptr=chptr->hnextch, j++) { if (j<progress2) continue; /* wind up to listprogress2 */ /* Safety check */ if (!sptr->user) continue; /* If it's secret, and none of the overriding conditions are true, don't send it */ if (SecretChannel(chptr) && !HasUmode(sptr,UMODE_USER_AUSPEX) && !IsMember(sptr, chptr) && !IsLogger(sptr, chptr)) continue; if (chptr->users < minusers) continue; sendto_one(sptr, form_str(RPL_LIST), me.name, parv[0], chptr->chname, chptr->users, chptr->topic); if (IsSendqPopped(sptr)) { sptr->listprogress=i; sptr->listprogress2=j; return 0; } } sptr->listprogress2 = 0; } } sendto_one(sptr, form_str(RPL_LISTEND), me.name, parv[0]); if (IsSendqPopped(sptr)) { /* popped with the RPL_LISTEND code. d0h */ sptr->listprogress = -1; return 0; } ClearDoingList(sptr); /* yupo, its over */ return 0; } /* Grr, mIRC -- jilles */ if (parc == 2 && !strcmp(parv[1], "<10000")) { #if 0 /* discussed #hyperion 20050807, considered unnecessary and confusing */ sendto_one(sptr, ":%s NOTICE %s :Your client is buggy, it sends LIST <10000 even though we don't advertise ELIST=U in 005. Please upgrade or contact the developers.", me.name, parv[0]); #endif parc--; } sendto_one(sptr, form_str(RPL_LISTSTART), me.name, parv[0]); if (parc < 2 || BadPtr(parv[1])) { SetDoingList(sptr); /* only set if its a full list */ ClearSendqPop(sptr); /* just to make sure */ /* we'll do this by looking through each hash table bucket */ for (i=0; i<CH_MAX; i++) { for (j=0, chptr = (struct Channel*)(hash_get_channel_block(i).list); (chptr) && (j<hash_get_channel_block(i).links); chptr = chptr->hnextch, j++) { /* Safety check */ if (!sptr->user) continue; /* If it's secret, and none of the overriding conditions are true, don't send it */ if (SecretChannel(chptr) && !HasUmode(sptr,UMODE_USER_AUSPEX) && !IsMember(sptr, chptr) && !IsLogger(sptr, chptr)) continue; if (chptr->users < minusers) continue; sendto_one(sptr, form_str(RPL_LIST), me.name, parv[0], chptr->chname, chptr->users, chptr->topic); if (IsSendqPopped(sptr)) { sptr->listprogress=i; sptr->listprogress2=j; return 0; } } } sendto_one(sptr, form_str(RPL_LISTEND), me.name, parv[0]); if (IsSendqPopped(sptr)) { sptr->listprogress=-1; return 0; } ClearDoingList(sptr); /* yupo, its over */ return 0; } p = strchr(parv[1],','); if(p) *p = '\0'; name = parv[1]; /* strtoken(&p, parv[1], ","); */ /* while(name) */ if(name) { chptr = hash_find_channel(name, NullChn); if (chptr && ShowChannel(sptr, chptr) && sptr->user) sendto_one(sptr, form_str(RPL_LIST), me.name, parv[0], name, chptr->users, chptr->topic); /* name = strtoken(&p, (char *)NULL, ","); */ } sendto_one(sptr, form_str(RPL_LISTEND), me.name, parv[0]); return 0; }