/**************************************************

*** Project Title: Command Post (KFLASH) ***

*** Author: Greg Dietsche ***

*** Date: 07/23/2002 ***

*** Description: An application designed for ***

*** use with the TI-89 and TI-92 Plus Graphing ***

*** calculators during the testing and ***

*** debugging phases of FLASH APPS and RAM ***

*** programs ***

***************************************************/

// $Id: dasm_driver.c 15 2004-08-05 21:00:59Z dietsche $

#include <tiams.h>

#include "KFLASHr1.h"

#include "KFLASH.h"

#include "undoc.h"

#include "eggs.h"

#include "dasm.h"

#include "hexedit.h"

typedef struct {

unsigned short *baseaddr;

unsigned short *pc;

USHORT entries;

USHORT max_entries;

HANDLE hOffsetTable;

}BACKGROUND_DAT;

static void ScrollFromBottom(WINDOW *w, HEX_DAT *d);

static void ScrollFromTop(WINDOW *w, HEX_DAT *d);

static void WinPaint(WINDOW *w, HEX_DAT *d);

static void Activate_Deactivate(void);

static void DoBackgroundProcessing(HEX_DAT *hex_dat);

//static char * top_addr; d->top

static char * bottom_addr;

static BACKGROUND_DAT gBGDAT;

static short ScrollFromBottom_helper; //this tells me exactly where the last line should be drawn. I can count on it because the window must be fully painted in order to swith screen sizes via the mode dialog.

void DASMEditorEventLoop(pFrame self, PEvent e)

{

HEX_DAT *d=&global.hex_dat;

switch(e->command)

{

case CM_BACKGROUND:

DoBackgroundProcessing(d);

break;

case CM_ACTIVATE:

{

ACB *myid=(ACB*)HeapDeref(GetMyAppID());

d->top+=d->addr;

d->addr=0;

if(((unsigned long)d->top)%2)d->top--; //watch out for odd addresses

global.BgEventMask|=BG_Disassemble;

myid->flags|=ACB_BG;

Activate_Deactivate();

break;

}

case CM_DEACTIVATE:

HeapFreeIndir(&gBGDAT.hOffsetTable);

global.BgEventMask&= ~BG_Disassemble;

Activate_Deactivate();

appW.Flags|=WF_VIRTUAL;

WinClr(&appW);

break;

case ACM_Defaults:

break;

case CM_INSTALL:

break;

case ACM_New_Formats: //the user changed something in the FORMATS dialog

break;

case CM_WPAINT:

WinPaint(&appW, d);

break;

case CM_KEY_PRESS:

switch(e->info.keyInfo.keyCode)

{

case KB_PGUP:

{

void *old_top=d->top;

while(bottom_addr>old_top)

{

ScrollFromTop(&appW, d);

}

}

break;

case KB_PGDN:

d->top=bottom_addr;

WinPaint(&appW, d);

break;

case KB_TOP:

d->top=d->kb_left_most + 2;

WinPaint(&appW, d);

break;

case KB_BOTTOM:

d->top=d->kb_right_most;

WinPaint(&appW, d);

//pushkey(KB_PGUP);

break;

case KB_DOWN: //scroll the screen up

ScrollFromBottom(&appW, d);

HexSTShowMemStr();

break;

case KB_UP: //scroll the screen down

ScrollFromTop(&appW, d);

break;

case '+':

d->top+=2;

WinPaint(&appW, d);

break;

case '-':

d->top-=2;

WinPaint(&appW, d);

break;

case KB_BEGIN:

case KB_END:

HexEditorEventLoop(self, e);

WinPaint(&appW, d);

break;

};

break;

case ACM_Hex_Refresh:

appW.Flags|=WF_VIRTUAL; //don't show the cleared screen (WinPaint will unset this flag)

WinClr(&appW); //Clear The ENTIRE window

WinPaint(&appW, d); //redraw the WHOLE window

break;

case ACM_Hex_SetBookMark1:

d->kb_left_most-=2;

HeapFreeIndir(&gBGDAT.hOffsetTable);

HexEditorEventLoop(self, e);

break;

case CM_PASTE_HANDLE:

{ char *old=d->top;

HeapFreeIndir(&gBGDAT.hOffsetTable);

HexEditorEventLoop(self, e);

if(d->top != old) //if it changed, then adjust by 2 bytes since the hex editor will point us at the length bytes, and not the code.

d->top+=2; //not 100% fool proof ... if the cursor is already at the new d->top for instance...

}

break;

case ACM_Hex_JumpBookMark2:

HexEditorEventLoop(self, e);

//pushkey(KB_PGUP);

WinPaint(&appW, d);

break;

case ACM_Hex_SetBookMark2:

HeapFreeIndir(&gBGDAT.hOffsetTable);

HexEditorEventLoop(self, e);

break;

case ACM_Hex_JumpBookMark1:

HexEditorEventLoop(self, e);

d->top+=2;

WinPaint(&appW, d);

break;

case ACM_Hex_JumpVar:

case ACM_Hex_JumpTo:

case ACM_Hex_ResizeHandle:

case ACM_Hex_AMS_GlobalVars:

case ACM_Hex_JumpCommon:

HexEditorEventLoop(self, e);

break;

}; //end switch

}

