void ximsWaitDone() { int ret; UserSelection *sel = &userSel; DPR(("ximsWaitDone():\tOpState=%s OpErrCode=%s[%d]\n", StateName(), error_name(OpErrCode), OpErrCode)); set_sig_chld(False); ret = sel->renv->status; switch (ret) { case ErrImsWaiting: sel->status = ErrImsTimeout; put_xims_log("'%s' timed-out.", sel->name, 0, 0); break; case ErrImsWaitDone: sel->status = NoError; # ifdef old_hpux if ((OpFlag & FLAG_CONNECT) || (sel->ent->ims->flags & F_TRY_CONNECT)) { sel->status = try_connection(sel); } # endif /* old_hpux */ break; case ErrImsConnecting: case ErrImsConnectDone: sel->status = NoError; break; case ErrImsAborted: /* put_xims_log("'%s' aborted.", sel->name, 0, 0); */ case ErrImsExecution: default: sel->status = ret; break; } if (sel->status != NoError) { OpErrCode = sel->status; DPR(("ximsWaitDone(): OpErrCode=%s[%d]\n", error_name(OpErrCode), OpErrCode)); } restore_resources(); settle_ims(sel); /* clear WM_COMMAND property */ OpState = OpErrCode == NoError ? State_Wait_Done : State_Wait_Err; ximsMain(); }
void DeviceInfo::UpdateDeviceState(enum DevState aDevState, FILETIME aNow, unsigned aScanId) { // check for change of state, eg removed etc... if (devState != aDevState) { BOOL chgState = FALSE; if (aDevState == DevAbsent) { if ((devState == DevPresent) || (devState == DevArrived)) { #ifdef _DEBUG PrintDebugStatus(_T("Change state to removed\n")); #endif // update DeviceTracker counts, decide on notifications gdevTracker->DetermineRemovalNotifications(devType, devState, DevRemoved); devState = DevRemoved; devElapsed = 0; devTimestamp = aNow; chgState = TRUE; // update counts DecDeviceTypeCount(); } } else if (aDevState == DevPresent) { if ((devState == DevAbsent) || (devState == DevRemoved)) { #ifdef _DEBUG PrintDebugStatus(_T("Change state to arrived\n")); #endif devDeleteOnUnlock = FALSE; // device has returned, no longer need to delete // update DeviceTracker counts, decide on notifications gdevTracker->DetermineArrivalNotifications(devType, aDevState); devState = gdevTracker->CheckInitialScanFlag(devType) ? DevPresent : DevArrived; devTimestamp = aNow; devElapsed = 0; chgState = TRUE; // update counts IncDeviceTypeCount(); } } if (chgState) { TCHAR buffer[20]; StringCbPrintf(buffer, sizeof(buffer), _T("%s 0min"), StateName()); SetDeviceIcon(); // update port status & icon on display gdevTracker->UpdateViewItemIconAndState(devImage, buffer, (LPARAM)this); } } devScanId = aScanId; }
// update time, returns TRUE device is still valid FALSE if no longer visible BOOL DeviceInfo::UpdateTimeInState(FILETIME now, BOOL showNotPresent, DWORD limit) { ULARGE_INTEGER t1, t2; t1.LowPart = devTimestamp.dwLowDateTime; t1.HighPart = devTimestamp.dwHighDateTime; t2.LowPart = now.dwLowDateTime; t2.HighPart = now.dwHighDateTime; t2.QuadPart -= t1.QuadPart; t2.QuadPart /= 600000000l; // minutes if (t2.LowPart <= limit) { if (devElapsed != t2.LowPart) { TCHAR buffer[20]; devElapsed = t2.LowPart; StringCbPrintf(buffer, sizeof(buffer), _T("%s %imin"), StateName(), t2.LowPart); gdevTracker->UpdateViewItemState(buffer, (LPARAM)this); } return TRUE; } else { // > 10s elapsed if (devState == DevArrived) { devState = DevPresent; } else { assert(devState == DevRemoved); devState = DevAbsent; if (!showNotPresent) { // device should no longer be listed return FALSE; } } gdevTracker->UpdateViewItemState(StateName(), (LPARAM)this); return TRUE; } }
void ximsWait() { OpStateVal oldOpState = OpState; UserSelection *sel = &userSel; struct timeval interval; time_t start_tm = 0; int lapse; DPR(("ximsWait(): OpState=%s OpErrCode=%s[%d]\n", StateName(), error_name(OpErrCode), OpErrCode)); OpState = State_Wait; if (oldOpState == State_Start_Err) { /* don't change OpErrCode */ OpState = State_Wait_Err; return; } if (!is_waiting() || (OpFlag & FLAG_NOWAIT)) { ximsWaitDone(); } if (im_mod_available(sel->renv) != 1) { if (useWINDOW()) { xt_start_waiting(); /* never returns unless failed */ } /* waiting */ lapse = 0; interval.tv_sec = Opt.Interval / 1000; interval.tv_usec = (Opt.Interval % 1000) * 1000; start_tm = time((time_t) 0); while (is_waiting()) { select(0, 0, 0, 0, &interval); /* usleep */ lapse = (int) time((time_t) 0) - start_tm; if (im_mod_available(sel->renv) != 0 || lapse >= Opt.Timeout) { DPR(("ximsWait(tmout=%d): wait done (%d sec.)\n", Opt.Timeout, lapse)); break; } } } ximsWaitDone(); }
void rf_ContinueRaidAccess(RF_RaidAccessDesc_t *desc) { int suspended = RF_FALSE; int current_state_index = desc->state; RF_AccessState_t current_state = desc->states[current_state_index]; #if RF_DEBUG_STATES int unit = desc->raidPtr->raidid; #endif do { current_state_index = desc->state; current_state = desc->states[current_state_index]; switch (current_state) { case rf_QuiesceState: suspended = rf_State_Quiesce(desc); break; case rf_IncrAccessesCountState: suspended = rf_State_IncrAccessCount(desc); break; case rf_MapState: suspended = rf_State_Map(desc); break; case rf_LockState: suspended = rf_State_Lock(desc); break; case rf_CreateDAGState: suspended = rf_State_CreateDAG(desc); break; case rf_ExecuteDAGState: suspended = rf_State_ExecuteDAG(desc); break; case rf_ProcessDAGState: suspended = rf_State_ProcessDAG(desc); break; case rf_CleanupState: suspended = rf_State_Cleanup(desc); break; case rf_DecrAccessesCountState: suspended = rf_State_DecrAccessCount(desc); break; case rf_LastState: suspended = rf_State_LastState(desc); break; } /* after this point, we cannot dereference desc since * desc may have been freed. desc is only freed in * LastState, so if we renter this function or loop * back up, desc should be valid. */ #if RF_DEBUG_STATES if (rf_printStatesDebug) { printf("raid%d: State: %-24s StateIndex: %3i desc: 0x%ld %s\n", unit, StateName(current_state), current_state_index, (long) desc, suspended ? "callback scheduled" : "looping"); } #endif } while (!suspended && current_state != rf_LastState); return; }
bool FunctionTab::AnalyzeNumChar(QChar c) { int type = ClassifyChar(c); //MainWindow::Debug(QString("type: ").arg()) if(type == ERROR) { NumeratorInvalid(c); return false; } int transition = TransitionNum(type); MainWindow::Debug(QString("%1 -> %2").arg(StateName(numerator_state),StateName(transition))); if(transition == ERROR) { NumeratorInvalid(c); return false; } switch(numerator_state) { case IDLE: switch(transition) { case POLY: current_poly = new CPoly(); sign = 1; break; default: NumeratorInvalid(c); return false; break; } break; case POLY: switch(transition) { case TOKEN_INT: current_token = new CToken; cst_string = c; current_token->SetSign(sign); break; case TOKEN_DEC: current_token = new CToken; cst_string = c; break; case IDLE: m_numerator.push_back(current_poly); break; case VAR: current_token = new CToken; current_token->m_c = 1; current_token->SetSign(sign); break; default: NumeratorInvalid(c); return false; break; } break; case TOKEN_INT: switch(transition) { case TOKEN_INT: cst_string.append(c); break; case POLY: current_token->m_c = cst_string.toDouble(); current_poly->Add(current_token); break; case TOKEN_DEC: cst_string.append(c); break; case IDLE: current_token->m_c = cst_string.toDouble(); current_poly->Add(current_token); m_numerator.push_back(current_poly); break; case VAR: current_token->m_c = cst_string.toDouble(); if(cst_string[0]== '-' || cst_string[0]=='+') current_token->m_c = 1; break; default: NumeratorInvalid(c); return false; break; } break; case TOKEN_DEC: switch(transition) { case TOKEN_DEC: cst_string.append(c); break; case POLY: current_token->m_c = cst_string.toDouble(); current_poly->Add(current_token); break; case IDLE: current_token->m_c = cst_string.toDouble(); current_poly->Add(current_token); m_numerator.push_back(current_poly); break; case VAR: current_token->m_c = cst_string.toDouble(); break; default: NumeratorInvalid(c); return false; break; } break; case VAR: switch(transition) { case POLY: current_token->m_p = 1; current_poly->Add(current_token); break; case EXP: pwr_string = c; break; case IDLE: current_token->m_p = 1; current_poly->Add(current_token); m_numerator.push_back(current_poly); break; default: NumeratorInvalid(c); return false; break; } break; case EXP: switch(transition) { case EXP: pwr_string.append(c); break; case POLY: current_token->m_p = pwr_string.toInt(); current_poly->Add(current_token); break; case IDLE: current_token->m_p = pwr_string.toInt(); current_poly->Add(current_token); m_numerator.push_back(current_poly); break; default: NumeratorInvalid(c); return false; break; } break; default: MainWindow::Debug("Unknow state"); break; } numerator_state = transition; // MainWindow::Debug("OK"); return true; }
void ChangeState(OTTCP *x, State s) { #ifdef DEBUG post("Changing state from %s to %s", StateName(x->o_state), StateName(s)); #endif x->o_state = s; }
void ottcp_tellmeeverything(OTTCP *x) { OTResult r; EnterCallback(); post("ottcp_tellmeeverything: You asked for it"); version(x); post(" This object error does %sreport errors", x->o_errorreporting ? "" : "not "); post(" state: %s", StateName(x->o_state)); if (x->o_state == OUTPUTTING) { post(" whatToOutput: %s", StateName(x->o_whatToOutput)); post(" nextRequest: %s", StateName(x->o_nextRequest)); } else if (x->o_state == GET_NBYTES) { post(" Getting %ld bytes.", x->o_numBytesWeWant); } else if (x->o_state == GET_DELIM) { post(" Looking for %ld-byte delimiterthat starts with \"%c\"", x->o_delimiterLen, x->o_delimiterBytes[0]); } if (x->o_datawaiting) { post(" There is data waiting in TCP's buffer"); } else { post(" There doesn't seem to be any data waiting in TCP's buffer"); } if (x->o_tcp_ep == 0) { post(" This object has not created an endpoint yet."); } else { post(" This object's endpoint reference is %p", x->o_tcp_ep); post(" Endpoint info: addr %ld, options %ld, tsdu %ld, etsdu %ld, connect %ld", x->epinfo.addr, x->epinfo.options, x->epinfo.tsdu, x->epinfo.etsdu, x->epinfo.connect); post(" discon %ld, servtype %lu, flags %lu", x->epinfo.discon, x->epinfo.servtype, x->epinfo.flags); } r = OTGetEndpointState(x->o_tcp_ep); if (r == T_UNINIT) { post(" Endpoint state: T_UNINIT"); } else if (r == T_UNBND) { post(" Endpoint state: T_UNBND"); } else if (r == T_IDLE) { post(" Endpoint state: T_IDLE"); } else if (r == T_OUTCON) { post(" Endpoint state: T_OUTCON"); } else if (r == T_INCON) { post(" Endpoint state: T_INCON"); } else if (r == T_DATAXFER) { post(" Endpoint state: T_DATAXFER"); } else if (r == T_OUTREL) { post(" Endpoint state: T_OUTREL"); } else if (r == T_INREL) { post(" Endpoint state: T_INREL"); } else { post(" еее Unrecognized endpoints state %ld!", r); } { char hostnameBuf[100]; post(" You asked to write to internet host \"%s\"", x->o_inetHostName); OTInetHostToString(x->o_inetHost, hostnameBuf); post(" Writing to internet host %s", hostnameBuf); post(" Writing to port %ld", (long)( x->o_inetPort)); } post(" This object reads from port %ld", (long) x->o_receiveInetPort); post(" Read buffers: size %ld, %ld bytes in current buffer, %ld bytes in next buffer", x->o_ReadBufSize, x->o_bytesRead, x->o_bytesReadForNextTime); post(" Write buffer: size %ld, read position %ld, write position %ld", x->o_WriteBufSize, x->o_WBReadPos, x->o_WBWritePos); ExitCallback(); }
Analysis::RetType Analysis_State::Analyze() { // Only process as much data as is in the smallest data set. size_t nframes = States_.front().DS().Size(); for (StateArray::const_iterator state = States_.begin(); state != States_.end(); ++state) { if ( state != States_.begin() && nframes != state->DS().Size() ) mprintf("Warning: Set '%s' for state '%s' has a different # of frames (%zu)" " than previous sets (%zu).\n", state->DS().legend(), state->id(), state->DS().Size(), nframes); nframes = std::min( nframes, state->DS().Size() ); } mprintf("\tProcessing %zu frames.\n", nframes); if (nframes < 1) return Analysis::ERR; std::vector<Transition> Status; Status.reserve( States_.size() + 1 ); // +1 for state -1, undefined for (int i = 0; i != (int)States_.size() + 1; i++) { DataSet* ds = masterDSL_->AddSet(DataSet::DOUBLE, MetaData(state_data_->Meta().Name(), "sCurve", i)); if (ds == 0) return Analysis::ERR; if (curveOut_ != 0) curveOut_->AddDataSet( ds ); ds->SetLegend( StateName(i-1) ); Status.push_back( Transition((DataSet_double*)ds) ); } int last_state = -2; size_t last_State_Start = 0; size_t final_frame = nframes - 1; for (size_t frm = 0; frm != nframes; frm++) { // Determine which state we are in. int state_num = -1; for (StateArray::const_iterator state = States_.begin(); state != States_.end(); ++state) { double dVal = state->DS().Dval( frm ); if (dVal >= state->Min() && dVal < state->Max()) { // TODO: Periodic if (state_num != -1) mprintf("Warning: Frame %zu already defined as state '%s', also matches state '%s'.\n", frm, States_[state_num].id(), state->id()); else state_num = (int)(state - States_.begin()); } } state_data_->Add( frm, &state_num ); // Determine if there has been a transition. if (last_state == -2) // First frame, no possible transition yet. last_state = state_num; else if (state_num != last_state || frm == final_frame) { int length = (int)(frm - last_State_Start); if (state_num != last_state) { // There has been a transition from last_state to state_num. StatePair sPair(last_state, state_num); TransMapType::iterator entry = TransitionMap_.find( sPair ); if (entry == TransitionMap_.end()) { // New transition DataSet* ds = masterDSL_->AddSet( DataSet::DOUBLE, MetaData(state_data_->Meta().Name(), "tCurve", TransitionMap_.size()) ); if (ds == 0) return Analysis::ERR; if (curveOut_ != 0) curveOut_->AddDataSet( ds ); ds->SetLegend( StateName(last_state) + "->" + StateName(state_num) ); TransitionMap_.insert( TransPair(sPair, Transition(length, (DataSet_double*)ds)) ); } else // Update previous transition entry->second.Update(length); } // Update single state information. Status[last_state + 1].Update(length); last_State_Start = frm; last_state = state_num; } } // DEBUG: Print single state info. if (debug_ > 0) { mprintf(" States:\n"); mprintf("\t%i: %s max= %i sum= %i n= %i Avg= %g\n", -1, "Undefined", Status.front().Max(), Status.front().Sum(), Status.front().Nlifetimes(), Status.front().Avg()); StateArray::const_iterator state = States_.begin(); for (std::vector<Transition>::const_iterator s = Status.begin() + 1; s != Status.end(); ++s, ++state) mprintf("\t%u: %s max= %i sum= %i n= %i Avg= %g\n", state - States_.begin(), state->id(), s->Max(), s->Sum(), s->Nlifetimes(), s->Avg()); // DEBUG: Print transitions. mprintf(" Transitions:\n"); for (TransMapType::const_iterator trans = TransitionMap_.begin(); trans != TransitionMap_.end(); ++trans) mprintf("\t%i -> %i: max= %i sum= %i n= %i Avg= %g\n", trans->first.first, trans->first.second, trans->second.Max(), trans->second.Sum(), trans->second.Nlifetimes(), trans->second.Avg()); } stateOut_->Printf("%-8s %12s %12s %12s %s\n", "#Index", "N", "Average", "Max", "State"); for (int idx = 0; idx != (int)Status.size(); idx++) stateOut_->Printf("%-8i %12i %12.4f %12i %s\n", idx-1, Status[idx].Nlifetimes(), Status[idx].Avg(), Status[idx].Max(), stateName(idx-1)); transOut_->Printf("%-12s %12s %12s %s\n", "#N", "Average", "Max", "Transition"); for (TransMapType::const_iterator trans = TransitionMap_.begin(); trans != TransitionMap_.end(); ++trans) transOut_->Printf("%-12i %12.4f %12i %s\n", trans->second.Nlifetimes(), trans->second.Avg(), trans->second.Max(), trans->second.DS().legend()); if (normalize_) { for (std::vector<Transition>::const_iterator s = Status.begin(); s != Status.end(); ++s) s->NormalizeCurve(); for (TransMapType::const_iterator trans = TransitionMap_.begin(); trans != TransitionMap_.end(); ++trans) trans->second.NormalizeCurve(); } return Analysis::OK; }
void ximsStart() { int ret; UserSelection *sel = &userSel; OpStateVal oldOpState = OpState; DPR(("ximsStart(): OpState=%s OpErrCode=%s[%d]\n", StateName(), error_name(OpErrCode), OpErrCode)); OpState = State_Start; #ifdef DEBUG if (DebugLvl > 1) pr_UserSelection(sel); #endif ret = NoError; if (oldOpState == State_Select_Err) { /* don't change OpErrCode */ OpState = State_Start_Err; return; } if (oldOpState == State_Select_Canceled) { clear_UserSelection(sel); ret = ErrNoSelection; } else { /* save selection */ if (!(OpFlag & FLAG_NOSAVE) && (sel->flag & F_SELECT_CHANGED)) { if (save_user_selection(sel, NULL) != NoError) { DPR(("save_user_selection(): failed\n")); put_xims_warnmsg(ErrSaveSelection, 0, 0, 0); /* ret = ErrSaveSelection; */ } } } if (ret != NoError) { OpErrCode = ret; OpState = State_Start_Err; return; } if ((ret = check_selection(sel)) != NoError) { if (ret == ErrIsNone || ret == ErrNotRun) { build_run_env(sel); /* for make_new_environ() */ } OpErrCode = ret; OpState = State_Start_Done; return; } build_run_env(sel); if (useWINDOW()) /* initilaize Xt */ init_window_env(); ret = run_ims(sel); OpErrCode = ret; OpState = ret == NoError ? State_Start_Done : State_Start_Err; return; }