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;
}
