Quelltext /~heha/hs/borg.zip/DISIO.CPP

/************************************************************************
*		 disio.cpp						*
* This is a fairly big class, and yet it was originally part of the	*
* larger disasm class. I finally got around to splitting off some of	*
* 3500 lines of code from that class into here. This represents the	*
* disasm I/O functions for window I/O and file I/O. Version 2.11 was	*
* when this was split. There are still a huge number of confusing	*
* functions and code in here which probably needs more work to clean it *
* up, and better split/define the classes. Some of the functions are	*
* friends of disasm because it has been difficult to split the classes	*
* effectively and both access the complex main disassembly structures	*
************************************************************************/

#include <windows.h>
#include <stdio.h>	      // for sprintf, for float printing

#include "disio.h"
#include "disasm.h"
#include "data.h"
#include "dasm.h"
#include "schedule.h"
#include "gname.h"
#include "xref.h"
#include "range.h"
#include "debug.h"

/************************************************************************
* globals								*
* - actually some constants used in file i/o as a header		*
************************************************************************/
char hdr[] =";\t      Created by Borg Disassembler\r\n";
char hdr2[]=";\t      written by Cronos + h#s\r\n";
disio *cvd;	// pointer to data of focused view

/************************************************************************
* constructor function							*
* - this just enables window updates and sets the subline to null	*
* - the subline (subitem) is basically the line in the disassembly that *
*   you see for any given loc. As a loc may refer to many lines (like	*
*   segheader, comments, xref, actual instruction are all separate	*
*   line, and subline says which of these it is)			*
************************************************************************/
disio::disio(HWND w) {
 wnd=w;
 subitem=dsmnull;
// bufferbusy=false;   
}

/************************************************************************
* destructor function							*
* - currently null							*
* - note that disio has no particular structs the same way most of the	*
*   other classes in Borg do						*
************************************************************************/
disio::~disio()
{
}

/************************************************************************
* argoverdec								*
* - disio also acts as a go between for the user and the disasm engine	*
* - here we translate the users current line of the disassembly and	*
*   their request for a decimal override into a call to the disasm	*
*   engine to add the override to the instruction that is there		*
* - note that these kind of calls come from the scheduler and are part	*
*   of the secondary thread						*
************************************************************************/
void disio::argoverdec(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  dsm->disargoverdec(outhere);
}

/************************************************************************
* argoversingle								*
* - very similar to argoverdec, for a single (float) override		*
************************************************************************/
void disio::argoversingle(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  dsm->disargoversingle(outhere);
}

/************************************************************************
* argovernegate								*
* - very similar to argoverdec, for an argument negation override	*
************************************************************************/
void disio::arg_negate(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  dsm->disargnegate(outhere);
}

/************************************************************************
* argoverhex								*
* - very similar to argoverdec, for a hex override			*
************************************************************************/
void disio::argoverhex(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  dsm->disargoverhex(outhere);
}

/************************************************************************
* argoveroffsetdseg							*
* - very similar to argoverdec, for a dseg override			*
************************************************************************/
void disio::argoveroffsetdseg(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  dsm->disargoveroffsetdseg(outhere);
}

/************************************************************************
* argoverchar								*
* - very similar to argoverdec, for a char override			*
************************************************************************/
void disio::argoverchar(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  dsm->disargoverchar(outhere);
}

/************************************************************************
* makedword								*
* - disio acts as a go between for the user and the disasm engine	*
* - here we translate the users current line of the disassembly and	*
*   their request for a dword into a call to the disasm engine to	*
*   disassemble a dword at the current point				*
* - note that these kind of calls come from the scheduler and are part	*
*   of the secondary thread						*
************************************************************************/
void disio::makedword(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  if(outhere==curraddr)
    subitem=dsmnull;
  dsm->disdatadword(outhere);
}

/************************************************************************
* makesingle								*
* - very similar to makedword, this time to disassemble a single	*
*   (float)								*
************************************************************************/
void disio::makesingle(void) {
 lptr outhere;
 findcurrentaddr(&outhere);
 if (outhere==curraddr) subitem=dsmnull;
 dsm->disdatasingle(outhere);
}

/************************************************************************
* makedouble								*
* - very similar to makedword, this time to disassemble a double	*
*   (double float)							*
************************************************************************/
void disio::makedouble(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  if(outhere==curraddr)
    subitem=dsmnull;
  dsm->disdatadouble(outhere);
}

/************************************************************************
* makelongdouble							*
* - very similar to makedword, this time to disassemble a long double	*
*   (long double)							*
************************************************************************/
void disio::makelongdouble(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  if(outhere==curraddr)
    subitem=dsmnull;
  dsm->disdatalongdouble(outhere);
}

/************************************************************************
* makeword								*
* - very similar to makedword, this time to disassemble a word		*
************************************************************************/
void disio::makeword(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  if(outhere==curraddr)
    subitem=dsmnull;
  dsm->disdataword(outhere);
}

/************************************************************************
* makestring								*
* - very similar to makedword, this time to disassemble a string	*
*   (standard C string)							*
************************************************************************/
void disio::makestring(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  if(outhere==curraddr)
    subitem=dsmnull;
  dsm->disdatastring(outhere);
}

/************************************************************************
* pascalstring								*
* - very similar to makedword, this time to disassemble a string	*
*   (standard pascal string)						*
************************************************************************/
void disio::pascalstring(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  if(outhere==curraddr)
    subitem=dsmnull;
  dsm->disdatapstring(outhere);
}

/************************************************************************
* ucstring								*
* - very similar to makedword, this time to disassemble a string	*
*   (unicode C string)							*
************************************************************************/
void disio::ucstring(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  if(outhere==curraddr)
    subitem=dsmnull;
  dsm->disdataucstring(outhere);
}

/************************************************************************
* upstring								*
* - very similar to makedword, this time to disassemble a string	*
*   (unicode pascal string)						*
************************************************************************/
void disio::upstring(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  if(outhere==curraddr)
    subitem=dsmnull;
  dsm->disdataupstring(outhere);
}

/************************************************************************
* dosstring								*
* - very similar to makedword, this time to disassemble a string	*
*   (dos style string)							*
************************************************************************/
void disio::dosstring(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  if(outhere==curraddr)
    subitem=dsmnull;
  dsm->disdatadosstring(outhere);
}

/************************************************************************
* generalstring								*
* - very similar to makedword, this time to disassemble a string	*
*   (general string)							*
************************************************************************/
void disio::generalstring(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  if(outhere==curraddr)
    subitem=dsmnull;
  dsm->disdatageneralstring(outhere);
}

/************************************************************************
* makecode								*
* - very similar to makedword, but this time to disassemble as code	*
*   from the current location, and continue disassembling		*
************************************************************************/
void disio::makecode(void)
{ lptr outhere;
  findcurrentaddr(&outhere);
  if(outhere==curraddr)
    subitem=dsmnull;
  dsm->disblock(outhere);
}

/************************************************************************
* vertsetpos								*
* - this function takes a position of the vertical scroll bar, from 0	*
*   to the VERTSCROLLRANGE and it sets the current address to that	*
*   point								*
************************************************************************/
void disio::vertsetpos(int pos) {
 unsigned long location;
#ifdef WIN32
 location=(unsigned)MulDiv(pos,(int)total_data_size,VERTSCROLLRANGE);
#else
 location=(unsigned long)((float)pos/VERTSCROLLRANGE*total_data_size);
#endif
 setcuraddr(dta->getlocpos(location));	// linear to seg:ofs
}