// \/

//there is an address error somewhere in this routine.

static void ScrollFromTop(WINDOW *w, HEX_DAT *d)

{

WIN_RECT wr={ 0, 0, 0, 0 };

BACKGROUND_DAT *bg=&gBGDAT;

USHORT result_top;

USHORT result_bottom;

USHORT *ptr;

char buff[150];

DASM_DAT dasm;

wr.x1=WinWidth(w);

wr.y1=ScrollFromBottom_helper+C(6-1,8-1);

if((ULONG)bg->baseaddr && (ULONG)d->top>(ULONG)bg->baseaddr && bg->hOffsetTable)

{

ptr=HeapDeref(bg->hOffsetTable);

result_top=bsearch(ptr, (ULONG)d->top - (ULONG)bg->baseaddr, bg->entries-1);

result_bottom=bsearch(ptr, (ULONG)bottom_addr - (ULONG)bg->baseaddr, bg->entries-1);

if(result_top==USHRT_MAX || result_bottom==USHRT_MAX)

{

d->top-=2;

WinPaint(w, d);

#ifdef DEBUG

ST_helpMsg("Address Not In Buffer.");

#endif

return;

}

if(result_top)

{

result_top--; //the previous instruction

result_bottom--;

}

d->top=(char*)&bg->baseaddr[ptr[result_top]>>1];

bottom_addr=(char*)&bg->baseaddr[ptr[result_bottom]>>1];

WinScrollV(w, &wr, C(-6,-8));

disassemble_one((unsigned short*)d->top, &dasm);

sprintf(buff, "%lx%s", d->top, dasm.text);

WinStrXY(w, 1, 1, buff);

}

else

{

d->top-=2;

WinPaint(w,d);

}

}

// /\

static void ScrollFromBottom(WINDOW *w, HEX_DAT *d)

{//scope brackets

WIN_RECT wr={ 0, 0, 0, 0 };

char buff[150];

DASM_DAT dat;

wr.x1=WinWidth(w);

wr.y1=ScrollFromBottom_helper+C(6,8);

disassemble_one((unsigned short*)d->top, &dat);

d->top=(char*)dat.pc; //update the top pointer

disassemble_one((unsigned short*)bottom_addr, &dat); //disassemble and update bottom pointer

sprintf(buff, "%lx%s", bottom_addr, dat.text);

WinScrollV(w, &wr, C(6,8));

WinStrXY(w, 1, ScrollFromBottom_helper, buff);//+2 //89

bottom_addr=(char*)dat.pc;

}//end scope brackets

static void WinPaint(WINDOW *w, HEX_DAT *d)

