//--------------------------------------------------------------------------
static void read_dyninfo(ulong offset, ulong size)
{
qlseek(li, offset);
const int entsize = elf64 ? sizeof(Elf64_Dyn) : sizeof(Elf32_Dyn);
for(int i = 1; i < size; i += entsize )
{
Elf64_Dyn dyn;
if ( elf64 )
{
if(lread8bytes(li, &dyn.d_tag, mf) ||
lread8bytes(li, &dyn.d_un, mf)) errstruct();
}
else
{
ulong tag, val;
if(lread4bytes(li, &tag, mf) ||
lread4bytes(li, &val, mf)) errstruct();
dyn.d_tag = tag;
dyn.d_un = val;
}
switch ( WC4(dyn.d_tag) )
{
case DT_STRTAB:
dynstr_off = map_ea(dyn.d_un);
break;
case DT_SYMTAB:
dynsym_off = map_ea(dyn.d_un);
break;
case DT_REL:
dynrel_off = map_ea(dyn.d_un);
break;
case DT_RELA:
dynrela_off = map_ea(dyn.d_un);
break;
case DT_STRSZ:
dynstr_size = ulong(dyn.d_un);
break;
case DT_RELSZ:
dynrel_size = ulong(dyn.d_un);
break;
case DT_RELASZ:
dynrela_size = ulong(dyn.d_un);
break;
}
}
ulong off = dynstr_off;
if ( dynrel_off ) off = qmin(dynrel_off, off);
if ( dynrela_off ) off = qmin(dynrela_off, off);
dynsym_size = off - dynsym_off;
}
/*
* ========================
* Z_Realloc
* ========================
*/
void *
Z_Realloc(const void *ptr, int size)
{
memblock_t *block;
int orig_size;
void *ret;
if (!ptr)
return Z_Malloc(size);
block = (memblock_t *)((byte *)ptr - sizeof(memblock_t));
if (block->id != ZONEID)
Sys_Error("%s: realloced a pointer without ZONEID", __func__);
if (!block->tag)
Sys_Error("%s: realloced a freed pointer", __func__);
orig_size = block->size;
orig_size -= sizeof(memblock_t);
orig_size -= 4;
Z_Free(ptr);
ret = Z_TagMalloc(size, 1);
if (!ret)
Sys_Error("%s: failed on allocation of %i bytes", __func__, size);
if (ret != ptr)
memmove(ret, ptr, qmin(orig_size, size));
return ret;
}
//---------------------------------------------------------------------------
uchar putVal(const op_t &x, uchar mode, uchar warn)
{
char *ptr = get_output_ptr();
{
flags_t sv_uFlag = uFlag;
uFlag = 0;
OutValue(x, mode);
uFlag = sv_uFlag;
}
char str[MAXSTR];
char *end = set_output_ptr(ptr);
size_t len = end - ptr;
qstrncpy(str, ptr, qmin(len+1, sizeof(str)));
if ( warn )
out_tagon(COLOR_ERROR);
if ( warn )
len = tag_remove(str, str, 0);
else
len = tag_strlen(str);
if ( chkOutLine(str, len) )
return 0;
if ( warn )
out_tagoff(COLOR_ERROR);
return 1;
}
static void idaapi s_py_get_user_defined_prefix(
ea_t ea,
int lnnum,
int indent,
const char *line,
char *buf,
size_t bufsize)
{
PYW_GIL_GET;
newref_t py_ret(
PyObject_CallFunction(
py_get_user_defined_prefix,
PY_FMT64 "iis" PY_FMT64,
ea, lnnum, indent, line, bufsize));
// Error? Display it
// No error? Copy the buffer
if ( !PyW_ShowCbErr("py_get_user_defined_prefix") )
{
Py_ssize_t py_len;
char *py_str;
if ( PyString_AsStringAndSize(py_ret.o, &py_str, &py_len) != -1 )
{
memcpy(buf, py_str, qmin(bufsize, py_len));
if ( py_len < bufsize )
buf[py_len] = '\0';
}
}
}
/*!
Get min joint values.
\return Minimal joint values for the 4 dof
X, Y, A, B. Translation Y is expressed in meters. Rotations
X,A and B in radians.
*/
vpColVector
vpAfma4::getJointMin() const
{
vpColVector qmin(4);
for (unsigned int i=0; i < 4; i ++)
qmin[i] = this->_joint_min[i];
return qmin;
}
static int
ntb_transport_setup_qp_mw(struct ntb_transport_ctx *nt, unsigned int qp_num)
{
struct ntb_transport_qp *qp = &nt->qp_vec[qp_num];
struct ntb_transport_mw *mw;
void *offset;
ntb_q_idx_t i;
size_t rx_size;
unsigned num_qps_mw, mw_num, mw_count;
mw_count = nt->mw_count;
mw_num = QP_TO_MW(nt, qp_num);
mw = &nt->mw_vec[mw_num];
if (mw->virt_addr == NULL)
return (ENOMEM);
if (nt->qp_count % mw_count && mw_num + 1 < nt->qp_count / mw_count)
num_qps_mw = nt->qp_count / mw_count + 1;
else
num_qps_mw = nt->qp_count / mw_count;
rx_size = mw->xlat_size / num_qps_mw;
qp->rx_buff = mw->virt_addr + rx_size * (qp_num / mw_count);
rx_size -= sizeof(struct ntb_rx_info);
qp->remote_rx_info = (void*)(qp->rx_buff + rx_size);
/* Due to house-keeping, there must be at least 2 buffs */
qp->rx_max_frame = qmin(rx_size / 2,
transport_mtu + sizeof(struct ntb_payload_header));
qp->rx_max_entry = rx_size / qp->rx_max_frame;
qp->rx_index = 0;
qp->remote_rx_info->entry = qp->rx_max_entry - 1;
/* Set up the hdr offsets with 0s */
for (i = 0; i < qp->rx_max_entry; i++) {
offset = (void *)(qp->rx_buff + qp->rx_max_frame * (i + 1) -
sizeof(struct ntb_payload_header));
memset(offset, 0, sizeof(struct ntb_payload_header));
}
qp->rx_pkts = 0;
qp->tx_pkts = 0;
qp->tx_index = 0;
return (0);
}
//--------------------------------------------------------------------------
static int parse_dyninfo(const dyninfo_t &dyninfo)
{
for ( int i=0; i < dyninfo.size(); i++ )
{
const Elf64_Dyn &dyn = dyninfo[i];
switch ( dyn.d_tag )
{
case DT_STRTAB:
dynstr_off = map_ea(dyn.d_un);
break;
case DT_SYMTAB:
dynsym_off = map_ea(dyn.d_un);
break;
case DT_REL:
dynrel_off = map_ea(dyn.d_un);
break;
case DT_RELA:
dynrela_off = map_ea(dyn.d_un);
break;
case DT_STRSZ:
dynstr_size = uint32(dyn.d_un);
break;
case DT_RELSZ:
dynrel_size = uint32(dyn.d_un);
break;
case DT_RELASZ:
dynrela_size = uint32(dyn.d_un);
break;
}
}
size_t off = dynstr_off;
if ( dynrel_off ) off = qmin(dynrel_off, off);
if ( dynrela_off ) off = qmin(dynrela_off, off);
dynsym_size = off - dynsym_off;
return 0;
}
bool checkURDF2DHForAGivenChain(const KDL::CoDyCo::UndirectedTree& undirectedTree,
const std::string& base_frame,
const std::string& end_effector_frame)
{
KDL::Chain kdl_chain;
iCub::iKin::iKinLimb ikin_limb;
//cerr << "urdf2dh test testing chain extraction between " << base_frame
// << " and " << end_effector_frame << endl;
KDL::Tree kdl_rotated_tree = undirectedTree.getTree(base_frame);
bool result = kdl_rotated_tree.getChain(base_frame,end_effector_frame,kdl_chain);
if( !result )
{
cerr << "urdf2dh: Impossible to find " << base_frame << " or "
<< end_effector_frame << " in the URDF." << endl;
return false;
}
//
// Convert the chain and the limits to an iKin chain (i.e. DH parameters)
//
KDL::JntArray qmin(kdl_chain.getNrOfJoints()),qmax(kdl_chain.getNrOfJoints());
for(size_t i=0; i < qmin.rows(); i++ ) { qmin(i) = -10.0; qmax(i) = 10.0; }
result = iKinLimbFromKDLChain(kdl_chain,ikin_limb,qmin,qmax,1000);
if( !result )
{
cerr << "urdf2dh: Could not export KDL::Tree to iKinChain" << endl;
return false;
}
return checkChainsAreEqual(kdl_chain,ikin_limb);
}
/*
* tunable_mbinit() has to be run before any mbuf allocations are done.
*/
static void
tunable_mbinit(void *dummy)
{
#ifndef __rtems__
quad_t realmem;
/*
* The default limit for all mbuf related memory is 1/2 of all
* available kernel memory (physical or kmem).
* At most it can be 3/4 of available kernel memory.
*/
realmem = qmin((quad_t)physmem * PAGE_SIZE,
vm_map_max(kmem_map) - vm_map_min(kmem_map));
maxmbufmem = realmem / 2;
TUNABLE_QUAD_FETCH("kern.ipc.maxmbufmem", &maxmbufmem);
if (maxmbufmem > realmem / 4 * 3)
maxmbufmem = realmem / 4 * 3;
#else /* __rtems__ */
maxmbufmem = rtems_bsd_get_allocator_domain_size(
RTEMS_BSD_ALLOCATOR_DOMAIN_MBUF);
#endif /* __rtems__ */
TUNABLE_INT_FETCH("kern.ipc.nmbclusters", &nmbclusters);
if (nmbclusters == 0)
nmbclusters = maxmbufmem / MCLBYTES / 4;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbop", &nmbjumbop);
if (nmbjumbop == 0)
nmbjumbop = maxmbufmem / MJUMPAGESIZE / 4;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbo9", &nmbjumbo9);
if (nmbjumbo9 == 0)
nmbjumbo9 = maxmbufmem / MJUM9BYTES / 6;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbo16", &nmbjumbo16);
if (nmbjumbo16 == 0)
nmbjumbo16 = maxmbufmem / MJUM16BYTES / 6;
/*
* We need at least as many mbufs as we have clusters of
* the various types added together.
*/
TUNABLE_INT_FETCH("kern.ipc.nmbufs", &nmbufs);
if (nmbufs < nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16)
nmbufs = lmax(maxmbufmem / MSIZE / 5,
nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16);
}
//----------------------------------------------------------------------
bool jump_pattern_t::match(ea_t ea)
{
// unfortunately we can not do this in the constructor
check[0x00] = &jump_pattern_t::jpi0;
check[0x01] = &jump_pattern_t::jpi1;
check[0x02] = &jump_pattern_t::jpi2;
check[0x03] = &jump_pattern_t::jpi3;
check[0x04] = &jump_pattern_t::jpi4;
check[0x05] = &jump_pattern_t::jpi5;
check[0x06] = &jump_pattern_t::jpi6;
check[0x07] = &jump_pattern_t::jpi7;
check[0x08] = &jump_pattern_t::jpi8;
check[0x09] = &jump_pattern_t::jpi9;
check[0x0a] = &jump_pattern_t::jpia;
check[0x0b] = &jump_pattern_t::jpib;
check[0x0c] = &jump_pattern_t::jpic;
check[0x0d] = &jump_pattern_t::jpid;
check[0x0e] = &jump_pattern_t::jpie;
check[0x0f] = &jump_pattern_t::jpif;
memset(skip, 0, sizeof(skip));
memset(eas, -1, sizeof(eas));
memset(r, -1, sizeof(r));
eas[0] = ea;
failed = false;
func_t *pfn = get_fchunk(ea);
if ( pfn == NULL )
pfn = get_prev_fchunk(ea);
minea = pfn != NULL ? pfn->startEA : getseg(ea)->startEA;
if ( !(this->*check[0])() )
return false;
while ( *roots )
{
memset(spoiled, 0, sizeof(spoiled));
if ( !follow_tree(eas[0], *roots++) || failed )
return false;
}
ea_t start = eas[0];
for ( int i=1; i < qnumber(eas); i++ )
start = qmin(start, eas[i]);
si.startea = start;
return !failed;
}
/*
* tunable_mbinit() has to be run before any mbuf allocations are done.
*/
static void
tunable_mbinit(void *dummy)
{
quad_t realmem, maxmbufmem;
/*
* The default limit for all mbuf related memory is 1/2 of all
* available kernel memory (physical or kmem).
* At most it can be 3/4 of available kernel memory.
*/
realmem = qmin((quad_t)physmem * PAGE_SIZE,
vm_map_max(kernel_map) - vm_map_min(kernel_map));
maxmbufmem = realmem / 2;
TUNABLE_QUAD_FETCH("kern.maxmbufmem", &maxmbufmem);
if (maxmbufmem > realmem / 4 * 3)
maxmbufmem = realmem / 4 * 3;
TUNABLE_INT_FETCH("kern.ipc.nmbclusters", &nmbclusters);
if (nmbclusters == 0)
nmbclusters = maxmbufmem / MCLBYTES / 4;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbop", &nmbjumbop);
if (nmbjumbop == 0)
nmbjumbop = maxmbufmem / MJUMPAGESIZE / 4;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbo9", &nmbjumbo9);
if (nmbjumbo9 == 0)
nmbjumbo9 = maxmbufmem / MJUM9BYTES / 6;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbo16", &nmbjumbo16);
if (nmbjumbo16 == 0)
nmbjumbo16 = maxmbufmem / MJUM16BYTES / 6;
/*
* We need at least as many mbufs as we have clusters of
* the various types added together.
*/
TUNABLE_INT_FETCH("kern.ipc.nmbufs", &nmbufs);
if (nmbufs < nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16)
nmbufs = lmax(maxmbufmem / MSIZE / 5,
nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16);
}
//----------------------------------------------------------------------
uchar putShort(ushort value, uchar wsym)
{
char *p = get_output_ptr();
out_tagon(COLOR_ERROR);
if ( wsym )
OutChar(wsym);
OutLong(value,
#ifdef __debug__
debugmode ? 16 :
#endif
10);
out_tagoff(COLOR_ERROR);
char tmpstr[32];
char *end = set_output_ptr(p);
size_t len = end - p;
qstrncpy(tmpstr, p, qmin(len+1, sizeof(tmpstr)));
return chkOutLine(tmpstr, tag_strlen(tmpstr));
}
//---------------------------------------------------------- main thread ---
void win32_debmod_t::handle_pdb_request()
{
if ( pdbthread.req_kind == 1 )
{
// read input file
bytevec_t cmd;
append_dq(cmd, pdbthread.off_ea);
append_dd(cmd, pdbthread.count);
void *outbuf = NULL;
ssize_t outsize = 0;
// send request to IDA
int rc = send_ioctl(WIN32_IOCTL_READFILE, &cmd[0], cmd.size(), &outbuf, &outsize);
if ( rc == 1 && outbuf != NULL )
{
// OK
size_t copylen = qmin(pdbthread.count, outsize);
memcpy(pdbthread.buffer, outbuf, copylen);
pdbthread.count = copylen;
pdbthread.req_result = true;
}
else
{
pdbthread.req_result = false;
}
if ( outbuf != NULL )
qfree(outbuf);
}
else if ( pdbthread.req_kind == 2 )
{
// read memory
ssize_t rc = _read_memory(ea_t(pdbthread.off_ea), pdbthread.buffer, pdbthread.count);
if ( rc >= 0 )
pdbthread.count = rc;
pdbthread.req_result = rc >= 0;
}
else
{
// unknown request
pdbthread.req_result = false;
}
}
void
SCR_EraseCenterString(void)
{
int y, height;
if (scr_erase_center++ > vid.numpages) {
scr_erase_lines = 0;
return;
}
if (scr_center_lines <= 4)
y = vid.height * 0.35;
else
y = 48;
/* Make sure we don't draw off the bottom of the screen*/
height = qmin(8 * scr_erase_lines, ((int)vid.height) - y - 1);
scr_copytop = 1;
Draw_TileClear(0, y, vid.width, height);
}
/*
* ===================
* Hunk_AllocName
* ===================
*/
void *
Hunk_AllocName(int size, const char *name)
{
hunk_t *h;
#ifdef PARANOID
Hunk_Check();
#endif
if (size < 0)
Sys_Error("%s: bad size: %i", __func__, size);
size = sizeof(hunk_t) + ((size + 15) & ~15);
if (hunk_size - hunk_low_used - hunk_high_used < size) {
/* Sys_Error ("%s: failed on %i bytes", __func__, size); */
#ifdef _WIN32
Sys_Error("Not enough RAM allocated. Try starting using "
"\"-heapsize 16000\" on the command line.");
#else
Sys_Error("Not enough RAM allocated. Try starting using "
"\"-mem 16\" on the command line.");
#endif
}
h = (hunk_t *)(hunk_base + hunk_low_used);
hunk_low_used += size;
Cache_FreeLow(hunk_low_used);
memset(h, 0, size);
h->size = size;
h->sentinal = HUNK_SENTINAL;
memset(h->name, 0, HUNK_NAMELEN);
memcpy(h->name, name, qmin((int)strlen(name), HUNK_NAMELEN));
return (void *)(h + 1);
}
void usepotion(pChar pc, pItem pi)
{
int x;
if ( ! pc ) return;
pPC tmp;
pClient client = (tmp = dynamic_cast<pPC>(pc))? tmp->getClient() : NULL;
switch(pi->morey)
{
case 1: // Agility Potion
staticFX(pc, 0x373A, 0, 15);
switch(pi->morez)
{
case 1:
tempfx::add(pc, pc, tempfx::tmpfxSpellAgility, 5+RandomNum(1,10), 0, 0, 120);
if(client) client->sysmessage("You feel more agile!");
break;
case 2:
tempfx::add(pc, pc, tempfx::tmpfxSpellAgility, 10+RandomNum(1,20), 0, 0, 120);
if(client) client->sysmessage("You feel much more agile!");
break;
default:
SWITCH_FALLOUT;
return;
}
pc->playSFX(0x01E7);
if (s!=INVALID)
pc->updateStamina();
break;
case 2: // Cure Potion
if ( pc->getBody()->getPoisoned() == poisonNone )
if(client) client->sysmessage("The potion had no effect.");
else
{
switch(pi->morez)
{
case 1:
x=RandomNum(1,100);
if (pc->getBody()->getPoisoned() == poisonWeak && x<81) pc->getBody()->setPoisoned(poisonNone);
if (pc->getBody()->getPoisoned() == poisonNormal && x<41) pc->getBody()->setPoisoned(poisonNone);
if (pc->getBody()->getPoisoned() == poisonGreater && x<21) pc->getBody()->setPoisoned(poisonNone);
if (pc->getBody()->getPoisoned() == poisonDeadly && x< 6) pc->getBody()->setPoisoned(poisonNone);
break;
case 2:
x=RandomNum(1,100);
if (pc->getBody()->getPoisoned() == poisonWeak) pc->getBody()->setPoisoned(poisonNone);
if (pc->getBody()->getPoisoned() == poisonNormal && x<81) pc->getBody()->setPoisoned(poisonNone);
if (pc->getBody()->getPoisoned() == poisonGreater && x<41) pc->getBody()->setPoisoned(poisonNone);
if (pc->getBody()->getPoisoned() == poisonDeadly && x<21) pc->getBody()->setPoisoned(poisonNone);
break;
case 3:
x=RandomNum(1,100);
if (pc->getBody()->getPoisoned() == poisonWeak) pc->getBody()->setPoisoned(poisonNone);
if (pc->getBody()->getPoisoned() == poisonNormal) pc->getBody()->setPoisoned(poisonNone);
if (pc->getBody()->getPoisoned() == poisonGreater && x<81) pc->getBody()->setPoisoned(poisonNone);
if (pc->getBody()->getPoisoned() == poisonDeadly && x<61) pc->getBody()->setPoisoned(poisonNone);
break;
default:
SWITCH_FALLOUT;
return;
}
if (pc->poisoned)
if(client) client->sysmessage("The potion was not able to cure this poison.");
else
{
staticFX(pc, 0x373A, 0, 15);
pc->playSFX(0x01E0); //cure sound - SpaceDog
if(client) client->sysmessage("The poison was cured.");
}
}
client->sendchar(pc);
break;
case 3: {// Explosion Potion
if (region[pc->region].priv&0x01) // Ripper 11-14-99
{
if(client) client->sysmessage(" You cant use that in town!");
return;
}
if(client) client->sysmessage("Now would be a good time to throw it!");
tempfx::add(pc, pc, tempfx::tmpfxExplosionMsg, 0, 1, 3);
tempfx::add(pc, pc, tempfx::tmpfxExplosionMsg, 0, 2, 2);
tempfx::add(pc, pc, tempfx::tmpfxExplosionMsg, 0, 3, 1);
tempfx::add(pc, pi, tempfx::tmpfxExplosionExp, 0, 4, 0);
pTarget targ= clientInfo[s]->newTarget( new cTarget() );
targ->code_callback=target_expPotion;
targ->buffer[0]= pi->getSerial();
targ->send(client);
client->sysmessage( "*throw*" );
return;
}
case 4: // Heal Potion
switch(pi->morez)
{
case 1:
pc->hp=qmin(pc->hp+5+RandomNum(1,5)+pc->skill[17]/100,pc->getStrength());
if(client) client->sysmessage("You feel better!");
break;
case 2:
pc->hp=qmin(pc->hp+15+RandomNum(1,10)+pc->skill[17]/50,pc->getStrength());
if(client) client->sysmessage("You feel more healty!");
break;
case 3:
pc->hp=qmin(pc->hp+20+RandomNum(1,20)+pc->skill[17]/40, pc->getStrength());
if(client) client->sysmessage("You feel much more healty!");
break;
default:
SWITCH_FALLOUT;
return;
}
if (client)
pc->updateHp();
staticFX(pc, 0x376A, 9, 6); // Sparkle effect
pc->playSFX(0x01F2); //Healing Sound - SpaceDog
break;
case 5: // Night Sight Potion
staticFX(pc, 0x376A, 9, 6);
tempfx::add(pc, pc, tempfx::tmpfxSpellNightSight, 0, 0, 0,(720*secondsperuominute*SECS));
pc->playSFX(0x01E3);
break;
case 6: // Poison Potion
if(pc->poisoned < (PoisonType)pi->morez)
pc->poisoned=(PoisonType)pi->morez;
if(pi->morez>4)
pi->morez=4;
pc->poisonwearofftime=getClockmSecs()+(SECS*SrvParms->poisontimer); // lb, poison wear off timer setting
client->sendchar(pc);
pc->playSFX(0x0246); //poison sound - SpaceDog
if(client) client->sysmessage("You poisoned yourself! *sigh*"); //message -SpaceDog
break;
case 7: // Refresh Potion
switch(pi->morez)
{
case 1:
pc->stm=qmin(pc->stm+20+RandomNum(1,10), pc->dx);
if(client) client->sysmessage("You feel more energetic!");
break;
case 2:
pc->stm=qmin(pc->stm+40+RandomNum(1,30), pc->dx);
if(client) client->sysmessage("You feel much more energetic!");
break;
default:
SWITCH_FALLOUT;
return;
}
if (s!=INVALID)
pc->updateStamina();
staticFX(pc, 0x376A, 9, 6);
pc->playSFX(0x01F2); //Healing Sound
break;
case 8: // Strength Potion
staticFX(pc, 0x373A, 0, 15);
switch(pi->morez)
{
case 1:
tempfx::add(pc, pc, tempfx::tmpfxSpellStrength, 5+RandomNum(1,10), 0, 0, 120);
if(client) client->sysmessage("You feel more strong!");
break;
case 2:
tempfx::add(pc, pc, tempfx::tmpfxSpellStrength, 10+RandomNum(1,20), 0, 0, 120);
if(client) client->sysmessage("You feel much more strong!");
break;
default:
SWITCH_FALLOUT;
return;
}
pc->playSFX(0x01EE);
break;
case 9: // Mana Potion
switch(pi->morez)
{
case 1:
pc->mn=qmin(pc->mn+10+pi->morex/100, (unsigned)pc->in);
break;
case 2:
pc->mn=qmin(pc->mn+20+pi->morex/50, (unsigned)pc->in);
break;
default:
SWITCH_FALLOUT;
return;
}
if (client)
pc->updateMana();
staticFX(pc, 0x376A, 9, 6); // Sparkle effect
pc->playSFX(0x01E7); //agility sound - SpaceDog
break;
case 10: //LB's LSD potion, 5'th november 1999
if (pi->getId()!=0x1841) return; // only works with an special flask
if (client) return;
if( clientInfo[s]->lsd )
{
if(client) client->sysmessage("no,no,no,cant you get enough ?");
return;
}
tempfx::add(pc, pc, tempfx::tmpfxLSD, 60+RandomNum(1,120), 0, 0); // trigger effect
staticFX(pc, 0x376A, 9, 6); // Sparkle effect
pc->playSFX(0x00F8, true); // lsd sound :)
break;
default:
SWITCH_FALLOUT;
return;
}
pc->playSFX(0x0030);
if (pc->HasHumanBody() && !pc->getBody()->isMounted())
pc->playAction(0x22);
pi->ReduceAmount( 1 );
if (pi->morey!=3)
{
int lsd=pi->morey; // save morey before overwritten
pi = new cItem(cItem::nextSerial());
pi->setId( 0x0F0E );
if (lsd==10) // empty Lsd potions
{
pi->setId( 0x183d );
}
pi->pileable=1;
pItem pack=pc->getBackpack();
if (pack) {
pack->AddItem( pi );
}
else {
pi->MoveTo( pc->getPosition() );
pi->setDecay();
pi->Refresh();
}
}
}
static void
ntb_transport_init_queue(struct ntb_transport_ctx *nt, unsigned int qp_num)
{
struct ntb_transport_mw *mw;
struct ntb_transport_qp *qp;
vm_paddr_t mw_base;
uint64_t mw_size, qp_offset;
size_t tx_size;
unsigned num_qps_mw, mw_num, mw_count;
mw_count = nt->mw_count;
mw_num = QP_TO_MW(nt, qp_num);
mw = &nt->mw_vec[mw_num];
qp = &nt->qp_vec[qp_num];
qp->qp_num = qp_num;
qp->transport = nt;
qp->ntb = nt->ntb;
qp->client_ready = false;
qp->event_handler = NULL;
ntb_qp_link_down_reset(qp);
if (nt->qp_count % mw_count && mw_num + 1 < nt->qp_count / mw_count)
num_qps_mw = nt->qp_count / mw_count + 1;
else
num_qps_mw = nt->qp_count / mw_count;
mw_base = mw->phys_addr;
mw_size = mw->phys_size;
tx_size = mw_size / num_qps_mw;
qp_offset = tx_size * (qp_num / mw_count);
qp->tx_mw = mw->vbase + qp_offset;
KASSERT(qp->tx_mw != NULL, ("uh oh?"));
/* XXX Assumes that a vm_paddr_t is equivalent to bus_addr_t */
qp->tx_mw_phys = mw_base + qp_offset;
KASSERT(qp->tx_mw_phys != 0, ("uh oh?"));
tx_size -= sizeof(struct ntb_rx_info);
qp->rx_info = (void *)(qp->tx_mw + tx_size);
/* Due to house-keeping, there must be at least 2 buffs */
qp->tx_max_frame = qmin(tx_size / 2,
transport_mtu + sizeof(struct ntb_payload_header));
qp->tx_max_entry = tx_size / qp->tx_max_frame;
callout_init(&qp->link_work, 0);
callout_init(&qp->queue_full, 1);
callout_init(&qp->rx_full, 1);
mtx_init(&qp->ntb_rx_q_lock, "ntb rx q", NULL, MTX_SPIN);
mtx_init(&qp->ntb_tx_free_q_lock, "ntb tx free q", NULL, MTX_SPIN);
TASK_INIT(&qp->rx_completion_task, 0, ntb_complete_rxc, qp);
TASK_INIT(&qp->rxc_db_work, 0, ntb_transport_rxc_db, qp);
STAILQ_INIT(&qp->rx_post_q);
STAILQ_INIT(&qp->rx_pend_q);
STAILQ_INIT(&qp->tx_free_q);
callout_reset(&qp->link_work, 0, ntb_qp_link_work, qp);
}
//--------------------------------------------------------------------------
// Process debugging information item and try to incorporate it into
// the database.
// NOTE: This function does not process all debugging information.
// It knows only about some types of debugingo.
static size_t process_item(uchar *di, size_t disize, section_t *sect)
{
uchar *const end = di + disize;
uint32 fw = *(uint32 *)di;
if ( mf )
fw = swap32(fw);
size_t len = fw >> 16;
if ( len == 0 || len > disize )
return 0;
switch ( fw & 0xFFFF )
{
case AIF_DEB_SECT: // section
if ( disize < sizeof(section_t) )
return 0;
sect = (section_t *)di;
if ( mf )
swap_section(sect);
if ( sect->debugsize != 0 )
len = sect->debugsize;
switch ( sect->lang )
{
case LANG_C:
add_long_cmt(sect->codestart,1,"C source level debugging data is present");
break;
case LANG_PASCAL:
add_long_cmt(sect->codestart,1,"Pascal source level debugging data is present");
break;
case LANG_FORTRAN:
add_long_cmt(sect->codestart,1,"Fortran-77 source level debugging data is present");
break;
case LANG_ASM:
add_long_cmt(sect->codestart,1,"ARM assembler line number data is present");
break;
}
if ( sect->lang == LANG_NONE )
{
size_t nsyms = size_t(sect->name);
dsym_t *ds = (dsym_t *)(sect+1);
char *str = (char *)(ds+nsyms);
if ( str >= (char *)end )
return 0;
bool use_pascal = swap_symbols(ds, str, end, nsyms);
for ( int i=0; i < nsyms; i++,ds++ )
{
if ( ds->sym & ASD_16BITSYM ) continue;
size_t off = size_t(ds->sym & ASD_SYMOFF);
char *name = str + off + use_pascal;
if ( name < str || name >= (char *)end )
continue;
if ( special_name(name) )
continue;
if ( ds->sym & ASD_ABSSYM ) // if the symbol is absolute
{
add_pgm_cmt("%s = 0x%X", name, ds->value);
}
else if ( isEnabled(ds->value) )
{
if ( ds->sym & ASD_GLOBSYM )
{
add_entry(ds->value, ds->value, name, is_true_text_symbol(ds, name));
}
else
{
do_name_anyway(ds->value, name);
if ( is_true_text_symbol(ds, name) )
auto_make_code(ds->value);
}
}
}
}
else
{
char name[64];
const uchar *nptr = (const uchar *)§->name;
size_t namelen = *nptr++;
namelen = qmin(namelen, sizeof(name) - 1);
namelen = qmin(namelen, end - nptr);
memcpy(name, nptr, namelen); //lint !e670
name[namelen] = '\0';
if ( sect->codestart != 0 )
add_long_cmt(sect->codestart,1,"Section \"%s\", size 0x%X",name,sect->codesize);
if ( sect->datastart != 0 )
add_long_cmt(sect->datastart,1,"Section \"%s\", size 0x%X",name,sect->datasize);
}
#if 0
if ( sect->fileinfo != 0 ) { // fileinfo is present?
process_item(di+size_t(sect->fileinfo),sect);
}
#endif
break;
case AIF_DEB_FDEF: // procedure/function definition
deb(IDA_DEBUG_LDR, "procedure/function definition\n");
break;
case AIF_DEB_ENDP: // endproc
deb(IDA_DEBUG_LDR, "endproc\n");
break;
case AIF_DEB_VAR: // variable
deb(IDA_DEBUG_LDR, "variable\n");
break;
case AIF_DEB_TYPE: // type
deb(IDA_DEBUG_LDR, "type\n");
break;
case AIF_DEB_STRU: // struct
deb(IDA_DEBUG_LDR, "struct\n");
break;
case AIF_DEB_ARRAY: // array
deb(IDA_DEBUG_LDR, "array\n");
break;
case AIF_DEB_RANGE: // subrange
deb(IDA_DEBUG_LDR, "subrange\n");
break;
case AIF_DEB_SET: // set
deb(IDA_DEBUG_LDR, "set\n");
break;
case AIF_DEB_FILE: // fileinfo
deb(IDA_DEBUG_LDR, "fileinfo\n");
break;
case AIF_DEB_CENUM: // contiguous enumeration
deb(IDA_DEBUG_LDR, "contiguous enumeration\n");
break;
case AIF_DEB_DENUM: // discontiguous enumeration
deb(IDA_DEBUG_LDR, "discontiguous enumeration\n");
break;
case AIF_DEB_FDCL: // procedure/function declaration
deb(IDA_DEBUG_LDR, "procedure/function declaration\n");
break;
case AIF_DEB_SCOPE: // begin naming scope
deb(IDA_DEBUG_LDR, "begin naming scope\n");
break;
case AIF_DEB_ENDS: // end naming scope
deb(IDA_DEBUG_LDR, "end naming scope\n");
break;
case AIF_DEB_BITF: // bitfield
deb(IDA_DEBUG_LDR, "bitfield\n");
break;
case AIF_DEB_MACRO: // macro definition
deb(IDA_DEBUG_LDR, "macro definition\n");
break;
case AIF_DEB_ENDM: // macro undefinition
deb(IDA_DEBUG_LDR, "macro undefinition\n");
break;
case AIF_DEB_CLASS: // class
deb(IDA_DEBUG_LDR, "class\n");
break;
case AIF_DEB_UNION: // union
deb(IDA_DEBUG_LDR, "union\n");
break;
case AIF_DEB_FPMAP: // FP map fragment
deb(IDA_DEBUG_LDR, "FP map fragment\n");
break;
default:
msg("unknown (0x%d.)!!!\n", fw & 0xFFFF);
break;
}
return len;
}
// =====================================================================================
// GetUsedWads
// parse the "wad" keyvalue into wadpath_t structs
// =====================================================================================
void GetUsedWads()
{
const char* pszWadPaths;
char szTmp[_MAX_PATH];
int i, j;
pszWadPaths = ValueForKey(&g_entities[0], "wad");
#ifdef HLCSG_AUTOWAD_NEW
for (i = 0; ; )
{
for (j = i; pszWadPaths[j] != '\0'; j++)
{
if (pszWadPaths[j] == ';')
{
break;
}
}
if (j - i > 0)
{
int count = qmin (j - i, _MAX_PATH - 1);
memcpy (szTmp, &pszWadPaths[i], count);
szTmp[count] = '\0';
if (g_iNumWadPaths >= MAX_WADPATHS)
{
Error ("Too many wad files");
}
PushWadPath (szTmp, true);
}
if (pszWadPaths[j] == '\0')
{
break;
}
else
{
i = j + 1;
}
}
#else
for(i = 0; i < MAX_WADPATHS; i++)
{
memset(szTmp, 0, sizeof(szTmp)); // are you happy zipster?
for (j = 0; j < _MAX_PATH; j++, pszWadPaths++)
{
if (pszWadPaths[0] == ';')
{
pszWadPaths++;
PushWadPath(szTmp, true);
break;
}
if (pszWadPaths[0] == 0)
{
PushWadPath(szTmp, true); // fix by AmericanRPG for last wadpath ignorance bug
return;
}
szTmp[j] = pszWadPaths[0];
}
}
#endif
}
/*
* Boot time overrides that are scaled against main memory
*/
void
init_param2(long physpages)
{
quad_t realmem;
/* Base parameters */
maxusers = MAXUSERS;
TUNABLE_INT_FETCH("kern.maxusers", &maxusers);
if (maxusers == 0) {
maxusers = physpages / (2 * 1024 * 1024 / PAGE_SIZE);
if (maxusers < 32)
maxusers = 32;
#ifdef VM_MAX_AUTOTUNE_MAXUSERS
if (maxusers > VM_MAX_AUTOTUNE_MAXUSERS)
maxusers = VM_MAX_AUTOTUNE_MAXUSERS;
#endif
/*
* Scales down the function in which maxusers grows once
* we hit 384.
*/
if (maxusers > 384)
maxusers = 384 + ((maxusers - 384) / 8);
}
/*
* The following can be overridden after boot via sysctl. Note:
* unless overriden, these macros are ultimately based on maxusers.
* Limit maxproc so that kmap entries cannot be exhausted by
* processes.
*/
maxproc = NPROC;
TUNABLE_INT_FETCH("kern.maxproc", &maxproc);
if (maxproc > (physpages / 12))
maxproc = physpages / 12;
maxprocperuid = (maxproc * 9) / 10;
/*
* The default limit for maxfiles is 1/12 of the number of
* physical page but not less than 16 times maxusers.
* At most it can be 1/6 the number of physical pages.
*/
maxfiles = imax(MAXFILES, physpages / 8);
TUNABLE_INT_FETCH("kern.maxfiles", &maxfiles);
if (maxfiles > (physpages / 4))
maxfiles = physpages / 4;
maxfilesperproc = (maxfiles / 10) * 9;
/*
* Cannot be changed after boot.
*/
nbuf = NBUF;
TUNABLE_INT_FETCH("kern.nbuf", &nbuf);
/*
* XXX: Does the callout wheel have to be so big?
*
* Clip callout to result of previous function of maxusers maximum
* 384. This is still huge, but acceptable.
*/
ncallout = imin(16 + maxproc + maxfiles, 18508);
TUNABLE_INT_FETCH("kern.ncallout", &ncallout);
/*
* The default limit for all mbuf related memory is 1/2 of all
* available kernel memory (physical or kmem).
* At most it can be 3/4 of available kernel memory.
*/
realmem = qmin((quad_t)physpages * PAGE_SIZE,
VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS);
maxmbufmem = realmem / 2;
TUNABLE_QUAD_FETCH("kern.maxmbufmem", &maxmbufmem);
if (maxmbufmem > (realmem / 4) * 3)
maxmbufmem = (realmem / 4) * 3;
/*
* The default for maxpipekva is min(1/64 of the kernel address space,
* max(1/64 of main memory, 512KB)). See sys_pipe.c for more details.
*/
maxpipekva = (physpages / 64) * PAGE_SIZE;
TUNABLE_LONG_FETCH("kern.ipc.maxpipekva", &maxpipekva);
if (maxpipekva < 512 * 1024)
maxpipekva = 512 * 1024;
if (maxpipekva > (VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS) / 64)
maxpipekva = (VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS) /
64;
}
void checkauto() // Check automatic/timer controlled stuff (Like fighting and regeneration)
{
// static TIMERVAL checkspawnregions=0;
static TIMERVAL checktempfx=0;
static TIMERVAL checknpcs=0;
static TIMERVAL checktamednpcs=0;
static TIMERVAL checknpcfollow=0;
static TIMERVAL checkitemstime=0;
static TIMERVAL lighttime=0;
static TIMERVAL htmltime=0;
static TIMERVAL housedecaytimer=0;
LOGICAL lightChanged = false;
//
// Accounts
//
if (SrvParms->auto_a_reload > 0 && TIMEOUT( Accounts->lasttimecheck + (SrvParms->auto_a_reload*60*MY_CLOCKS_PER_SEC) ) )
Accounts->CheckAccountFile();
//
// Weather (change is handled by crontab)
//
// Calendar
//
if ( TIMEOUT( uotickcount ) )
{
if (Calendar::advanceMinute())
day++;
uotickcount=uiCurrentTime+secondsperuominute*MY_CLOCKS_PER_SEC;
if (Calendar::g_nMinute%8==0)
moon1=(UI08)((moon1+1)%8);
if (Calendar::g_nMinute%3==0)
moon2=(UI08)((moon2+1)%8);
}
//
// Light
//
if( TIMEOUT( lighttime ) )
{
UI08 lightLevel = worldcurlevel;
SI32 timenow = (Calendar::g_nHour * 60) + Calendar::g_nMinute;
SI32 dawntime = (Calendar::g_nCurDawnHour * 60) + Calendar::g_nCurDawnMin;
SI32 sunsettime = (Calendar::g_nCurSunsetHour * 60) + Calendar::g_nCurSunsetMin;
SI32 nighttime = qmin((sunsettime+120), (1439));
SI32 morntime = qmax((dawntime-120), (0));
SI32 const middaytime = 750;
// SI32 const midnighttime = 0; // unused variable
UI08 dawnlight = (UI08)((((worlddarklevel - worldbrightlevel))/3) + worldbrightlevel);
//
// default lights at dawn and sunset
//
if ( timenow == dawntime || timenow==sunsettime )
lightLevel = dawnlight;
//
// highest light at midday
//
else if( timenow == middaytime )
lightLevel = (UI08) qmax(worldbrightlevel-1, 0);
//
// darkest light during night
//
else if( timenow >= nighttime )
lightLevel = worlddarklevel;
//
else if( timenow <= morntime )
lightLevel = worlddarklevel;
//
// fading light slight before dawn
//
else if( timenow > morntime && timenow < dawntime )
lightLevel = (UI08)linInterpolation(morntime, worlddarklevel, dawntime, dawnlight, timenow);
//
// fading light slight from dawn to midday
else if( timenow > dawntime && timenow < middaytime )
lightLevel = (UI08)linInterpolation(dawntime, dawnlight, middaytime, worldbrightlevel, timenow);
//
// fading light slight from midday to sunset
//
else if( timenow > middaytime && timenow < sunsettime )
lightLevel = (UI08)linInterpolation(middaytime, worldbrightlevel, sunsettime, dawnlight, timenow);
//
// fading light slight from sunset to night
//
else if( timenow > sunsettime && timenow < nighttime )
lightLevel = (UI08)linInterpolation(sunsettime, dawnlight, nighttime, worlddarklevel, timenow);
if (wtype)
lightLevel += 2;
if (moon1+moon2<4)
++lightLevel;
if (moon1+moon2<10)
++lightLevel;
if (lightLevel != worldcurlevel)
{
worldcurlevel = lightLevel;
lightChanged = true;
}
lighttime=uiCurrentTime+secondsperuominute*5*MY_CLOCKS_PER_SEC;
}
//
// Housedecay and stabling
//
if ( TIMEOUT( housedecaytimer ) )
{
//////////////////////
///// check_houses
/////////////////////
if( SrvParms->housedecay_secs != UINVALID )
cHouses::check_house_decay();
housedecaytimer = uiCurrentTime+MY_CLOCKS_PER_SEC*60*60; // check only each hour
}
//
// Spawns
//
if( TIMEOUT( Spawns->check ) )
{
Spawns->doSpawn();
}
//
// Shoprestock
//
Restocks->doRestock();
//
// Prison release
//
prison::checkForFree();
//
// Temporary effects
//
if( TIMEOUT( checktempfx ) )
tempfx::checktempeffects();
//
// Characters & items
//
NxwSocketWrapper sw;
sw.fillOnline();
for( sw.rewind(); !sw.isEmpty(); sw++ )
{
NXWCLIENT ps = sw.getClient();
if( ps == NULL )
continue;
P_CHAR pc=ps->currChar();
if( !ISVALIDPC( pc ) )
continue;
if( lightChanged )
dolight(ps->toInt(),worldcurlevel);
pc->heartbeat();
if( TIMEOUT( checknpcs ) || TIMEOUT( checktamednpcs ) || TIMEOUT( checknpcfollow ) )
{
#ifdef SPAR_C_LOCATION_MAP
PCHAR_VECTOR *pCV = pointers::getNearbyChars( pc, VISRANGE, pointers::NPC );
PCHAR_VECTOR it( pCV->begin() ), end( pCV->end() );
P_CHAR pNpc = 0;
while( it != end )
{
pNpc = (*it);
if( pNpc->lastNpcCheck != uiCurrentTime &&
(TIMEOUT( checknpcs ) ||
(TIMEOUT( checktamednpcs ) && pNpc->tamed) ||
(TIMEOUT( checknpcfollow ) && pNpc->npcWander == WANDER_FOLLOW ) ) )
{
pNpc->heartbeat();
pNpc->lastNpcCheck = uiCurrentTime;
}
++it;
}
#else
NxwCharWrapper sc;
sc.fillCharsNearXYZ( pc->getPosition(), VISRANGE, true, false );
for( sc.rewind(); !sc.isEmpty(); sc++ )
{
P_CHAR npc=sc.getChar();
if(!ISVALIDPC(npc) || !npc->npc )
continue;
if( npc->lastNpcCheck != uiCurrentTime &&
(TIMEOUT( checknpcs ) ||
(TIMEOUT( checktamednpcs ) && npc->tamed) ||
(TIMEOUT( checknpcfollow ) && npc->npcWander == WANDER_FOLLOW ) ) )
{
npc->heartbeat();
npc->lastNpcCheck = uiCurrentTime;
}
}
#endif
}
if( TIMEOUT( checkitemstime ) )
{
NxwItemWrapper si;
si.fillItemsNearXYZ( pc->getPosition(), 2*VISRANGE, false );
for( si.rewind(); !si.isEmpty(); si++ )
{
P_ITEM pi=si.getItem();
if( !ISVALIDPI( pi ) )
continue;
pi->doDecay();
switch( pi->type )
{
case 51 :
case 52 :
//if( TIMEOUT( pi->gatetime ) )
//for (int k=0;k<2;++k) Sparhawk what's this???? Let's comment it out for now
// pi->deleteItem(); // bugfix for items disappearing
//pi->deleteItem();
break;
case 61 :
case 62 :
case 63 :
case 64 :
case 65 :
case 69 :
case 125 :
break; //SPAWNERS may not decay!!! --> Sparhawk then don't use the decay tag in the script
case 88 :
if( pi->morey >= 0 && pi->morey < 25 )
if (pc->distFrom(pi)<=pi->morey)
if( (UI32)RandomNum(1,100) <= pi->morez )
soundeffect4(ps->toInt(), pi, (UI16)pi->morex);
break;
}
}
}
// Check boats extra, or else they will only be updated every CHECK_ITEMS time
std::map<int,P_BOAT>::iterator iter_boat;
for ( iter_boat= s_boat.begin();iter_boat != s_boat.end();iter_boat++)
{
P_BOAT boat=iter_boat->second;
P_ITEM pi=boat->getShipLink();
if( pi->type2 == 1 || pi->type2 == 2 )
if( TIMEOUT( pi->gatetime ) )
{
if (pi->type2==1)
Boats->Move(ps->toInt(),pi->dir,pi);
else
{
int dir=pi->dir+4;
dir%=8;
Boats->Move(ps->toInt(),dir,pi);
}
pi->gatetime=(TIMERVAL)(uiCurrentTime + (R64)(SrvParms->boatspeed*MY_CLOCKS_PER_SEC));
}
}
}//for i<now
if( TIMEOUT( checkitemstime ) )
checkitemstime = (TIMERVAL)((R64) uiCurrentTime+(speed.itemtime*MY_CLOCKS_PER_SEC));
if( TIMEOUT( checknpcs ) )
checknpcs = (TIMERVAL)((R64) uiCurrentTime+(speed.npctime*MY_CLOCKS_PER_SEC));
if( TIMEOUT( checktamednpcs ) )
checktamednpcs=(TIMERVAL)((R64) uiCurrentTime+(speed.tamednpctime*MY_CLOCKS_PER_SEC));
if( TIMEOUT( checknpcfollow ) )
checknpcfollow=(TIMERVAL)((R64) uiCurrentTime+(speed.npcfollowtime*MY_CLOCKS_PER_SEC));
//
// Html
//
if(SrvParms->html>0 && (htmltime<=uiCurrentTime ))
{
updatehtml();
htmltime=uiCurrentTime+(SrvParms->html*MY_CLOCKS_PER_SEC);
}
//
// Finish
//
if ( TIMEOUT( nextfieldeffecttime ) )
nextfieldeffecttime = (TIMERVAL)((R64) uiCurrentTime + (0.5*MY_CLOCKS_PER_SEC));
if ( TIMEOUT( nextdecaytime ) )
nextdecaytime = uiCurrentTime + (15*MY_CLOCKS_PER_SEC);
if( TIMEOUT( checktempfx ) )
checktempfx = (TIMERVAL)((R64) uiCurrentTime+(0.5*MY_CLOCKS_PER_SEC));
}
static int idaapi hook_ui(void *user_data, int notification_code, va_list va)
{
switch (notification_code)
{
case ui_notification_t::ui_get_custom_viewer_hint:
{
TCustomControl *viewer = va_arg(va, TCustomControl *);
place_t *place = va_arg(va, place_t *);
int *important_lines = va_arg(va, int *);
qstring &hint = *va_arg(va, qstring *);
if (place == NULL)
return 0;
int x, y;
if (get_custom_viewer_place(viewer, true, &x, &y) == NULL)
return 0;
char buf[MAXSTR];
const char *line = get_custom_viewer_curline(viewer, true);
tag_remove(line, buf, sizeof(buf));
if (x >= (int)strlen(buf))
return 0;
idaplace_t &pl = *(idaplace_t *)place;
if (decode_insn(pl.ea) && dbg_started)
{
insn_t _cmd = cmd;
int flags = calc_default_idaplace_flags();
linearray_t ln(&flags);
for (int i = 0; i < qnumber(_cmd.Operands); i++)
{
op_t op = _cmd.Operands[i];
if (op.type != o_void)
{
switch (op.type)
{
case o_mem:
case o_near:
{
idaplace_t here;
here.ea = op.addr;
here.lnnum = 0;
ln.set_place(&here);
hint.cat_sprnt((COLSTR(SCOLOR_INV"OPERAND#%d (ADDRESS: $%a)\n", SCOLOR_DREF)), op.n, op.addr);
(*important_lines)++;
int n = qmin(ln.get_linecnt(), 10); // how many lines for this address?
(*important_lines) += n;
for (int j = 0; j < n; ++j)
{
hint.cat_sprnt("%s\n", ln.down());
}
} break;
case o_phrase:
case o_reg:
{
regval_t reg;
int reg_idx = idp_to_dbg_reg(op.reg);
const char *reg_name = dbg->registers(reg_idx).name;
if (get_reg_val(reg_name, ®))
{
idaplace_t here;
here.ea = (uint32)reg.ival;
here.lnnum = 0;
ln.set_place(&here);
hint.cat_sprnt((COLSTR(SCOLOR_INV"OPERAND#%d (REGISTER: %s)\n", SCOLOR_DREF)), op.n, reg_name);
(*important_lines)++;
int n = qmin(ln.get_linecnt(), 10); // how many lines for this address?
(*important_lines) += n;
for (int j = 0; j < n; ++j)
{
hint.cat_sprnt("%s\n", ln.down());
}
}
} break;
case o_displ:
{
regval_t main_reg, add_reg;
int main_reg_idx = idp_to_dbg_reg(op.reg);
int add_reg_idx = idp_to_dbg_reg(op.specflag1 & 0xF);
main_reg.ival = 0;
add_reg.ival = 0;
if (op.specflag2 & 0x10)
{
get_reg_val(dbg->registers(add_reg_idx).name, &add_reg);
if (op.specflag1 & 0x10)
add_reg.ival &= 0xFFFF;
}
if (main_reg_idx != R_PC)
get_reg_val(dbg->registers(main_reg_idx).name, &main_reg);
idaplace_t here;
ea_t addr = (uint32)main_reg.ival + op.addr + (uint32)add_reg.ival; // TODO: displacements with PC and other regs unk_123(pc, d0.l); unk_111(d0, d2.w)
here.ea = addr;
here.lnnum = 0;
ln.set_place(&here);
hint.cat_sprnt((COLSTR(SCOLOR_INV"OPERAND#%d (DISPLACEMENT: [$%s%X($%X", SCOLOR_DREF)),
op.n,
((int)op.addr < 0) ? "-" : "", ((int)op.addr < 0) ? -(int)op.addr : op.addr,
(uint32)main_reg.ival
);
if (op.specflag2 & 0x10)
hint.cat_sprnt((COLSTR(",$%X", SCOLOR_DREF)), (uint32)add_reg.ival);
hint.cat_sprnt((COLSTR(")])\n", SCOLOR_DREF)));
(*important_lines)++;
int n = qmin(ln.get_linecnt(), 10); // how many lines for this address?
(*important_lines) += n;
for (int j = 0; j < n; ++j)
{
hint.cat_sprnt("%s\n", ln.down());
}
} break;
}
}
}
return 1;
}
}
default:
return 0;
}
}