// reverse function, sets scroll bar to seg:ofs given
// Vertical scroll bar has no PAGESIZE feedback yet
void disio::setscrollpos(lptr loc) {
 DWORD current_data_pos=dta->datagetpos(loc);	// seg:ofs to linear
#ifdef WIN32
 int sbarpos=MulDiv((int)current_data_pos,VERTSCROLLRANGE,(int)total_data_size+1);
#else
 int sbarpos=(int)((float)current_data_pos/(total_data_size+1)*VERTSCROLLRANGE;
#endif
 SetScrollPos(wnd,SB_VERT,sbarpos,true);
}

/************************************************************************
* setcuraddr								*
* - sets the address as a location for the screen output to start at	*
* - also sets the scroll bar position for the vertical scroll bar	*
* - also ensures that its not set to a mid-instruction address and	*
*   sets the subline							*
* - called from many places in the source code				*
************************************************************************/
void disio::setcuraddr(lptr loc) {
 dsmitem titem,*tblock;
 dsegitem *l_ds;
  // check for non-existant address added v2.20
 l_ds=dta->findseg(loc);
 if (!l_ds) return;
 curraddr=loc;		// set top line address
 titem.addr=curraddr;
 titem.type=dsmnull;
 dsm->findnext(&titem);
 tblock=dsm->nextiterator();
 if (tblock) subitem=tblock->type;
 else subitem=dsmnull;
 tblock=dsm->nextiter_code(tblock);
 if (tblock && loc.between(tblock->addr,tblock->addr+tblock->length-1))
   curraddr=tblock->addr;
 outend=loc+50;
 sel=0;
 updatewindow();
 setscrollpos(loc);
}

// calculates the rectangle for item at line <item> using CharBox.y
void disio::GetItemRect(int item, PRECT R) {
 GetClientRect(wnd,R);
 R->top=item*CharBox.y;
 R->bottom=R->top+CharBox.y;
}

/************************************************************************
* setpos								*
* - when the left mouse button is pressed the line is changed to the	*
*   line the mouse points at. This routine sets the line, and asks for	*
*   a screen update if needed (the screen update method here is a	*
*   primary thread request that simply invalidates the window rather	*
*   than requesting through the scheduler...				*
************************************************************************/
void disio::setpos(int ypos) {
 if (ypos!=sel) {
  RECT R;
  GetItemRect(sel,&R);
  sel=ypos;
  InvalidateRect(wnd,&R,TRUE);	// let remove marker
  GetItemRect(sel,&R);
  InvalidateRect(wnd,&R,TRUE);	// let set marker
 }
}

/************************************************************************
* printlineheader							*
* - prints an appropriate line header with the address if needed and	*
*   sets the cursor position for the next LastPrintBuff call		*
************************************************************************/
void disio::printlineheader(lptr loc,bool printaddrs) {
 if (options.mode32) {
  if (printaddrs) PrintBuff(/*"%04lx:"*/"%08lx",/*loc.segm,*/loc.offs);
  else PrintBuff("");
  LastPrintBuffEpos(BYTEPOS-5);
 }else{
  if (printaddrs) PrintBuff("%04lx:%04lx",loc.segm,loc.offs);
  else PrintBuff("");
  LastPrintBuffEpos(BYTEPOS-4);
 }
}

/************************************************************************
* outinst								*
* - this is the routine which results in the output of an address, hex	*
*   bytes, instruction and arguments					*
************************************************************************/
void disio::outinst(dsmitem *inst,bool printaddrs) {
 dsegitem *dblock;
 int i;
 int prefixptr;
 byte pbyte;
 printlineheader(inst->addr,printaddrs);
 dblock=dta->findseg(inst->addr);      // find segment item.
 switch (inst->type) {
  case dsmcode: {
   i=inst->length;
   if (printaddrs) {
    while (i) {
     if (dblock) {
      if (dblock->typ==uninitdata) LastPrintBuff("??");
      else LastPrintBuff("%02x",inst->data[inst->length-i]);
     }else LastPrintBuff("%02x",inst->data[inst->length-i]);
     i--;
     if (i+8<inst->length && inst->length>10) {
      LastPrintBuff("..");
      break;
     }
    }
   }
   if (options.mode32) LastPrintBuffEpos(ASMPOS+4);
   else	LastPrintBuffEpos(ASMPOS);
   if (inst->flags&FLAGS_PREFIX) {
    prefixptr=0;
    while (!isprefix(inst->data[prefixptr]) && prefixptr<15) prefixptr++;
    pbyte=inst->data[prefixptr];
    outprefix(pbyte);
   }
   LastPrintBuff(DSMITEM_NAME(inst));
   LastPrintBuff(" ");
   if (options.mode32) LastPrintBuffEpos(ARGPOS+4);
   else	LastPrintBuffEpos(ARGPOS);
   if (dblock) {
    if (dblock->typ==uninitdata) LastPrintBuff("?");
    else{
     outargs(inst,DSMITEM_ARG1(inst));
     if (DSMITEM_ARG2(inst)!=ARG_NONE) {
      LastPrintBuff(", ");
      outargs(inst,DSMITEM_ARG2(inst));
     }
     if (DSMITEM_ARG3(inst)!=ARG_NONE) {
      LastPrintBuff(", ");
      outargs(inst,DSMITEM_ARG3(inst));
     }
    }
   }else{
    outargs(inst,DSMITEM_ARG1(inst));
    if (DSMITEM_ARG2(inst)!=ARG_NONE) {
     LastPrintBuff(", ");
     outargs(inst,DSMITEM_ARG2(inst));
    }
    if (DSMITEM_ARG3(inst)!=ARG_NONE) {
     LastPrintBuff(", ");
     outargs(inst,DSMITEM_ARG3(inst));
    }
   }
  }break;
 }
}

/************************************************************************
* outdb									*
* - this is similar to outinst, but when there is no disassembly for a	*
*   loc we call this to output a db xxh or a db ? if its uninitdata    *
************************************************************************/
void disio::outdb(lptr *lp,bool printaddrs) {
 dsegitem *dblock;
 dword aaddr;
 byte *mcode;
 printlineheader(*lp,printaddrs);
 dblock=dta->findseg(*lp);	// find segment item.
 if (!dblock) {
  if (printaddrs) LastPrintBuff("??");
 }else if (dblock->typ==uninitdata) {
  if (printaddrs) LastPrintBuff("??");
 }else{
  aaddr=(*lp-dblock->addr);
  mcode=dblock->data+aaddr;
  if (printaddrs) LastPrintBuff("%02x",mcode[0]);
 }
 if (options.mode32) LastPrintBuffEpos(ASMPOS+4);
 else LastPrintBuffEpos(ASMPOS);

 LastPrintBuff("db");

 if (options.mode32) LastPrintBuffEpos(ARGPOS+4);
 else LastPrintBuffEpos(ARGPOS);
  // changed to single ? - 2.25
 if (!dblock) LastPrintBuff("?");
 else if (dblock->typ==uninitdata) {
  LastPrintBuff("?");
 }else{
  LastPrintBuffHexValue(mcode[0]);
  if (isprint(mcode[0])) {
   LastPrintBuffEpos(COMMENTPOS);
   LastPrintBuff(";'%c'",mcode[0]);
  }
 }
}

/************************************************************************
* issegprefix								*
* - returns true if byte is a segment prefix valid value		*
************************************************************************/
bool disio::issegprefix(byte byt) {
 switch (byt) {
  case 0x2e:
  case 0x36:
  case 0x3e:
  case 0x26:
  case 0x64:
  case 0x65: return true;
 }
 return false;
}

/************************************************************************
* isprefix								*
* - returns true if byte is a prefix valid value (rep/repne/lock)	*
************************************************************************/
bool disio::isprefix(byte byt) {
 switch (byt) {
  case 0xf0:
  case 0xf2:
  case 0xf3: return true;
 }
 return false;
}

/************************************************************************
* outprefix								*
* - here we output a prefix segment override				*
************************************************************************/
void disio::outprefix(byte prefixbyte) {
 char *s;
 switch (prefixbyte) {
  case 0x2e: s="cs:";	break;
  case 0x36: s="ss:";	break;
  case 0x3e: s="ds:";	break;
  case 0x26: s="es:";	break;
  case 0x64: s="fs:";	break;
  case 0x65: s="gs:";	break;
  case 0xf0: s="lock ";	break;
  case 0xf2: s="repne ";break;
  case 0xf3: s="repe ";	break;
  default: s="err:";
 }
 LastPrintBuff(s);
}

/************************************************************************
* jumpback								*
* - when the user presses ESC, or selects jump back we get the last	*
*   address from the top of the address stack and call setcuraddr and	*
*   update the window and so the disassembly listing flicks back	*
************************************************************************/
void disio::jumpback(void) {
 if (!retstack.stacktop) return;
 setcuraddr(retstack.pop());
 sel=selstack[retstack.stacktop];
 if ((unsigned)sel>=(unsigned)size.y) sel=0;	// for invalid values
 updatewindow();
}

/************************************************************************
* jumpto								*
* - more complex than the jumpback is the jumpto. The complexity lies	*
*   in deciding where we are jumping to and what the arguments value is *
*   and if the location exists. Actually making the jump consists of	*
*   saving the current location to the address stack and then changing	*
*   the curraddr for output, and updating the window			*
* - most of this routine is a complex decipherment of a modrm address	*
*   to jump to								*
* NB I need to stick this in a function of its own at some point, as it *
* would be quite useful to just get an argument address in several	*
* places in the code							*
************************************************************************/
void disio::jumpto(bool arg1) {
 dsmitem *tblock;
 lptr outhere;
 byte *data;
 bool madejump;
 byte modrm,sib;
 word rm;
 tblock=findcurrentline();
 outhere.assign(0,0);
 if (tblock && tblock->type!=dsmcode) return;
 madejump=false;
 if (tblock) {
  if (arg1) {
   switch (DSMITEM_ARG1(tblock)) {
    case ARG_FADDR: {
     data=tblock->data+tblock->length;
     if (tblock->mode32) {
      data-=6;
      outhere.assign(((word *)(&data[4]))[0],((dword *)(&data[0]))[0]);
     }else{
      data-=4;
      outhere.assign(((word *)(&data[2]))[0],((word *)(&data[0]))[0]);
     }
     if (follow(outhere)) madejump=true;
    }break;
    case ARG_IMM32: {
     if (tblock->override!=over_dsoffset) break;
     data=tblock->data+tblock->length;
     data-=4;
     outhere.assign(options.dseg,((dword *)(&data[0]))[0]);
     if (follow(outhere)) madejump=true;
    }break;
    case ARG_MEMLOC: {
     data=tblock->data+tblock->length;
     if (options.mode32) {
      data-=4;
      outhere.assign(tblock->addr.segm,((dword *)data)[0]);
     }else{
      data-=2;
      outhere.assign(tblock->addr.segm,((word *)data)[0]);
     }
     if (follow(outhere)) madejump=true;
    }break;
    case ARG_IMM: {
     if (tblock->override!=over_dsoffset) break;
     if (options.mode32) {
      data=tblock->data+tblock->length;
      data-=4;
      outhere.assign(options.dseg,((dword *)(&data[0]))[0]);
      if (follow(outhere)) madejump=true;
     }
    }break;
    case ARG_RELIMM: {
     data=tblock->data+tblock->length;
     outhere=tblock->addr;
     if (tblock->mode32) {
      data-=4;
      outhere+=((dword *)data)[0]+tblock->length;
     }else{
      data-=2;
      outhere+=(word)(((word *)data)[0]+tblock->length);
     }
     if (follow(outhere)) madejump=true;
    }break;
    case ARG_RELIMM8: {
     data=tblock->data+tblock->length-1;
     outhere=tblock->addr;
     if (tblock->mode32) {
      if (data[0]&0x80) outhere+=(dword)(data[0]+0xffffff00+tblock->length);
      else		outhere+=(dword)(data[0]+tblock->length);
     }else{
      if (data[0]&0x80) outhere+=(word)(data[0]+0xff00+tblock->length);
      else		outhere+=(word)(data[0]+tblock->length);
     }
     if (follow(outhere)) madejump=true;
    }break;
    case ARG_MMXMODRM:
    case ARG_XMMMODRM:
    case ARG_MODRM_S:
    case ARG_MODRMM512:
    case ARG_MODRMQ:
    case ARG_MODRM_SREAL:
    case ARG_MODRM_PTR:
    case ARG_MODRM_WORD:
    case ARG_MODRM_SINT:
    case ARG_MODRM_EREAL:
    case ARG_MODRM_DREAL:
    case ARG_MODRM_WINT:
    case ARG_MODRM_LINT:
    case ARG_MODRM_BCD:
    case ARG_MODRM_FPTR:
    case ARG_MODRM: {
     data=tblock->data+tblock->modrm;
     rm=(byte)((data[0]&0xc0)>>6);
     modrm=(byte)(data[0]&0x07);
     switch (rm) {
      case 0: {
       if (options.mode32) {
        if (modrm==5) {
         outhere.assign(tblock->addr.segm,((dword *)(&data[1]))[0]);
        }else if (modrm==4) {	 // case 4=sib
 	 sib=data[1];
	 if ((sib&0x07)==5) { // disp32
	  outhere.assign(tblock->addr.segm,((dword *)(&data[2]))[0]);
	 }
        }
       }else{
        if (modrm==6) {
         outhere.assign(tblock->addr.segm,((word *)(&data[1]))[0]);
        }
       }
      }break;
      case 1: break;
      case 2: {
       if (options.mode32) {
        outhere.assign(tblock->addr.segm,((dword *)(&data[1]))[0]);
	if (modrm==4) {	    // case 4=sib
	 outhere.assign(tblock->addr.segm,((dword *)(&data[2]))[0]);
	}
       }else{
        outhere.assign(tblock->addr.segm,((word *)(&data[1]))[0]);
       }
      }break;
      case 3: break;
     }/*switch(rm)*/
     if (follow(outhere)) madejump=true;
    }break;
   }/*switch(DSM_ITEM...)*/
  }/*if(arg1)*/
  if (!madejump) {
   switch (DSMITEM_ARG2(tblock)) {
    case ARG_IMM32: {
     if (tblock->override!=over_dsoffset) break;
     data=tblock->data+tblock->length;
     data-=4;
     outhere.assign(options.dseg,((dword *)(&data[0]))[0]);
     follow(outhere);
    }break;
    case ARG_IMM: {
     if (tblock->override!=over_dsoffset) break;
     if (options.mode32) {
      data=tblock->data+tblock->length;
      data-=4;
      outhere.assign(options.dseg,((dword *)(&data[0]))[0]);
      follow(outhere);
     }
    }break;
    case ARG_MEMLOC: {
     data=tblock->data+tblock->length;
     if (options.mode32) {
      data-=4;
      outhere.assign(tblock->addr.segm,((dword *)data)[0]);
     }else{
      data-=2;
      outhere.assign(tblock->addr.segm,((word *)data)[0]);
     }
     follow(outhere);
    }break;
    case ARG_MMXMODRM:
    case ARG_XMMMODRM:
    case ARG_MODRM_S:
    case ARG_MODRMM512:
    case ARG_MODRMQ:
    case ARG_MODRM_SREAL:
    case ARG_MODRM_PTR:
    case ARG_MODRM_WORD:
    case ARG_MODRM_SINT:
    case ARG_MODRM_EREAL:
    case ARG_MODRM_DREAL:
    case ARG_MODRM_WINT:
    case ARG_MODRM_LINT:
    case ARG_MODRM_BCD:
    case ARG_MODRM_FPTR:
    case ARG_MODRM: {
     data=tblock->data+tblock->modrm;
     rm=(byte)((data[0]&0xc0)>>6);
     modrm=(byte)(data[0]&0x07);
     switch (rm) {
      case 0:
	      if(options.mode32)
	      { if(modrm==5)
		{ outhere.assign(tblock->addr.segm,((dword *)(&data[1]))[0]);
		}
		else if(modrm==4)	 // case 4=sib
		{ sib=data[1];
		  if((sib&0x07)==5) // disp32
		  { outhere.assign(tblock->addr.segm,((dword *)(&data[2]))[0]);
		  }
		}
	      }
	      else
	      { if(modrm==6)
		{ outhere.assign(tblock->addr.segm,((word *)(&data[1]))[0]);
		}
	      }
	      break;
      case 1:
	      break;
      case 2:
	      if(options.mode32)
	      { outhere.assign(tblock->addr.segm,((dword *)(&data[1]))[0]);
		if(modrm==4)	    // case 4=sib
		{ outhere.assign(tblock->addr.segm,((dword *)(&data[2]))[0]);
		}
	      }
	      else
	      { outhere.assign(tblock->addr.segm,((word *)(&data[1]))[0]);
	      }
	      break;
      case 3:
	      break;
     }/*switch(rm)*/
     follow(outhere);
    }break;
   }/*switch(DSMITEM...)*/
  }
 }
}

/************************************************************************
* findcurrentline							*
* - this routine finds the current screen address and output line in	*
*   the disassembly database and from there works out the disassembly	*
*   item on the currently selected line.				*
* - it is used by jumpto, when the user presses return to follow a jump *
* - comments added to the procedure, it is a useful one to follow and	*
*   see the strategy employed, which is a fairly common Borg strategy	*
************************************************************************/
dsmitem *disio::findcurrentline(void) {
 dsmitem titem,*tblock;
 lptr outhere;
 int i;
  // strategy
  // - use pointer to first item if available (so comments,etc included in list
  // - otherwise use address.
 titem.addr=curraddr;
 titem.type=subitem;
  // hunt for current addr and subitem
 tblock=dsm->find(&titem);
 if (tblock) tblock=dsm->nextiterator();
  // on overlap - reset the curraddr.
  // [on the spot error correction]
 if (tblock) {
  if(curraddr.between(tblock->addr,tblock->addr+tblock->length-1))
     curraddr.offs=tblock->addr.offs;
 }
  // ensure we point to the right item, or the next one
 if (tblock) {
  if((tblock->addr<curraddr)||((tblock->addr==curraddr)&&(tblock->type<subitem)))
      tblock=dsm->nextiterator();
 }
  // now at the top of the screen, the next loop moves down to the user selection line
 outhere=curraddr;
 for (i=0;i<sel;i++) {
  if (tblock) {
   if (outhere==tblock->addr) {
    outhere+=tblock->length;
    tblock=dsm->nextiterator();
   }else outhere++;
  }else outhere++;
    // check if gone beyond seg, get next seg.
  if (dta->beyondseg(outhere)) {
   outhere.offs--;
   dta->nextseg(&outhere);
  }
  if (!outhere.segm) break;
 }
  // now we either have the line we are pointing to, in the database
  // or we have moved beyond the database and have a null
  // or we have an address which would be a db
 if (tblock && outhere!=tblock->addr) return NULL;
 return tblock;
}

/************************************************************************
* findcurrentaddr							*
* - this is very similar to findcurrentline, but it instead finds just	*
*   the location. the search strategy is the same			*
************************************************************************/
void disio::findcurrentaddr(lptr *loc) {
 dsmitem titem,*tblock;
 lptr outhere;
 int i;
  // strategy
  // - use pointer to first item if available (so comments,etc included in list
  // - otherwise use address.
 titem.addr=curraddr;
 titem.type=subitem;
 tblock=dsm->find(&titem);
 if (tblock) tblock=dsm->nextiterator();
 if (tblock && curraddr.between(tblock->addr,tblock->addr+tblock->length-1))
   curraddr.offs=tblock->addr.offs;
 if (tblock && tblock->addr<curraddr) tblock=dsm->nextiterator();
  // added 2.25 - bugfix
  // - wasnt finding correct lines when in mid-line......
 if (tblock) {
  while (tblock->addr==curraddr && tblock->type<subitem) {
   tblock=dsm->nextiterator();
   if (!tblock)	break;
  }
 }
 outhere=curraddr;
 for (i=0;i<sel;i++) {
  if (tblock && outhere==tblock->addr) {
   outhere+=tblock->length;
   tblock=dsm->nextiterator();
  }else outhere++;
    // check if gone beyond seg, get next seg.
  if (dta->beyondseg(outhere)) {
   outhere.offs--;
   dta->nextseg(&outhere);
  }
  if (!outhere.segm) break;
 }
 if (outhere.segm) *loc=outhere;
 else *loc=curraddr;
}

/************************************************************************
* findaddr								*
* Ich verstehe diesen Quelltext nicht, aber hier versuche ich eine
* Zeile im Bildschirm zu finden, die die angegebene Adresse enthält	*
************************************************************************/
int disio::findaddr(const lptr &loc) {
 dsmitem titem,*tblock;
 lptr outhere;
 int i;
  // strategy
  // - use pointer to first item if available (so comments,etc included in list
  // - otherwise use address.
 titem.addr=curraddr;
 titem.type=subitem;
 tblock=dsm->find(&titem);
 if (tblock) tblock=dsm->nextiterator();
 if (tblock && curraddr.between(tblock->addr,tblock->addr+tblock->length-1))
   curraddr.offs=tblock->addr.offs;
 if (tblock && tblock->addr<curraddr) tblock=dsm->nextiterator();
  // added 2.25 - bugfix
  // - wasnt finding correct lines when in mid-line......
 if (tblock) {
  while (tblock->addr==curraddr && tblock->type<subitem) {
   tblock=dsm->nextiterator();
   if (!tblock)	break;
  }
 }
 outhere=curraddr;
 for (i=0;i<size.y;i++) {
  if (tblock && outhere==tblock->addr) {
   outhere+=tblock->length;
   tblock=dsm->nextiterator();
  }else outhere++;
    // check if gone beyond seg, get next seg.
  if (dta->beyondseg(outhere)) {
   outhere.offs--;
   dta->nextseg(&outhere);
  }
  if (outhere==loc) return i+1;		// weiß nicht warum das +1 ...
  if (!outhere.segm) break;
 }
 return -1;
}

/************************************************************************
* savecuraddr								*
* - this simply saves the window top line location to the return stack	*
* - this is called when the user selects to jump somewhere (like to a	*
*   named location) rather than the 'jumpto' routine used to jump to a	*
*   location specified by a disassembly argument			*
************************************************************************/
void disio::savecuraddr(void) {
 if (retstack.stacktop==CALLSTACKSIZE) {
	// if stack is full, move down its content (damn, no STL)
  memmove(selstack,selstack+1,sizeof(selstack)-sizeof(selstack[0]));
 }
 retstack.push(curraddr);
 selstack[retstack.stacktop-1]=sel;
}

// same as ^F in Turbo Debugger
bool disio::follow(const lptr &loc) {
 if (!dta->findseg(loc)) return false;
 savecuraddr();
 int i=findaddr(loc);
 if (i>=0) sel=i;	// NICHT ROLLEN wenn im Bildschirm!!!
 else setcuraddr(loc);
 updatewindow();
 return true;
}

/************************************************************************
* updatewindowifwithinrange						*
* - adds a scheduler task for a window update if the current window	*
*   overlaps with the specified range					*
************************************************************************/
void disio::updatewindowifwithinrange(lptr loc_start,lptr loc_end) {
 if (loc_end>=curraddr && loc_start<=outend)
   scheduler.addtask(windowupdate,priority_window,nlptr,NULL);
}

/************************************************************************
* updatewindowifinrange							*
* - adds a scheduler task for a window update if the current window	*
*   contains the loc specified						*
************************************************************************/
void disio::updatewindowifinrange(lptr loc) {
 if (loc.between(curraddr,outend))
   scheduler.addtask(windowupdate,priority_window,nlptr,NULL);
}

/************************************************************************
* updatewindow								*
* - this function rewrites the buffers for the disassembly output to	*
*   the window, and then requests a screen refresh which will paint the *
*   buffers into the window. The ClearBuff and DoneBuff functions	*
*   when the buffers are full and it is safe to refresh the screen with *
*   a repaint								*
************************************************************************/
// this functions job to output a window
// of disassembly to the buffer.
void disio::updatewindow(void) {
 dsmitem titem,*tblock;
 lptr outhere;
 int i;
  // find current position.
 titem.addr=curraddr;
 titem.type=subitem;
 tblock=dsm->find(&titem);
 if (tblock) tblock=dsm->nextiterator();
  // now tblock= current position, or previous one.
  // check if in middle of instruction
 if (tblock) {
 // bugfix 2.27
  if (tblock->length>1 
  && curraddr.between(tblock->addr,tblock->addr+tblock->length-1)) {
   curraddr.offs=tblock->addr.offs;
   subitem=tblock->type;
  }
 }
  // check if previous one. get next
 if (tblock) {
  if (tblock->addr<curraddr
  || tblock->addr==curraddr && tblock->type<subitem)
    tblock=dsm->nextiterator();
 }
  // tblock is now top of the page.
 outhere=curraddr;
 ClearBuff();			      // start again
 for (i=0; i<size.y;i++) {
  if (tblock) {
   if (outhere==tblock->addr) {
    switch (tblock->type) {
     case dsmcode: {
      outinst(tblock,true);
     }break;
     case dsmnameloc: {
      printlineheader(tblock->addr,true);
      LastPrintBuff("%s:",tblock->data);
     }break;
     case dsmxref: {
      printlineheader(tblock->addr,true);
      LastPrintBuff(";");
      LastPrintBuffEpos(COMMENTPOS);
      LastPrintBuff("XREFS First: ");
      xrefs->printfirst(tblock->addr);
     }break;
     default: {
      printlineheader(tblock->addr,true);
      outcomment(tblock);
     }
    }
    outhere+=tblock->length;
    tblock=dsm->nextiterator();
   }else{
    outdb(&outhere,true);
    outhere++;
   }
  }else{
   outdb(&outhere,true);
   outhere++;
  }
    // check if gone beyond seg, get next seg.
  if (dta->beyondseg(outhere)) {
   outhere.offs--;
   dta->nextseg(&outhere);
  }
  if (!outhere.segm) break;
  else outend=outhere;
 }
 DoneBuff();			      // mark as done
 InvalidateRect(wnd,NULL,true);
}

/************************************************************************
* scroller								*
* - this routine controls simple vertical scrolls. A vertical scroll is *
*   a movement of the currently selected line. Only if this line moves	*
*   beyond the boundaries of the window do we need to move the windowed *
*   disassembly output itself. Simple moves are handled quickly, and if *
*   we need to regenerate the buffers then we first recalculate the top *
*   position and then we call windowupdate to handle the rest.		*
************************************************************************/
void disio::scroller(int amount) {
 dsmitem titem,*tblock;
 int newpos=sel+amount;
  // simple move bar on screen
 if ((unsigned)newpos<(unsigned)(size.y-1)) {
  setpos(newpos);
  return;
 }
  // find top of page
 titem.addr=curraddr;
 titem.type=subitem;
 tblock=dsm->find(&titem);
 // tblock is now top of page or previous item.
 // if moving up find previous inst
 if ((unsigned)amount<100 && tblock) tblock=dsm->nextiterator();
 if ((unsigned)amount>100 && tblock 
 && tblock->addr==titem.addr && tblock->type==subitem)
   tblock=dsm->lastiterator();
 // move up - tblock=previous inst.
 // if moving down, check if tblock=previous item.
 if (tblock && (unsigned)amount<100) {
  if (tblock->addr<curraddr
  || tblock->addr==curraddr && tblock->type<subitem)
    tblock=dsm->nextiterator();
 }
 // moving down - tblock=current top.
 if ((unsigned)amount<100) while (amount) {
  if (sel<=size.y-3) sel++;
  else{
   if (tblock) {
    if (curraddr==tblock->addr) {
     curraddr+=tblock->length;
     tblock=dsm->nextiterator();
     if (tblock && curraddr==tblock->addr) subitem=tblock->type;
     else subitem=dsmcode;
    }else{
     subitem=dsmnull;
     curraddr++;
    }
   }else{
    subitem=dsmnull;
    curraddr++;
   }
// check if gone beyond seg, get next seg.
   if (dta->beyondseg(curraddr)) {
    curraddr.offs--;
    dta->nextseg(&curraddr);
    subitem=dsmnull;
   }
   if (!curraddr.segm) break;
   titem.addr=curraddr;
  }
  amount--;
 }else{
  while (amount) {
   if (sel) sel--;
   else{
    if (tblock) {
     if (curraddr==tblock->addr+tblock->length) {
      curraddr.offs-=tblock->length;
      subitem=tblock->type;
      tblock=dsm->lastiterator();
     }else{
      subitem=dsmcode;
      curraddr.offs--;
     }
    }else{
     subitem=dsmnull;
     curraddr.offs--;
    }
// check if gone beyond seg, get previous seg.
    if (dta->beyondseg(curraddr)) {
     curraddr++;
     dta->lastseg(&curraddr);
    }
    if (!curraddr.segm) break;
    titem.addr=curraddr;
   }
   amount++;
  }
 }
 if (!curraddr.segm) curraddr=titem.addr;
 updatewindow();
 setscrollpos(curraddr);
//  current_data_pos=dta->datagetpos();
//  sbarpos=((float)current_data_pos)/((float)total_data_size+(float)1.0)*(float)VERTSCROLLRANGE;
//  SetScrollPos(MainWnd,SB_VERT,(int)sbarpos,true);
}

BOOL PrintFoundName(lptr loc) {
 if (name->isname(loc))		name->printname(loc);
 else if (import->isname(loc))	import->printname(loc);
 else if(expt->isname(loc))	expt->printname(loc);
 else return FALSE;
 return TRUE;
}

void PrintLongHex(lptr loc) {
 if (!PrintFoundName(loc)) cvd->LastPrintBuffLongHexValue(loc.offs);
}

void PrintOffset(lptr loc) {
 cvd->LastPrintBuff("offset ");
 PrintLongHex(loc);
}

void PrintMemVar(lptr loc) {
 cvd->LastPrintBuff("[");
 PrintLongHex(loc);
 cvd->LastPrintBuff("]");
}

/************************************************************************
* outargs								*
* - this is a very long routine which handles every kind of argument	*
*   that we have set up in the processor tables. It outputs the ascii	*
*   form of the instructions arguments to the buffer. It handles	*
*   complex modrm and sib encodings, the display of names and locations *
*   which must be decoded, etc.						*
************************************************************************/
void disio::outargs(dsmitem *inst,argtype a) {
 byte *dta,modrm,sib;
  // rm extended to word. build 15. re M Ogden and VC++ warnings.
 word rm;
 argtype a1,a2;
 dword targetd;
 dword targetw;
 lptr loc;
 char fbuff[40];
 int i,sp;	      // sp= string printed
 byte pbyte; // prefix byte.
 int prefixptr;
 if(inst->flags&FLAGS_SEGPREFIX) {
  prefixptr=0;
  while (!issegprefix(inst->data[prefixptr]) && prefixptr<15)
    prefixptr++;
  pbyte=inst->data[prefixptr];
 }
 if (inst->flags&FLAGS_ADDRPREFIX) options.mode32=!options.mode32;
 switch (a) {
  case ARG_REG_AX: {
   if (inst->mode32) LastPrintBuff("eax");
   else		     LastPrintBuff("ax");
  }break;
  case ARG_REG_BX: {
   if (inst->mode32) LastPrintBuff("ebx");
   else		     LastPrintBuff("bx");
  }break;
  case ARG_REG_CX: {
   if (inst->mode32) LastPrintBuff("ecx");
   else		     LastPrintBuff("cx");
  }break;
  case ARG_REG_DX: {
   if(inst->mode32)  LastPrintBuff("edx");
   else		     LastPrintBuff("dx");
  }break;
  case ARG_16REG_DX: LastPrintBuff("dx"); break;
  case ARG_REG_SP: {
   if (inst->mode32) LastPrintBuff("esp");
   else		     LastPrintBuff("sp");
  }break;
  case ARG_REG_BP: {
   if (inst->mode32) LastPrintBuff("ebp");
   else		     LastPrintBuff("bp");
  }break;
  case ARG_REG_SI: {
   if (inst->mode32) LastPrintBuff("esi");
   else		     LastPrintBuff("si");
  }break;
  case ARG_REG_DI: {
   if (inst->mode32) LastPrintBuff("edi");
   else		     LastPrintBuff("di");
  }break;
  case ARG_REG_AL:   LastPrintBuff("al"); break;
  case ARG_REG_AH:   LastPrintBuff("ah"); break;
  case ARG_REG_BL:   LastPrintBuff("bl"); break;
  case ARG_REG_BH:   LastPrintBuff("bh"); break;
  case ARG_REG_CL:   LastPrintBuff("cl"); break;
  case ARG_REG_CH:   LastPrintBuff("ch"); break;
  case ARG_REG_DL:   LastPrintBuff("dl"); break;
  case ARG_REG_DH:   LastPrintBuff("dh"); break;
  case ARG_REG_ST0:  LastPrintBuff("st(0)"); break;
  case ARG_REG_ES:   LastPrintBuff("es"); break;
  case ARG_REG_CS:   LastPrintBuff("cs"); break;
  case ARG_REG_DS:   LastPrintBuff("ds"); break;
  case ARG_REG_SS:   LastPrintBuff("ss"); break;
  case ARG_REG_FS:   LastPrintBuff("fs"); break;
  case ARG_REG_GS:   LastPrintBuff("gs"); break;
  case ARG_REG_A:    LastPrintBuff("a"); break;
  case ARG_REG_B:    LastPrintBuff("b"); break;
  case ARG_REG_C:    LastPrintBuff("c"); break;
  case ARG_REG_D:    LastPrintBuff("d"); break;
  case ARG_REG_E:    LastPrintBuff("e"); break;
  case ARG_REG_H:    LastPrintBuff("h"); break;
  case ARG_REG_L:    LastPrintBuff("l"); break;
  case ARG_REG_I:    LastPrintBuff("i"); break;
  case ARG_REG_R:    LastPrintBuff("r"); break;
  case ARG_REG_HL_IND: LastPrintBuff("(hl)"); break;
  case ARG_REG_BC:   LastPrintBuff("bc"); break;
  case ARG_REG_DE:   LastPrintBuff("de"); break;
  case ARG_REG_HL:   LastPrintBuff("hl"); break;
  case ARG_REG_BC_IND: LastPrintBuff("(bc)"); break;
  case ARG_REG_DE_IND: LastPrintBuff("(de)"); break;
  case ARG_REG_SP_IND: LastPrintBuff("(sp)"); break;
  case ARG_REG_IX:   LastPrintBuff("ix"); break;
  case ARG_REG_IX_IND: {
   LastPrintBuff("(ix");
   if (inst->flags&FLAGS_INDEXREG) {
    dta=inst->data+2;
    LastPrintBuff("+");
    LastPrintBuffLongHexValue((word)(dta[0]));
   }LastPrintBuff(")");
  }break;
  case ARG_REG_IY:   LastPrintBuff("iy"); break;
  case ARG_REG_IY_IND: {
   LastPrintBuff("(iy");
   if (inst->flags&FLAGS_INDEXREG) {
    dta=inst->data+2;
    LastPrintBuff("+");
    LastPrintBuffLongHexValue((word)(dta[0]));
   }
   LastPrintBuff(")");
  }break;
  case ARG_REG_C_IND:LastPrintBuff("(c)"); break;
  case ARG_REG_AF:   LastPrintBuff("af"); break;
  case ARG_REG_AF2:  LastPrintBuff("af'"); break;
  case ARG_IMM: {
   dta=inst->data+inst->length;
   if (inst->mode32) {
    dta-=4;
    switch (inst->override) {
     case over_decimal: {
      if (inst->displayflags&DISPFLAG_NEGATE) LastPrintBuff("-%02lu",0-*(dword *)dta);
      else				      LastPrintBuff("%02lu",*(dword *)dta);
     }break;
     case over_char: {
      LastPrintBuff("'");
      for (i=3;i>=0;i--) if (dta[i]) LastPrintBuff("%c",dta[i]);
      LastPrintBuff("'");
     }break;
     case over_dsoffset: {
      loc.assign(inst->addr.segm,*(dword *)dta);
      PrintOffset(loc);
     }break;
     case over_single: {
      sprintf(fbuff,"(float)%g",*(float *)dta);
      LastPrintBuff(fbuff);
     }break;
     default: {
      if (inst->displayflags&DISPFLAG_NEGATE) {
       LastPrintBuff("-");
       LastPrintBuffLongHexValue(0-*(dword *)dta);
      }else LastPrintBuffLongHexValue(*(dword *)dta);
     }break;
    }/*switch*/
   }else{ dta-=2;
    if (inst->override==over_decimal) {
     if (inst->displayflags&DISPFLAG_NEGATE)
      LastPrintBuff("-%02lu",0x10000-((word *)dta)[0]);
     else LastPrintBuff("%02lu",((word *)dta)[0]);
    }else if(inst->override==over_char)	{
     LastPrintBuff("\"");
     for (i=1;i>=0;i--) if (dta[i]) LastPrintBuff("%c",dta[i]);
     LastPrintBuff("\"");
    }else{
     if (inst->displayflags&DISPFLAG_NEGATE) {
      LastPrintBuff("-");
      LastPrintBuffLongHexValue(0x10000-((word *)dta)[0]);
     }else LastPrintBuffLongHexValue(((word *)dta)[0]);
    }
   }
  }break;
  case ARG_IMM_SINGLE:
   dta=inst->data+inst->length-4;
   sprintf(fbuff,"%g",*(float *)dta);
   LastPrintBuff(fbuff);
   break;
  case ARG_IMM_DOUBLE:
   dta=inst->data+inst->length-8;
   sprintf(fbuff,"%g",*(double *)dta);
   LastPrintBuff(fbuff);
   break;
  case ARG_IMM_LONGDOUBLE:
   dta=inst->data+inst->length-10;
   sprintf(fbuff,"%Lg",*(long double *)dta);
   LastPrintBuff(fbuff);
   break;
  case ARG_IMM32: {
   dta=inst->data+inst->length-4;
   switch (inst->override) {
    case over_decimal:
     if (inst->displayflags&DISPFLAG_NEGATE) LastPrintBuff("-%02lu",0-((dword *)dta)[0]);
     else				     LastPrintBuff( "%02lu",((dword *)dta)[0]);
     break;
    case over_char:
     LastPrintBuff("\'");
     for(i=3;i>=0;i--) if(dta[i]) LastPrintBuff("%c",dta[i]);
     LastPrintBuff("\'");
     break;
    case over_dsoffset:
     loc.assign(inst->addr.segm,*(dword *)dta);
     PrintOffset(loc);
     break;
    case over_single:
     sprintf(fbuff,"(float)%g",*(float *)dta);
     LastPrintBuff(fbuff);
     break;
    default:
     if (inst->displayflags&DISPFLAG_NEGATE) {
      LastPrintBuff("-");
      LastPrintBuffLongHexValue(0-((dword *)dta)[0]);
     }else LastPrintBuffLongHexValue(((dword *)dta)[0]);
     break;
   }/*switch*/
  }break;
  case ARG_STRING: {
   rm=0;
   LastPrintBuff("\"");
   sp=0;
   while (inst->data[rm]) {
    if (inst->data[rm]<32) {
     LastPrintBuff("\",");
     LastPrintBuffHexValue(inst->data[rm]);
     LastPrintBuff(",\"");
    }else LastPrintBuff("%c",inst->data[rm]);
    rm++;
    sp++;
    if (sp>MAX_STRINGPRINT) break;
   }
   LastPrintBuff("\",00h");
  }break;
  case ARG_PSTRING: {
   dta=inst->data;
   rm=dta[0];
   dta++;
   LastPrintBuffHexValue((byte)rm);
   LastPrintBuff(",\"");
   sp=0;
   while (rm) {
    if (dta[0]<32) {
     LastPrintBuff("\",");
     LastPrintBuffHexValue(*dta);
     LastPrintBuff(",\"");
    }else LastPrintBuff("%c",*dta);
    dta++;
    rm--;
    sp++;
    if (sp>MAX_STRINGPRINT) break;
   }
   LastPrintBuff("\"");
  }break;
  case ARG_DOSSTRING: {
   dta=inst->data;
   rm=inst->length;
   rm--;
   LastPrintBuff("\"");
   sp=0;
   while (rm) {
    if (dta[0]<32) {
     LastPrintBuff("\",");
     LastPrintBuffHexValue(dta[0]);
     LastPrintBuff(",\"");
    }else LastPrintBuff("%c",dta[0]);
    dta++;
    rm--;
    sp++;
    if (sp>MAX_STRINGPRINT) break;
   }
   LastPrintBuff("\"");
  }break;
  case ARG_CUNICODESTRING:	// missing DW instead DB (?)
   dta=inst->data;
   rm=inst->length;
   rm-=(byte)2;
   LastPrintBuff("\"");
   sp=0;
   while (rm) {
    if (dta[0]<32) {
     LastPrintBuff("\",");
     LastPrintBuffHexValue(dta[0]);
     LastPrintBuff(",\"");
    }else LastPrintBuff("%c",dta[0]);
    dta+=2;
    rm-=(byte)2;
    sp++;
    if (sp>MAX_STRINGPRINT) break;
   }
   LastPrintBuff("\"");
   break;
  case ARG_PUNICODESTRING:
   dta=inst->data+2;
   rm=inst->length;
   rm-=(byte)2;
   sp=0;
   LastPrintBuffHexValue((byte)(rm/2));
   LastPrintBuff(",\"");
   while (rm) {
    if (dta[0]<32) {
     LastPrintBuff("\",");
     LastPrintBuffHexValue(dta[0]);
     LastPrintBuff(",\"");
    }else LastPrintBuff("%c",dta[0]);
    dta+=2;
    rm-=(byte)2;
    sp++;
    if (sp>MAX_STRINGPRINT) break;
   }
   LastPrintBuff("\"");
   break;
  case ARG_MEMLOC:
   if (inst->flags&FLAGS_SEGPREFIX) outprefix(pbyte);
   dta=inst->data+inst->length;
   if (options.mode32) {
    dta-=4;
    loc.assign(inst->addr.segm,*(dword *)dta);
    if (inst->flags&FLAGS_8BIT) LastPrintBuff("byte ptr");
    else if (inst->flags&FLAGS_ADDRPREFIX) LastPrintBuff("word ptr");
    else LastPrintBuff("dword ptr");
    PrintMemVar(loc);
   }else{
    dta-=2;
    loc.assign(inst->addr.segm,((word *)dta)[0]);
    if (inst->flags&FLAGS_8BIT) LastPrintBuff("byte ptr");
    if (inst->flags&FLAGS_ADDRPREFIX) LastPrintBuff("dword ptr");
    else LastPrintBuff("word ptr");
    PrintMemVar(loc);
   }
   break;
  case ARG_MEMLOC16:
   if (inst->flags&FLAGS_SEGPREFIX) outprefix(pbyte);
   dta=inst->data+inst->length-2;
   if (options.processor==PROC_Z80) {
    loc.assign(inst->addr.segm,*(dword *)dta);
    PrintMemVar(loc);
   }else{
    loc.assign(inst->addr.segm,*(word *)dta);
    PrintMemVar(loc);
   }
   break;
  case ARG_SIMM8:
   dta=inst->data+inst->length-1;
   if (inst->override==over_char) {
    LastPrintBuff("\"");
    for(i=0;i>=0;i--) if(dta[i]) LastPrintBuff("%c",dta[i]);
    LastPrintBuff("\"");
   }else if (dta[0]&0x80) {
    if (inst->override==over_decimal) LastPrintBuff("%02lu",(word)(0x100-dta[0]));
    else{
     LastPrintBuff("-");
     LastPrintBuffLongHexValue((word)(0x100-dta[0]));
    }
   }else{
    if (inst->override==over_decimal) LastPrintBuff("%02lu",(word)(dta[0]));
    else LastPrintBuffLongHexValue((word)(dta[0]));
   }
   break;
  case ARG_IMM8:
      dta=inst->data+inst->length-1;
      if(inst->override==over_decimal)
      { if(inst->displayflags&DISPFLAG_NEGATE)
	  LastPrintBuff("-%02lu",0x100-(word)(dta[0]));
	else
	  LastPrintBuff("%02lu",(word)(dta[0]));
      }
      else if(inst->override==over_char)
      { LastPrintBuff("\"");
	for(i=0;i>=0;i--)
	  if(dta[i])
	    LastPrintBuff("%c",dta[i]);
	LastPrintBuff("\"");
      }
      else
      { if(inst->displayflags&DISPFLAG_NEGATE)
	{  LastPrintBuff("-");
	   LastPrintBuffLongHexValue(0x100-(word)(dta[0]));
	}
	else
	  LastPrintBuffLongHexValue((word)(dta[0]));
      }
      break;
  case ARG_IMM8_IND:
      dta=inst->data+inst->length-1;
      LastPrintBuff("(");
      LastPrintBuffLongHexValue((word)(dta[0]));
      LastPrintBuff(")");
      break;
  case ARG_IMM16:
      dta=inst->data+inst->length-2;
      if(inst->override==over_decimal)
      { if(inst->displayflags&DISPFLAG_NEGATE)
	  LastPrintBuff("-%02lu",0x10000-((word *)dta)[0]);
	else
	  LastPrintBuff("%02lu",((word *)dta)[0]);
      }
      else if(inst->override==over_char)
      { LastPrintBuff("\"");
	for(i=1;i>=0;i--)
	  if(dta[i])
	    LastPrintBuff("%c",dta[i]);
	LastPrintBuff("\"");
      }
      else
      { if(inst->displayflags&DISPFLAG_NEGATE)
	{  LastPrintBuff("-");
	   LastPrintBuffLongHexValue(0x10000-((word *)dta)[0]);
	}
	else
	  LastPrintBuffLongHexValue(((word *)dta)[0]);
      }
      break;
  case ARG_IMM16_A:
      dta=inst->data+inst->length-3;
      LastPrintBuffLongHexValue(((word *)dta)[0]);
      break;
  case ARG_RELIMM8:
      dta=inst->data+inst->length-1;
      if(inst->mode32) {
       targetd=(dword)((signed char)dta[0]+inst->addr.offs+inst->length);
       loc.assign(inst->addr.segm,targetd);
       PrintLongHex(loc);
      }else{
       targetw=(word)((signed char)dta[0]+inst->addr.offs+inst->length);
       loc.assign(inst->addr.segm,targetw);
       PrintLongHex(loc);
      }
      break;
  case ARG_RELIMM:
      dta=inst->data+inst->length;
      if(inst->mode32)
      { dta-=4;
	targetd=((dword *)dta)[0]+inst->addr.offs+inst->length;
	loc.assign(inst->addr.segm,targetd);
        PrintLongHex(loc);
      }
      else
      { dta-=2;
	targetw=(word)(((word *)dta)[0]+inst->addr.offs+inst->length);
	loc.assign(inst->addr.segm,targetw);
        PrintLongHex(loc);
      }
      break;
  case ARG_REG:
      dta=inst->data+inst->modrm;
      if(options.processor==PROC_Z80)
	LastPrintBuff(regzascii[dta[0]&0x07]);
      else if(((asminstdata *)(inst->tptr))->flags&FLAGS_8BIT)
	LastPrintBuff(reg8ascii[(dta[0]>>3)&0x07]);
      else if(inst->mode32)
	LastPrintBuff(reg32ascii[(dta[0]>>3)&0x07]);
      else
	LastPrintBuff(reg16ascii[(dta[0]>>3)&0x07]);
      break;
  case ARG_MREG:
      dta=inst->data+inst->modrm;
      LastPrintBuff(regmascii[(dta[0]>>3)&0x07]);
      break;
  case ARG_XREG:
      dta=inst->data+inst->modrm;
      LastPrintBuff(regxascii[(dta[0]>>3)&0x07]);
      break;
  case ARG_FREG:
      dta=inst->data+inst->modrm;
      LastPrintBuff(regfascii[dta[0]&0x07]);
      break;
  case ARG_SREG:
      dta=inst->data+inst->modrm;
      LastPrintBuff(regsascii[(dta[0]>>3)&0x07]);
      break;
  case ARG_CREG:
      dta=inst->data+inst->modrm;
      LastPrintBuff(regcascii[(dta[0]>>3)&0x07]);
      break;
  case ARG_DREG:
      dta=inst->data+inst->modrm;
      LastPrintBuff(regdascii[(dta[0]>>3)&0x07]);
      break;
  case ARG_TREG:
    case ARG_TREG_67:
      dta=inst->data+inst->modrm;
      LastPrintBuff(regtascii[(dta[0]>>3)&0x07]);
      break;
  case ARG_MODREG:
  case ARG_MMXMODRM:
  case ARG_XMMMODRM:
  case ARG_MODRM8:
  case ARG_MODRM16:
  case ARG_MODRM_S:
  case ARG_MODRMM512:
  case ARG_MODRMQ:
  case ARG_MODRM_SREAL:
  case ARG_MODRM_PTR:
  case ARG_MODRM_WORD:
  case ARG_MODRM_BCD:
  case ARG_MODRM_SINT:
  case ARG_MODRM_EREAL:
  case ARG_MODRM_DREAL:
  case ARG_MODRM_WINT:
  case ARG_MODRM_LINT:
  case ARG_MODRM_FPTR:
  case ARG_MODRM: {
   dta=inst->data+inst->modrm;
   rm=(byte)((dta[0]&0xc0)>>6);
   modrm=(byte)(dta[0]&0x07);
   a1=DSMITEM_ARG1(inst);
   a2=DSMITEM_ARG2(inst);
   sib=dta[1];
   if (a1==ARG_IMM || a2==ARG_IMM || a1==ARG_IMM8 || a2==ARG_IMM8 || a2==ARG_NONE
   ||a1==ARG_SIMM8 || a2==ARG_SIMM8 || modrm==5 && rm==0
   || modrm==4 && rm==2 && sib&0x07==5
   || modrm==4 && rm==0 && sib&0x07==5) {
    if (rm<3) {
     switch (a) {
      case ARG_MODRM8:		LastPrintBuff("byte ptr ");	break;
      case ARG_MODRM16:
      case ARG_MODRM_WORD:	LastPrintBuff("word ptr ");	break;
      case ARG_MMXMODRM:
      case ARG_XMMMODRM:	LastPrintBuff("dword ptr ");	break;
      case ARG_MODRMQ:		LastPrintBuff("qword ptr ");	break;
      case ARG_MODRM_S:		LastPrintBuff("fword ptr ");	break;	// 6 bytes=fword
      case ARG_MODRM_SREAL:	LastPrintBuff("dword ptr ");	break;	// single real=4 bytes=dword
      case ARG_MODRM_BCD:	LastPrintBuff("tbyte ptr ");	break;	// packed bcd=10 bytes=tbyte
      case ARG_MODRM_SINT:	LastPrintBuff("dword ptr ");	break;	// short int=4 bytes
      case ARG_MODRM_WINT:	LastPrintBuff("word ptr ");	break;	// word int =2 bytes
      case ARG_MODRM_LINT:	LastPrintBuff("qword ptr ");	break;	// long int = 8 bytes
      case ARG_MODRMM512:	LastPrintBuff("byte ptr ");	break;	// points to 512 bits=64 bytes of memory......
      case ARG_MODRM_EREAL:	LastPrintBuff("tbyte ptr ");	break;	// extended real=10 bytes
      case ARG_MODRM_DREAL:	LastPrintBuff("qword ptr ");	break;	// double real=8 bytes
      case ARG_MODRM:
       if (inst->flags&FLAGS_8BIT)	LastPrintBuff("byte ptr ");
       else if (inst->mode32)		LastPrintBuff("dword ptr ");
       else				LastPrintBuff("word ptr ");
       break;
     }/*switch(a)*/
    }
   }else if (a1==ARG_REG || a2==ARG_REG) {
    if (rm<3) {
     switch (a) {		    // re movzx, movsx type instructions
      case ARG_MODRM8:		LastPrintBuff("byte ptr ");	break;
      case ARG_MODRM16:		LastPrintBuff("word ptr ");	break;
     }/*switch(a)*/
    }
   }
   switch (rm) {
    case 0:
	  if(inst->flags&FLAGS_SEGPREFIX)
	    outprefix(pbyte);
	  if(options.mode32)
	  { if(modrm==5)
	    { loc.assign(inst->addr.segm,((dword *)(&dta[1]))[0]);
	      PrintMemVar(loc);
	    }
	    else if(modrm==4)	     // case 4=sib
	    { sib=dta[1];
	      if((sib&0x07)==5) // disp32
	      { loc.assign(inst->addr.segm,((dword *)(&dta[2]))[0]);
	        PrintMemVar(loc);
	      }
	      else
	      { LastPrintBuff("[%s]",reg32ascii[sib&0x07]);
	      }
	      if(((sib>>3)&0x07)==4) // no scaled index reg
	      {
	      }
	      else
	      { LastPrintBuff("[%s",reg32ascii[(sib>>3)&0x07]);
		switch(sib>>6)
		{ case 0:
		    LastPrintBuff("]");
		    break;
		  case 1:
		    LastPrintBuff("*2]");
		    break;
		  case 2:
		    LastPrintBuff("*4]");
		    break;
		  case 3:
		    LastPrintBuff("*8]");
		    break;
		}
	      }
	    }
	    else
	      LastPrintBuff("[%s]",reg32ascii[dta[0]&0x07]);
	  }
	  else
	  { if(modrm==6)
	    { loc.assign(inst->addr.segm,((word *)(&dta[1]))[0]);
	      PrintMemVar(loc);
	    }
	    else
	      LastPrintBuff("[%s]",regind16ascii[dta[0]&0x07]);
	  }
	  break;
    case 1:
	  if(inst->flags&FLAGS_SEGPREFIX)
	    outprefix(pbyte);
	  if(options.mode32)
	  { if(modrm==4)	// case 4=sib
	    { sib=dta[1];
	      if(dta[2]&0x80)
	      { LastPrintBuff("[%s-",reg32ascii[dta[1]&0x07]);
		LastPrintBuffHexValue((byte)(-dta[2]));
	      }
	      else
	      { LastPrintBuff("[%s+",reg32ascii[dta[1]&0x07]);
		LastPrintBuffHexValue(dta[2]);
	      }
	      if(((sib>>3)&0x07)==4) // no scaled index reg
		LastPrintBuff("]");
	      else
	      { LastPrintBuff("][%s",reg32ascii[(sib>>3)&0x07]);
		switch(sib>>6)
		{ case 0:
		    LastPrintBuff("]");
		    break;
		  case 1:
		    LastPrintBuff("*2]");
		    break;
		  case 2:
		    LastPrintBuff("*4]");
		    break;
		  case 3:
		    LastPrintBuff("*8]");
		    break;
		}
	      }
	    }
	    else if(dta[1]&0x80)
	    { LastPrintBuff("[%s-",reg32ascii[dta[0]&0x07]);
	      LastPrintBuffHexValue((byte)(-dta[1]));
	      LastPrintBuff("]");
	    }
	    else
	    { LastPrintBuff("[%s+",reg32ascii[dta[0]&0x07]);
	      LastPrintBuffHexValue(dta[1]);
	      LastPrintBuff("]");
	    }
	  }
	  else
	  { if(dta[1]&0x80)
	    { LastPrintBuff("[%s-",regind16ascii[dta[0]&0x07]);
	      LastPrintBuffHexValue((byte)(-dta[1]));
	      LastPrintBuff("]");
	    }
	    else
	    { LastPrintBuff("[%s+",regind16ascii[dta[0]&0x07]);
	      LastPrintBuffHexValue(dta[1]);
	      LastPrintBuff("]");
	    }
	  }
	  break;
    case 2:
     if (inst->flags&FLAGS_SEGPREFIX) outprefix(pbyte);
     if (options.mode32) {
      loc.assign(inst->addr.segm,((dword *)(&dta[1]))[0]);
      if (modrm==4) {	// case 4=sib
       sib=dta[1];
       loc.assign(inst->addr.segm,((dword *)(&dta[2]))[0]);
       LastPrintBuff("[");
       if (name->isname(loc)) {
        LastPrintBuff("%s+",reg32ascii[sib&0x07]);
	name->printname(loc);
       }else if (import->isname(loc)) {
        LastPrintBuff("%s+",reg32ascii[sib&0x07]);
	import->printname(loc);
       }else if(expt->isname(loc)) {
        LastPrintBuff("%s+",reg32ascii[sib&0x07]);
	expt->printname(loc);
       }else if(dta[5]&0x80) {
        LastPrintBuff("%s-",reg32ascii[sib&0x07]);
	LastPrintBuffLongHexValue(0-((dword *)(&dta[2]))[0]);
       }else{
        LastPrintBuff("%s+",reg32ascii[sib&0x07]);
	LastPrintBuffLongHexValue(((dword *)(&dta[2]))[0]);
       }
       if (((sib>>3)&0x07)==4) // no scaled index reg
	 LastPrintBuff("]");
       else{
        LastPrintBuff("][%s",reg32ascii[(sib>>3)&0x07]);
	switch (sib>>6)	{
	 case 0: LastPrintBuff("]");	break;
	 case 1: LastPrintBuff("*2]");	break;
	 case 2: LastPrintBuff("*4]");	break;
	 case 3: LastPrintBuff("*8]");	break;
	}
       }
      }else if (name->isname(loc)) {
       name->printname(loc);
       LastPrintBuff("[%s]",reg32ascii[dta[0]&0x07]);
      }else if (import->isname(loc)) {
       import->printname(loc);
       LastPrintBuff("[%s]",reg32ascii[dta[0]&0x07]);
      }else if (expt->isname(loc)) {
       expt->printname(loc);
       LastPrintBuff("[%s]",reg32ascii[dta[0]&0x07]);
      }else if (dta[4]&0x80) {
       LastPrintBuff("[%s-",reg32ascii[dta[0]&0x07]);
       LastPrintBuffLongHexValue(0-*(dword*)(dta+1));
       LastPrintBuff("]");
      }else{
       LastPrintBuff("[%s+",reg32ascii[dta[0]&0x07]);
       LastPrintBuffLongHexValue(*(dword*)(dta+1));
       LastPrintBuff("]");
      }
     }else{
      loc.assign(inst->addr.segm,((word *)(&dta[1]))[0]);
      if (name->isname(loc)) {
       name->printname(loc);
       LastPrintBuff("[%s]",regind16ascii[*dta&0x07]);
      }else if (import->isname(loc)) {
       import->printname(loc);
       LastPrintBuff("[%s]",regind16ascii[*dta&0x07]);
      }else if (expt->isname(loc)) {
       expt->printname(loc);
       LastPrintBuff("[%s]",regind16ascii[*dta&0x07]);
      }else if (dta[2]&0x80) {
       LastPrintBuff("[%s-",regind16ascii[*dta&0x07]);
       LastPrintBuffLongHexValue(0x10000-((word *)(&dta[1]))[0]);
       LastPrintBuff("]");
      }else{
       LastPrintBuff("[%s+",regind16ascii[dta[0]&0x07]);
       LastPrintBuffLongHexValue(((word *)(&dta[1]))[0]);
       LastPrintBuff("]");
      }
     }
    break;
    case 3:
     if (a==ARG_MMXMODRM) LastPrintBuff(regmascii[dta[0]&0x07]);
     else if(a==ARG_XMMMODRM)
       LastPrintBuff(regxascii[dta[0]&0x07]);
     else if((((asminstdata *)(inst->tptr))->flags&FLAGS_8BIT)||(a==ARG_MODRM8))
       LastPrintBuff(reg8ascii[dta[0]&0x07]);
     else if((inst->mode32)&&(a!=ARG_MODRM16))
       LastPrintBuff(reg32ascii[dta[0]&0x07]);
     else LastPrintBuff(reg16ascii[dta[0]&0x07]);
   }/*switch(rm)*/
  }break;
  case ARG_IMM_1:
      if(inst->override==over_decimal)
	LastPrintBuff("1");
      else
	LastPrintBuff("1h");
      break;
  case ARG_FADDR:
      dta=inst->data+inst->length;
      if(options.mode32)
      { dta-=6;
	loc.assign(((word *)(&dta[4]))[0],((dword *)(&dta[0]))[0]);
        if (!PrintFoundName(loc)) LastPrintBuff("%04x:%08lxh",loc.segm,loc.offs);
      }
      else
      { dta-=4;
	loc.assign(((word *)(&dta[2]))[0],((word *)(&dta[0]))[0]);
        if (!PrintFoundName(loc)) LastPrintBuff("%04x:%04xh",loc.segm,loc.offs);
      }
      break;
  case ARG_BIT:
      dta=inst->data+inst->length-1;
      LastPrintBuff("%x",(dta[0]>>3)&7);
      break;
  case ARG_NONE:
      if(inst->flags&FLAGS_SEGPREFIX)
	outprefix(pbyte);
      break;
  case ARG_NONEBYTE: break;
 }
 if (inst->flags&FLAGS_ADDRPREFIX)
   options.mode32=!options.mode32;
}

/************************************************************************
* outcomment								*
* - prints a disassembly comment to the buffer				*
************************************************************************/
void disio::outcomment(dsmitem *inst) {
 LastPrintBuff(";%s",inst->tptr);
}

/************************************************************************
* dumpblocktofile							*
* - this is the text and asm output routine. It needs a lot more work	*
*   doing to it and is presently a fairly simple dump of a block of	*
*   code.								*
* - this routine was a quick hack and complete rip of the dumptofile	*
*   routine which follows. the two routines need the common workings	*
*   put together and both need rewriting				*
************************************************************************/
void disio::dumpblocktofile(char *fname,bool printaddrs) {
 HANDLE efile;
 dword num;
 dsmitem *tblock,fdsm;
 dsegitem *dblock,*nxtblock;
 lptr outhere,nptr;
 int i;
 char ehdr[300];
 if (!blk.checkblock()) return;
 efile=CreateFile(fname,GENERIC_WRITE,0,NULL,CREATE_NEW,0,NULL);
 if(efile==INVALID_HANDLE_VALUE) {
  MessageBox(MainWnd,"File Creation Failed","Borg Disassembler Alert",MB_OK);
  return;
 }
// scheduler.stopthread();
 WriteFile(efile,"; ",2,&num,NULL);
 WriteFile(efile,winname,lstrlen(winname),&num,NULL);
 WriteFile(efile,"\r\n;\r\n",5,&num,NULL);
 WriteFile(efile,hdr,lstrlen(hdr),&num,NULL);
 WriteFile(efile,hdr2,lstrlen(hdr2),&num,NULL);
 WriteFile(efile,";\r\n",3,&num,NULL);
 wsprintf(ehdr,"; block dump from: %04x:%08lxh to %04x:%08lxh",blk.top.segm,blk.top.offs,blk.bottom.segm,blk.bottom.offs);
 WriteFile(efile,ehdr,lstrlen(ehdr),&num,NULL);
 WriteFile(efile,"\r\n",2,&num,NULL);
 WriteFile(efile,"\r\n",2,&num,NULL);
  // find current position.
 fdsm.addr=blk.top;
 fdsm.type=dsmnull;
 tblock=dsm->find(&fdsm);
 while (tblock) {
  if (tblock->addr<blk.top) tblock=dsm->nextiterator();
  else break;
 }
  // now tblock= first position
 dblock=dta->findseg(blk.top);
 outhere=blk.top;
 while (dblock && (outhere<=blk.bottom)) {
  ClearBuff(); // clear buffer - ready to start
  for (i=0;i<size.y;i++) {
   if (tblock) {
    if(outhere==tblock->addr)	{
     switch(tblock->type) {
      case dsmcode:
      outinst(tblock,printaddrs);
      break;
      case dsmnameloc:
      printlineheader(tblock->addr,printaddrs);
      LastPrintBuff("%s:",tblock->data);
      break;
      case dsmxref:
      // temp measure - print first (build 17)
      printlineheader(tblock->addr,printaddrs);
      LastPrintBuff(";");
      LastPrintBuffEpos(COMMENTPOS);
      LastPrintBuff("XREFS First: ");
      xrefs->printfirst(tblock->addr);
      break;
      default:
      printlineheader(tblock->addr,printaddrs);
      outcomment(tblock);
     }
     outhere+=tblock->length;
     tblock=dsm->nextiterator();
    }else{
     outdb(&outhere,printaddrs);
     outhere++;
    }
   }else{
    outdb(&outhere,printaddrs);
    outhere++;
   }
     // check if gone beyond seg, get next seg.
     /*if(dta->beyondseg(outhere))*/	 // changed build 14
     // rewritten build 17. seeks dseg from start, and finds next now.
   if (outhere>=(dblock->addr+dblock->size)) {
    dta->resetiterator();
    nxtblock=dta->nextiterator();
    while (nxtblock) {
     if (nxtblock->addr==dblock->addr) {
      dblock=dta->nextiterator();
      break;
     }
     nxtblock=dta->nextiterator();
     if (!nxtblock) dblock=NULL;
    }
    if (!dblock) break;
    outhere=dblock->addr;
   }
   if (outhere>blk.bottom) break;
   if (!outhere.segm) break;
  }
  DumpBuff(efile);
 }
 DoneBuff();
 CloseHandle(efile);
// scheduler.continuethread();
 scheduler.addtask(windowupdate,priority_window,nlptr,NULL);
}

/************************************************************************
* dumptofile								*
* - this is the text and asm output routine. It needs a lot more work	*
*   doing to it and is presently a fairly simple dump of the code.	*
************************************************************************/
void disio::dumptofile(char *fname,bool printaddrs)
{ SECURITY_ATTRIBUTES securityatt;
  HANDLE efile;
  dword num;
  dsmitem *tblock;
  dsegitem *dblock,*nxtblock;
  lptr outhere,nptr;
  int i;
  securityatt.nLength=sizeof(SECURITY_ATTRIBUTES);
  securityatt.lpSecurityDescriptor=NULL;
  securityatt.bInheritHandle=false;
  efile=CreateFile(fname,GENERIC_WRITE,0,&securityatt,CREATE_NEW,0,NULL);
  if(efile==INVALID_HANDLE_VALUE)
  { MessageBox(MainWnd,"File Creation Failed","Borg Disassembler Alert",MB_OK);
    return;
  }
//  scheduler.stopthread();
  WriteFile(efile,"; ",2,&num,NULL);
  WriteFile(efile,winname,lstrlen(winname),&num,NULL);
  WriteFile(efile,"\r\n;\r\n",5,&num,NULL);
  WriteFile(efile,hdr,lstrlen(hdr),&num,NULL);
  WriteFile(efile,hdr2,lstrlen(hdr2),&num,NULL);
  WriteFile(efile,"\r\n",2,&num,NULL);
  // find current position.
  dsm->resetiterator();
  tblock=dsm->nextiterator();
  // now tblock= first position
  dta->resetiterator();
  dblock=dta->nextiterator();
  outhere=dblock->addr;
 while (dblock) {
  ClearBuff(); // clear buffer - ready to start
  for (i=0;i<size.y;i++) {
   if (tblock) {
    if (outhere==tblock->addr) {
     switch (tblock->type) {
      case dsmcode:
	      outinst(tblock,printaddrs);
	      break;
      case dsmnameloc:
	      printlineheader(tblock->addr,printaddrs);
	      LastPrintBuff("%s:",tblock->data);
	      break;
      case dsmxref:
	      // temp measure - print first (build 17)
	      printlineheader(tblock->addr,printaddrs);
	      LastPrintBuff(";");
	      LastPrintBuffEpos(COMMENTPOS);
	      LastPrintBuff("XREFS First: ");
	      xrefs->printfirst(tblock->addr);
	      break;
      default:
	      printlineheader(tblock->addr,printaddrs);
	      outcomment(tblock);
     }
     outhere+=tblock->length;
     tblock=dsm->nextiterator();
    }else{
     outdb(&outhere,printaddrs);
     outhere++;
    }
   }else{
    outdb(&outhere,printaddrs);
    outhere++;
   }
      // check if gone beyond seg, get next seg.
      /*if(dta->beyondseg(outhere))*/	 // changed build 14
      // rewritten build 17. seeks dseg from start, and finds next now.
   if (outhere>=(dblock->addr+dblock->size)) {
    dta->resetiterator();
    nxtblock=dta->nextiterator();
    while (nxtblock!=NULL) {
     if (nxtblock->addr==dblock->addr) {
      dblock=dta->nextiterator();
      break;
     }
     nxtblock=dta->nextiterator();
     if (!nxtblock) dblock=NULL;
    }
    if (!dblock) break;
    outhere=dblock->addr;
   }
   if (!outhere.segm) break;
  }
  DumpBuff(efile);
 }
 DoneBuff();
 CloseHandle(efile);
// scheduler.continuethread();
 scheduler.addtask(windowupdate,priority_window,nlptr,NULL);
}

/************************************************************************
*		  mainwind.cpp						*
* This is one of a few files which contain some old code, a lot of	*
* hacks, a lot of hastily stuffed lines and variables, etc, and is in	*
* in need of an overhaul. Its also why I left commenting it until the	*
* last four files (disasm,fileload,dasm and this one!). Whilst making	*
* these comments I have taken a small opportunity to tidy it a little.	*
* This file controls output to the main window. It keeps a small buffer *
* of disassembled lines, and it uses this buffer to repaint the main	*
* window when WM_PAINT requests are received.				*
* Whenever the disassembly is changed or the user scrolls there is a	*
* windowupdate request sent to the scheduler with a high priority.	*
* When the windowupdate is processed it is passed to the windowupdate	*
* or scroller function in disio. disio will regenerate the buffer as	*
* required and then invalidate the main window so that a repaint is	*
* done.									*
* The functions here include basic formatted output to the buffer as	*
* well as the window repaints. Repaints will not be done while the	*
* buffer is being updated, but will wait for the buffer update to	*
* finish and then do the repaint.					*
* The functions also use extensive critical sections which ensure that	*
* we do not start clearing the buffer during a window update, etc	*
************************************************************************/

/************************************************************************
* DoPaint								*
* - This is the main painting routine. If the program is quitting then	*
*   it returns (we dont want thread clashes due to critical sections	*
*   here and theres no point to repainting when we're exitting).	*
* - If the buffer is not ready then we wait, and go to sleep.		*
* - Otherwise the routine paints the screen from the buffer, using the	*
*   selected font and colours						*
************************************************************************/
void disio::DoPaint(void) {
 PAINTSTRUCT ps;    // holds PAINT information
 int i;

// while (bufferbusy) Sleep(0);	// wait if filling buffer
// if (KillThread) return;

// EnterCriticalSection(&cs);
 BeginPaint(wnd,&ps);
 SelectObject(ps.hdc,Font);
 SetTextColor(ps.hdc,options.textcolor);
 for (i=0;i<size.y;i++) {
  RECT R;
  SetBkColor(ps.hdc,
    i==sel ? options.highcolor : options.bgcolor);
  GetItemRect(i,&R);
  ExtTextOut(ps.hdc,-hpos*CharBox.x,R.top,ETO_OPAQUE,&R,
    MainBuff[i],i<lastline?lstrlen(MainBuff[i]):0,NULL);
 }
 EndPaint(wnd,&ps);
// LeaveCriticalSection(&cs);
}

/************************************************************************
* ClearBuff								*
* - This should be called before each reworking of the buffer. It	*
*   clears the buffer and stops any repainting from taking place.	*
* - It also resets the line pointer to the start of the buffer.		*
************************************************************************/
void disio::ClearBuff(void) {
// int i;
// EnterCriticalSection(&cs);
// for (i=0;i<size.y;i++) {
//  MainBuff[i][0]='\0';
// }
 lastline=0;
// bufferbusy=true;
// LeaveCriticalSection(&cs);
}

/************************************************************************
* DoneBuff								*
* - This should be called after a reworking of the buffer. It reenables *
*   window repainting.							*
************************************************************************/
void disio::DoneBuff(void) {
// EnterCriticalSection(&cs);
// bufferbusy=false;
// LeaveCriticalSection(&cs);
}

/************************************************************************
* PrintBuff								*
* - This is the printf of the buffer and is similar to wvsprintf but	*
*   output is to the main buffer. Note that the line pointer is moved	*
*   on after a call, so we move to the next line automatically.		*
************************************************************************/
// adds next line to the buffer.
void disio::PrintBuff(char *szFormat,...) {
// EnterCriticalSection(&cs);
 va_list vaArgs;
 va_start(vaArgs,szFormat);
 if (lastline<size.y) {
  wvsprintf(MainBuff[lastline++],szFormat,vaArgs);
 }
 va_end(vaArgs);
  // just zero end of buffer.....in case.
//  MainBuff[BUFFER_LINES*max_length]=0;
//  LeaveCriticalSection(&cs);
}

/************************************************************************
* LastPrintBuffEpos							*
* - Often we use PrintBuff followed by LastPrintBuff to construct a	*
*   line of output a piece at a time. This function provides basic	*
*   formatting by allowing us to set the cursor position on the last	*
*   line printed, by adding spaces until the position.			*
************************************************************************/
// adds blanks to previous line to set position
void disio::LastPrintBuffEpos(int xpos) {
 int i;
 int spos;
 if (!lastline) return;
// EnterCriticalSection(&cs);
 spos=lastline-1;
 i=lstrlen(MainBuff[spos]);
 while (i<xpos) {
  MainBuff[spos][i]=' ';
  i++;
  MainBuff[spos][i]='\0';
 }
// LeaveCriticalSection(&cs);
}

/************************************************************************
* LastPrintBuffHexValue							*
* - Same as LastPrintBuff, but prints num only, in hex. It prints a	*
*   leading zero where the leading char is alpha.			*
************************************************************************/
void disio::LastPrintBuffHexValue(byte num)
{ char tstr[20];
  wsprintf(tstr,"%02xh",num);
  if((tstr[0]>='a')&&(tstr[0]<='f'))
    LastPrintBuff("0");
  LastPrintBuff("%02xh",num);
}

/************************************************************************
* LastPrintBuffHexValue							*
* - Same as LastPrintBuff, but prints num only, in hex. It prints a	*
*   leading zero where the leading char is alpha.			*
************************************************************************/
void disio::LastPrintBuffLongHexValue(dword num) {
 char tstr[20];
 wsprintf(tstr,"%02lxh",num);
 if (tstr[0]>='a' && tstr[0]<='f') LastPrintBuff("0");
 LastPrintBuff(tstr);	// doesn't contain "%"
}

/************************************************************************
* LastPrintBuff								*
* - This is the same as PrintBuff except that instead of printing a new *
*   line it goes back to the last line and adds more to the end of it	*
* - So a set of calls tends to look like PrintBuff, LastPrintBuffEPos,	*
*   LastPrintBuff, LastPrintBuffEPos, LastPrintBuff, PrintBuff, etc	*
************************************************************************/
void disio::LastPrintBuff(char *szFormat,...) {
 int spos,len;
 char s[MAX_LENGTH];

 if (!lastline) return;
 spos=lastline-1;
// EnterCriticalSection(&cs);
 va_list vaArgs;
 va_start(vaArgs,szFormat);
 wvsprintf(s,szFormat,vaArgs);
 va_end(vaArgs);
 len=lstrlen(MainBuff[spos]);
 lstrcpyn(MainBuff[spos]+len,s,MAX_LENGTH-len);	// append and watch size
// LeaveCriticalSection(&cs);
}

/************************************************************************
* DumpBuff								*
* - Now this is a real hack. Instead of writing proper file IO routines *
*   I simply write a buffer full at a time, and dump each to a file.... *
*   Then when I've written the file out I regenerate the buffer for the *
*   display again....... to be rewritten......				*
************************************************************************/
void disio::DumpBuff(HANDLE efile) {
 DWORD num;
 int i;
 for (i=0;i<lastline;i++) {
  WriteFile(efile,MainBuff[i],lstrlen(MainBuff[i]),&num,NULL);
  WriteFile(efile,"\r\n",2,&num,NULL);
 }
}
Vorgefundene Kodierung: UTF-80