/************************************************************************
* Dasm.cpp *
* *
* Borg Disassembler *
* v2.24 *
* by Cronos *
* *
* Contributors: *
* Thanks to Mark Ogden for many bugfixes and mods for assembly under *
* VC++, in its early stages (v2 beta builds). Also changes from *
* wvsprintf to wsprintf to allow compilation under VC++. *
* Thanks to Eugen Polukhin for some interesting alternate code and *
* ideas around v2.11 and feedback on fonts, etc. *
* Thanks to Pawe3 Kunio for a lot of coding ideas and advice re C++ *
* usage around v2.22 *
* Thanks to Howard Chu for some coding additions on default names, and *
* more block functions *
************************************************************************/
/************************************************************************
* dasm.cpp *
* - this whole file is a declaration and global routine dumping area *
* - it includes winmain and the main message callback routine, along *
* with initialisation code and the registry read/write code, odd *
* dialog boxes and helper functions for the main routines. The whole *
* file is a bit of a mish-mash of stuff which hasnt found its way *
* elsewhere. *
* - a lot of the code in here has grown, and i mean grown from the *
* ground up, and at some point it will require reorganisation, or *
* maybe that point was long ago.... *
************************************************************************/
#include <windows.h>
#include <commctrl.h>
#include <stdio.h>
//#include "menuids.rh"
#include "resource.h"
#include "exeload.h"
#include "data.h"
#include "schedule.h"
#include "proctab.h"
#include "disasm.h"
#include "dasm.h"
#include "gname.h"
#include "xref.h"
#include "relocs.h"
#include "srch.h"
#include "disio.h"
#include "range.h"
#include "decrypt.h"
#include "registry.h"
#include "help.h"
#include "database.h"
#include "user_fn.h"
#include "debug.h" // for ShowLastError()
//#define _CRTDBG_MAP_ALLOC
//#include <crtdbg.h>
/************************************************************************
* decaration dumping ground........ *
************************************************************************/
//CRITICAL_SECTION cs;
//volatile bool KillThread;
//volatile bool InThread;
globaloptions options;
LOGFONT UserFont;
fileloader floader;
dataseg *dta; // Segmente
schedule scheduler;
disasm *dsm;
//disio dio;
xref *xrefs;
gname *import;
gname *expt;
gname *name; // all other names
relocs *reloc;
range blk;
decrypt decrypter;
char winname[300];
HINSTANCE hInst;
//HANDLE ThreadHandle;
//DWORD ThreadId;
HWND Toolbar; // comctl32.dll's toolbar, most handled like TOOLSTAT.PAS
HWND Status; // comctl32.dll's status bar
HWND MainWnd; // main (frame) window containing Toolbar and Status too
HWND View[2]; // up to two viewer windows on client area of MainWnd
HWND KBHand; // handle of focused modeless dialog box (keyboard handler)
HACCEL Accel; // Accelerator Table
//POINT mainwndsize;
HFONT Font; // disassembly font
bool StockFont; // whether to free the font
POINT CharBox; // font size, for hit testing
HMENU rmenu; // right-click (and Shift+F10) context menu
//bool charinputenabled=false;
char szWinName[]="Dasm";
char program_name[]="Borg Disassembler";
TCHAR current_exe_name[MAX_PATH];
void CalcClientRect(RECT &R) {
// Calculates the client rectangle of MainWnd,
// removing a tool bar and the status line from height
RECT R2;
GetClientRect(MainWnd,&R);
if (Toolbar) {
GetWindowRect(Toolbar,&R2);
ScreenToClient(MainWnd,(LPPOINT)(&R2.right)); // convert the "bottom" member
R.top=R2.bottom;
}
if (Status) {
GetWindowRect(Status,&R2);
ScreenToClient(MainWnd,(LPPOINT)(&R2.left)); // convert the "top" member
R.bottom=R2.top;
}
}
void InitStruct(LPVOID mem, DWORD size) { // initialize most Windows structures
ZeroMemory(mem,size);
*(LPDWORD)mem=size;
}
/************************************************************************
* savefile_text *
* - this is the savefile as text dialog which asks the user to select *
* a file for the save. The filedump is then controlled by disio *
* - this is for text or asm saves *
************************************************************************/
bool savefile_text(HWND,bool printaddrs,bool block) {
TCHAR savefname[MAX_PATH];
UINT FilterIndex;
if (scheduler.sizelist()) {
MessageBox(MainWnd,"There are still items to process yet","Borg Warning",
MB_OK|MB_ICONEXCLAMATION);
return false;
}
savefname[0]=0;
if (!getfiletosave(savefname,elemof(savefname),IDS_FILTERTEXT,FilterIndex))
return false;
StatusMessage("Saving...");
if (block) cvd->dumpblocktofile(savefname,printaddrs);
else cvd->dumptofile(savefname,printaddrs);
StatusMessage("Saved.");
return true;
}
/************************************************************************/
/* Calculates the (global) size of display font, for easier hit-testing */
/************************************************************************/
void SetCharBox(HDC dc) {
TEXTMETRIC tm;
GetTextMetrics(dc,&tm);
CharBox.x=tm.tmAveCharWidth;
CharBox.y=tm.tmHeight+tm.tmExternalLeading;
}
void SetFont(HFONT NewFont, bool NewStockFont) {
if (!NewFont) return; // don't accept non-existing fonts
if (!StockFont && Font) DeleteObject(Font);
Font=NewFont;
StockFont=NewStockFont;
}
/************************************************************************
* setupfont *
* - handles the setting up of a font (like selecting the object for *
* window painting and setting checkmarks on the menu, etc) *
************************************************************************/
void setupfont(byte fontindex) {
static UINT MenuIDs[6]={font_ansi,font_system,font_courier,font_courier10,
font_courier12,font_user};
int i;
HDC hdc;
HFONT ofont;
HMENU hMenu;
LOGFONT lf;
options.font=fontindex;
hdc=GetDC(MainWnd);
hMenu=GetMenu(MainWnd);
ZeroMemory(&lf,sizeof(lf));
lstrcpy(lf.lfFaceName,T("Courier New"));
lf.lfWeight=FW_LIGHT;
for (i=0; i<6; i++) CheckMenuItem(hMenu,MenuIDs[i],
options.font-ansifont==i ? MF_CHECKED : MF_UNCHECKED);
switch (options.font) {
case systemfont: SetFont((HFONT)GetStockObject(SYSTEM_FIXED_FONT),true); break;
case courierfont: {
lf.lfHeight=-MulDiv(8, GetDeviceCaps(hdc,LOGPIXELSY),72);
SetFont(CreateFontIndirect(&lf),false);
}break;
case courierfont10: {
lf.lfHeight=-MulDiv(10, GetDeviceCaps(hdc,LOGPIXELSY),72);
SetFont(CreateFontIndirect(&lf),false);
}break;
case courierfont12: {
lf.lfHeight=-MulDiv(12, GetDeviceCaps(hdc,LOGPIXELSY),72);
SetFont(CreateFontIndirect(&lf),false);
}break;
case userfont: SetFont(CreateFontIndirect(&UserFont),false); break;
default: SetFont((HFONT)GetStockObject(ANSI_FIXED_FONT),true);
}
ofont=(HFONT)SelectObject(hdc,Font);
SetCharBox(hdc);
SelectObject(hdc,ofont);
ReleaseDC(MainWnd,hdc);
if (View[0]) {
SendMessage(View[0],WM_SETFONT,(WPARAM)Font,TRUE); // let the View do the rest
scheduler.addtask(windowupdate,priority_window,nlptr,NULL);
}
}
void FontSel(void) {
CHOOSEFONT cf;
InitStruct(&cf,sizeof(cf));
cf.hwndOwner=MainWnd;
cf.lpLogFont=&UserFont;
cf.Flags=CF_INITTOLOGFONTSTRUCT|CF_FIXEDPITCHONLY|CF_FORCEFONTEXIST
|CF_SCREENFONTS;
if (!ChooseFont(&cf)) return;
setupfont(userfont);
}
/************************************************************************
* changemenus *
* erm..... everytime I added a menu function I just added another line *
* in here :) *
************************************************************************/
void changemenus(bool HaveProject) {
static UINT IDmenu[]={file_save,save_asm,
Seg_Viewer,Names_Viewer,Xrefs_Viewer,Imports_Viewer,Exports_Viewer,
make_code,undefine_line,undefine_lines,undefine_lines_long,
line_jumpto,line_jumptoarg2,
make_dword,make_word,make_string,pascal_string,uc_string,up_string,dos_string,general_string,
Name_Location,Jump_Back,argover_dec,argover_hex,argover_char,argnegate,offset_dseg,
main_search,save_database,get_comment,
block_top,block_bottom,block_view,block_saveasm,block_savetext,block_undefine,
float_single,float_double,float_longdouble,arg_single,
search_again,cm_decrypt,IDM_Close};
static UINT IDrmenu[]={cm_decrypt,
arg_single,float_single,float_double,float_longdouble,block_top,
block_bottom,make_code,get_comment,
undefine_line,undefine_lines,undefine_lines_long,line_jumpto,line_jumptoarg2,
make_dword,make_word,make_string,pascal_string,uc_string,up_string,dos_string,general_string,
Name_Location,Xrefs_Viewer,argover_dec,argover_hex,argover_char,argnegate,offset_dseg};
HMENU hMenu;
int i;
hMenu=GetMenu(MainWnd);
EnableMenuItem(hMenu,file_open,HaveProject?MF_GRAYED:MF_ENABLED);
EnableMenuItem(hMenu,load_database,HaveProject?MF_GRAYED:MF_ENABLED);
for (i=0; i<sizeof(IDmenu)/sizeof(UINT); i++) {
EnableMenuItem(hMenu,IDmenu[i],HaveProject?MF_ENABLED:MF_GRAYED);
}
for (i=0; i<sizeof(IDrmenu)/sizeof(UINT); i++) {
EnableMenuItem(rmenu,IDrmenu[i],HaveProject?MF_ENABLED:MF_GRAYED);
// eigentlich Unsinn, ist Bestandteil des View-Fensters
}
// charinputenabled=HaveProject;
if (View[0]) DestroyWindow(View[0]); View[0]=0;
if (dsm) {
delete dsm; dsm=NULL; // Zeiger für offenes Projekt
delete import;
delete expt;
delete name;
delete dta;
delete reloc;
delete xrefs;
}
if (HaveProject) {
RECT R;
dsm=new disasm;
import=new gname;
expt=new gname;
name=new gname;
dta=new dataseg;
reloc=new relocs;
xrefs=new xref;
CalcClientRect(R);
View[0]=CreateWindow("BorgView",NULL,WS_CHILD|WS_VISIBLE|WS_VSCROLL,
R.left,R.top,R.right-R.left,R.bottom-R.top,
MainWnd,0,hInst,NULL);
SetFocus(View[0]);
}
}
/************************************************************************
* Thread *
* - this is the secondary thread interface. It just keeps calling the *
* scheduler to process any items in the queue, until such time as the *
* main thread wants to quit. *
************************************************************************/
/*
void Thread(PVOID) {
// needs to setup initial schedule list
// continually monitor schedule list for jobs
do {
if (scheduler.process() && !KillThread)
StatusMessage("Processing Completed");
Sleep(1);
}while (!KillThread);
InThread=false;
ExitThread(0);
}
*/
/************************************************************************
* StatusMessage *
* - output a simple message to the status bar *
************************************************************************/
void StatusMessage(char *msg) {
/*EnterCriticalSection(&cs);*/ // was causing locks (possibly)
Status_SetText(Status,0,0,msg);
/*LeaveCriticalSection(&cs); */
}
/************************************************************************
* StatusMessageNItems *
* - shows how many items there are left to process *
************************************************************************/
void StatusMessageNItems(dword nolistitems) {
static char buff[40];
wsprintf(buff,"Items to Process: %lu",nolistitems);
StatusMessage(buff);
}
/************************************************************************
* optionsinit *
* - initialises the global options struct with some default values *
************************************************************************/
void optionsinit(void) {
options.loaddebug=true;
options.mode16=false;
options.mode32=false;
options.loaddata=true;
options.loadresources=false;
options.cfa=true;
options.demangle=true;
options.processor=PROC_PENTIUM;
options.codedetect=CD_PUSHBP|CD_EAXFROMESP|CD_MOVEAX;
options.bgcolor=GetSysColor(COLOR_WINDOW);
options.highcolor=RGB(0,255,0);
options.textcolor=0;
options.font=ansifont;
options.readonly=false;
options.winmax=false;
}
/************************************************************************
* TestThread *
* - this is used on exit to wait for the secondary thread to finish. *
* - I try every possible way of getting the thread to exit normally *
* before we eventually kill it in the MainWnd, WM_DESTROY handler *
************************************************************************/
/*
bool TestThread(void){
HWND sbox;
bool ttest;
sbox=CreateDialog(hInst,MAKEINTRESOURCE(Borg_Shutdown),MainWnd,shutbox);
if (InThread)
SetThreadPriority(ThreadHandle,THREAD_PRIORITY_TIME_CRITICAL);
Sleep(2000);
DestroyWindow(sbox);
Sleep(5000);
//EnterCriticalSection(&cs);
ttest=InThread;
//LeaveCriticalSection(&cs);
return ttest;
}
*/
void RegisterFileTypes(void) {
TCHAR fn[MAX_PATH],s[1024];
static TCHAR proj[]="Compressed Borg Disassembly Project"; // used twice
GetModuleFileName(NULL,fn,elemof(fn));
wsprintf(s,"\"%s\" \"%%1\"",fn);
if(RegSetValue(HKEY_CLASSES_ROOT,T(".dasm"),REG_SZ,proj+11,25)==ERROR_SUCCESS
&& RegSetValue(HKEY_CLASSES_ROOT,T(".dasm\\shell\\open\\command"),REG_SZ,s,
lstrlen(s)+1)==ERROR_SUCCESS
&& RegSetValue(HKEY_CLASSES_ROOT,T(".cdasm"),REG_SZ,proj,36)==ERROR_SUCCESS
&& RegSetValue(HKEY_CLASSES_ROOT,T(".cdasm\\shell\\open\\command"),REG_SZ,s,
lstrlen(s)+1)==ERROR_SUCCESS) {
MessageBox(MainWnd,"Extensions .dasm and .cdasm registered.","Borg Message",MB_OK);
}else ShowLastError();
}
/************************************************************************
* dasm *
* - dasm is the application main window. *
* - everything the main window does is in this routine (for now) and *
* where a response is quick it appears in one of its helper functions *
* later in this file, otherwise it has been substantial enough to *
* warrant its own file and routines........ *
* - this is long *
************************************************************************/
LRESULT CALLBACK dasm(HWND hwnd,UINT Msg,WPARAM wParam,LPARAM lParam) {
// int killcount;
MainWnd=hwnd;
switch (Msg) {
case WM_CREATE: {
TCHAR *cmdline,*filename;
bool inquote,inspace;
optionsinit();
// InitializeCriticalSection(&cs);
Status=CreateStatusWindow(WS_CHILD|WS_VISIBLE|SBS_SIZEGRIP,
"No File Loaded",hwnd,2);
// KillThread=false;
// InThread=false;
rmenu=GetSubMenu(LoadMenu(hInst,MAKEINTRESOURCE(right_click_menu)),0);
load_reg_entries();
setupfont(options.font);
// get one (here: the last) file name from command line
inquote=false;
inspace=false;
filename=NULL;
for (cmdline=GetCommandLine(); *cmdline; cmdline++) {
switch (*cmdline) {
case '"': {
inquote=!inquote;
*cmdline=0;
}break;
case ' ': {
if (!inquote) {
*cmdline=0;
inspace=true;
}
}break;
default: if (inspace) {
inspace=false;
filename=cmdline;
}
}
}
// if a file name is given, open it (as uncompressed)
if (filename) loaddb(filename,0);
}break;
case WM_DROPFILES: {
TCHAR filename[MAX_PATH];
if (DragQueryFile((HDROP)wParam,(UINT)-1,NULL,0)!=1) {
MessageBox(hwnd,"Dropping of multiple files is not supported.\n"
"Borg will take only the first file.","Borg Message",
MB_OK|MB_ICONINFORMATION);
}
DragQueryFile((HDROP)wParam,0,filename,elemof(filename));
DragFinish((HDROP)wParam);
loaddb(filename,0);
}break;
case WM_ACTIVATE: {
if (View[0]) SetFocus(View[0]);
}break;
case WM_COMMAND: switch (LOWORD(wParam)) {
case CM_RegisterFileTypes: RegisterFileTypes(); break;
case IDM_Close: {
/*
KillThread=true;
killcount=0;
Sleep(0);
SetPriorityClass(ThreadHandle,HIGH_PRIORITY_CLASS);
if (InThread) while (TestThread()) {
killcount++;
if (killcount>2) {
// this is a nasty way of getting out.
// sometimes the thread just will not exit nicely when its busy.
if (TerminateThread(ThreadHandle,1)) {
CloseHandle(ThreadHandle);
break;
}
}
}
*/
if (dsm->dirty && MessageBox(hwnd,"Unsaved Data!\nClose file?","Borg",
MB_YESNO|MB_ICONQUESTION)!=IDYES) break;
CloseHandle(floader.efile);
floader.efile=INVALID_HANDLE_VALUE;
SetWindowText(hwnd,winname);
exportsviewer(false);
importsviewer(false);
namesviewer(NULL);
xrefsviewer(NULL);
segviewer(false);
changemenus(false);
}break;
case file_exit: SendMessage(MainWnd,WM_CLOSE,0,0); break;
case file_save: savefile_text(hwnd,true,false); break;
case get_comment: getcomment(); break;
case save_database: savedb(); break;
case load_database: {
TCHAR szFile[MAX_PATH];
UINT FilterIndex;
if (getfiletoload(szFile, elemof(szFile),IDS_FILTERSAVE,FilterIndex))
loaddb(szFile,FilterIndex);
}break;
case save_asm:
if (MessageBox(hwnd,"Sorry, saving text file only",NULL,MB_OKCANCEL)==IDOK)
savefile_text(hwnd,false,false); break;
case block_saveasm:
if (MessageBox(hwnd,"Sorry, saving text file only",NULL,MB_OKCANCEL)==IDOK)
savefile_text(hwnd,false,true); break;
case block_savetext: savefile_text(hwnd,true,true); break;
case cm_decrypt: decrypterdialog(); break;
case file_open: newfile(); break;
case Seg_Viewer: segviewer(true); break;
case Names_Viewer: {
lptr loc;
cvd->findcurrentaddr(&loc);
namesviewer(&loc);
} break;
case Imports_Viewer: importsviewer(true); break;
case Exports_Viewer: exportsviewer(true); break;
case Xrefs_Viewer: {
lptr loc;
cvd->findcurrentaddr(&loc);
xrefsviewer(&loc);
} break;
case make_code:
scheduler.addtask(user_makecode,priority_userrequest,nlptr,NULL); break;
case make_dword:
scheduler.addtask(user_makedword,priority_userrequest,nlptr,NULL); break;
case float_single:
scheduler.addtask(user_makesingle,priority_userrequest,nlptr,NULL); break;
case float_double:
scheduler.addtask(user_makedouble,priority_userrequest,nlptr,NULL); break;
case float_longdouble:
scheduler.addtask(user_makelongdouble,priority_userrequest,nlptr,NULL);break;
case make_word:
scheduler.addtask(user_makeword,priority_userrequest,nlptr,NULL); break;
case make_string:
scheduler.addtask(user_makestring,priority_userrequest,nlptr,NULL); break;
case pascal_string:
scheduler.addtask(user_pascalstring,priority_userrequest,nlptr,NULL);break;
case uc_string:
scheduler.addtask(user_ucstring,priority_userrequest,nlptr,NULL); break;
case up_string:
scheduler.addtask(user_upstring,priority_userrequest,nlptr,NULL); break;
case dos_string:
scheduler.addtask(user_dosstring,priority_userrequest,nlptr,NULL); break;
case general_string:
scheduler.addtask(user_generalstring,priority_userrequest,nlptr,NULL);break;
case argover_dec:
scheduler.addtask(user_argoverdec,priority_userrequest,nlptr,NULL); break;
case arg_single:
scheduler.addtask(user_argsingle,priority_userrequest,nlptr,NULL); break;
case argover_hex:
scheduler.addtask(user_argoverhex,priority_userrequest,nlptr,NULL); break;
case argnegate:
scheduler.addtask(user_argnegate,priority_userrequest,nlptr,NULL); break;
case offset_dseg:
scheduler.addtask(user_argoveroffsetdseg,priority_userrequest,nlptr,NULL);break;
case argover_char:
scheduler.addtask(user_argoverchar,priority_userrequest,nlptr,NULL);break;
case undefine_line:
scheduler.addtask(user_undefineline,priority_userrequest,nlptr,NULL);break;
case undefine_lines:
scheduler.addtask(user_undefinelines,priority_userrequest,nlptr,NULL);break;
case undefine_lines_long:
scheduler.addtask(user_undefinelines_long,priority_userrequest,nlptr,NULL);break;
case block_undefine:
scheduler.addtask(user_undefineblock,priority_userrequest,nlptr,NULL);break;
case block_view: blockview(); break;
case block_top:
scheduler.addtask(user_marktopblock,priority_userrequest,nlptr,NULL);break;
case block_bottom:
scheduler.addtask(user_markbottomblock,priority_userrequest,nlptr,NULL);break;
case line_jumpto:
scheduler.addtask(user_jumpto,priority_userrequest,nlptr,NULL); break;
case line_jumptoarg2:
scheduler.addtask(user_jumptoarg2,priority_userrequest,nlptr,NULL); break;
case Name_Location: namelocation(); break;
case help_short:
if (HelpShortcuts) SetActiveWindow(HelpShortcuts);
else HelpShortcuts=CreateDialog(hInst,MAKEINTRESOURCE(help_shortcuts),hwnd,helpshortcuts);
break;
case help_about:
DialogBox(hInst,MAKEINTRESOURCE(D_help_about),hwnd,habox);
break;
case Jump_Back:
scheduler.addtask(user_jumpback,priority_userrequest,nlptr,NULL);
break;
case main_search: searchengine(); break;
case search_again: searchmore(); break;
case set_bg_color:
if (choosecolour(options.bgcolor) && View[0]) InvalidateRect(View[0],NULL,true);
scheduler.addtask(windowupdate,priority_window,nlptr,NULL);
break;
case set_high_color:
if (choosecolour(options.highcolor) && View[0]) InvalidateRect(View[0],NULL,true);
scheduler.addtask(windowupdate,priority_window,nlptr,NULL);
break;
case set_text_color:
if (choosecolour(options.textcolor) && View[0]) InvalidateRect(View[0],NULL,true);
scheduler.addtask(windowupdate,priority_window,nlptr,NULL);
break;
case font_system: setupfont(systemfont); break;
case font_courier: setupfont(courierfont); break;
case font_courier10: setupfont(courierfont10); break;
case font_courier12: setupfont(courierfont12); break;
case font_ansi: setupfont(ansifont); break;
case font_user: FontSel(); break;
// default:
// return DefWindowProc(hwnd,Msg,wParam,lParam);
}break;
case WM_QUERYENDSESSION:
save_reg_entries();
if (dsm && dsm->dirty && MessageBox(MainWnd,
"Unsaved Data!\n"
"Are you sure that you want to exit Borg?\n"
"Hit Yes To Exit\n"
"Hit No to Stay","Borg Disassembler",
MB_ICONEXCLAMATION|MB_YESNO)==IDNO) return FALSE;
return TRUE;
case WM_CLOSE:
if (!SendMessage(hwnd,WM_QUERYENDSESSION,0,0)) break;
// scheduler.stopthread();
// scheduler.addtask(quitborg,priority_quit,nlptr,NULL);
// KillThread=true;
// if(InThread)
// SetThreadPriority(ThreadHandle,THREAD_PRIORITY_TIME_CRITICAL);
DestroyWindow(MainWnd);
return 0;
case WM_DESTROY: {
// if (View[0]) SendMessage(hwnd,WM_COMMAND,IDM_Close,0);
// DeleteCriticalSection(&cs);
PostQuitMessage(0);
}break;
case WM_SIZE: {
// if(wParam==SIZE_MAXIMIZED)
// options.winmax=true;
// else if (wParam==SIZE_RESTORED)
// options.winmax=false;
// mainwndsize.top=0;
// mainwndsize.left=0;
// GetWindowRect(Status,&StatusWindowSize);
// GetWindowRect(MainWnd,&mainwnd);
// MoveWindow(Status,0,mainwndsize.bottom-StatusWindowSize.bottom+StatusWindowSize.top,
// mainwndsize.right,StatusWindowSize.bottom-StatusWindowSize.top,true);
if (Toolbar) SendMessage(Toolbar,Msg,wParam,lParam); // self-sizing
if (Status) SendMessage(Status,Msg,wParam,lParam); // self-sizing
if (View[0]) { // Yet only one View window, later dividable
RECT R;
CalcClientRect(R);
MoveWindow(View[0],R.left,R.top,R.right-R.left,R.bottom-R.top,TRUE);
}
}break;
// case WM_REPEATNAMEVIEW: namesviewer(); break;
// case WM_REPEATXREFVIEW: xrefsviewer(); break;
// maximises window, used when the reg is read in at the start to maximise
// the main window after initialisation of it
// case WM_MAXITOUT:
// ShowWindow(MainWnd,SW_MAXIMIZE);
// break;
default: return DefWindowProc(hwnd,Msg,wParam,lParam);
}
return 0;
}
int limit(int i, int u, int o) {
// limit i to the both bounds given; if o<u then return=u
return max(min(i,o),u);
}
/****************************************************/
/* Window Procedure of (one of both) View window(s) */
/****************************************************/
LRESULT CALLBACK ViewWndProc(HWND hwnd,UINT Msg,WPARAM wParam,LPARAM lParam) {
// Get (or create) associated ViewData for the window
disio *vd=(disio*)GetWindowLong(hwnd,GWL_USERDATA);
if (!vd) {
vd=new disio(hwnd); //(PVIEWDATA)LocalAlloc(LPTR,sizeof(VIEWDATA));
vd->MainBuff=0;
SetWindowLong(hwnd,GWL_USERDATA,(LPARAM)vd);
}
// distribute the messages
switch (Msg) {
case WM_CREATE: {
SetScrollRange(hwnd,SB_VERT,0,VERTSCROLLRANGE,false);
SetScrollPos(hwnd,SB_VERT,0,false);
}break;
case WM_SETFONT: if (lParam) InvalidateRect(hwnd,NULL,TRUE);
case WM_SIZE: {
RECT R;
SCROLLINFO SI;
GetClientRect(hwnd,&R);
vd->size.x=(R.right +CharBox.x-1)/CharBox.x; // rounding up
vd->size.y=(R.bottom+CharBox.y-1)/CharBox.y;
// (re)allocate space for disassembly lines
UINT alloc=sizeof(dasm_line)*vd->size.y;
vd->MainBuff=(dasm_line*)(
vd->MainBuff ? LocalReAlloc(vd->MainBuff,alloc,LMEM_ZEROINIT) : LocalAlloc(LPTR,alloc));
// correct hpos
vd->hpos=limit(vd->hpos,0,MAX_LENGTH-vd->size.x);
// correct the horizontal scroll bar
SI.cbSize=sizeof(SI);
SI.fMask=SIF_ALL;
SI.nMin=0;
SI.nMax=MAX_LENGTH;
SI.nPage=vd->size.x;
SI.nPos=vd->hpos;
SetScrollInfo(hwnd,SB_HORZ,&SI,TRUE);
}break;
case WM_SETFOCUS: {
cvd=vd; // set global pointer to focused window
}break;
case WM_PAINT: {
vd->DoPaint();
}break;
case WM_VSCROLL: {
lptr scrll;
switch (LOWORD(wParam)) {
case SB_LINEUP:
scrll.assign(0,(dword)-1);
scheduler.addtask(scrolling,priority_userrequest,scrll,NULL);
break;
case SB_LINEDOWN:
scrll.assign(0,1);
scheduler.addtask(scrolling,priority_userrequest,scrll,NULL);
break;
case SB_PAGEUP:
scrll.assign(0,-(vd->size.y-1));
scheduler.addtask(scrolling,priority_userrequest,scrll,NULL);
break;
case SB_PAGEDOWN:
scrll.assign(0,vd->size.y-1);
scheduler.addtask(scrolling,priority_userrequest,scrll,NULL);
break;
case SB_THUMBPOSITION:
scrll.assign(0,HIWORD(wParam));
scheduler.addtask(vthumbposition,priority_userrequest,scrll,NULL);
break;
}
}break;
case WM_HSCROLL: {
lptr scrll;
int amount,x;
switch (LOWORD(wParam)) {
case SB_THUMBTRACK:
case SB_THUMBPOSITION: amount=(int)HIWORD(wParam)-vd->hpos; goto set;
case SB_LINEUP: amount=-1; goto set;
case SB_LINEDOWN: amount= 1; goto set;
case SB_PAGEUP: amount=-8; goto set;
case SB_PAGEDOWN: amount= 8; set:
x=limit(vd->hpos+amount,0,MAX_LENGTH-vd->size.x);
amount=vd->hpos-x; vd->hpos=x;
SetScrollPos(hwnd,SB_HORZ,vd->hpos,TRUE);
ScrollWindow(hwnd,amount*CharBox.x,0,NULL,NULL);
break;
}
}break;
case WM_CONTEXTMENU: {
POINT p={(short)LOWORD(lParam),(short)HIWORD(lParam)};
if (lParam==(LPARAM)-1) { // from keyboard
p.x=35*CharBox.x;
p.y=(vd->sel+1)*CharBox.y;
ClientToScreen(hwnd,&p);
}
TrackPopupMenu(rmenu,0,p.x,p.y,0,MainWnd,NULL);
}break;
case WM_KEYDOWN: switch (wParam) {
case VK_HOME: SendMessage(hwnd,WM_VSCROLL,SB_TOP,0L); break;
case VK_PRIOR: SendMessage(hwnd,WM_VSCROLL,SB_PAGEUP,0L); break;
case VK_NEXT: SendMessage(hwnd,WM_VSCROLL,SB_PAGEDOWN,0L); break;
case VK_DOWN: SendMessage(hwnd,WM_VSCROLL,SB_LINEDOWN,0L); break;
case VK_UP: SendMessage(hwnd,WM_VSCROLL,SB_LINEUP,0L); break;
case VK_LEFT: SendMessage(hwnd,WM_HSCROLL,SB_PAGEUP,0L); break;
case VK_RIGHT: SendMessage(hwnd,WM_HSCROLL,SB_PAGEDOWN,0L); break;
case VK_RETURN:
scheduler.addtask(
GetKeyState(VK_SHIFT)<0 ? user_jumptoarg2 : user_jumpto,
priority_userrequest,nlptr,NULL);
break;
case VK_ESCAPE:
scheduler.addtask(user_jumpback,priority_userrequest,nlptr,NULL);
break;
case VK_F3:
searchmore();
break;
}break;
case WM_LBUTTONDOWN: {
SetFocus(hwnd);
}nobreak;
case WM_RBUTTONDOWN: {
vd->setpos(HIWORD(lParam)/CharBox.y);
}break;
case WM_LBUTTONDBLCLK: {
SendMessage(hwnd,WM_KEYDOWN,VK_RETURN,0);
}break;
case WM_NCDESTROY: {
LocalFree(vd->MainBuff);
delete vd;
}break;
default: return DefWindowProc(hwnd,Msg,wParam,lParam);
}
return 0;
}
/************************************************************************
* WinMain..... it all starts here *
************************************************************************/
int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int) {
WNDCLASS wc;
MSG msg;
InitCommonControls();
hInst=GetModuleHandle(NULL);
/* Define window class */
ZeroMemory(&wc,sizeof(wc));
wc.style=CS_DBLCLKS;
wc.lpfnWndProc=dasm; // A fürchterlicher Name!!
wc.hInstance=hInst;
wc.hIcon=LoadIcon(hInst,MAKEINTRESOURCE(100));
wc.hCursor=LoadCursor(NULL,IDC_ARROW);
wc.hbrBackground=(HBRUSH)(COLOR_APPWORKSPACE+1);
wc.lpszMenuName=MAKEINTRESOURCE(100);
wc.lpszClassName=szWinName;
/* Register window classes */
RegisterClass(&wc);
wc.lpfnWndProc=ViewWndProc;
wc.hbrBackground=0;
wc.lpszClassName="BorgView";
RegisterClass(&wc);
Accel=LoadAccelerators(hInst,MAKEINTRESOURCE(100));
/* Create window */
wsprintf(winname,"Borg Disassembler v%0d.%2da",(int)BORG_VER/100,BORG_VER%100);
MainWnd=CreateWindowEx(WS_EX_ACCEPTFILES,szWinName,winname,WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,
NULL,NULL,hInst,NULL);
/* Display window */
ShowWindow(MainWnd,SW_SHOWDEFAULT);
/* Message Loop */
for (;;){
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) {
if (msg.message==WM_QUIT) break;
if (KBHand && IsDialogMessage(KBHand,&msg)) continue;
if (Accel && TranslateAccelerator(MainWnd,Accel,&msg)) continue;
TranslateMessage(&msg);
DispatchMessage(&msg);
}else{
if (!scheduler.process()) WaitMessage();
}
}
#ifdef _DEBUG
_CrtMemDumpAllObjectsSince(NULL);
#endif
return msg.wParam;
}
| Vorgefundene Kodierung: UTF-8 | 0
|