//----------------------------------------------------------------------
static void process_operand(op_t &x, bool isload)
{
ea_t ea;
dref_t dref;
if ( is_forced_operand(cmd.ea, x.n) ) return;
switch ( x.type )
{
case o_reg:
case o_phrase:
break;
case o_imm:
if ( !isload ) interr("emu1");
process_immediate_number(x.n);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, OOFS_IFSIGN|OOFW_IMM);
break;
case o_mem:
ea = calc_mem(x.addr);
ua_dodata2(x.offb, ea, x.dtyp);
dref = cmd.itype == I960_lda ? dr_O : isload ? dr_R : dr_W;
ua_add_dref(x.offb, ea, dref);
break;
case o_near:
{
cref_t ftype = fl_JN;
ea = calc_mem(x.addr);
if ( InstrIsSet(cmd.itype, CF_CALL) )
{
flow = func_does_return(ea);
ftype = fl_CN;
}
ua_add_cref(x.offb, ea, ftype);
}
break;
case o_displ:
dref = cmd.itype == I960_lda ? dr_O : isload ? dr_R : dr_W;
process_immediate_number(x.n);
if ( x.reg == IP )
{
ea_t ea = cmd.ea + 8 + x.addr;
ua_add_dref(x.offb, ea, dref);
}
else
{
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dref, OOFS_IFSIGN|OOF_SIGNED|OOF_ADDR|OOFW_32);
}
break;
default:
interr("emu");
}
}
static void handle_operand(op_t &op) {
switch (op.type) {
// code address
case o_near:
{
ea_t ea = toEA(cmd.cs, op.addr);
cref_t mode = fl_JN;
if (cmd.itype == m740_jsr)
{
if ( !func_does_return(ea) )
flow = false;
mode = fl_CN;
}
ua_add_cref(op.offb, ea, mode);
}
break;
// data address
case o_mem:
{
enum dref_t mode = dr_U;
if (is_addr_ind(op)) mode = dr_R; /* NOT dr_O */
else if (is_addr_read(op)) mode = dr_R;
else if (is_addr_write(op)) mode = dr_W;
ua_add_dref(op.offb, toEA(cmd.cs, op.addr), mode);
ua_dodata2(op.offb, op.addr, op.dtyp);
}
break;
// immediate
case o_imm:
handle_imm(op);
// if the value was converted to an offset, then create a data xref:
if (isOff(uFlag, op.n))
ua_add_off_drefs2(op, dr_O, 0);
break;
// displ
case o_displ:
if (isOff(uFlag, op.n)) {
ua_add_off_drefs2(op, dr_O, OOF_ADDR);
ua_dodata2(op.offb, op.addr, op.dtyp);
}
break;
// reg - do nothing
case o_reg:
case o_void:
break;
default:
IDA_ERROR("Invalid op.type in handle_operand()");
}
}
//----------------------------------------------------------------------
static void TouchArg( op_t &x, int isload )
{
switch( x.type )
{
case o_imm:
doImmd(cmd.ea);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, OOF_SIGNED);
break;
case o_indexed: // addr[value]
doImmd(cmd.ea);
if ( x.value == 0 && !isDefArg(uFlag, x.n) )
set_offset(cmd.ea, x.n, toEA(cmd.cs, 0));
if ( isOff(uFlag, x.n) ) // xref to addr
{
uval_t saved = x.value;
x.value = x.addr;
ua_add_off_drefs2(x, saved ? dr_O : isload ? dr_R : dr_W, OOF_SIGNED|OOF_ADDR);
x.value = saved;
}
if ( x.value != 0 ) // xref to value
{ // no references to ZERO_REG
ea_t ea = toEA(cmd.cs, x.value);
ua_add_dref(x.offb, ea, isload ? dr_R : dr_W );
ua_dodata2(x.offb, ea, x.dtyp);
}
break;
case o_indirect:
case o_indirect_inc:
case o_mem:
{
ea_t dea = toEA( cmd.cs, x.addr );
ua_dodata2(x.offb, dea, x.dtyp);
if( !isload )
doVar(dea);
ua_add_dref( x.offb, dea, isload ? dr_R : dr_W );
if ( !isload && (x.addr == 0x14 || x.addr == 0x15) )
{
sel_t wsrval = BADSEL;
if ( cmd.Op2.type == o_imm ) wsrval = sel_t(cmd.Op2.value);
splitSRarea1(cmd.ea, x.addr == 0x14 ? WSR : WSR1, wsrval, SR_auto);
}
}
break;
case o_near:
ea_t ea = toEA( cmd.cs, x.addr );
int iscall = InstrIsSet( cmd.itype, CF_CALL );
ua_add_cref( x.offb, ea, iscall ? fl_CN : fl_JN );
if ( flow && iscall )
flow = func_does_return(ea);
}
}
//----------------------------------------------------------------------
static void TouchArg(op_t &x,int isAlt,int isload)
{
switch ( x.type )
{
case o_reg:
case o_phrase:
case o_port:
break;
case o_imm:
if ( !isload ) goto badTouch;
doImmdValue(x.n);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, OOF_SIGNED);
break;
case o_displ:
doImmdValue(x.n);
if ( isAlt ) break;
if ( isOff(uFlag, x.n) )
{
ua_add_off_drefs2(x, isload ? dr_R : dr_W, OOF_ADDR);
ea_t ea = calc_target(cmd.ea+x.offb, cmd.ea, x.n, x.addr);
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isload )
doVar(ea);
}
break;
case o_near:
{
cref_t ftype = fl_JN;
ea_t ea = toEA(cmd.cs, x.addr);
if ( InstrIsSet(cmd.itype, CF_CALL) )
{
if ( !func_does_return(ea) )
flow = false;
ftype = fl_CN;
}
ua_add_cref(x.offb, ea, ftype);
}
break;
case o_mem:
{
ea_t ea = toEA(dataSeg(), x.addr);
ua_add_dref(x.offb, ea, isload ? dr_R : dr_W);
}
break;
default:
badTouch:
if ( cmd.itype != AVR_lpm && cmd.itype != AVR_elpm )
warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
}
//----------------------------------------------------------------------
static void process_operand(op_t &x,int isAlt,int isload)
{
switch ( x.type )
{
case o_reg:
break;
default:
// interr("emu");
break;
case o_imm:
// if ( !isload ) interr("emu2");
process_immediate_number(x.n);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, x.amode & amode_signed ? OOF_SIGNED : 0);
break;
case o_phrase:
if ( !isAlt && isOff(uFlag, x.n) )
{
ua_add_off_drefs2(x, isload ? dr_R : dr_W, OOF_ADDR);
ea_t ea = calc_target(cmd.ea+x.offb, cmd.ea, x.n, x.addr);
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isload ) doVar(ea);
}
break;
case o_mem:
{
ea_t ea = calc_mem(x);
ua_add_dref(x.offb, ea, isload ? dr_R : dr_W);
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isload ) doVar(ea);
}
break;
case o_near:
add_near_ref(x, calc_mem(x));
break;
case o_textphrase:
break;
case o_local: // local variables
if ( may_create_stkvars() )
{
func_t *pfn = get_func(cmd.ea);
if ( (pfn != NULL) && (pfn->flags & FUNC_FRAME) && ua_stkvar2(x, x.addr, STKVAR_VALID_SIZE) )
op_stkvar(cmd.ea, x.n);
}
break;
}
}
static void TouchArg( op_t &x, int isload )
{
switch( x.type )
{
case o_imm:
case o_displ:
if ( isOff(uFlag, x.n) ) ua_add_off_drefs(x, dr_O);
break;
case o_mem:
case o_ind_mem:
{
ulong dea = intmem + x.addr;
ua_dodata( dea, x.dtyp );
if( !isload ) doVar( dea );
ua_add_dref( x.offb, dea, isload ? dr_R : dr_W );
}
break;
case o_near:
ulong ea = toEA( cmd.cs, x.addr );
int iscall = InstrIsSet( cmd.itype, CF_CALL );
ua_add_cref( x.offb, ea, iscall ? fl_CN : fl_JN );
if( flow && iscall )
{
if ( !func_does_return(ea) )
flow = false;
}
}
}
static void TouchArg( op_t &x, int isload )
{
switch( x.type )
{
case o_displ:
case o_imm:
if ( isOff(uFlag, x.n) )
{
int outf = x.type != o_imm ? OOF_ADDR : 0;
ua_add_off_drefs2(x, dr_O, outf|OOF_SIGNED);
}
break;
case o_mem:
case o_ind_mem:
{
ea_t dea = intmem + x.addr;
ua_dodata2(x.offb, dea, x.dtyp);
if( !isload )
doVar( dea );
ua_add_dref( x.offb, dea, isload ? dr_R : dr_W );
}
break;
case o_near:
ea_t ea = toEA( cmd.cs, x.addr );
int iscall = InstrIsSet( cmd.itype, CF_CALL );
ua_add_cref( x.offb, ea, iscall ? fl_CN : fl_JN );
if( flow && iscall )
{
if ( !func_does_return(ea) )
flow = false;
}
}
}
CpuAction *CpuCas01::sleep(double duration)
{
if (duration > 0)
duration = MAX(duration, sg_surf_precision);
XBT_IN("(%s,%g)", getName(), duration);
CpuCas01Action *action = new CpuCas01Action(getModel(), 1.0, isOff(), speed_.scale * speed_.peak, getConstraint());
// FIXME: sleep variables should not consume 1.0 in lmm_expand
action->maxDuration_ = duration;
action->suspended_ = 2;
if (duration == NO_MAX_DURATION) {
/* Move to the *end* of the corresponding action set. This convention is used to speed up update_resource_state */
action->getStateSet()->erase(action->getStateSet()->iterator_to(*action));
action->stateSet_ = static_cast<CpuCas01Model*>(getModel())->p_cpuRunningActionSetThatDoesNotNeedBeingChecked;
action->getStateSet()->push_back(*action);
}
lmm_update_variable_weight(getModel()->getMaxminSystem(), action->getVariable(), 0.0);
if (getModel()->getUpdateMechanism() == UM_LAZY) { // remove action from the heap
action->heapRemove(getModel()->getActionHeap());
// this is necessary for a variable with weight 0 since such variables are ignored in lmm and we need to set its
// max_duration correctly at the next call to share_resources
getModel()->getModifiedSet()->push_front(*action);
}
XBT_OUT();
return action;
}
void ElidedLabel::paintEvent(QPaintEvent* e)
{
QFrame::paintEvent(e);
if(rect().width() <= 0 || rect().height() <= 0)
return;
QPainter painter(this);
const QRect r = rect();
const QRect ar = r.adjusted(1, 1, -1, -1);
ItemBackgroundPainter ibp;
ibp.drawBackground(&painter, r, palette(), 1, 1, !hasOffMode() || !isOff() ? r : QRect());
if (hasFocus())
{
if (_hovered)
painter.setPen(QPen(QColor(239,239,239)));
else
painter.setPen(QPen(Qt::white));
}
else if (_hovered)
painter.setPen(QPen(QColor(48,48,48)));
else
painter.setPen(QPen(Qt::black));
painter.setRenderHint(QPainter::Antialiasing);
painter.setFont(_curFont);
QFontMetrics fm = painter.fontMetrics();
QString elidedText = fm.elidedText(_text, _elideMode, r.width());
// painter.drawText(QPoint(0, fm.ascent()), elidedText);
painter.drawText(ar, _alignment, elidedText);
}
StorageAction *StorageN11::open(const char* mount, const char* path)
{
XBT_DEBUG("\tOpen file '%s'",path);
sg_size_t size, *psize;
psize = (sg_size_t*) xbt_dict_get_or_null(content_, path);
// if file does not exist create an empty file
if(psize)
size = *psize;
else {
psize = xbt_new(sg_size_t,1);
size = 0;
*psize = size;
xbt_dict_set(content_, path, psize, nullptr);
XBT_DEBUG("File '%s' was not found, file created.",path);
}
surf_file_t file = xbt_new0(s_surf_file_t,1);
file->name = xbt_strdup(path);
file->size = size;
file->mount = xbt_strdup(mount);
file->current_position = 0;
StorageAction *action = new StorageN11Action(getModel(), 0, isOff(), this, OPEN);
action->p_file = file;
return action;
}
CpuAction *CpuCas01::execution_start(double size)
{
XBT_IN("(%s,%g)", getName(), size);
CpuCas01Action *action = new CpuCas01Action(getModel(), size, isOff(), speed_.scale * speed_.peak, getConstraint());
XBT_OUT();
return action;
}
void Light::_blink() {
if(isOn() && _shouldBlinkOff()) {
_blinkOff();
}
else if(isOff() && _shouldBlinkOn()) {
_blinkOn();
}
}
StorageAction *StorageN11::write(surf_file_t fd, sg_size_t size)
{
char *filename = fd->name;
XBT_DEBUG("\tWrite file '%s' size '%llu/%llu'",filename,size,fd->size);
StorageAction *action = new StorageN11Action(getModel(), size, isOff(), this, WRITE);
action->p_file = fd;
/* Substract the part of the file that might disappear from the used sized on the storage element */
usedSize_ -= (fd->size - fd->current_position);
// If the storage is full before even starting to write
if(usedSize_==size_) {
action->setState(Action::State::failed);
}
return action;
}
StorageAction *StorageN11::read(surf_file_t fd, sg_size_t size)
{
if(fd->current_position + size > fd->size){
if (fd->current_position > fd->size){
size = 0;
} else {
size = fd->size - fd->current_position;
}
fd->current_position = fd->size;
}
else
fd->current_position += size;
StorageAction *action = new StorageN11Action(getModel(), size, isOff(), this, READ);
return action;
}
void Light::_min() {
if(_shouldBeMin()) {
if(!isOff()) {
off(false); // don't stop everything
}
}
else {
if(!_forever) {_times--;}
if(_times == 0 && !_forever) {
_stopFading();
}
else {
_up_timer.restart();
_state = _RISING;
}
}
}
//----------------------------------------------------------------------
static bool TouchArg(op_t &x,int isload)
{
dref_t xreftype;
uchar outf;
switch ( x.type )
{
case o_phrase: // 2 registers
case o_reg:
break;
case o_imm:
if ( ! isload ) goto badTouch;
xreftype = dr_O;
outf = OOF_SIGNED;
goto makeImm;
case o_displ:
xreftype = isload ? dr_R : dr_W;
outf = OOF_SIGNED|OOF_ADDR;
makeImm:
doImmdValue();
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, xreftype, outf);
break;
case o_mem:
ua_dodata2(x.offb, x.addr, x.dtyp);
if ( !isload )
doVar(x.addr);
ua_add_dref(x.offb,x.addr,isload ? dr_R : dr_W);
break;
case o_near:
{
int iscall = InstrIsSet(cmd.itype,CF_CALL);
ua_add_cref(x.offb,x.addr,iscall ? fl_CN : fl_JN);
if ( iscall && !func_does_return(x.addr) )
return false;
}
break;
default:
badTouch:
warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
return true;
}
void CpuCas01::apply_event(tmgr_trace_iterator_t event, double value)
{
if (event == speed_.event) {
/* TODO (Hypervisor): do the same thing for constraint_core[i] */
xbt_assert(coresAmount_ == 1, "FIXME: add speed scaling code also for constraint_core[i]");
speed_.scale = value;
onSpeedChange();
tmgr_trace_event_unref(&speed_.event);
} else if (event == stateEvent_) {
/* TODO (Hypervisor): do the same thing for constraint_core[i] */
xbt_assert(coresAmount_ == 1, "FIXME: add state change code also for constraint_core[i]");
if (value > 0) {
if(isOff())
host_that_restart.push_back(getHost());
turnOn();
} else {
lmm_constraint_t cnst = getConstraint();
lmm_variable_t var = nullptr;
lmm_element_t elem = nullptr;
double date = surf_get_clock();
turnOff();
while ((var = lmm_get_var_from_cnst(getModel()->getMaxminSystem(), cnst, &elem))) {
Action *action = static_cast<Action*>(lmm_variable_id(var));
if (action->getState() == Action::State::running ||
action->getState() == Action::State::ready ||
action->getState() == Action::State::not_in_the_system) {
action->setFinishTime(date);
action->setState(Action::State::failed);
}
}
}
tmgr_trace_event_unref(&stateEvent_);
} else {
xbt_die("Unknown event!\n");
}
}
StorageAction *StorageN11::close(surf_file_t fd)
{
XBT_DEBUG("\tClose file '%s' size '%llu'", fd->name, fd->size);
// unref write actions from storage
for (std::vector<StorageAction*>::iterator it = writeActions_.begin(); it != writeActions_.end();) {
StorageAction *write_action = *it;
if ((write_action->p_file) == fd) {
write_action->unref();
it = writeActions_.erase(it);
} else {
++it;
}
}
free(fd->name);
free(fd->mount);
xbt_free(fd);
StorageAction *action = new StorageN11Action(getModel(), 0, isOff(), this, CLOSE);
return action;
}
//----------------------------------------------------------------------
static void SaveArg(op_t &x)
{
switch ( x.type )
{
case o_reg:
{
// if ( x.reg == R_sp ) return;
// AbstractRegister *out = &i5_getreg(x.reg);
// if ( ! isDef(r) ) {
// out->undef();
// } else {
// out->doInt(r.value());
// }
return;
}
case o_mem:
{
ea_t ea = toEA(dataSeg_op(x.n),x.addr);
ua_dodata2(x.offb, ea, x.dtyp);
doVar(ea);
ua_add_dref(x.offb,ea,dr_W);
}
break;
case o_displ:
doImmdValue(x.n);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_W, OOF_ADDR);
case o_phrase:
break;
default:
switch ( cmd.itype )
{
case Z80_in0:
case Z80_outaw:
break;
default:
// warning("%a: %s,%d: bad save optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
break;
}
}
//----------------------------------------------------------------------
static void TouchArg(op_t &x,int isload)
{
switch ( x.type )
{
case o_regpair:
case o_reg:
case o_phrase:
break;
case o_imm:
if ( !isload ) goto badTouch;
/* no break */
case o_displ:
doImmdValue(x.n);
if ( isOff(uFlag, x.n) ) ua_add_off_drefs(x, dr_O);
break;
case o_near:
ua_add_cref(x.offb,toEA(cmd.cs,x.addr),fl_JN);
break;
default:
badTouch:
warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
}
//----------------------------------------------------------------------
static void TouchArg(op_t &x,int isload)
{
switch ( x.type )
{
case o_regpair:
case o_reg:
case o_phrase:
case o_spmask:
case o_stgcyc:
break;
case o_imm:
if ( !isload ) goto badTouch;
/* no break */
case o_displ:
doImmdValue(x.n);
if ( isOff(uFlag, x.n) )
{
int outf = x.type != o_imm ? OOF_ADDR : 0;
if ( x.dtyp == dt_word )
outf |= OOF_SIGNED;
ua_add_off_drefs2(x, dr_O, outf);
}
break;
case o_near:
{
ea_t ea = toEA(cmd.cs,x.addr);
ea_t ref = find_first_insn_in_packet(ea);
ua_add_cref(x.offb, ref, fl_JN);
}
break;
default:
badTouch:
warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
}
//----------------------------------------------------------------------
static void TouchArg(op_t &x,int isload)
{
ea_t ea;
switch ( x.type )
{
case o_phrase: // 2 registers or indirect addressing
if ( cmd.itype != TMS_mar && cmd.itype != TMS2_mar
&& find_ar(&ea) ) goto set_dref;
case o_reg:
case o_bit:
case o_cond:
break;
case o_imm:
if ( ! isload ) goto badTouch;
doImmdValue();
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, is_mpy() ? OOF_SIGNED : 0);
break;
case o_mem:
ea = toEA(dataSeg_op(x.n),x.addr);
set_dref:
ua_dodata2(x.offb, ea, x.dtyp);
if ( ! isload )
doVar(ea);
ua_add_dref(x.offb,ea,isload ? dr_R : dr_W);
if ( x.type == o_mem )
if ( cmd.itype == TMS_dmov ||
cmd.itype == TMS_ltd ||
cmd.itype == TMS_macd ||
cmd.itype == TMS_madd ||
cmd.itype == TMS2_dmov ||
cmd.itype == TMS2_macd ) ua_add_dref(x.offb,ea+1,dr_W);
break;
case o_near:
{
ea_t segbase = codeSeg(x.addr, x.n);
ea = toEA(segbase, x.addr);
if ( cmd.itype == TMS_blpd ||
cmd.itype == TMS_mac ||
cmd.itype == TMS_macd ||
cmd.itype == TMS2_blkp ||
cmd.itype == TMS2_mac ||
cmd.itype == TMS2_macd
) goto set_dref;
uval_t thisseg = cmd.cs;
int iscall = InstrIsSet(cmd.itype,CF_CALL);
if ( cmd.itype == TMS_rptb && isTail(get_flags_novalue(ea)) )
{
// small hack to display end_loop-1 instead of before_end_loop+1
ea++;
}
ua_add_cref(x.offb,
ea,
iscall ? ((segbase == thisseg) ? fl_CN : fl_CF)
: ((segbase == thisseg) ? fl_JN : fl_JF));
if ( iscall )
{
if ( !func_does_return(ea) )
flow = false;
}
}
break;
default:
badTouch:
warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
}
CpuAction *CpuCas01::execution_start(double size)
{
return new CpuCas01Action(getModel(), size, isOff(), speed_.scale * speed_.peak, getConstraint());
}
//----------------------------------------------------------------------
// поставим использование/изменение операндов
static void near TouchArg(op_t &x,int isAlt,int isload)
{
ea_t ea = toEA(codeSeg(x.addr,x.n), x.addr);
switch ( x.type ) {
// эта часть не используется !
case o_void: break;
// тут тоже нечего делать
case o_reg: break;
// непосредственный операнд
case o_imm: // непосредственный не может меняться
if ( ! isload ) goto badTouch;
// поставим флажок непосредственного операнда
doImmd(cmd.ea);
// если не форсирован и помечен смещением
if ( !isAlt && isOff(uFlag,x.n) )
// это смещение !
ua_add_dref(x.offb,ea,dr_O);
break;
// переход или вызов
case o_near: // это вызов ? (или переход)
if(InstrIsSet(cmd.itype,CF_CALL)){
// поставим ссылку на код
ua_add_cref(x.offb,ea,fl_CN);
// это функция без возврата ?
#if IDP_INTERFACE_VERSION > 37
flow = func_does_return(ea);
#else
// получим описатель функции
func_t *pfn = get_func(ea);
// если функция описана и не имеет возврата - остановим
if(pfn != NULL && (pfn->flags & FUNC_NORET) ) flow = false;
#endif
}
else ua_add_cref(x.offb,ea,fl_JN);
break;
// ссылка на ячейку памяти
case o_mem: // сделаем данные по указанному адресу
ua_dodata2(x.offb, ea, x.dtyp);
// если изменяется - поставим переменную
if ( ! isload ) doVar(ea);
// добавим ссылку на память
ua_add_dref(x.offb,ea,isload ? dr_R : dr_W);
break;
// прочее - сообщим ошибку
default:
badTouch:
#if IDP_INTERFACE_VERSION > 37
warning("%a %s,%d: bad optype %d",
cmd.ea, cmd.get_canon_mnem(),
#else
warning("%08lX %s,%d: bad optype (%x)",
cmd.ea,(char far *)Instructions[cmd.itype].name,
#endif
x.n, x.type);
break;
}
}
void Storage::turnOn() {
if (isOff()) {
Resource::turnOn();
storageStateChangedCallbacks(this, 0, 1);
}
}
void Link::turnOn(){
if (isOff()) {
Resource::turnOn();
onStateChange(this);
}
}
//----------------------------------------------------------------------
// вывод одного операнда
bool N78K_outop(op_t &x)
{
#if IDP_INTERFACE_VERSION <= 37
uFlag = getFlags(cmd.ea);
#endif
switch(x.type){
case o_void: return 0;
case o_reg:
if(x.FormOut & FORM_OUT_SKOBA) out_symbol('[');
OutReg(x.reg);
if(x.FormOut & FORM_OUT_PLUS) out_symbol('+');
if(x.FormOut & FORM_OUT_DISP){
if(isOff(uFlag, x.n)){
OutVarNameVal(x);
}
else OutValue(x, OOFW_IMM );
}
if(x.FormOut & FORM_OUT_REG){
out_keyword( ph.regNames[x.SecondReg] );
}
if(x.FormOut & FORM_OUT_SKOBA) out_symbol(']');
break;
case o_bit:
switch(x.FormOut){
case FORM_OUT_S_ADDR:
case FORM_OUT_SFR:
OutVarName(x);
out_symbol('.');
#if IDP_INTERFACE_VERSION > 37
if( !nec_find_ioport_bit(x.addr, x.value) )
#endif
{
OutValue(x, OOFW_IMM);
}
break;
case FORM_OUT_A:
OutLine("A.");
OutValue(x, OOFW_IMM);
break;
case FORM_OUT_PSW:
OutLine("PSW.");
switch(x.value){
case 0: OutLine("CY");break;
case 1: OutLine("ISP");break;
case 3: OutLine("RBS0");break;
case 4: OutLine("AC");break;
case 5: OutLine("RBS1");break;
case 6: OutLine("Z");break;
case 7: OutLine("IE");break;
default:OutValue(x, OOFW_IMM);
}
break;
case FORM_OUT_HL:
out_symbol('[');
OutReg(rHL);
out_symbol(']');
out_symbol('.');
if(isOff(uFlag, x.n)){
OutVarNameVal(x);
}
else OutValue(x, OOFW_IMM );
break;
}
break;
case o_imm:
out_symbol('#');
if(isOff(uFlag, x.n)){
OutVarNameVal(x);
}
else OutValue(x, OOFW_IMM );
break;
case o_mem:
//выводит имя переменной из памяти(например byte_98)
if(x.FormOut & FORM_OUT_VSK) out_symbol('!');
if(x.FormOut & FORM_OUT_SKOBA) out_symbol('[');
//Вывод имени переменной
OutVarName(x);
if(x.FormOut & FORM_OUT_SKOBA) out_symbol(']');
break;
case o_near:
if(x.FormOut & FORM_OUT_VSK) out_symbol('!');
if(x.FormOut & FORM_OUT_SKOBA) out_symbol('[');
{
ulong adr;
adr = toEA(codeSeg(x.addr,x.n),x.addr);
#if IDP_INTERFACE_VERSION > 37
if( !out_name_expr(x, adr, x.addr)){
OutValue(x, OOF_ADDR | OOF_NUMBER | OOFW_16);
QueueMark(Q_noName, cmd.ea);
}
#else
{const char *ptr;
ptr=get_name_expr(cmd.ea+x.offb, adr, x.addr);
if( ptr == NULL ){
OutValue(x, OOF_ADDR | OOF_NUMBER | OOFW_16);
QueueMark(Q_noName, cmd.ea);
}
else OutLine(ptr);
}
#endif
}
if(x.FormOut & FORM_OUT_SKOBA) out_symbol(']');
break;
// неизвестный операнд
default: warning("out: %lx: bad optype",cmd.ea,x.type);
break;
}
return(1);
}
//----------------------------------------------------------------------
static int LoadArg(op_t &x)
{
dref_t xreftype;
switch ( x.type ) {
case o_reg:
{
if ( x.reg == R_sp ) goto Undefined;
// AbstractRegister *in = &i5_getreg(x.reg);
// if ( ! in->isDef() ) goto Undefined;
// r.doInt(in->value());
return 1;
}
case o_imm:
// r.doInt(unsigned(x.value));
xreftype = dr_O;
MakeImm:
doImmdValue(x.n);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, xreftype, 0);
return 1;
case o_displ:
// r.undef();
xreftype = dr_R;
goto MakeImm;
case o_mem:
{
ea_t ea = toEA(dataSeg_op(x.n),x.addr);
ua_add_dref(x.offb,ea,dr_R);
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isVar(get_flags_novalue(ea)) && isLoaded(ea) )
{
// r.doInt( x.dtyp != dt_byte ? get_word(ea) : char(get_byte(ea)) );
return 1;
}
}
case o_phrase:
Undefined:
// r.undef();
break;
case o_near:
{
ea_t segbase = codeSeg(x.addr,x.n);
ea_t ea = toEA(segbase,x.addr);
ea_t thisseg = cmd.cs;
int iscall = InstrIsSet(cmd.itype,CF_CALL);
ua_add_cref(x.offb,
ea,
iscall ? ((segbase == thisseg) ? fl_CN : fl_CF)
: ((segbase == thisseg) ? fl_JN : fl_JF));
if ( iscall && !func_does_return(ea) )
flow = false;
// r.doInt(unsigned(x.addr));
}
return 1;
default:
// warning("%a: %s,%d: bad load optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
return 0;
}
void StreamWatch::usherReply(QNetworkReply *reply)
{
if(reply->error() != QNetworkReply::NoError)
{
textEdit->setText("usher get error!");
retryTimer->start();
randomError();
return;
}
int code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if(code >= 300 && code <= 310)
{
textEdit->setText(QString("Usher redirected to") + reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toString());
QNetworkRequest req(reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toString());
QNetworkReply *reply = nam->get(req);
connect(reply, &QNetworkReply::finished, this, [this, reply]()
{
usherReply(reply);
});
return;
}
if(code != 200)
{
textEdit->setText("Get usher failed: Error" + code);
retryTimer->start();
randomError();
return;
}
QString m3u8 = QString::fromUtf8(reply->readAll());
if(m3u8.trimmed() == "[]")
{
textEdit->setText("m3u8 is empty, channel likely not live, retrying in 30 seconds");
isOff();
retryTimer->start();
return;
}
QStringList lines = m3u8.split('\n');
for(const QString &line: lines)
{
QString tline = line.trimmed();
if(tline.startsWith("http"))
{
textEdit->setText(m3u8);
isOn();
return;
}
}
textEdit->setText("no channel found in m3u8, retrying in 30 seconds");
retryTimer->start();
randomError();
}
// Emulate an operand.
static void handle_operand(op_t &op, bool write) {
switch ( op.type ) {
// Code address
case o_near:
{
cref_t mode;
ea_t ea = toEA(cmd.cs, op.addr);
// call or jump ?
if ( cmd.itype == st9_call || cmd.itype == st9_calls )
{
if ( !func_does_return(ea) )
flow = false;
mode = fl_CN;
}
else
{
mode = fl_JN;
}
ua_add_cref(op.offb, ea, mode);
}
break;
// Memory address
case o_mem:
{
enum dref_t mode;
mode = write ? dr_W: dr_R;
ua_add_dref(op.offb, toEA(cmd.cs, op.addr), mode);
ua_dodata2(op.offb, op.addr, op.dtyp);
}
break;
// Immediate value
case o_imm:
doImmd(cmd.ea);
// create a comment if this immediate is represented in the .cfg file
{
const ioport_t * port = find_sym(op.value);
if ( port != NULL && !has_cmt(uFlag) ) {
set_cmt(cmd.ea, port->cmt, false);
}
}
// if the value was converted to an offset, then create a data xref:
if ( isOff(uFlag, op.n) )
ua_add_off_drefs2(op, dr_O, 0);
break;
// Displacement
case o_displ:
doImmd(cmd.ea);
if ( isOff(uFlag, op.n) ) {
ua_add_off_drefs2(op, dr_O, OOF_ADDR);
ua_dodata2(op.offb, op.addr, op.dtyp);
}
// create stack variables if required
if ( may_create_stkvars() && !isDefArg(uFlag, op.n) ) {
func_t *pfn = get_func(cmd.ea);
if ( pfn != NULL && pfn->flags & FUNC_FRAME ) {
if ( ua_stkvar2(op, op.addr, STKVAR_VALID_SIZE) ) {
op_stkvar(cmd.ea, op.n);
if ( cmd.Op2.type == o_reg ) {
regvar_t *r = find_regvar(pfn, cmd.ea, ph.regNames[cmd.Op2.reg]);
if ( r != NULL ) {
struc_t *s = get_frame(pfn);
member_t *m = get_stkvar(op, op.addr, NULL);
char b[20];
qsnprintf(b, sizeof b, "%scopy", r->user);
set_member_name(s, m->soff, b);
}
}
}
}
}
break;
// Register - Phrase - Void: do nothing
case o_reg:
case o_phrase:
case o_void:
break;
default:
IDA_ERROR("Invalid op.type in handle_operand()");
}
}
