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