{

register char *next;

char buff[200];

WIN_COORDS height=WinHeight(w)-C(6,8);

USHORT counter;

DASM_DAT dat;

next=d->top;

w->Flags|=WF_VIRTUAL; //hide the drawing process

WinClr(w);

#ifdef _89

WinFont(&appW, F_4x6);

#endif

for(counter=1;counter<height;counter+=C(6,8))

{

disassemble_one((unsigned short*)next, &dat);

sprintf(buff, "%lx%s", next, dat.text);

WinStrXY(w, 1, counter, buff);

next=(char*)dat.pc;

ScrollFromBottom_helper=counter;

}

bottom_addr=next;

w->Flags&=((~WF_VIRTUAL) & (~WF_DIRTY));

WinBackupToScr(w); //w->Flags|=WF_DIRTY;

HexSTShowMemStr();

}

static void DoBackgroundProcessing(HEX_DAT *hex_dat)

{

//#ifdef SADF

BACKGROUND_DAT * d=&gBGDAT;

USHORT *ptr;

DASM_DAT dasm;

char buff[100];

if(!d->hOffsetTable)

{

d->max_entries=(hex_dat->kb_right_most - hex_dat->kb_left_most)>>1;

if(d->max_entries==0) return;

d->entries=0;

d->baseaddr=(unsigned short*)(hex_dat->kb_left_most);

d->baseaddr++; //skip the 2 length bytes

d->pc=d->baseaddr;

if(!(d->hOffsetTable=HeapAllocHigh(d->max_entries<<1)))

return;

memset(HLock(d->hOffsetTable), 0xff, HeapSize(d->hOffsetTable));

}

if(!d->hOffsetTable) return;

if(d->entries>=d->max_entries) return;

ptr=HLock(d->hOffsetTable);

if(d->entries==0) ptr[0]=0;

#ifdef DEBUG

if(&d->baseaddr[d->entries]<d->baseaddr)

{

ST_helpMsg("Error in Background DASM processing!");

ngetchx();

}

#endif

disassemble_one(d->pc, &dasm);

ptr[d->entries++]=(char*)d->pc-(char*)d->baseaddr;

d->pc=dasm.pc;

if(!(d->entries%100))

{

if(d->max_entries - d->entries < 100)

ST_eraseHelp();//clean up the status line if *almost* done buffering...

else

{

sprintf(buff, XR_stringPtr(XR_DASM_Buffering), (double)d->entries/(double)d->max_entries*100. );

ST_helpMsg(buff);

}

}

//#endif

}

USHORT bsearch(USHORT * array, USHORT key, USHORT last)

{

register USHORT mid;

register USHORT first=0;

while(first <= last)

{

mid=(first+last)>>1;

if (key>array[mid]) first=mid+1;

else if (key<array[mid]) last=mid-1;

else return mid;

}

return USHRT_MAX;

}

static void Activate_Deactivate(void)

{

BOOL DISAM_Disable=!global.DisassemblerActive;

HANDLE h_menu=GetAppDefaultMenuHandle(GetMyAppID());

if(h_menu)

{

MenuCheck(h_menu, ACM_DisASMViewToggle, MC_FLIP);

//MenuTopStat(h_menu, 4, DISAM_Disable); //F5

//MenuSubStat(h_menu, ACM_Hex_Refresh, DISAM_Disable);

MenuSubStat(h_menu, CM_COPY, DISAM_Disable);

MenuSubStat(h_menu, CM_PASTE, DISAM_Disable);

MenuSubStat(h_menu, ACM_UNUSED_FIND_INDEX, DISAM_Disable);

//MenuSubStat(h_menu, ACM_UNUSED_BOOKMARK_INDEX, DISAM_Disable);

MenuSubStat(h_menu, ACM_Hex_Edit, DISAM_Disable);

MenuOn(h_menu); //redraw the top level menu items

}

appW.Flags|=WF_DIRTY;

}