开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
Nestreme.cpp
资源名称：fcSOURCE.rar　[点击查看]
上传用户：luhy168
上传日期：2022-01-10
资源大小：240k
文件大小：62k
源码类别：

模拟服务器

开发平台：

Visual C++

Nestreme.cpp：源码内容
  1. //------------------------------------------------------------------------------
  2. // Name: Nestreme.cpp
  3. // Desc: 
  4. //
  5. // Things still left to add in the debugger.
  6. // =========================================
  7. // 1.  Viewing all the memory, main, stack, prg-rom, chr-rom
  8. // 2.  Adding the memory registers to the register list view.
  9. // 3.  Better breakpoints, adding in dialog box, setting when dissassembling.
  10. // 4.  Step over.
  11. // 5.  View screen shot.
  12. // 6.  Editing memory.
  13. // 7.  
  14. //
  15. // Things to add to the CPU.
  16. // =========================
  17. // 1.  More acurate cpu cycle emulation.
  18. // 2.  Test all the instructions.
  19. // 3.  Update cpu bytes and cycles array.
  20. //
  21. // Things to add to the PPU.
  22. // =========================
  23. // 1.  Accurate emulation of registers 2005/2006.
  24. //------------------------------------------------------------------------------
  27. // Includes
  28. #include <windows.h>
  29. #include <commctrl.h>
  30. #include <afxres.h>
  31. #include <stdio.h>
  32. #include "resource.h"
  34. #include "Nestreme.h"
  35. #include "Cpu.h"
  36. #include "Io.h"
  37. #include "PrintInstrToString.h"
  38. #include "Gfx.h"
  39. #include "Sound.h"
  40. #include "NESData.h"
  43. //------------------------------------------------------------------------------
  44. // Name: WinMain()
  45. // Desc: Main entry point for a windows application.
  46. //------------------------------------------------------------------------------
  47. INT WINAPI WinMain(HINSTANCE hInstance,
  48.    HINSTANCE hPrevInst,
  49.    LPSTR lpCmdLine,
  50.    int nCmdShow)
  51. {
  52. MSG    msg;
  53. HACCEL hAccel;
  55. // Save the global variables
  56. g_hInstance = hInstance;
  58. // Initialize our classes.
  59. if (InitializeApp() != S_OK)
  60. return TRUE;
  62. // Create our main window
  63. hwndMain = CreateWindowEx(WS_EX_OVERLAPPEDWINDOW,
  64.   strClassName,
  65.   strAppName,
  66.   WS_OVERLAPPEDWINDOW,
  67.   CW_USEDEFAULT,
  68.   CW_USEDEFAULT,
  69.   CW_USEDEFAULT,
  70.   CW_USEDEFAULT,
  71.   NULL,
  72.   NULL,
  73.   hInstance,
  74.   NULL);
  76. // Make sure we could create our window.
  77. if (hwndMain == NULL)
  78. return TRUE;
  80. // Load the keyboard accelerators.
  81. hAccel = LoadAccelerators(g_hInstance, MAKEINTRESOURCE(IDR_MAINACCEL));
  83. // Show and update our window.
  84. ShowWindow(hwndMain, SW_SHOWMAXIMIZED);
  85. UpdateWindow(hwndMain);
  87. // Now enter our main windows messaging loop.
  88. while (GetMessage(&msg, NULL, 0, 0))
  89. {
  90.     if (!TranslateAccelerator(hwndMain, hAccel, &msg))
  91. {
  92. TranslateMessage(&msg);
  93. DispatchMessage(&msg);
  94. }
  95. } // end windows messaging loop.
  97. // Make sure to delete everything we allocate.
  98. CleanUp();
  100. return msg.wParam;
  101. } // end WinMain()
  104. //------------------------------------------------------------------------------
  105. // Name: WndProcMain()
  106. // Desc: Our message handling procedure for windows messages.
  107. //------------------------------------------------------------------------------
  108. LRESULT CALLBACK WndProcMain(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  109. {
  110. HANDLE hThreadGo;    // Handle to the thread created when go is selected.
  111. DWORD  dwThreadIDGo; // Thread ID of the thread created when go is selected.
  113. switch (uMsg)
  114. {
  115. case WM_QUIT:
  116. case WM_DESTROY:
  117. PostQuitMessage(0);
  118. break;
  120. case WM_CREATE: 
  121. CreateMDIClientWindow(hwnd);
  122. break;
  124. case WM_COMMAND:
  125. switch (LOWORD(wParam))
  126. {
  127. case ID_DEBUG_BREAK:
  128. bBreak = TRUE;
  129. break;
  131. case ID_DEBUG_GO:
  132. hThreadGo = CreateThread(NULL, 0, CPU_RunUntilBreak, 
  133. NULL, NULL, &dwThreadIDGo);
  134. if (hThreadGo == NULL)
  135. FATAL(hwnd, "Couldn't create thread for execution.");
  136. break;
  138. case ID_DEBUG_RESTART:
  139. ResetNES();
  140. break;
  142. case ID_DEBUG_STEPINTO:
  143. CPU_Step();
  144. break;
  146. case ID_FILE_FREE:
  147. FreeNESFile();
  148. break;
  150. case ID_FILE_OPEN:
  151. LoadNESFile(hwnd);
  152. break;
  154. case ID_FILE_RUN:
  155. bRunning = TRUE;
  156. hThreadRun = CreateThread(NULL, 0, CPU_Run, 
  157. NULL, NULL, &dwThreadIDRun);
  158. if (hThreadRun == NULL)
  159. FATAL(hwnd, "Couldn't create thread for execution.");
  160. break;
  162. case ID_FILE_EXIT:
  163. PostQuitMessage(0);
  164. break;
  166. case ID_VIEW_MEMORY:
  167. CreateMemoryWindow(hwnd);
  168. break;
  170. case ID_VIEW_DISASSEMBLY:
  171. CreateDebugWindow(hwnd);
  172. DissassembleROM();
  173. UpdateDebugInfo();
  174. break;
  176. case ID_WINDOW_TILEHORIZONTALLY:
  177. SendMessage(hwndMDIClient, WM_MDITILE, MDITILE_HORIZONTAL, 0);
  178. break;
  180. case ID_WINDOW_TILEVERTICALLY:
  181. SendMessage(hwndMDIClient, WM_MDITILE, MDITILE_VERTICAL, 0);
  182. break;
  183. }
  185. default:
  186. return DefFrameProc(hwnd, hwndMDIClient, uMsg, wParam, lParam);
  187. }
  189. return 0;
  190. } // end WndProcMain()
  193. //------------------------------------------------------------------------------
  194. // Name: WndProcDebug()
  195. // Desc: Our message handling procedure for windows messages.
  196. //------------------------------------------------------------------------------
  197. LRESULT CALLBACK WndProcDebug(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  198. {
  199. switch (uMsg)
  200. {
  201. case WM_NOTIFY:
  202. // Process notification messages.            
  203. switch (((LPNMHDR)lParam)->code) 
  204. { 
  205. case NM_DBLCLK:
  206. ToggleBreakpoint(((LPNMITEMACTIVATE)lParam)->iItem);
  207. break;
  208. }
  209. break;
  211. case WM_SIZE:
  212. ResizeDebugControls(hwndDebugWnd, hwndCodeLV, hwndRegsLV);
  214. default:
  215. return DefMDIChildProc(hwnd, uMsg, wParam, lParam);
  216. }
  218. return 0;
  219. } // end WndProcDebug()
  222. //------------------------------------------------------------------------------
  223. // Name: WndProcMemory()
  224. // Desc: Our message handling procedure for windows messages.
  225. //------------------------------------------------------------------------------
  226. LRESULT CALLBACK WndProcMemory(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  227. {
  228. static HWND hwndEdit = NULL;      // Handle to the edit control to hold the memory contents.
  229. static HWND hwndButton = NULL;    // Handle to the refresh button.
  230. static HWND hwndMemoryTab = NULL; // Handle to the memory tab control.
  232. switch (uMsg)
  233. {
  234. case WM_COMMAND:
  235. if (HIWORD(wParam) == BN_CLICKED) 
  236. {
  237. // Display the memory that corresponds, on what tab is selected.
  238. switch (TabCtrl_GetCurSel(hwndMemoryTab))
  239. {
  240. case 0:
  241. // Dump the main memory to the control.
  242. DisplayMainMemDump(hwndEdit);
  243. break;
  245. case 1:
  246. // Dump the stack memory to the control.
  247. DisplayStackMemDump(hwndEdit);
  248. break;
  250. case 2:
  251. // Dump the PRG-ROM memory to the control.
  252. DisplayPRGROMMemDump(hwndEdit);
  253. break;
  255. case 3:
  256. // Dump the PPU memory to the control.
  257. DisplayPPUMemDump(hwndEdit);
  258. break;
  260. case 4:
  261. // Dump the Sprite memory to the control.
  262. DisplaySpriteMemDump(hwndEdit);
  263. break;
  265. default:
  266. break;
  267. }
  268. }
  269. break;
  271. case WM_CREATE:
  272. // Create the tab control to hold all the different types of memory.
  273. if ((hwndMemoryTab = CreateTabControl(hwnd, IDS_MEMORY_MAIN, 5)) == NULL)
  274. FATAL(hwnd, "Couldn't create tab control.");
  276. // Create the edit control and initialize it.
  277. if (CreateMemoryDump(hwnd, &hwndEdit, &hwndButton) != S_OK)
  278. FATAL(hwnd, "Couldn't create the edit window.")
  280. // Dump the memory to the control.
  281. DisplayMainMemDump(hwndEdit);
  282. break;
  284. case WM_NOTIFY: 
  285. switch (((LPNMHDR) lParam)->code)
  286. { 
  287. case TCN_SELCHANGE: 
  288. {
  289. RECT rc;
  291. // Create the edit control and initialize it.
  292. if (CreateMemoryDump(hwnd, &hwndEdit, &hwndButton) != S_OK)
  293. FATAL(hwnd, "Couldn't create the edit window.")
  295. // Display the memory that corresponds, on what tab is selected.
  296. switch (TabCtrl_GetCurSel(hwndMemoryTab))
  297. {
  298. case 0:
  299. // Dump the main memory to the control.
  300. DisplayMainMemDump(hwndEdit);
  301. break;
  303. case 1:
  304. // Dump the stack memory to the control.
  305. DisplayStackMemDump(hwndEdit);
  306. break;
  308. case 2:
  309. // Dump the PRG-ROM memory to the control.
  310. DisplayPRGROMMemDump(hwndEdit);
  311. break;
  313. case 3:
  314. // Dump the PPU memory to the control.
  315. DisplayPPUMemDump(hwndEdit);
  316. break;
  318. case 4:
  319. // Dump the Sprite memory to the control.
  320. DisplaySpriteMemDump(hwndEdit);
  321. break;
  323. default:
  324. break;
  325. }
  327. // Update the window by calling sending the size message.
  328. GetClientRect(hwnd, &rc);
  329. SendMessage(hwnd, WM_SIZE, SIZE_RESTORED, MAKELPARAM(rc.right-rc.left, rc.bottom-rc.top));
  330. break; 
  331. }
  333. case TCN_SELCHANGING:
  334. DestroyWindow(hwndEdit);
  335. DestroyWindow(hwndButton);
  336. break;
  337. } 
  338. break; 
  340.         case WM_SIZE: 
  341. { 
  342.                 HDWP hdwp; 
  343.                 RECT rc; 
  344.  
  345.                 // Calculate the display rectangle, assuming the 
  346.                 // tab control is the size of the client area. 
  347.                 SetRect(&rc, 0, 0, LOWORD(lParam), HIWORD(lParam)); 
  348.                 TabCtrl_AdjustRect(hwndMemoryTab, FALSE, &rc); 
  349.  
  350.                 // Size the tab control to fit the client area. 
  351.                 hdwp = BeginDeferWindowPos(3); 
  352.                 DeferWindowPos(hdwp, hwndMemoryTab, NULL, 0, 0, 
  353.                     LOWORD(lParam), HIWORD(lParam), SWP_NOMOVE | SWP_NOZORDER); 
  354.  
  355.                 // Position and size the button control to fit at
  356. // the bottom of the tab control window.
  357.                 DeferWindowPos(hdwp, hwndButton, HWND_TOP, rc.left,
  358. rc.bottom-rc.top, 70, 20, 0); 
  360. // Position and size the edit control to fit the 
  361.                 // tab control's display area minus some room for
  362. // the button, and make sure the edit control is 
  363. // in front of the tab control. 
  364.                 DeferWindowPos(hdwp, hwndEdit, HWND_TOP, rc.left, rc.top, 
  365.                     rc.right-rc.left, rc.bottom-rc.top-30, 0); 
  366.                 EndDeferWindowPos(hdwp); 
  367. } 
  369. default:
  370. return DefMDIChildProc(hwnd, uMsg, wParam, lParam);
  371. }
  373. return 0;
  374. } // end WndProcMemory()
  377. //------------------------------------------------------------------------------
  378. // Name: WndProcRun()
  379. // Desc: Our message handling procedure for windows messages.
  380. //------------------------------------------------------------------------------
  381. LRESULT CALLBACK WndProcRun(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  382. {
  383. switch (uMsg)
  384. {
  385. case WM_DESTROY:
  386. case WM_CLOSE:
  387. // Tell the thread that runs the program to exit.
  388. bRunning = FALSE;
  389. break;
  391. case WM_KEYDOWN:
  392. switch (wParam)
  393. {
  394. case VK_ESCAPE:
  395. bRunning = FALSE;
  396. break;
  398. case 0x41: // A
  399. Joy1.SetButton(JOYSELECT);
  400. break;
  402. case 0x53: // S
  403. Joy1.SetButton(JOYSTART);
  404. break;
  406. case 0x5A: // Z
  407. Joy1.SetButton(JOYB);
  408. break;
  410. case 0x58: // X
  411. Joy1.SetButton(JOYA);
  412. break;
  414. case VK_UP:
  415. Joy1.SetButton(JOYUP);
  416. break;
  418. case VK_DOWN:
  419. Joy1.SetButton(JOYDOWN);
  420. break;
  422. case VK_LEFT:
  423. Joy1.SetButton(JOYLEFT);
  424. break;
  426. case VK_RIGHT:
  427. Joy1.SetButton(JOYRIGHT);
  428. break;
  430. case 0x31: // 1
  431. Options_bBackgroundEnabled ^= TRUE;
  432. break;
  434. case 0x32: // 2
  435. Options_bSpritesEnabled ^= TRUE;
  436. break;
  438. default:
  439. break;
  440. }
  441. break;
  443. case WM_KEYUP:
  444. switch (wParam)
  445. {
  446. case 0x41: // A
  447. Joy1.ClearButton(JOYSELECT);
  448. break;
  450. case 0x53: // S
  451. Joy1.ClearButton(JOYSTART);
  452. break;
  454. case 0x5A: // Z
  455. Joy1.ClearButton(JOYB);
  456. break;
  458. case 0x58: // X
  459. Joy1.ClearButton(JOYA);
  460. break;
  462. case VK_UP:
  463. Joy1.ClearButton(JOYUP);
  464. break;
  466. case VK_DOWN:
  467. Joy1.ClearButton(JOYDOWN);
  468. break;
  470. case VK_LEFT:
  471. Joy1.ClearButton(JOYLEFT);
  472. break;
  474. case VK_RIGHT:
  475. Joy1.ClearButton(JOYRIGHT);
  476. break;
  478. default:
  479. break;
  480. }
  481. break;
  483. case WM_SIZE:
  484. UpdateBounds(hwnd);
  486. default:
  487. return DefMDIChildProc(hwnd, uMsg, wParam, lParam);
  488. }
  490. return 0;
  491. } // end WndProcRun()
  494. //------------------------------------------------------------------------------
  495. // Name: AddBreakpoint()
  496. // Desc: Adds a breakpoint to the array of breakpoints.
  497. //------------------------------------------------------------------------------
  498. HRESULT AddBreakpoint(WORD wAddress, UINT uListViewItem)
  499. {
  500. // As long as we have room for another breakpoint add it to the array,
  501. // and check the list view check box.
  502. if (dwNumBreakpoints < OPTIONS_NUM_BREAKPOINTS)
  503. {
  504. awBreakpoints[dwNumBreakpoints++] = wAddress;
  505. ListView_Check(hwndCodeLV, uListViewItem);
  506. }
  507. else
  508. FATAL(hwndMain, "No more breakpoints allowed.");
  510. return S_OK;
  511. } // end AddBreakpoint()
  514. //------------------------------------------------------------------------------
  515. // Name: AddRegistersToListView()
  516. // Desc: Adds all the registers to the registers list view.
  517. //------------------------------------------------------------------------------
  518. HRESULT AddRegistersToListView()
  519. {
  520. char strText[128]; // Text to hold the info to be added.
  522. // Add the A register.
  523. ADD_VAR_TO_REG_LISTVIEW(0, "A", CPU.A);
  524. // Add the X register.
  525. ADD_VAR_TO_REG_LISTVIEW(1, "X", CPU.X);
  526. // Add the Y register.
  527. ADD_VAR_TO_REG_LISTVIEW(2, "Y", CPU.Y);
  528. // Add the SP register.
  529. ADD_VAR_TO_REG_LISTVIEW(3, "SP", CPU.S);
  530. // Add the PC register.
  531. ADD_VAR_TO_REG_LISTVIEW(4, "PC", CPU.P);
  532. // Add the flags register.
  533. ADD_VAR_TO_REG_LISTVIEW(5, "Flags", CPU.F);
  534. // Add a blank space in the list view.
  535. ADD_BLANK_TO_REG_LISTVIEW(6);
  537. // Add the Nintendo registers to the list view.
  538. ADD_VAR_TO_REG_LISTVIEW(7, "$2000", CPU.Memory[0x2000]);
  539. ADD_VAR_TO_REG_LISTVIEW(8, "$2001", CPU.Memory[0x2001]);
  540. ADD_VAR_TO_REG_LISTVIEW(9, "$2002", CPU.Memory[0x2002]);
  541. ADD_VAR_TO_REG_LISTVIEW(10, "$2003", CPU.Memory[0x2003]);
  542. ADD_VAR_TO_REG_LISTVIEW(11, "$2004", CPU.Memory[0x2004]);
  543. ADD_VAR_TO_REG_LISTVIEW(12, "$2005", CPU.Memory[0x2005]);
  544. ADD_VAR_TO_REG_LISTVIEW(13, "$2006", CPU.Memory[0x2006]);
  545. ADD_VAR_TO_REG_LISTVIEW(14, "$2007", CPU.Memory[0x2007]);
  546. ADD_VAR_TO_REG_LISTVIEW(15, "$4000", CPU.Memory[0x4000]);
  547. ADD_VAR_TO_REG_LISTVIEW(16, "$4001", CPU.Memory[0x4001]);
  548. ADD_VAR_TO_REG_LISTVIEW(17, "$4002", CPU.Memory[0x4002]);
  549. ADD_VAR_TO_REG_LISTVIEW(18, "$4003", CPU.Memory[0x4003]);
  550. ADD_VAR_TO_REG_LISTVIEW(19, "$4004", CPU.Memory[0x4004]);
  551. ADD_VAR_TO_REG_LISTVIEW(20, "$4005", CPU.Memory[0x4005]);
  552. ADD_VAR_TO_REG_LISTVIEW(21, "$4006", CPU.Memory[0x4006]);
  553. ADD_VAR_TO_REG_LISTVIEW(22, "$4007", CPU.Memory[0x4007]);
  554. ADD_VAR_TO_REG_LISTVIEW(23, "$4008", CPU.Memory[0x4008]);
  555. ADD_VAR_TO_REG_LISTVIEW(24, "$4009", CPU.Memory[0x4009]);
  556. ADD_VAR_TO_REG_LISTVIEW(25, "$4010", CPU.Memory[0x4010]);
  557. ADD_VAR_TO_REG_LISTVIEW(26, "$4011", CPU.Memory[0x4011]);
  558. ADD_VAR_TO_REG_LISTVIEW(17, "$4012", CPU.Memory[0x4012]);
  559. ADD_VAR_TO_REG_LISTVIEW(18, "$4013", CPU.Memory[0x4013]);
  560. ADD_VAR_TO_REG_LISTVIEW(19, "$4014", CPU.Memory[0x4014]);
  561. ADD_VAR_TO_REG_LISTVIEW(30, "$4015", CPU.Memory[0x4015]);
  562. ADD_VAR_TO_REG_LISTVIEW(31, "$4016", CPU.Memory[0x4016]);
  563. ADD_VAR_TO_REG_LISTVIEW(32, "$4017", CPU.Memory[0x4017]);
  565. // Add a blank space in the list view.
  566. ADD_BLANK_TO_REG_LISTVIEW(33);
  567. // Add the cycles to the list view.
  568. sprintf(strText, "Cycles");
  569. InsertListViewText(hwndRegsLV, 34, 0, strText);
  570. sprintf(strText, "%d", CPU.byCycles);
  571. InsertListViewText(hwndRegsLV, 34, 1, strText);
  572. // Add the scanlines to the list view.
  573. sprintf(strText, "Scanline");
  574. InsertListViewText(hwndRegsLV, 35, 0, strText);
  575. sprintf(strText, "%d", wScanline);
  576. InsertListViewText(hwndRegsLV, 35, 1, strText);
  577. // Add the VRAM address to the list view.
  578. ADD_VAR_TO_REG_LISTVIEW(36, "VRAM Address", wVRAMAddress);
  580. return S_OK;
  581. } // end AddRegistersToListView()
  584. //------------------------------------------------------------------------------
  585. // Name: CleanUp()
  586. // Desc: Deletes everthing that has been dynamically created.
  587. //------------------------------------------------------------------------------
  588. HRESULT CleanUp()
  589. {
  590. // Delete our rom that we allocated.
  591. FreeNESFile();
  593. return S_OK;
  594. } // end CleanUp()
  597. //------------------------------------------------------------------------------
  598. // Name: CreateMemoryDump()
  599. // Desc: Creates an edit control to hold our memory contents and
  600. //       a button for refreshing them.
  601. //------------------------------------------------------------------------------
  602. HRESULT CreateMemoryDump(HWND hwndParent, HWND* phwndEdit, HWND* phwndButton)
  603. {
  604. // Create the edit control.
  605. *phwndEdit = CreateWindow("EDIT", NULL,
  606. WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_BORDER | ES_LEFT | ES_MULTILINE | ES_READONLY, 
  607. 20, 20, 200, 200, hwndParent, NULL, g_hInstance, NULL);
  609. *phwndButton = CreateWindow( 
  610. "BUTTON",   // predefined class 
  611. "Refresh",       // button text 
  612. WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,  // styles 
  613. 0,         // starting x position 
  614. 0,         // starting y position 
  615. 40,        // button width 
  616. 20,        // button height 
  617. hwndParent, // parent window 
  618. NULL,       // No menu 
  619. g_hInstance, 
  620. NULL);      // pointer not needed 
  622. // Set the text to a fixed width font and the background color to white.
  623. SendMessage(*phwndEdit, WM_SETFONT, (WPARAM)GetStockObject(ANSI_FIXED_FONT), TRUE);
  624. SendMessage(*phwndButton, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
  626. return S_OK;
  627. } // CreateMemoryDump()
  630. //------------------------------------------------------------------------------
  631. // Name: CreateDebugWindow()
  632. // Desc: Creates the window to hold our disassembly and register contents.
  633. //       This is a MDI child window with a splitter to separate the registers
  634. //       and the code disassembly.
  635. //------------------------------------------------------------------------------
  636. HRESULT CreateDebugWindow(HWND hwndParent)
  637. {
  638. // Create the child window for the code and registers.
  639. hwndDebugWnd = CreateWindowEx(WS_EX_MDICHILD,
  640.   strDebugClassName,
  641.   strDebugTitleName,
  642.   WS_CHILD,
  643.   CW_USEDEFAULT,
  644.   CW_USEDEFAULT,
  645.   CW_USEDEFAULT,
  646.   CW_USEDEFAULT,
  647.   hwndMDIClient,
  648.   NULL,
  649.   g_hInstance,
  650.   NULL);
  651. if (hwndDebugWnd == NULL)
  652. FATAL(hwndParent, "Couldn't Create the debug window");
  654. ShowWindow(hwndDebugWnd, SW_SHOWMAXIMIZED);
  656. // Create the code list view box
  657. hwndCodeLV = CreateListView(hwndDebugWnd, IDS_CODE_COLUMN0, 4);
  658. if (hwndCodeLV == NULL)
  659. FATAL(hwndParent, "Couldn't create the code list view. Make sure IE3 is installed.");
  661. // Create the registers list view.
  662. hwndRegsLV = CreateListView(hwndDebugWnd, IDS_REGS_COLUMN0, 2);
  663. if (hwndCodeLV == NULL)
  664. FATAL(hwndParent, "Couldn't create the registers list view. Make sure IE3 is installed.");
  666. // Set the font to a fixed width font
  667. SendMessage(hwndCodeLV, WM_SETFONT, (WPARAM)GetStockObject(ANSI_FIXED_FONT), TRUE);
  668. SendMessage(hwndRegsLV, WM_SETFONT, (WPARAM)GetStockObject(ANSI_FIXED_FONT), TRUE);
  670. // Set the extended styles for the list views.
  671. ListView_SetExtendedListViewStyle(hwndCodeLV, 
  672. LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_CHECKBOXES);
  674. // Create and resize the code and registers list boxes
  675. // to fit the child window.
  676. ResizeDebugControls(hwndDebugWnd, hwndCodeLV, hwndRegsLV);
  678. // Add the registers to the registers list view.
  679. AddRegistersToListView();
  681. // Create the tooltip window for viewing our memory contents.
  682. //CreateTooltip(hwndCodeLV, "Hello!");
  683. //SendMessage(hwndCodeLV, LVM_SETTOOLTIPS, 0, (LPARAM)hwndTT);
  685. return S_OK;
  686. } // end CreateDebugWindow()
  689. //------------------------------------------------------------------------------
  690. // Name: CreateListView()
  691. // Desc: Creates a list view control, initializes the columns, and
  692. //       returns the handle to the window if successful.
  693. //------------------------------------------------------------------------------
  694. HWND CreateListView(HWND hWndParent, UINT uFirstColRsc, UINT uNumColumns)
  695. {
  696. HWND      hwndListView;
  697. LV_COLUMN lvC;
  698. char      strCol[50];
  700. // Create a list view control in report view.
  701. hwndListView = CreateWindowEx(0L, WC_LISTVIEW, "", WS_VISIBLE | WS_CHILD |
  702.   WS_CHILD | LVS_REPORT | LVS_SINGLESEL | LVS_SHOWSELALWAYS,
  703.   0, 0, 0, 0, hWndParent, 
  704.   NULL, g_hInstance, NULL);
  705. if (hwndListView == NULL)
  706.   return NULL;
  708. // Create columns.
  709. lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  710. lvC.fmt = LVCFMT_LEFT;
  711. lvC.cx = 150;
  712. lvC.pszText = strCol;
  714. // Add the columns.
  715. for (UINT i = 0; i < uNumColumns; i++)
  716. {
  717. lvC.iSubItem = i;
  718. LoadString(g_hInstance, uFirstColRsc+i, strCol, sizeof(strCol));
  719. if (ListView_InsertColumn(hwndListView, i, &lvC) == -1)
  720. return NULL;
  721. }
  723. return hwndListView;
  724. } // end CreateListView()
  727. //------------------------------------------------------------------------------
  728. // Name: CreateMDIClientWindow()
  729. // Desc: Creates the client window for our frame window.
  730. //------------------------------------------------------------------------------
  731. HRESULT CreateMDIClientWindow(HWND hwndFrame)
  732. {
  733. CLIENTCREATESTRUCT ccs; 
  735. // Retrieve the handle to the window menu and assign the 
  736. // first child window identifier. 
  737. ccs.hWindowMenu = GetSubMenu(GetMenu(hwndFrame), WINDOWMENU);
  738. ccs.idFirstChild = IDM_WINDOWCHILD;
  740. // Create the MDI client window.
  741. hwndMDIClient = CreateWindow( "MDICLIENT", (LPCTSTR)NULL,
  742. WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL,
  743. 0, 0, 0, 0, hwndFrame, (HMENU)0xCAC, g_hInstance, (LPSTR)&ccs);
  745. ShowWindow(hwndMDIClient, SW_SHOW);
  747. return S_OK;
  748. } // end CreateMDIClientWindow()
  751. //------------------------------------------------------------------------------
  752. // Name: CreateMemoryWindow()
  753. // Desc: Creates the window hold our memory contents.
  754. //------------------------------------------------------------------------------
  755. HRESULT CreateMemoryWindow(HWND hwndParent)
  756. {
  757. // Create the child window for the code and registers.
  758. hwndMemoryWnd = CreateWindowEx(WS_EX_MDICHILD,
  759.    strMemoryClassName,
  760.    strMemoryTitleName,
  761.    WS_CHILD,
  762.    CW_USEDEFAULT,
  763.    CW_USEDEFAULT,
  764.    CW_USEDEFAULT,
  765.    CW_USEDEFAULT,
  766.    hwndMDIClient,
  767.    NULL,
  768.    g_hInstance,
  769.    NULL);
  770. if (hwndMemoryWnd == NULL)
  771. FATAL(hwndParent, "Couldn't Create the debug window");
  773. return S_OK;
  774. } // end CreateMemoryWindow()
  777. //------------------------------------------------------------------------------
  778. // Name: CreateTabControl()
  779. // Desc: Creates a tab control, sized to fit the specified parent window's 
  780. //       client area, and adds the number of tabs passed into the function. 
  781. //       All the strings in the string table must be in order.
  782. //------------------------------------------------------------------------------
  783. HWND WINAPI CreateTabControl(HWND hwndParent, UINT uTextResource, UINT uNumTabs)
  784. { 
  785. RECT   rcClient;     // Client rectangle coordinates.
  786. HWND   hwndTab;      // Window handle to the tab control.
  787. TCITEM tie;          // Tab item struction
  788. char   strText[128]; // Text to hold the string of the tab
  790. // Get the dimensions of the parent window's client area, and 
  791. // create a tab control child window of that size. 
  792. GetClientRect(hwndParent, &rcClient); 
  793. hwndTab = CreateWindow(WC_TABCONTROL, "", 
  794. WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE, 
  795. 0, 0, rcClient.right, rcClient.bottom, 
  796. hwndParent, NULL, g_hInstance, NULL); 
  797. if (hwndTab == NULL) 
  798. return NULL; 
  800. // Add the number of tabs passed to the function.
  801. tie.mask = TCIF_TEXT | TCIF_IMAGE; 
  802. tie.iImage = -1; 
  803. tie.pszText = strText; 
  805. for (UINT i = 0; i < uNumTabs; i++) 
  806. { 
  807. LoadString(g_hInstance, uTextResource+i, strText, sizeof(strText)); 
  808. if (TabCtrl_InsertItem(hwndTab, i, &tie) == -1) 
  809. { 
  810. DestroyWindow(hwndTab); 
  811. return NULL; 
  812. } 
  813. } 
  815. // Set the font of the control.
  816. SendMessage(hwndTab, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
  818. return hwndTab; 
  819. } // CreateTabControl()
  822. //------------------------------------------------------------------------------
  823. // Name: CreateTooltip()
  824. // Desc: Creates a tooltip window adding the string as the text.
  825. //------------------------------------------------------------------------------
  826. HRESULT CreateTooltip(HWND hwnd, LPSTR strToolTip)
  827. {
  828. TOOLINFO ti;      // struct specifying info about tool in tooltip control.
  829. UINT     uid = 0; // for ti initialization.
  830. RECT     rect;    // for client area coordinates.
  832. // Create the tooltip window.
  833. hwndTT = CreateWindowEx(WS_EX_TOPMOST,
  834. TOOLTIPS_CLASS,
  835. NULL,
  836. WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
  837. CW_USEDEFAULT,
  838. CW_USEDEFAULT,
  839. CW_USEDEFAULT,
  840. CW_USEDEFAULT,
  841. hwnd,
  842. NULL,
  843. g_hInstance,
  844. NULL);
  846. // Set the window position.
  847. SetWindowPos(hwndTT,
  848. HWND_TOPMOST,
  849. 0,
  850. 0,
  851. 0,
  852. 0,
  853. SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
  855. // Get coordinates of the main window.
  856. GetClientRect(hwnd, &rect);
  858. // Initialize the members fo the tool tip info structure.
  859. ti.cbSize = sizeof(TOOLINFO);
  860. ti.uFlags = TTF_SUBCLASS;
  861. ti.hwnd = hwnd;
  862. ti.hinst = g_hInstance;
  863. ti.uId = uid;
  864. ti.lpszText = strToolTip;
  866. // Tooltip control will cover the whole window
  867. ti.rect.left = rect.left;    
  868. ti.rect.top = rect.top;
  869. ti.rect.right = rect.right;
  870. ti.rect.bottom = rect.bottom;
  872. // Send a message to add the tooltip
  873. SendMessage(hwndTT, TTM_ADDTOOL, 0, (LPARAM)(LPTOOLINFO)&ti);
  874. SendMessage(hwndTT, TTM_ACTIVATE, (WPARAM)TRUE, 0);
  876. return S_OK;
  877. } // end CreateTooltip()
  880. //------------------------------------------------------------------------------
  881. // Name: DisableBreakpoint()
  882. // Desc: Disables a breakpoint by removing it from the breakpoint array.
  883. //------------------------------------------------------------------------------
  884. HRESULT DisableBreakpoint(UINT uBreakpointIndex, UINT uListViewItem)
  885. {
  886. // Remove the breakpoint from the array by setting it 0.
  887. awBreakpoints[uBreakpointIndex] = 0;
  889. // Copy all the old breakpoints into the old position.
  890. for (int i = uBreakpointIndex; i < OPTIONS_NUM_BREAKPOINTS-1; i++)
  891. awBreakpoints[i] = awBreakpoints[i+1];
  893. // Uncheck the breakpoint in the list view.
  894. ListView_UnCheck(hwndCodeLV, uListViewItem);
  896. // Finally decrement the number of breakpoints.
  897. dwNumBreakpoints--;
  899. return S_OK;
  900. } // end DisableBreakpoint()
  903. //------------------------------------------------------------------------------
  904. // Name: DisplayMainMemDump()
  905. // Desc: Dumps the main memory to a string and sets the text of an edit
  906. //       control to that string.
  907. //------------------------------------------------------------------------------
  908. HRESULT DisplayMainMemDump(HWND hwndEditCtrl)
  909. {
  910. char  strMemDump[0x1FFFF];       // String to hold the memory dump.
  911. char* pstrMemDump = strMemDump; // Pointer to the memory dump string.
  913. // Dump the first part of main memory to the string.
  914. sprintf(pstrMemDump, "Main Memory: %c%c%c%c%c%c", 13, 13, 10, 13, 13, 10);
  915. pstrMemDump += strlen(strMemDump);
  916. MemoryDumpToString(&pstrMemDump, &CPU.Memory[0], 0, 0x8000);
  918. // Set the text in the edit control.
  919. SendMessage(hwndEditCtrl, WM_SETTEXT, 0, (LPARAM) strMemDump);
  921. return S_OK;
  922. } // DisplayMainMemDump()
  925. //------------------------------------------------------------------------------
  926. // Name: DisplayPPUMemDump()
  927. // Desc: Dumps the PPU memory to a string and sets the text of an edit
  928. //       control to that string.
  929. //------------------------------------------------------------------------------
  930. HRESULT DisplayPPUMemDump(HWND hwndEditCtrl)
  931. {
  932. char  strMemDump[0x1FFFF];       // String to hold the memory dump.
  933. char* pstrMemDump = strMemDump; // Pointer to the memory dump string.
  935. // Dump the first bank of CHR-ROM to the string.
  936. sprintf(pstrMemDump, "CHR-ROM Bank 1: %c%c%c%c%c%c", 13, 13, 10, 13, 13, 10);
  937. pstrMemDump += 22;
  938. MemoryDumpToString(&pstrMemDump, &(*(PPU.apbyPatternTables[0])), 0, 0x1000);
  940. // Dump the second bank of CHR-ROM to the string.
  941. sprintf(pstrMemDump, "%c%c%c%c%c%cCHR-ROM Bank 2: %c%c%c%c%c%c", 
  942. 13, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10);
  943. pstrMemDump += 28;
  944. MemoryDumpToString(&pstrMemDump, &(*(PPU.apbyPatternTables[1])), 0, 0x1000);
  946. // Dump the first name and attribute table to the string.
  947. sprintf(pstrMemDump, "%c%c%c%c%c%cName Table 1: %c%c%c%c%c%c", 
  948. 13, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10);
  949. pstrMemDump += 26;
  950. MemoryDumpToString(&pstrMemDump, &(*(PPU.apbyNameTables[0])), 0, 0x400);
  952. // Dump the second name and attribute table to the string.
  953. sprintf(pstrMemDump, "%c%c%c%c%c%cName Table 2: %c%c%c%c%c%c", 
  954. 13, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10);
  955. pstrMemDump += 26;
  956. MemoryDumpToString(&pstrMemDump, &(*(PPU.apbyNameTables[1])), 0, 0x400);
  958. // Dump the third name and attribute table to the string.
  959. sprintf(pstrMemDump, "%c%c%c%c%c%cName Table 3: %c%c%c%c%c%c", 
  960. 13, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10);
  961. pstrMemDump += 26;
  962. MemoryDumpToString(&pstrMemDump, &(*(PPU.apbyNameTables[2])), 0, 0x400);
  964. // Dump the fourth name and attribute table to the string.
  965. sprintf(pstrMemDump, "%c%c%c%c%c%cName Table 4: %c%c%c%c%c%c", 
  966. 13, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10);
  967. pstrMemDump += 26;
  968. MemoryDumpToString(&pstrMemDump, &(*(PPU.apbyNameTables[3])), 0, 0x400);
  970. // Dump the palettes to the string.
  971. sprintf(pstrMemDump, "%c%c%c%c%c%cPalettes: %c%c%c%c%c%c", 
  972. 13, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10);
  973. pstrMemDump += 22;
  974. MemoryDumpToString(&pstrMemDump, &(PPU.abyPalettes[0]), 0, 0x20);
  976. // Set the text in the edit control.
  977. SendMessage(hwndEditCtrl, WM_SETTEXT, 0, (LPARAM) strMemDump);
  979. return S_OK;
  980. } // DisplayPPUMemDump()
  983. //------------------------------------------------------------------------------
  984. // Name: DisplayPRGROMMemDump()
  985. // Desc: Dumps the stack memory to a string and sets the text of an edit
  986. //       control to that string.
  987. //------------------------------------------------------------------------------
  988. HRESULT DisplayPRGROMMemDump(HWND hwndEditCtrl)
  989. {
  990. char  strMemDump[0x1FFFF];       // String to hold the memory dump.
  991. char* pstrMemDump = strMemDump; // Pointer to the memory dump string.
  993. // Dump the first bank of memory to the string.
  994. sprintf(pstrMemDump, "PRG-ROM Bank 1: %c%c%c%c%c%c", 13, 13, 10, 13, 13, 10);
  995. pstrMemDump += 22;
  996. MemoryDumpToString(&pstrMemDump, &(*CPU.pbyPRGROMBank1), 0, 0x4000);
  998. // Dump the second bank of memory to the string.
  999. sprintf(pstrMemDump, "%c%c%c%c%c%cPRG-ROM Bank 2: %c%c%c%c%c%c", 
  1000. 13, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10);
  1001. pstrMemDump += 28;
  1002. MemoryDumpToString(&pstrMemDump, &(*CPU.pbyPRGROMBank2), 0, 0x4000);
  1004. // Set the text in the edit control.
  1005. SendMessage(hwndEditCtrl, WM_SETTEXT, 0, (LPARAM) strMemDump);
  1007. return S_OK;
  1008. } // DisplayPRGROMMemDump()
  1011. //------------------------------------------------------------------------------
  1012. // Name: DisplaySpriteMemDump()
  1013. // Desc: Dumps the sprite memory to a string and sets the text of an edit
  1014. //       control to that string.
  1015. //------------------------------------------------------------------------------
  1016. HRESULT DisplaySpriteMemDump(HWND hwndEditCtrl)
  1017. {
  1018. char  strMemDump[0xFFFF];       // String to hold the memory dump.
  1019. char* pstrMemDump = strMemDump; // Pointer to the memory dump string.
  1021. // Dump the sprite memory to the string.
  1022. sprintf(pstrMemDump, "Sprite Memory: %c%c%c%c%c%c", 13, 13, 10, 13, 13, 10);
  1023. pstrMemDump += strlen(strMemDump);
  1024. MemoryDumpToString(&pstrMemDump, abySPRRAM, 0, 0x100);
  1026. // Set the text in the edit control.
  1027. SendMessage(hwndEditCtrl, WM_SETTEXT, 0, (LPARAM) strMemDump);
  1029. return S_OK;
  1030. } // DisplaySpriteMemDump()
  1033. //------------------------------------------------------------------------------
  1034. // Name: DisplayStackMemDump()
  1035. // Desc: Dumps the stack memory to a string and sets the text of an edit
  1036. //       control to that string.
  1037. //------------------------------------------------------------------------------
  1038. HRESULT DisplayStackMemDump(HWND hwndEditCtrl)
  1039. {
  1040. char  strMemDump[0xFFFF];       // String to hold the memory dump.
  1041. char* pstrMemDump = strMemDump; // Pointer to the memory dump string.
  1043. // Dump the stack memory to the string.
  1044. sprintf(pstrMemDump, "Stack Memory: %c%c%c%c%c%c", 13, 13, 10, 13, 13, 10);
  1045. pstrMemDump += strlen(strMemDump);
  1046. MemoryDumpToString(&pstrMemDump, &CPU.Memory[0x100], 0, 0x100);
  1048. // Set the text in the edit control.
  1049. SendMessage(hwndEditCtrl, WM_SETTEXT, 0, (LPARAM) strMemDump);
  1051. return S_OK;
  1052. } // DisplayStackMemDump()
  1055. //------------------------------------------------------------------------------
  1056. // Name: DissassembleROM()
  1057. // Desc: Dissassembles the rom from the current PC position and displays
  1058. //       the results in the code dissassemble list box.
  1059. //------------------------------------------------------------------------------
  1060. HRESULT DissassembleROM()
  1061. {
  1062. char strInstr[128]; // String to hold the instruction output.
  1063. WORD wPC = CPU.P;   // Temporary PC register.
  1064. BYTE byNumBytes;    // Number of bytes to add to the temp PC register.
  1066. // Clear the list view.
  1067. ListView_DeleteAllItems(hwndCodeLV);
  1069. // Display all the instructions.
  1070. for (int i = 0; i < OPTIONS_NUM_DEBUGLINES; i++)
  1071. {
  1072. // Reset the instruction string.
  1073. memset(strInstr, '', 128);
  1075. // Print the instruction to our string.
  1076. byNumBytes = PrintInstrToString(strInstr, wPC);
  1078. // Add the strings to the code list view.
  1079. InsertListViewText(hwndCodeLV, i, 0, &strInstr[DISASM_PC_OFFSET]);
  1080. InsertListViewText(hwndCodeLV, i, 1, &strInstr[DISASM_MACHINECODE_OFFSET]);
  1081. InsertListViewText(hwndCodeLV, i, 2, &strInstr[DISASM_INSTRUCTION_OFFSET]);
  1082. InsertListViewText(hwndCodeLV, i, 3, &strInstr[DISASM_MEMCONTENTS_OFFSET]);
  1084. // TODO: Make sure to add the breakpoint stuff here.
  1086. // Move to the next instruction.
  1087. wPC += byNumBytes;
  1088. }
  1090. return S_OK;
  1091. } // end DissassembleROM()
  1094. //------------------------------------------------------------------------------
  1095. // Name: FreeNESFile()
  1096. // Desc: Unloads the ROM that has been loaded so a new one can be loaded.
  1097. //------------------------------------------------------------------------------
  1098. HRESULT FreeNESFile()
  1099. {
  1100. // Free the mapper library.
  1101. FreeLibrary(hinstMapperLib);
  1103. // Delete our rom that we allocated.
  1104. SAFE_DELETE_ARRAY(abyPRGROM);
  1105. SAFE_DELETE_ARRAY(abyCHRROM);
  1107. return S_OK;
  1108. } // end FreeNESFile()
  1111. //------------------------------------------------------------------------------
  1112. // Name: InitializeApp()
  1113. // Desc: Does any initialization that needs to be done before the
  1114. //       main windows loop begins.
  1115. //------------------------------------------------------------------------------
  1116. HRESULT InitializeApp()
  1117. {
  1118. WNDCLASS wc;
  1119. INITCOMMONCONTROLSEX icex;
  1121. // Register the frame windows class.
  1122. wc.cbClsExtra    = 0;
  1123. wc.cbWndExtra    = 0;
  1124. wc.hbrBackground = (HBRUSH)GetStockObject(DKGRAY_BRUSH);
  1125. wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
  1126. wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
  1127. wc.hInstance     = g_hInstance;
  1128. wc.lpfnWndProc   = (WNDPROC)WndProcMain;
  1129. wc.lpszClassName = strClassName;
  1130. wc.lpszMenuName  = MAKEINTRESOURCE(IDR_MAINMENU);
  1131. wc.style         = CS_HREDRAW | CS_VREDRAW;
  1133. if (!RegisterClass(&wc))
  1134. return ERROR;
  1136. // Register the debug window class. 
  1137.     wc.hIcon         = LoadIcon(g_hInstance, IDI_APPLICATION); 
  1138.     wc.lpfnWndProc   = (WNDPROC)WndProcDebug; 
  1139.     wc.lpszClassName = strDebugClassName; 
  1140.     wc.lpszMenuName  = (LPSTR)NULL; 
  1141.  
  1142.     if (!RegisterClass(&wc)) 
  1143.         return ERROR;
  1145. // Register the memory window class.
  1146.     wc.hIcon         = LoadIcon(g_hInstance, IDI_APPLICATION); 
  1147.     wc.lpfnWndProc   = (WNDPROC)WndProcMemory; 
  1148.     wc.lpszClassName = strMemoryClassName; 
  1149.     wc.lpszMenuName  = (LPSTR)NULL; 
  1151.     if (!RegisterClass(&wc)) 
  1152.         return ERROR;
  1154. // Register the run window class.
  1155.     wc.hIcon         = LoadIcon(g_hInstance, IDI_APPLICATION); 
  1156.     wc.lpfnWndProc   = (WNDPROC)WndProcRun; 
  1157.     wc.lpszClassName = strRunClassName; 
  1158.     wc.lpszMenuName  = (LPSTR)NULL; 
  1160.     if (!RegisterClass(&wc)) 
  1161.         return ERROR;
  1163. // Ensure that the common control DLL is loaded. 
  1164. icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
  1165. icex.dwICC  = ICC_LISTVIEW_CLASSES;
  1166. InitCommonControlsEx(&icex); 
  1168. // Initialize the global variables
  1169. abyPRGROM = NULL;
  1170. abyCHRROM = NULL;
  1172. return S_OK;
  1173. } // InitializeApp()
  1176. //------------------------------------------------------------------------------
  1177. // Name: InsertListViewText()
  1178. // Desc: Inserts text into an item of a list view control.
  1179. //------------------------------------------------------------------------------
  1180. HRESULT InsertListViewText(HWND hwndLV, UINT uRow, UINT uCol, LPSTR strText)
  1181. {
  1182. LV_ITEM lvI; // List view item structure.
  1184. // Fill out the item structure.
  1185. lvI.mask = LVIF_TEXT;
  1186. lvI.iItem = uRow;
  1187. lvI.iSubItem = uCol;
  1188. lvI.pszText = strText;
  1189. lvI.state = 0;
  1190. lvI.stateMask = 0;
  1191.     
  1192. // Add the item. First try adding it as an item. If that doesn't work,
  1193. // then try adding the item as a subitem. If no good, return an error.
  1194. if (ListView_InsertItem(hwndLV, &lvI) == -1)
  1195. if (ListView_SetItem(hwndLV, &lvI) == FALSE)
  1196. return ERROR;
  1198. return S_OK;
  1199. } // end InsertListViewText()
  1202. //------------------------------------------------------------------------------
  1203. // Name: LoadNESFile()
  1204. // Desc: Called when the user selected Open from the File menu. Loads
  1205. //       the ROM into memory and sets the program up for debugging or
  1206. //       runs the game depending on the option set.
  1207. //------------------------------------------------------------------------------
  1208. HRESULT LoadNESFile(HWND hwnd)
  1209. {
  1210. char strMapperLibName[512]; // FileName for the mapper .dll.
  1212. // Popup the open file dialog box.
  1213. PromptForFileOpen(hwnd);
  1215. // Load the ROM into memory.
  1216. LoadROMToMem((LPSTR)strFileName);
  1218. // Save the number of program and character rom pages.
  1219. wNumPRGROMPages = abyRomHeader[4];
  1220. wNumCHRROMPages = abyRomHeader[5];
  1222. // Some games only hold one (1) 16K bank of PRG-ROM, 
  1223. // which should be loaded into both $C000 and $8000.
  1224. // Otherwise initialize the banks to the first 2 pages.
  1225. if (abyRomHeader[4] == 1)
  1226. {
  1227. CPU.pbyPRGROMBank1 = &abyPRGROM[0];
  1228. CPU.pbyPRGROMBank2 = &abyPRGROM[0];
  1229. }
  1230. else
  1231. {
  1232. CPU.pbyPRGROMBank1 = &abyPRGROM[0];
  1233. CPU.pbyPRGROMBank2 = &abyPRGROM[NES_PRGROM_PAGESIZE];
  1234. }
  1236. // Initialize the pattern tables to point to the first and
  1237. // second banks of CHR-ROM.
  1238. PPU.apbyPatternTables[0] = &abyCHRROM[0];
  1239. PPU.apbyPatternTables[1] = &abyCHRROM[NES_CHRROM_PAGESIZE];
  1241. // Initialize the pointers to the name tables depending on the
  1242. // mirroring of the ROM. Bit 1 of the rom header offset 6
  1243. // is 1 for vertical mirroring and 0 for horizontal mirroring.
  1244. if (abyRomHeader[6] & 1)
  1245. {
  1246. // For vertical mirroring, name tables 0 and 2 point to
  1247. // the first name table and name tables 1 and 3 point to
  1248. // the second name table.
  1249. PPU.apbyNameTables[0] = &PPU.abyNameTables[0];
  1250. PPU.apbyNameTables[1] = &PPU.abyNameTables[0x400];
  1251. PPU.apbyNameTables[2] = &PPU.abyNameTables[0];
  1252. PPU.apbyNameTables[3] = &PPU.abyNameTables[0x400];
  1253. }
  1254. else
  1255. {
  1256. // For horizontal mirroring, name tables 0 and 1 point to
  1257. // the first name table and name tables 2 and 3 point to
  1258. // the second name table.
  1259. PPU.apbyNameTables[0] = &PPU.abyNameTables[0];
  1260. PPU.apbyNameTables[1] = &PPU.abyNameTables[0];
  1261. PPU.apbyNameTables[2] = &PPU.abyNameTables[0x400];
  1262. PPU.apbyNameTables[3] = &PPU.abyNameTables[0x400];
  1263. }
  1265. // Get the string for the file of the mapper .dll
  1266. sprintf(strMapperLibName, ".\mappers\mapper%d.dll", (abyRomHeader[6]>>4)|(abyRomHeader[7]&0xF0));
  1268. // Load the mapper .dll
  1269. if ((hinstMapperLib = LoadLibrary(strMapperLibName)) == NULL)
  1270. FATAL(hwnd, "Could not find the .dll for the mapper.");
  1272. // Get all the function addresses and save them.
  1273. if (hinstMapperLib != NULL)
  1274. {
  1275. MapperOnLoad = (MAPPERLOAD)GetProcAddress(hinstMapperLib, "?OnLoad@@YAHPAUtagNESData@@@Z");
  1276. MapperOnRead = (MAPPERREAD)GetProcAddress(hinstMapperLib, "?OnRead@@YAEG@Z");
  1277. MapperOnWrite = (MAPPERWRITE)GetProcAddress(hinstMapperLib, "?OnWrite@@YAHGE@Z");
  1278. }
  1280. // Make a call to the mapper to do anything that may have to 
  1281. // happen during a load. This usually involves setting up the
  1282. // pointers to PRG-ROM and CHR-ROM. Also use this as a time to
  1283. // pass the pointers to our variables that are needed by the
  1284. // memory mapper.
  1286. NESDATA NesData;
  1287. NesData.pCPU = &CPU;
  1288. NesData.pPPU = &PPU;
  1289. NesData.pabyPRGROM = abyPRGROM;
  1290. NesData.wNumPRGROMPages = wNumPRGROMPages;
  1291. NesData.pabyCHRROM = abyCHRROM;
  1292. NesData.wNumCHRROMPages = wNumCHRROMPages;
  1294. MapperOnLoad(&NesData);
  1296. // Reset the NES.
  1297. ResetNES();
  1299. // Now if debug is set in the options then create the window 
  1300. // to hold our disassembly and register contents disassemble
  1301. // the rom starting at the current PC position.
  1302. CreateDebugWindow(hwnd);
  1304. // Dissassemble the beginning of the NES Rom.
  1305. DissassembleROM();
  1307. // Update the debugging information.
  1308. UpdateDebugInfo();
  1310. return S_OK;
  1311. } // end LoadNESFile()
  1314. //------------------------------------------------------------------------------
  1315. // Name: LoadROMToMem()
  1316. // Desc: Loads the ROM into memory for use. The .NES file is 
  1317. //       structure as follow (copied from Yoshi's nes doc.
  1318. //
  1319. //    +--------+------+------------------------------------------+
  1320. //    | Offset | Size | Content(s)                               |
  1321. //    +--------+------+------------------------------------------+
  1322. //    |   0    |  3   | 'NES'                                    |
  1323. //    |   3    |  1   | $1A                                      |
  1324. //    |   4    |  1   | 16K PRG-ROM page count                   |
  1325. //    |   5    |  1   | 8K CHR-ROM page count                    |
  1326. //    |   6    |  1   | ROM Control Byte #1                      |
  1327. //    |        |      |   %####vTsM                              |
  1328. //    |        |      |    |  ||||+- 0=Horizontal mirroring      |
  1329. //    |        |      |    |  ||||   1=Vertical mirroring        |
  1330. //    |        |      |    |  |||+-- 1=SRAM enabled              |
  1331. //    |        |      |    |  ||+--- 1=512-byte trainer present  |
  1332. //    |        |      |    |  |+---- 1=Four-screen mirroring     |
  1333. //    |        |      |    |  |                                  |
  1334. //    |        |      |    +--+----- Mapper # (lower 4-bits)     |
  1335. //    |   7    |  1   | ROM Control Byte #2                      |
  1336. //    |        |      |   %####0000                              |
  1337. //    |        |      |    |  |                                  |
  1338. //    |        |      |    +--+----- Mapper # (upper 4-bits)     |
  1339. //    |  8-15  |  8   | $00                                      |
  1340. //    | 16-..  |      | Actual 16K PRG-ROM pages (in linear      |
  1341. //    |  ...   |      | order). If a trainer exists, it precedes |
  1342. //    |  ...   |      | the first PRG-ROM page.                  |
  1343. //    | ..-EOF |      | CHR-ROM pages (in ascending order).      |
  1344. //    +--------+------+------------------------------------------+
  1345. //
  1346. //------------------------------------------------------------------------------
  1347. HRESULT LoadROMToMem(LPSTR strRomFileName)
  1348. {
  1349. FILE* pRomFile = NULL;  // File pointer for NES Rom.
  1351. // Open the .NES file for reading.
  1352. if ((pRomFile = fopen(strRomFileName, "rb")) == NULL)
  1353. FATAL(hwndMain, "Couldn't open nes file for reading.");
  1355. // Read the rom's header.
  1356. fread(abyRomHeader, 16, 1, pRomFile);
  1358. // For now skip the trainer if it exists.
  1359. if (abyRomHeader[6] & 0x04)
  1360. fseek(pRomFile, 512, SEEK_CUR);
  1362. // Allocate our memory for PRG-ROM and load the pages into memory.
  1363. abyPRGROM = new BYTE[abyRomHeader[4]*NES_PRGROM_PAGESIZE];
  1364. fread(abyPRGROM, NES_PRGROM_PAGESIZE, abyRomHeader[4], pRomFile);
  1366. // Allocate our memory for CHR-ROM and load the pages into memory.
  1367. abyCHRROM = new BYTE[abyRomHeader[5]*(NES_CHRROM_PAGESIZE*2)];
  1368. fread(abyCHRROM, (NES_CHRROM_PAGESIZE*2), abyRomHeader[5], pRomFile);
  1370. // Close the file.
  1371. fclose(pRomFile);
  1373. return S_OK;
  1374. } // end LoadROMToMem()
  1377. //------------------------------------------------------------------------------
  1378. // Name: MemoryDumpToString()
  1379. // Desc: Writes the memory dump of the passed variable in bytes. It places
  1380. //       the memory text in the string passed to the function.
  1381. //------------------------------------------------------------------------------
  1382. HRESULT MemoryDumpToString(char** pstrMemory, BYTE* pMemory, UINT uStartByte, 
  1383.    UINT uEndByte)
  1384. {
  1385. // Start at the beginning byte passed to this function and begin
  1386. // disassembling. Every 16 bytes put the address at the left corner.
  1387. for (UINT i = 0; i < uEndByte - uStartByte; i++)
  1388. {
  1389. // Display the current address.
  1390. if ((i % 16) == 0)
  1391. {
  1392. if (i != 0)
  1393. {
  1394. sprintf(*pstrMemory, "%c%c%c", 13, 13, 10);
  1395. *pstrMemory += 3;
  1396. }
  1398. sprintf(*pstrMemory, "%04X: ", i + uStartByte);
  1399. *pstrMemory += 6;
  1400. }
  1402. // Print the memory byte and move on in the string.
  1403. sprintf(*pstrMemory, "%02X ", pMemory[i+uStartByte]);
  1404. *pstrMemory += 3;
  1405. }
  1407. return S_OK;
  1408. } // MemoryDumpToString()
  1411. //------------------------------------------------------------------------------
  1412. // Name: PromptForFileOpen()
  1413. // Desc: Prompts the user with the open file common dialog and 
  1414. //       returns the file name and path of the file the user selected.
  1415. //       If the user presses cancel the this function returns FALSE.
  1416. //------------------------------------------------------------------------------
  1417. HRESULT PromptForFileOpen(HWND hwndOwner)
  1418. {
  1419. OPENFILENAME ofn;
  1421. // Initialize OPENFILENAME
  1422. ZeroMemory(&ofn, sizeof(OPENFILENAME));
  1423. ofn.lStructSize = sizeof(OPENFILENAME);
  1424. ofn.hwndOwner = hwndOwner;
  1425. ofn.hInstance = g_hInstance;
  1426. ofn.lpstrFile = (LPSTR)strFileName;
  1427. ofn.nMaxFile = 512;
  1428. ofn.lpstrFilter = "NES Files (*.nes)*.nes;";
  1429. ofn.nFilterIndex = 1;
  1430. ofn.lpstrFileTitle = NULL;
  1431. ofn.nMaxFileTitle = 0;
  1432. ofn.lpstrInitialDir = NULL;
  1433. ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_EXPLORER;
  1435. // Prompt the user to select the file.
  1436. if (GetOpenFileName(&ofn) == FALSE)
  1437. return FALSE;
  1439. // Save the filename string for the user.
  1440. strcpy((LPSTR)strFileName, ofn.lpstrFile);
  1442. return TRUE;
  1443. } // end PromptForFileOpen()
  1446. //------------------------------------------------------------------------------
  1447. // Name: ResetNES()
  1448. // Desc: Pretty self explainitory, resets the NES.
  1449. //------------------------------------------------------------------------------
  1450. HRESULT ResetNES()
  1451. {
  1452. // Initialize the registers to their values.
  1453. CPU.A = 0;
  1454. CPU.X = 0;
  1455. CPU.Y = 0;
  1456. CPU.S = 0;
  1457. CPU.F = 0;
  1458. CPU.P = MAKEWORD(GetMemoryByte(0xFFFC), GetMemoryByte(0xFFFD));
  1460. // Zero all the memory.
  1461. ZeroMemory(CPU.Memory, 0x8000);
  1463. // Reset the number of cpu cycles until the next scanline.
  1464. CPU.byCycles = NUM_CYCLES_PER_SCANLINE;
  1466. // Now display the updated information.
  1467. UpdateDebugInfo();
  1469. return S_OK;
  1470. } // end ResetNES()
  1473. //------------------------------------------------------------------------------
  1474. // Name: ResizeDebugControls()
  1475. // Desc: Resizes the code dissassembly list box as well as the 
  1476. //       registers list box to fit the child window.
  1477. //------------------------------------------------------------------------------
  1478. HRESULT ResizeDebugControls(HWND hwndChild, HWND hwndCodeLB, HWND hwndRegLB)
  1479. {
  1480. RECT rcChild;    // RECT for the window the controls are in.
  1482. // The the client area of the window these controls are to occupy
  1483. GetClientRect(hwndChild, &rcChild);
  1485. // Compute the coordinates and dimensions that the
  1486. // list boxes will ocupy in the child window. We 
  1487. // want them to fill the whole window.
  1488. int nWidth = rcChild.right - rcChild.left;
  1489. int nHeight = rcChild.bottom - rcChild.top;
  1491. // Now move and resize the listboxes.
  1492. MoveWindow(hwndCodeLB, 0, 0, nWidth-REGISTER_LISTBOX_WIDTH, nHeight, TRUE);
  1493. MoveWindow(hwndRegLB, nWidth-REGISTER_LISTBOX_WIDTH, 0, 
  1494. REGISTER_LISTBOX_WIDTH, nHeight, TRUE);
  1496. return S_OK;
  1497. } // end ResizeDebugControls()
  1500. //------------------------------------------------------------------------------
  1501. // Name: CPU_DoCyclicTasks()
  1502. // Desc: Does all the tasks that must be done at the end of a scanline.
  1503. //------------------------------------------------------------------------------
  1504. HRESULT CPU_DoCyclicTasks()
  1505. {
  1506. // If the cpu cycles are less than 0 then we must do
  1507. // everything that must happen at the end of a scanline.
  1508. if ((signed char)CPU.byCycles < 0)
  1509. {
  1510. // Add the number of cycles per scanline to the cycles.
  1511. CPU.byCycles += NUM_CYCLES_PER_SCANLINE;
  1512. // Increment which scanline are on.
  1513. wScanline++;
  1515. // Check for the sprite #0 hit.
  1516. DoSprite0();
  1518. // If we are passed the number of scanlines on the screen then
  1519. // we are in vblank and we must update register $2002 and 
  1520. // execute an NMI interrupt if bit 7 of $2000 is set.
  1521. if (wScanline == NUM_SCANLINES_SCREEN)
  1522. {
  1523. // Set bit 7 of the PPU status register.
  1524. CPU.Memory[0x2002] |= 0x80;
  1526. // Do the NMI if we need to.
  1527. if (CPU.Memory[0x2000] & 0x80)
  1528. {
  1529. // Push the PC onto the stack high byte first.
  1530. PUSH_BYTE((BYTE)(CPU.P >> 8));
  1531. PUSH_BYTE((BYTE)(CPU.P & 0xFF));
  1533. // Push the flags register onto the stack.
  1534. PUSH_BYTE(CPU.F);
  1536. // Set the interrupt flag.
  1537. CPU.F |= 0x04;
  1539. // Set the PC equal to the address specified in the 
  1540. // vector table for the NMI interrupt.
  1541. CPU.P = MAKEWORD(GetMemoryByte(0xFFFA), GetMemoryByte(0xFFFB));
  1543. // Subtract the interrupt latency from the CPU cycles.
  1544. CPU.byCycles -= 7;
  1546. // Break on the NMI interrupt.
  1547. bBreak = TRUE;
  1548. }
  1549. }
  1551. // If we are done with Vblank then we must update register
  1552. // $2002 and reset the scanline counter.
  1553. if (wScanline == NUM_SCANLINES_VBLANK+NUM_SCANLINES_SCREEN)
  1554. {
  1555. // Clear bit 7 and 6 of the PPU status register.
  1556. CPU.Memory[0x2002] &= 0x3F;
  1557. // Reset the scanline counter.
  1558. wScanline = 0;
  1559. }
  1560. }
  1562. return S_OK;
  1563. } // end CPU_DoCyclicTasks()
  1566. //------------------------------------------------------------------------------
  1567. // Name: CPU_Run()
  1568. // Desc: Runs the NES in run mode.
  1569. //------------------------------------------------------------------------------
  1570. DWORD WINAPI CPU_Run(LPVOID lpParam)
  1571. {
  1572. DWORD dwBeginTime = 0; // The begining time of our frame.
  1573. DWORD dwEndTime   = 0; // The ending time of our frame.
  1574. DWORD dwTotalTime = 0; // The total time of our frame.
  1575. DWORD dwFrames    = 0; // The number of frames drawn in a second.
  1576. MSG   msg;             // Message structure.
  1578. DWORD dwSoundFrameSkip = OPTIONS_NUM_AUDIOFRAMESKIP;
  1579. DWORD dwGfxFrameSkip = OPTIONS_NUM_GFXFRAMESKIP;
  1581. char strFrameCount[128] = {0};
  1584. // Create the child window for running the program.
  1585. hwndRunWnd = CreateWindowEx(WS_EX_MDICHILD,
  1586.     strRunClassName,
  1587. strRunTitleName,
  1588. WS_CHILD,
  1589. CW_USEDEFAULT,
  1590. CW_USEDEFAULT,
  1591. CW_USEDEFAULT,
  1592. CW_USEDEFAULT,
  1593. hwndMDIClient,
  1594. NULL,
  1595. g_hInstance,
  1596. NULL);
  1597. if (hwndRunWnd == NULL)
  1598. FATAL(hwndMDIClient, "Couldn't Create the run window");
  1600. // Create DirectDraw for the window.
  1601. CreateDirectDraw(hwndRunWnd);
  1603. // Create and initialize DirectSound.
  1604. CreateSound(hwndRunWnd);
  1606. // Keep running the program until the user has chosen to stop.
  1607. while (bRunning == TRUE)
  1608. {
  1609. // If there is a message for this window, then we need
  1610. // to process it. Otherwise, we are free to run then 
  1611. // NES ROM until the user has chosen to stop. (bRunning == FALSE)
  1612. if (PeekMessage(&msg, hwndRunWnd, 0, 0, PM_REMOVE))
  1613. {
  1614. DispatchMessage(&msg);
  1615. TranslateMessage(&msg);
  1616. }
  1617. else
  1618. {
  1619. // If we are back at the beginning of the screen
  1620. // then clear the screen to the background color.
  1621. if (wScanline == 0)
  1622. {
  1623. // Start our FPS counter.
  1624. dwBeginTime = GetTickCount();
  1626. // Initialize the surface to do our drawing.
  1627. if (!dwGfxFrameSkip)
  1628. {
  1629. BeginDrawing();
  1630. }
  1632. // Draw all the sprites behind the background.
  1633. if (!dwGfxFrameSkip)
  1634. {
  1635. if (Options_bSpritesEnabled)
  1636. DrawSprites(SPRITE_BEHIND);
  1637. }
  1638. }
  1640. // Single step the cpu.
  1641. RunCPU(RUNCPU_RUN);
  1643. // Do all the cyclic tasks.
  1644. CPU_DoCyclicTasks();
  1646. // Draw the scanline if its one of the scanlines on the screen.
  1647. // i.e Don't draw the scanlines in VBlank.
  1648. if (!dwGfxFrameSkip)
  1649. {
  1650. if ((wScanline < 240) && (CPU.Memory[0x2001] & 0x08) && Options_bBackgroundEnabled)
  1651. DrawScanline();
  1652. }
  1654. // Flip the surfaces if we are done drawing the frame.
  1655. if (wScanline == NUM_SCANLINES_SCREEN)
  1656. {
  1657. // Draw all the sprites in front of the background.
  1658. if (!dwGfxFrameSkip)
  1659. {
  1660. if (Options_bSpritesEnabled)
  1661. DrawSprites(SPRITE_INFRONT);
  1662. }
  1664. // Output the number of frames per second.
  1665. OutputText(strFrameCount, 0, 0, RGB(255, 255, 255), 0);
  1667. // Now that everything has been drawn.
  1668. if (!dwGfxFrameSkip)
  1669. {
  1670. EndDrawing();
  1671. }
  1673. // Update our sound for the frame.
  1674. if (!dwSoundFrameSkip)
  1675. APU_DoFrame();
  1677. if ((dwSoundFrameSkip--) == 0)
  1678. dwSoundFrameSkip = OPTIONS_NUM_AUDIOFRAMESKIP;
  1680. if ((dwGfxFrameSkip--) == 0)
  1681. dwGfxFrameSkip = OPTIONS_NUM_GFXFRAMESKIP;
  1682. }
  1683. else if (wScanline == (NUM_SCANLINES_VBLANK+NUM_SCANLINES_SCREEN-1))
  1684. {
  1685. // Wait so we only go 60 FPS.
  1686. //DWORD dwTemp = GetTickCount();
  1687. //if ((dwTemp - dwBeginTime) < 16)
  1688. // Wait(16 - (dwTemp - dwBeginTime));
  1690. // Calculate the FPS.
  1691. dwFrames++;
  1692. dwEndTime = GetTickCount();
  1693. dwTotalTime += dwEndTime - dwBeginTime;
  1695. // Display the FPS every 1 second.
  1696. if (dwTotalTime >= 1000)
  1697. {
  1698. sprintf(strFrameCount, "Fps = %d", dwFrames);
  1699. dwFrames = 0;
  1700. dwTotalTime = 0;
  1701. }
  1702. }
  1703. }
  1704. }
  1706. // Clean up DirectDraw, DirectSound and destroy the window.
  1707. DestroyDirectDraw();
  1708. DestroySound();
  1709. DestroyWindow(hwndRunWnd);
  1711. return 0;
  1712. } // end CPU_Run()
  1715. //------------------------------------------------------------------------------
  1716. // Name: CPU_RunUntilBreak()
  1717. // Desc: Runs the NES in debug mode until a breakpoint is encountered or
  1718. //       the user selects the break command.
  1719. //------------------------------------------------------------------------------
  1720. DWORD WINAPI CPU_RunUntilBreak(LPVOID lpParam)
  1721. {
  1722. // As long as the user hasn't pressed break or we havn't
  1723. // encountered a breakpoint, keep executing.
  1724. while (bBreak == FALSE)
  1725. {
  1726. // Single step the cpu.
  1727. RunCPU(RUNCPU_STEP);
  1729. // Do all the cyclic tasks.
  1730. CPU_DoCyclicTasks();
  1732. // Check for breakpoints and tell the loop to break
  1733. // if the PC is at a breakpoint.
  1734. for (int i = 0; i < OPTIONS_NUM_BREAKPOINTS; i++)
  1735. {
  1736. if (CPU.P == awBreakpoints[i])
  1737. {
  1738. bBreak = TRUE;
  1739. break;
  1740. }
  1741. }
  1742. }
  1744. // Update all the debugging information and reset the break command.
  1745. UpdateDebugInfo();
  1746. bBreak = FALSE;
  1748. return 0;
  1749. } // end CPU_RunUntilBreak()
  1752. //------------------------------------------------------------------------------
  1753. // Name: CPU_Step()
  1754. // Desc: Single steps through instructions in debug mode.
  1755. //------------------------------------------------------------------------------
  1756. HRESULT CPU_Step()
  1757. {
  1758. // Single step the cpu.
  1759. RunCPU(RUNCPU_STEP);
  1761. // Do all the cyclic tasks.
  1762. CPU_DoCyclicTasks();
  1764. // Update all the debugging information.
  1765. UpdateDebugInfo();
  1767. return S_OK;
  1768. } // end CPU_Step()
  1771. //------------------------------------------------------------------------------
  1772. // Name: SetListViewText()
  1773. // Desc: Sets the text of an item in a list view control.
  1774. //------------------------------------------------------------------------------
  1775. HRESULT SetListViewText(HWND hwndLV, UINT uRow, UINT uCol, LPSTR strText)
  1776. {
  1777. LV_ITEM lvI; // List view item structure.
  1779. // Fill out the item structure.
  1780. lvI.mask = LVIF_TEXT;
  1781. lvI.iItem = uRow;
  1782. lvI.iSubItem = uCol;
  1783. lvI.pszText = strText;
  1784. lvI.state = 0;
  1785. lvI.stateMask = 0;
  1786.     
  1787. // Set the text of the item
  1788. if (ListView_SetItem(hwndLV, &lvI) == FALSE)
  1789. return ERROR;
  1791. return S_OK;
  1792. } // end SetListViewText()
  1795. //------------------------------------------------------------------------------
  1796. // Name: ToggleBreakpoint()
  1797. // Desc: Turns a breakpoint on or off.
  1798. //------------------------------------------------------------------------------
  1799. HRESULT ToggleBreakpoint(UINT uItem)
  1800. {
  1801. char strPC[5];      // Text to hold the PC address of the item.
  1802. char strAddress[5]; // Text to hold the address of the breakpoint.
  1804. // Get the address that the user has selected to add a breakpoint.
  1805. ListView_GetItemText(hwndCodeLV, uItem, 0, strPC, 5);
  1807. // Loop through and see if a breakpoint is already added on this line.
  1808. for (int i = 0; i < OPTIONS_NUM_BREAKPOINTS; i++)
  1809. {
  1810. // Convert the breakpoint address to a string.
  1811. sprintf(strAddress, "%04X", awBreakpoints[i]);
  1813. // If the breakpoint is already on this line, then we
  1814. // need to disable it.
  1815. if (strcmp(strAddress, strPC) == 0)
  1816. return DisableBreakpoint(i, uItem);
  1817. }
  1819. // If the breakpoint does not exist on this line, 
  1820. // then we must add a breakpoint.
  1821. return AddBreakpoint((WORD)strtoul(strPC, NULL, 16), uItem);
  1822. } // end ToggleBreakpoint()
  1825. //------------------------------------------------------------------------------
  1826. // Name: UpdateInstrCursorPos()
  1827. // Desc: Places the selection marker of the code list view on the
  1828. //       current instruction.
  1829. //------------------------------------------------------------------------------
  1830. HRESULT UpdateInstrCursorPos()
  1831. {
  1832. LVFINDINFO lvfi;      // List view find item info.
  1833. DWORD      dwItem;    // Current item to be selected.
  1834. char       strPC[10]; // String of the PC's value.
  1836. // Convert the PC's value to a hexadecimal string
  1837. sprintf(strPC, "%04X:", CPU.P);
  1839. // Initialize the structure to find our PC string.
  1840. lvfi.flags = LVFI_STRING;
  1841. lvfi.psz   = strPC;
  1843. // Find the item in the list view.
  1844. dwItem = ListView_FindItem(hwndCodeLV, -1, &lvfi);
  1846. // If the item is not found then we need to dissassemble the rom
  1847. // again because the program counter is out of range, then select
  1848. // the first instruction.
  1849. if (dwItem == -1)
  1850. {
  1851. DissassembleROM();
  1852. dwItem = 0;
  1853. }
  1855. // Select the item.
  1856. SetFocus(hwndCodeLV);
  1857. ListView_SetItemState(hwndCodeLV, dwItem, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED);
  1859. return S_OK;
  1860. } // end UpdateInstrCursorPos()
  1863. //------------------------------------------------------------------------------
  1864. // Name: UpdateDebugInfo()
  1865. // Desc: Updates all the debugging information in the Registers List View.
  1866. //------------------------------------------------------------------------------
  1867. HRESULT UpdateDebugInfo()
  1868. {
  1869. // Update all the registers.
  1870. UpdateRegisters();
  1872. // Select the current instruction line.
  1873. UpdateInstrCursorPos();
  1875. return S_OK;
  1876. } // end UpdateDebugInfo()
  1879. //------------------------------------------------------------------------------
  1880. // Name: UpdateRegisters()
  1881. // Desc: Updates all the register values in the register list view.
  1882. //------------------------------------------------------------------------------
  1883. HRESULT UpdateRegisters()
  1884. {
  1885. char strText[128]; // Text to hold the info to be added.
  1887. // Update the A register.
  1888. UPDATE_VAR_IN_REG_LISTVIEW(0, "A", CPU.A);
  1889. // Update the X register.
  1890. UPDATE_VAR_IN_REG_LISTVIEW(1, "X", CPU.X);
  1891. // Update the Y register.
  1892. UPDATE_VAR_IN_REG_LISTVIEW(2, "Y", CPU.Y);
  1893. // Update the SP register.
  1894. UPDATE_VAR_IN_REG_LISTVIEW(3, "SP", CPU.S);
  1895. // Update the PC register.
  1896. UPDATE_VAR_IN_REG_LISTVIEW(4, "PC", CPU.P);
  1897. // Update the flags register.
  1898. sprintf(strText, "Flags");
  1899. SetListViewText(hwndRegsLV, 5, 0, strText);
  1900. sprintf(&strText[0], "%c", (CPU.F & 0x80) ? 'S' : 's');
  1901. sprintf(&strText[1], "%c", (CPU.F & 0x40) ? 'V' : 'v');
  1902. sprintf(&strText[2], "%c", ' ');
  1903. sprintf(&strText[3], "%c", (CPU.F & 0x10) ? 'B' : 'b');
  1904. sprintf(&strText[4], "%c", (CPU.F & 0x08) ? 'D' : 'd');
  1905. sprintf(&strText[5], "%c", (CPU.F & 0x04) ? 'I' : 'i');
  1906. sprintf(&strText[6], "%c", (CPU.F & 0x02) ? 'Z' : 'z');
  1907. sprintf(&strText[7], "%c", (CPU.F & 0x01) ? 'C' : 'c');
  1908. SetListViewText(hwndRegsLV, 5, 1, strText);
  1910. // Update the Nintendo registers.
  1911. UPDATE_VAR_IN_REG_LISTVIEW(7, "$2000", CPU.Memory[0x2000]);
  1912. UPDATE_VAR_IN_REG_LISTVIEW(8, "$2001", CPU.Memory[0x2001]);
  1913. UPDATE_VAR_IN_REG_LISTVIEW(9, "$2002", CPU.Memory[0x2002]);
  1914. UPDATE_VAR_IN_REG_LISTVIEW(10, "$2003", CPU.Memory[0x2003]);
  1915. UPDATE_VAR_IN_REG_LISTVIEW(11, "$2004", CPU.Memory[0x2004]);
  1916. UPDATE_VAR_IN_REG_LISTVIEW(12, "$2005", CPU.Memory[0x2005]);
  1917. UPDATE_VAR_IN_REG_LISTVIEW(13, "$2006", CPU.Memory[0x2006]);
  1918. UPDATE_VAR_IN_REG_LISTVIEW(14, "$2007", CPU.Memory[0x2007]);
  1919. UPDATE_VAR_IN_REG_LISTVIEW(15, "$4000", CPU.Memory[0x4000]);
  1920. UPDATE_VAR_IN_REG_LISTVIEW(16, "$4001", CPU.Memory[0x4001]);
  1921. UPDATE_VAR_IN_REG_LISTVIEW(17, "$4002", CPU.Memory[0x4002]);
  1922. UPDATE_VAR_IN_REG_LISTVIEW(18, "$4003", CPU.Memory[0x4003]);
  1923. UPDATE_VAR_IN_REG_LISTVIEW(19, "$4004", CPU.Memory[0x4004]);
  1924. UPDATE_VAR_IN_REG_LISTVIEW(20, "$4005", CPU.Memory[0x4005]);
  1925. UPDATE_VAR_IN_REG_LISTVIEW(21, "$4006", CPU.Memory[0x4006]);
  1926. UPDATE_VAR_IN_REG_LISTVIEW(22, "$4007", CPU.Memory[0x4007]);
  1927. UPDATE_VAR_IN_REG_LISTVIEW(23, "$4008", CPU.Memory[0x4008]);
  1928. UPDATE_VAR_IN_REG_LISTVIEW(24, "$4009", CPU.Memory[0x4009]);
  1929. UPDATE_VAR_IN_REG_LISTVIEW(25, "$4010", CPU.Memory[0x4010]);
  1930. UPDATE_VAR_IN_REG_LISTVIEW(26, "$4011", CPU.Memory[0x4011]);
  1931. UPDATE_VAR_IN_REG_LISTVIEW(27, "$4012", CPU.Memory[0x4012]);
  1932. UPDATE_VAR_IN_REG_LISTVIEW(28, "$4013", CPU.Memory[0x4013]);
  1933. UPDATE_VAR_IN_REG_LISTVIEW(29, "$4014", CPU.Memory[0x4014]);
  1934. UPDATE_VAR_IN_REG_LISTVIEW(30, "$4015", CPU.Memory[0x4015]);
  1935. UPDATE_VAR_IN_REG_LISTVIEW(31, "$4016", CPU.Memory[0x4016]);
  1936. UPDATE_VAR_IN_REG_LISTVIEW(32, "$4017", CPU.Memory[0x4017]);
  1938. // Update the number of cpu cycles.
  1939. sprintf(strText, "Cycles");
  1940. SetListViewText(hwndRegsLV, 34, 0, strText);
  1941. sprintf(strText, "%d", CPU.byCycles);
  1942. SetListViewText(hwndRegsLV, 34, 1, strText);
  1943. // Update the scanline number.
  1944. sprintf(strText, "Scanline");
  1945. SetListViewText(hwndRegsLV, 35, 0, strText);
  1946. sprintf(strText, "%d", wScanline);
  1947. SetListViewText(hwndRegsLV, 35, 1, strText);
  1948. // Update the VRAM Address.
  1949. UPDATE_VAR_IN_REG_LISTVIEW(36, "VRAM Address", wVRAMAddress);
  1950. return S_OK;
  1951. } // end UpdateRegisters()
  1954. //------------------------------------------------------------------------------
  1955. // Name: Wait()
  1956. // Desc: Waits the number of milliseconds passed into the function.
  1957. //------------------------------------------------------------------------------
  1958. __inline VOID Wait(DWORD dwTime)
  1959. {
  1960. DWORD dwBegin = GetTickCount();
  1961. while ((GetTickCount() - dwBegin) <= dwTime);
  1962. } // end Wait()