cstring Mapper105::CartSwitches::GetValueName(uint dip,uint value) const { NST_ASSERT( dip < 2 ); if (dip == 0) { NST_ASSERT( value < 16 ); switch (value) { case 0x0: return "5.001"; case 0x1: return "5.316"; case 0x2: return "5.629"; case 0x3: return "5.942"; case 0x4: return "6.254"; case 0x5: return "6.567"; case 0x6: return "6.880"; case 0x7: return "7.193"; case 0x8: return "7.505"; case 0x9: return "7.818"; case 0xA: return "8.131"; case 0xB: return "8.444"; case 0xC: return "8.756"; case 0xD: return "9.070"; case 0xE: return "9.318"; case 0xF: return "9.695"; NST_UNREACHABLE } }
cstring Standard::CartSwitches::GetValueName(uint dip,uint value) const { NST_ASSERT( dip < 2 ); if (dip == 0) { NST_ASSERT( value < 4 ); return (value == 0) ? "1" : (value == 1) ? "2" : (value == 2) ? "3" : "4"; } else { NST_ASSERT( value < 3 ); return (value == 0) ? "Off" : (value == 1) ? "Controlled" : "On"; } }
LRESULT CALLBACK Instance::Global::Hooks::CBTProc(const int nCode,const WPARAM wParam,const LPARAM lParam) { NST_COMPILE_ASSERT( HCBT_CREATEWND >= 0 && HCBT_DESTROYWND >= 0 ); switch (nCode) { case HCBT_CREATEWND: NST_ASSERT( lParam ); if (const CREATESTRUCT* const createStruct = reinterpret_cast<const CBT_CREATEWND*>(lParam)->lpcs) { NST_VERIFY( wParam ); global.hooks.OnCreate( *createStruct, reinterpret_cast<HWND>(wParam) ); } return 0; case HCBT_DESTROYWND: NST_VERIFY( wParam ); if (wParam) global.hooks.OnDestroy( reinterpret_cast<HWND>(wParam) ); return 0; } return nCode < 0 ? ::CallNextHookEx( global.hooks.handle, nCode, wParam, lParam ) : 0; }
void Instance::Global::Hooks::OnDestroy(HWND const hWnd) { NST_ASSERT( hWnd ); Children::Iterator const child = children.Find( hWnd ); if (child) { Events::Signal( EVENT_SYSTEM_BUSY ); } else if (window != hWnd) { return; } { const Events::WindowDestroyParam param = { hWnd }; Events::Signal( EVENT_WINDOW_DESTROY, ¶m ); } if (child) children.Erase( child ); else window = NULL; }
uint AdapterFour::Peek(const uint line) { NST_ASSERT( line < 2 ); if (type == Api::Input::ADAPTER_NES) { const uint index = count[line]; if (index < 20) { count[line] += increaser; if (index < 16) { return devices[line + (index < 8 ? 0 : 2)]->Peek( line ); } else if (index >= 18) { return (index - 18) ^ line; } } return 0; } else { return ( (devices[line+0]->Peek( line ) << 0 & 0x1) | (devices[line+2]->Peek( line ) << 1 & 0x2) ); } }
bool File::Load(const Type type,Vector<byte>& vector,const dword maxsize) const { NST_ASSERT( maxsize ); bool matched = true; { Api::User::FileData file; Api::User::fileIoCallback( static_cast<Api::User::File>(type), file ); if (Api::User::FileData::size_type filesize = file.size()) { if (filesize > maxsize) { filesize = maxsize; matched = false; } vector.Resize( filesize ); std::memcpy( vector.Begin(), &file.front(), filesize ); } else { vector.Destroy(); return true; } } buffer.Load( vector.Begin(), vector.Size() ); return matched; }
Result Patcher::Test(const Block* const blocks,const uint numBlocks) const { NST_ASSERT( blocks || !numBlocks ); if (numBlocks > 1) { Vector<byte> buffer; try { dword size = 0; for (uint i=0; i < numBlocks; ++i) size += blocks[i].size; buffer.Reserve( size ); } catch (...) { return RESULT_ERR_OUT_OF_MEMORY; } for (uint i=0; i < numBlocks; ++i) buffer.Append( blocks[i].data, blocks[i].size ); return Test( buffer.Begin(), buffer.Size() ); } else { return Test( blocks ? blocks->data : NULL, blocks ? blocks->size : 0 ); } }
uint Standard::CartSwitches::GetValue(uint dip) const { NST_ASSERT( dip < 2 ); if (dip == 0) return data >> 6; else return data & DIPSWITCH_NMT;
Device& AdapterTwo::Connect(uint port,Device& device) { NST_ASSERT( port < 2 ); Device& old = *devices[port]; devices[port] = &device; return old; }
void ListView::ColumnsProxy::Insert(const uint index,wcstring const text) const { NST_ASSERT( text ); LVCOLUMN lvColumn; lvColumn.mask = LVCF_FMT|LVCF_TEXT; lvColumn.fmt = LVCFMT_LEFT; lvColumn.pszText = const_cast<wchar_t*>( text ); ListView_InsertColumn( control, index, &lvColumn ); }
Saver& Saver::End() { NST_ASSERT( chunks.Size() > 1 ); const dword written = chunks.Pop(); chunks.Back() += 4 + 4 + written; stream.Seek( -idword(written + 4) ); stream.Write32( written ); stream.Seek( written ); return *this; }
void NotificationHandler::OnNotify(Param& param) { NST_ASSERT( param.lParam ); const NMHDR& nmhdr = *reinterpret_cast<const NMHDR*>(param.lParam); if (control == nmhdr.idFrom) { Items::iterator it(items.find( nmhdr.code )); if (it != items.end()) it->second( nmhdr ); } }
void Configuration::Node::CheckReference(wcstring const key) const { NST_ASSERT( key ); if (map.empty()) { if (*key && !referenced) Io::Log() << "Configuration: warning, unused/invalid parameter: \"" << key << "\"\r\n"; } else for (Map::const_iterator it(map.begin()), end(map.end()); it != end; ++it) { it->second.CheckReference( it->first.Ptr() ); } }
void Renderer::FilterNtsc::BlitType(const Input& input,const Output& output,uint phase) const { NST_ASSERT( phase < 3 ); const uint bgcolor = this->bgColor; const Input::Pixel* NST_RESTRICT src = input.pixels; Pixel* NST_RESTRICT dst = static_cast<Pixel*>(output.pixels); const long pad = output.pitch - (NTSC_WIDTH-7) * sizeof(Pixel); phase &= lut.noFieldMerging; for (uint y=HEIGHT; y; --y) { NES_NTSC_BEGIN_ROW( &lut, phase, bgcolor, bgcolor, *src++ ); for (const Input::Pixel* const end=src+(NTSC_WIDTH/7*3-3); src != end; src += 3, dst += 7) { NES_NTSC_COLOR_IN( 0, src[0] ); NES_NTSC_RGB_OUT( 0, dst[0], BITS ); NES_NTSC_RGB_OUT( 1, dst[1], BITS ); NES_NTSC_COLOR_IN( 1, src[1] ); NES_NTSC_RGB_OUT( 2, dst[2], BITS ); NES_NTSC_RGB_OUT( 3, dst[3], BITS ); NES_NTSC_COLOR_IN( 2, src[2] ); NES_NTSC_RGB_OUT( 4, dst[4], BITS ); NES_NTSC_RGB_OUT( 5, dst[5], BITS ); NES_NTSC_RGB_OUT( 6, dst[6], BITS ); } NES_NTSC_COLOR_IN( 0, bgcolor ); NES_NTSC_RGB_OUT( 0, dst[0], BITS ); NES_NTSC_RGB_OUT( 1, dst[1], BITS ); NES_NTSC_COLOR_IN( 1, bgcolor ); NES_NTSC_RGB_OUT( 2, dst[2], BITS ); NES_NTSC_RGB_OUT( 3, dst[3], BITS ); NES_NTSC_COLOR_IN( 2, bgcolor ); NES_NTSC_RGB_OUT( 4, dst[4], BITS ); NES_NTSC_RGB_OUT( 5, dst[5], BITS ); NES_NTSC_RGB_OUT( 6, dst[6], BITS ); dst = reinterpret_cast<Pixel*>(reinterpret_cast<byte*>(dst) + pad); phase = (phase + 1) % 3; } }
cstring DirectSound::Update ( const uint deviceId, const uint rate, const uint bits, const Channels channels, const uint latency, const Pool pool, const bool globalFocus ) { NST_ASSERT( deviceId < adapters.list.size() ); if (device.id != deviceId || !device) { device.id = deviceId; Destroy(); if (FAILED(::DirectSoundCreate8( &adapters.list[device.id].guid, &device, NULL ))) return "DirectSoundCreate8()"; Io::Log() << "DirectSound: creating device #" << device.id << "\r\n"; device.priority = SUCCEEDED(device->SetCooperativeLevel( device.hWnd, DSSCL_PRIORITY )); device.buggy = adapters.list[device.id].buggy; if (!device.priority) { Io::Log() << "DirectSound: warning, IDirectSound8::SetCooperativeLevel( DSSCL_PRIORITY ) failed! Retrying with DSSCL_NORMAL..\r\n"; if (FAILED(device->SetCooperativeLevel( device.hWnd, DSSCL_NORMAL ))) { device.Release(); return "IDirectSound8::SetCooperativeLevel()"; } } } if (cstring errMsg = buffer.Update( **device, device.priority, rate, bits, channels, latency, pool, globalFocus )) { Destroy(); return errMsg; } return NULL; }
void Instance::Global::Hooks::OnCreate(const CREATESTRUCT& createStruct,HWND const hWnd) { NST_ASSERT( hWnd ); if (window == createStruct.hwndParent || !window) { { static const wchar_t menuClassName[] = L"#32768"; // documented on MSDN enum { MAX_LENGTH = NST_MAX( sizeof(array(appClassName)) - 1, NST_MAX( sizeof(array(STATUSCLASSNAME)) - 1, sizeof(array(menuClassName)) - 1 )) }; String::Stack<MAX_LENGTH,wchar_t> name; name.ShrinkTo( ::GetClassName( hWnd, name.Ptr(), MAX_LENGTH+1 ) ); if (name.Equal( menuClassName ) || name.Equal( STATUSCLASSNAME ) || name.Equal( L"IME" )) return; if (window) { children.PushBack( hWnd ); Events::Signal( EVENT_SYSTEM_BUSY ); } else if (name.Equal( appClassName )) { window = hWnd; } else { return; } } const Events::WindowCreateParam param = { hWnd, createStruct.cx > 0 ? createStruct.cx : 0, createStruct.cy > 0 ? createStruct.cy : 0 }; Events::Signal( EVENT_WINDOW_CREATE, ¶m ); } }
void Configuration::Node::Save(Xml::Node node,wcstring const key) const { NST_ASSERT( node && (!key || *key) ); if (map.empty()) { if (key) node.AddChild( key, string.Ptr() ); } else { if (key) node = node.AddChild( key ); for (Map::const_iterator it(map.begin()), end(map.end()); it != end; ++it) it->second.Save( node, it->first.Ptr() ); } }
bool Input::Commands::ForcePoll() { NST_ASSERT( keys.Size() ); Keys::Iterator it = keys.Begin(); Keys::ConstIterator const end = keys.End(); do { if (it->GetToggle( it->prev )) { window.PostCommand( it->cmd ); return true; } } while (++it != end); return false; }
bool Time::Set(wcstring const path) { NST_ASSERT( path && *path ); WIN32_FILE_ATTRIBUTE_DATA data; SYSTEMTIME system, local; if ( !::GetFileAttributesEx( path, GetFileExInfoStandard, &data ) || !::FileTimeToSystemTime( &data.ftLastWriteTime, &system ) || !::SystemTimeToTzSpecificLocalTime( NULL, &system, &local ) ) return false; SetLocal( &local ); return true; }
int Launcher::List::Files::Strings::Find(const GenericString needle) const { wcstring it = container.Ptr(); wcstring const end = it + container.Length(); NST_ASSERT( *(end-1) == '\0' ); do { const GenericString string( it ); if (needle == string) return it - container.Ptr(); it += string.Length() + 1; } while (it != end); return -1; }
dword ReadChecksum(const uint type,const uint index,Context::Rom& rom) { NST_ASSERT( type < 2 && index < 16 ); for (dword crc=stream.Read32(), i=0; i < 8; ++i) { uint c = crc >> (i*4) & 0xF; rom.crc[i] = (c < 0xA ? '0' + c : 'A' + (c - 0xA) ); } Log() << "Unif: " << (type ? "CHR-ROM " : "PRG-ROM ") << char(index < 10 ? index + '0' : index-10 + 'A') << " CRC: " << rom.crc << NST_LINEBREAK; return 4; }
void ListView::Item::TextProxy::GetText(Buffer& buffer) const { NST_ASSERT( buffer.Empty() ); LVITEM lvItem; lvItem.iSubItem = index; do { buffer.Resize( buffer.Length() + BLOCK_SIZE ); lvItem.cchTextMax = buffer.Length() + 1; lvItem.pszText = buffer.Ptr(); lvItem.cchTextMax = item.control.Send( LVM_GETITEMTEXT, item.index, &lvItem ); } while (*(buffer.Ptr() + buffer.Length())); buffer.ShrinkTo( lvItem.cchTextMax ); }
NES_HOOK(FamilyKeyboard::DataRecorder,Tape) { for (const qaword next = qaword(cpu.GetCycles()) * multiplier; cycles < next; cycles += clock) { if (status == PLAYING) { if (pos < stream.Size()) { const uint data = stream[pos++]; if (data >= 0x8C) { in = 0x2; } else if (data <= 0x74) { in = 0x0; } } else { Stop( false ); break; } } else { NST_ASSERT( status == RECORDING ); if (stream.Size() < MAX_LENGTH) { stream.Append( (out & 0x7) == 0x7 ? 0x90 : 0x70 ); } else { Stop( false ); break; } } } }
static void WINAPIV Run(void* data) { const Entry local( *static_cast<Entry*>(data) ); NST_ASSERT( local.hEnter && local.hExit ); if (local.priority) ::SetThreadPriority( ::GetCurrentThread(), local.priority ); ::SetEvent( local.hEnter ); try { local.callback( local.terminator ); } catch (...) { } ::SetEvent( local.hExit ); }
dword ReadRom(const uint type,const uint index,dword length,Context::Rom* const roms) { NST_ASSERT( type < 2 && index < 16 ); Log() << "Unif: " << (type ? "CHR-ROM " : "PRG-ROM ") << char(index < 10 ? index + '0' : index-10 + 'A') << " size: " << (length / SIZE_1K) << "k" NST_LINEBREAK; dword available = 0; for (uint i=0; i < 16; ++i) available += roms[i].data.Size(); available = MAX_ROM_SIZE - available; NST_VERIFY( length <= available ); if (length > available) { roms[index].truncated = length - available; length = available; Log() << "Unif: warning, " << (type ? "CHR-ROM " : "PRG-ROM ") << char(index < 10 ? index + '0' : index-10 + 'A') << " truncated to: " << (length / SIZE_1K) << "k" NST_LINEBREAK; } if (length) { roms[index].data.Set( length ); stream.Read( roms[index].data.Mem(), length ); } return length; }
void Datach::Reader::SaveState(State::Saver& state,const dword baseChunk) const { if (Reader::IsTransferring()) { NST_ASSERT( cycles != Cpu::CYCLE_MAX ); state.Begin( baseChunk ); state.Begin( AsciiId<'P','T','R'>::V ).Write8( stream - data ).End(); state.Begin( AsciiId<'D','A','T'>::V ).Compress( data ).End(); uint next; if (cycles > cpu.GetCycles()) next = (cycles - cpu.GetCycles()) / cpu.GetClock(); else next = 0; state.Begin( AsciiId<'C','Y','C'>::V ).Write16( next ).End(); state.End(); } }
Device& AdapterTwo::GetDevice(uint port) const { NST_ASSERT( port < 2 ); return *devices[port]; }
Device& AdapterFour::GetDevice(uint port) const { NST_ASSERT( port < 4 ); return *devices[port]; }
uint AdapterTwo::Peek(uint line) { NST_ASSERT( line < 2 ); return devices[line]->Peek( line ); }
static uint GetLightMap(uint pixel) { NST_ASSERT( pixel < Video::Screen::PALETTE ); return lightMap[pixel]; }