INLINE void _psxRcntWcount( u32 index, u32 value )
{
if( value > 0xffff )
{
#ifdef DEBUG_BIOS
dbgf("[RCNT %i] wcount > 0xffff: %x\n", index, value );
#endif
value &= 0xffff;
}
rcnts[index].cycleStart = psxRegs.cycle;
rcnts[index].cycleStart -= value * rcnts[index].rate;
// TODO: <=.
if( value < rcnts[index].target )
{
rcnts[index].cycle = rcnts[index].target * rcnts[index].rate;
rcnts[index].counterState = CountToTarget;
}
else
{
rcnts[index].cycle = 0xffff * rcnts[index].rate;
rcnts[index].counterState = CountToOverflow;
}
}
HRESULT IDirect3DDevice9New::CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,HANDLE* pSharedHandle)
{
dbgf("dev: CreateIndexBuffer %s %s", getUsage(Usage), getPool(Pool));
if(config.debug.compatibleIB)
{
// Compatible index buffer mode - do not use emulated IB, set dynamic memory instead
if(Pool == D3DPOOL_MANAGED)
{
ONCE dbg("DEBUG: using compatible index buffers (manage-emulation disabled)");
Pool = D3DPOOL_DEFAULT;
Usage |= D3DUSAGE_DYNAMIC;
}
return dev->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer, pSharedHandle);
}
#if USE_D3DEX || MANAGE_DEBUG_IB
/*if(Pool == D3DPOOL_MANAGED && Usage == D3DUSAGE_WRITEONLY)
Pool = D3DPOOL_DEFAULT; // No need for manage-emulation for writeonly buffers, just set pool to default*/
if(Pool == D3DPOOL_MANAGED)
{
*ppIndexBuffer = new IDirect3DIndexBuffer9Managed((IDirect3DDevice9Ex*)dev, this, Length, Usage, Format, Pool, pSharedHandle);
// TODO: check for failure
return D3D_OK;
}
#endif
return dev->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer, pSharedHandle);
}
HRESULT IDirect3DDevice9New::GetDirect3D(IDirect3D9** ppD3D9)
{
dbgf("dev: GetDirect3D");
*ppD3D9 = d3d;
d3d->AddRef();
return D3D_OK;
}
IDirect3DBaseTexture9* IDirect3DDevice9New::OriginalFromNewTexture(IDirect3DBaseTexture9* tex)
{
if(!tex)
return tex;
dbgf("IDirect3DDevice9New::OriginalFromNewTexture: 0x%08X (0x%08X)", tex, *tex);
void* nilIF;
// Manage-emulated texture?
if(tex->QueryInterface(IID_IDirect3DTexture9Managed, &nilIF) == S_OK) {
tex->Release();
return ((IDirect3DTexture9Managed*) tex)->GetRealTexture();
}
// Manage-emulated volume texture?
if(tex->QueryInterface(IID_IDirect3DVolumeTexture9Managed, &nilIF) == S_OK) {
tex->Release();
return ((IDirect3DVolumeTexture9Managed*) tex)->GetRealTexture();
}
// Overridden texture?
if(tex->QueryInterface(IID_IDirect3DTexture9New, &nilIF) == S_OK) {
tex->Release();
return ((IDirect3DTexture9New*) tex)->GetRealTexture();
}
return tex;
}
long dbpf(const char *pname,const char *pvalue)
{
DBADDR addr;
long status;
short dbrType;
size_t n = 1;
if (!pname || !*pname || !pvalue) {
printf("Usage: dbpf \"pv name\", \"value\"\n");
return 1;
}
if (nameToAddr(pname, &addr))
return -1;
if (addr.no_elements > 1 &&
(addr.dbr_field_type == DBR_CHAR || addr.dbr_field_type == DBR_UCHAR)) {
dbrType = addr.dbr_field_type;
n = strlen(pvalue) + 1;
}
else {
dbrType = DBR_STRING;
}
status = dbPutField(&addr, dbrType, pvalue, (long) n);
dbgf(pname);
return status;
}
static PyObject *
ZenEditor_replace_content(ZenEditor *self, PyObject *args)
{
PyObject *result;
gint sel_start = -1, sel_end = -1, ph_pos;
gchar *text, *ph, *tmp, *tmp2;
ScintillaObject *sci;
print_called();
py_return_none_if_null(sci = ZenEditor_get_scintilla(self));
if (PyArg_ParseTuple(args, "s|ii", &text, &sel_start, &sel_end))
{
tmp = ZenEditor_replace_caret_placeholder(self->caret_placeholder, text, &ph_pos);
tmp2 = ZenEditor_replace_range(tmp);
g_free(tmp);
if (sel_start == -1 && sel_end == -1)
{
/* replace whole editor content */
sci_set_text(sci, tmp2);
}
else if (sel_start != -1 && sel_end == -1)
{
/* insert text at sel_start */
sci_insert_text(sci, sel_start, tmp2);
}
else if (sel_start != -1 && sel_end != -1)
{
/* replace from sel_start to sel_end */
sci_set_selection_start(sci, sel_start);
sci_set_selection_end(sci, sel_end);
sci_replace_sel(sci, tmp2);
}
else
{
dbgf("Invalid arguments were supplied.");
g_free(tmp2);
Py_RETURN_NONE;
}
g_free(tmp2);
/* Move cursor to first placeholder position, if found */
if (ph_pos > -1)
sci_set_current_position(sci, sel_start + ph_pos, TRUE);
}
else
{
if (PyErr_Occurred())
{
PyErr_Print();
PyErr_Clear();
}
}
Py_RETURN_NONE;
}
static void dumplist (void)
{
shmpiece *x = shm_start;
#ifdef DEBUG_MEMORY
dbgf ("Start Dump:\n");
#endif
while (x) {
#ifdef DEBUG_MEMORY
dbgf (" this=%p, Native %p, id %d, prev=%p, next=%p, size=0x%08x\n",
x, x->native_address, x->id, x->prev, x->next, x->size);
#endif
x = x->next;
}
#ifdef DEBUG_MEMORY
dbgf ("End Dump:\n");
#endif
}
uae_u32 REGPARAM2 dummy_bget (uaecptr addr)
{
#ifdef DEBUG_MEMORY
dbgf("dummy_bget 0x%X\n",addr);
#endif
special_mem |= S_READ;
return 0xFF;
}
void *_debugRealloc(void *memoryParameter, uint32_t length, int32_t tag)
{
unsigned char *memory;
struct chunkHeader *chunkHeader=NULL;
struct chunkTrailer *chunkTrailer;
unsigned char *result;
uint32_t copyLength;
if (memoryParameter) { /* if memoryParameter==NULL, realloc() should work like malloc() !! */
memory = memoryParameter;
chunkHeader = (struct chunkHeader *)(memory - sizeof(struct chunkHeader));
if (chunkHeader->magicNumber != MAGIC_NUMBER)
{
dbgf( DBGL_SYS, DBGT_ERR,
"invalid magic number in header: %08x, malloc tag = %d",
chunkHeader->magicNumber, chunkHeader->tag );
cleanup_all( -500078 );
}
chunkTrailer = (struct chunkTrailer *)(memory + chunkHeader->length);
if (chunkTrailer->magicNumber != MAGIC_NUMBER)
{
dbgf( DBGL_SYS, DBGT_ERR,
"invalid magic number in trailer: %08x, malloc tag = %d",
chunkTrailer->magicNumber, chunkHeader->tag );
cleanup_all( -500079 );
}
}
result = _debugMalloc(length, tag);
if (memoryParameter) {
copyLength = length;
if (copyLength > chunkHeader->length)
copyLength = chunkHeader->length;
memcpy(result, memoryParameter, copyLength);
debugFree(memoryParameter, -300280);
}
return result;
}
void __lbDbgAssertExit(struct dbgModule *dbg, const char *assertion,
const char *filename, unsigned int line,
const char *function) {
dbgf(dbg, DBGERR, "%s (%s:%u): Assertion '%s' failed",
function, filename, line, assertion);
lbdFatalShutdown();
}
u32 psxRcntRtarget( u32 index )
{
#ifdef DEBUG_BIOS
dbgf("[RCNT %i] rtarget: %x\n", index, rcnts[index].target );
#endif
return rcnts[index].target;
}
IDirect3DVertexBuffer9* IDirect3DVertexBuffer9Managed::GetRealBuffer()
{
dbgf("IDirect3DVertexBuffer9Managed 0x%08X: GetRealBuffer", this);
if(locks)
dbg("WARNING: IDirect3DVertexBuffer9Managed 0x%08X: GetRealBuffer() with %d active locks", locks);
if(lockSections.size() || fullDirty)
{
#ifdef ALWAYS_FULL_UPDATE
fullDirty = true;
#endif
//dbg("IDirect3DVertexBuffer9Managed 0x%08X: UPDATE");
if(!fullDirty)
{
// Partial buffer lock
for(int i=0;i<lockSections.size();i++)
{
DWORD lockOffset = lockSections[i].lockOffset;
DWORD lockSize = lockSections[i].lockSize;
#ifdef RECREATE_ON_REUSE
const DWORD flags = NULL;
#else
// Improves performance - but isn't safe and not allowed by D3D spec
const DWORD flags = D3DLOCK_NOOVERWRITE;
#endif
// Copy sysmem to vidmem
void *vb;
if(buf->Lock(lockOffset, lockSize, &vb, flags) != D3D_OK) {
dbg("IDirect3DVertexBuffer9Managed: Unlock: Lock failed!");
return buf;
}
memcpy(vb, bufSys+lockOffset, lockSize?lockSize:bufSize);
buf->Unlock();
}
}
else
{
// Full buffer lock
// Copy sysmem to vidmem
void *vb;
if(buf->Lock(0, 0, &vb, FLOCKFLAGS/*|D3DLOCK_NOOVERWRITE*/) != D3D_OK) {
dbg("IDirect3DVertexBuffer9Managed: Unlock: Lock failed!");
return buf;
}
memcpy(vb, bufSys, bufSize);
buf->Unlock();
}
lockSections.clear();
fullDirty = false;
}
return buf;
}
uae_u32 REGPARAM2 mbres_bget (uaecptr addr)
{
#ifdef DEBUG_MEMORY
dbgf("mbres_bget 0x%X\n",addr);
#endif
special_mem |= S_READ;
return (addr & 0xFFFF) == 3 ? mbres_val : 0;
}
uae_u32 REGPARAM2 mbres_wget (uaecptr addr)
{
#ifdef DEBUG_MEMORY
dbgf("mbres_wget 0x%X\n",addr);
#endif
special_mem |= S_READ;
return 0;
}
static int32_t howto_plugin_init( void ) {
dbgf( DBGL_CHANGES, DBGT_INFO, "init plugin %s", HOWTO_PLUGIN );
register_options_array( howto_plugin_options, sizeof( howto_plugin_options ) );
return SUCCESS;
}
void REGPARAM2 bogomem_bput (uaecptr addr, uae_u32 b)
{
#ifdef DEBUG_MEMORY
dbgf("bogomem_bput 0x%X = 0x%X\n",addr,b);
#endif
addr -= bogomem_start & bogomem_mask;
addr &= bogomem_mask;
bogomemory[addr] = b;
}
uae_u32 REGPARAM2 rtarea_bget (uaecptr addr)
{
#ifdef DEBUG_MEMORY
dbgf("rtarea_bget 0x%X\n",addr);
#endif
special_mem |= S_READ;
addr &= 0xFFFF;
return rtarea[addr];
}
uae_u32 REGPARAM2 rtarea_lget (uaecptr addr)
{
#ifdef DEBUG_MEMORY
dbgf("rtarea_lget 0x%X\n",addr);
#endif
special_mem |= S_READ;
addr &= 0xFFFF;
return (uae_u32)(rtarea_wget (addr) << 16) + rtarea_wget (addr+2);
}
uae_u32 REGPARAM2 bogomem_bget (uaecptr addr)
{
#ifdef DEBUG_MEMORY
dbgf("bogomem_bget 0x%X\n",addr);
#endif
addr -= bogomem_start & bogomem_mask;
addr &= bogomem_mask;
return bogomemory[addr];
}
void REGPARAM2 a3000mem_bput (uaecptr addr, uae_u32 b)
{
#ifdef DEBUG_MEMORY
dbgf("a3000mem_bput 0x%X = 0x%X\n",addr,b);
#endif
addr -= a3000mem_start & a3000mem_mask;
addr &= a3000mem_mask;
a3000memory[addr] = b;
}
void processWifiMsg() {
char buff[JSON_MAX_SIZE + 1];
unsigned long start = millis();
uint8_t l = esp8266.receive(buff, JSON_MAX_SIZE);
if (l > 0) {
dbgf(debug, F(":HTTP:receive:%d bytes:[%d msec]\n"), l, millis() - start);
parseCommand(buff);
}
}
uae_u32 REGPARAM2 extendedkickmem_bget (uaecptr addr)
{
#ifdef DEBUG_MEMORY
dbgf("extendedkickmem_bget 0x%X\n",addr);
#endif
addr -= extendedkickmem_start & extendedkickmem_mask;
addr &= extendedkickmem_mask;
return extendedkickmemory[addr];
}
uae_u32 REGPARAM2 a3000mem_bget (uaecptr addr)
{
#ifdef DEBUG_MEMORY
dbgf("a3000mem_bget 0x%X\n",addr);
#endif
addr -= a3000mem_start & a3000mem_mask;
addr &= a3000mem_mask;
return a3000memory[addr];
}
void REGPARAM2 mbres_bput (uaecptr addr, uae_u32 b)
{
#ifdef DEBUG_MEMORY
dbgf("mbres_bput 0x%X = 0x%X\n",addr,b);
#endif
special_mem |= S_WRITE;
if ((addr & 0xFFFF) == 3)
mbres_val = b;
}
HRESULT IDirect3DIndexBuffer9Managed::Unlock()
{
dbgf("IDirect3DIndexBuffer9Managed 0x%08X: Unlock", this);
if(!bufSys || !buf)
return D3DERR_INVALIDCALL;
/*
DWORD lockOffset = lockSections[lockSections.size()-1].lockOffset;
DWORD lockSize = lockSections[lockSections.size()-1].lockSize;
// Copy sysmem to vidmem
void *vb;
if(buf->Lock(lockOffset, lockSize, &vb, D3DLOCK_NOOVERWRITE|D3DLOCK_DONOTWAIT) != D3D_OK) {
dbg("IDirect3DVertexBuffer9Managed: Unlock: FAILED!");
return D3D_OK;
}
memcpy(vb, bufSys+lockOffset, lockSize?lockSize:bufSize);
buf->Unlock();
lockSections.pop_back();
*/
#ifndef LATE_IB_UPDATE
/*DWORD flags = D3DLOCK_DISCARD; // Crashes A10-C
if(config.main.debugD3D)
{
flags = NULL; // Debug D3D doesn't like discard here
}
*/
DWORD flags = NULL;
if(lockSections.size() == 0)
{
dbg("WARNING: Indexbuffer unlock without lock??");
return D3DERR_INVALIDCALL;
}
DWORD lockOffset = lockSections[lockSections.size()-1].lockOffset;
DWORD lockSize = lockSections[lockSections.size()-1].lockSize;
// Copy locked buffer to video memory
void *ib;
if(buf->Lock(lockOffset, lockSize, &ib, flags) != D3D_OK) {
dbg("IDirect3DIndexBuffer9Managed: Unlock: Lock failed!");
return D3DERR_INVALIDCALL;
}
memcpy(ib, bufSys+lockOffset, lockSize?lockSize:bufSize);
buf->Unlock();
lockSections.pop_back();
#endif
return D3D_OK;
}
void init_func_names(void)
{
int inode_i = ext2_get_inode_i(EXT2_ROOT_INODE, FNAMES_FILE_NAME);
if (inode_i == 0) {
dbgf("File not found. %s\n", FNAMES_FILE_NAME);
return;
}
int size_B;
char *p = (char *) ext2_open(inode_i, &size_B);
if (p == 0) {
dbgf("Could not open file. %s\n", FNAMES_FILE_NAME);
return;
}
l_num_fnames = size_B / sizeof(struct FUNC_NAME);
l_func_names = (struct FUNC_NAME *) p;
}
uae_u32 REGPARAM2 extendedkickmem_wget (uaecptr addr)
{
#ifdef DEBUG_MEMORY
dbgf("extendedkickmem_wget 0x%X\n",addr);
#endif
uae_u16 *m;
addr -= extendedkickmem_start & extendedkickmem_mask;
addr &= extendedkickmem_mask;
m = (uae_u16 *)(extendedkickmemory + addr);
return swab_w(do_get_mem_word (m));
}
void REGPARAM2 a3000mem_wput (uaecptr addr, uae_u32 w)
{
#ifdef DEBUG_MEMORY
dbgf("a3000mem_wput 0x%X = 0x%X\n",addr,w);
#endif
uae_u16 *m;
addr -= a3000mem_start & a3000mem_mask;
addr &= a3000mem_mask;
m = (uae_u16 *)(a3000memory + addr);
do_put_mem_word (m, SWAP_W(w));
}
void REGPARAM2 a3000mem_lput (uaecptr addr, uae_u32 l)
{
#ifdef DEBUG_MEMORY
dbgf("a3000mem_lput 0x%X = 0x%X\n",addr,l);
#endif
uae_u32 *m;
addr -= a3000mem_start & a3000mem_mask;
addr &= a3000mem_mask;
m = (uae_u32 *)(a3000memory + addr);
do_put_mem_long (m, SWAP_L(l));
}
uae_u32 REGPARAM2 a3000mem_wget (uaecptr addr)
{
#ifdef DEBUG_MEMORY
dbgf("a3000mem_wget 0x%X\n",addr);
#endif
uae_u16 *m;
addr -= a3000mem_start & a3000mem_mask;
addr &= a3000mem_mask;
m = (uae_u16 *)(a3000memory + addr);
return SWAP_W(do_get_mem_word (m));
}
