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

/************************************************************************
*	       gname.cpp						*
* generic name class							*
* the basic gname class consists of a name and a location, and these	*
* are the basic management functions for the class. The class is	*
* inherited by names, exports and imports which are all treated very	*
* slightly differently. These are essentially the common routines	*
* The gname class itself inherits the list class for management of the	*
* array of named locations.						*
************************************************************************/

#include <windows.h>

#include "gname.h"
#include "disasm.h"
#include "data.h"
#include "debug.h"

#ifdef NEW_GNAME
gnameitem::gnameitem() { name=NULL;}
gnameitem::~gnameitem() {
 if (name)
   delete name;
}
#endif
/************************************************************************
* gname constructor function						*
************************************************************************/
gname::gname() { }

/************************************************************************
* gname destructor function						*
* - empty. the deletion of the list is carried out by the list class	*
*   and by the deletion function					*
************************************************************************/
gname::~gname() { }

/************************************************************************
* gname compare function						*
* - the compare function for ordering the list of names			*
* - the names are kept in location order				*
************************************************************************/
int gname::compare(gnameitem *i,gnameitem *j) {
 if (i->addr==j->addr) return 0;
 if (i->addr>j->addr)  return 1;
 return -1;
}

/************************************************************************
* gname delete function							*
* - overrides the stnadard gnamefunc delete function			*
************************************************************************/
#ifndef NEW_GNAME
void gname::delfunc(gnameitem *i) { // delete name.
 delete i->name;
  // delete gnameitem.
 delete i;
}
#endif
/************************************************************************
* addname								*
* - this is to add a name to the list of names.				*
* - if the address is not covered in our list of segments then we	*
*   ignore the request							*
* - we check that it is ok to name the location before naming it. This	*
*   basically ensures that names cannot be added in the middle of a	*
*   disassembled instruction, etc. It should not affect imports/exports *
*   since these will be named prior to disassembly			*
* - the name is copied and a new string created for it, so the calling	*
*   function must delete any memory created to hold the name		*
* - if the same location is named twice then the first name is deleted	*
* - the name is added to the disassembly so that it appears in the	*
*   listing.								*
* - naming a location with "" results in any name being deleted		*
************************************************************************/
BOOL gname::addname(lptr loc,char *nm) {
 gnameitem *newname,*checkdup;
 dsegitem *l_ds;
  // check for non-existant address added v2.20
 l_ds=dta->findseg(loc);
 if (!l_ds) return FALSE;
 if (!dsm->oktoname(loc)) return FALSE; // check not in the middle of an instruction.
 if (findname(nm)) return FALSE;
 newname=new gnameitem;
 newname->name=new char[lstrlen(nm)+1];
 lstrcpy(newname->name,nm);
 demangle(&newname->name);
 newname->addr=loc;
 checkdup=find(newname);
  // just add it once.
 if (checkdup) {
  if (NamesBox) PostMessage(NamesBox,WM_DELETENAME,0,(LPARAM)checkdup);
  if (checkdup->addr==loc) {
   delete checkdup->name;
   checkdup->name=newname->name;
   delete newname;
   dsm->delcomment(loc,dsmnameloc);
   if (lstrlen(checkdup->name)) {
    dsm->discomment(loc,dsmnameloc,(byte *)checkdup->name);
   }else{
    delfrom(checkdup);
   }
   return TRUE;
  }
 }
 if (!lstrlen(newname->name)) { // bugfix by Mark Ogden
  delete newname->name;
  delete newname;
  return TRUE;
 }
 checkdup=addto(newname);
 if (NamesBox) PostMessage(NamesBox,WM_ADDNAME,0,(LPARAM)checkdup);
 dsm->discomment(loc,dsmnameloc,(byte *)newname->name);
  // NB - no need for this anymore. Need to ensure that
  // printing of names is done as :
  // if names.isname() ...
  // else if imports.isname()...
  // else if export.isexport()...
  // so names aren't printed twice, and import names,etc are retained always
  //if(dta.findseg(loc)!=NULL)name.addname(loc,nm);
 return TRUE;
}

BOOL gname::findname(LPCTSTR nm) {
// Search for string in the list
 gnameitem *i;
 resetiterator();
 while (i=nextiterator()) {
  if (!lstrcmpi(i->name,nm)) return TRUE;
 }
 return FALSE;
}

/************************************************************************
* isname								*
* - returns true if loc has a name					*
************************************************************************/
bool gname::isname(lptr loc)
{ gnameitem checkit,*findit;
  checkit.addr=loc;
  findit=find(&checkit);
  if(findit!=NULL)
    if(findit->addr==loc)
      return true;
  return false;
}

/************************************************************************
* isname								*
* - prints name to last buffer location in mainwindow buffering array	*
* - use with isname, for example:					*
*   if(name.isname(loc))name.printname(loc); etc			*
************************************************************************/
void gname::printname(lptr loc)
{ gnameitem checkit,*findit;
  checkit.addr=loc;
  findit=find(&checkit);
  if(findit!=NULL)
    cvd->LastPrintBuff("%s",findit->name);
}

/************************************************************************
* delname								*
* - used as a simple name deleter for a given location			*
* - also deletes the name from the disassembly listing			*
************************************************************************/
void gname::delname(lptr loc)
{ gnameitem dname,*checkdup;
  dname.addr=loc;
  checkdup=find(&dname);
  if(checkdup!=NULL)
    if(checkdup->addr==loc)
      delfrom(checkdup);
  dsm->delcomment(loc,dsmnameloc);
}

/************************************************************************
* getoffsfromname							*
* - this checks to see if a name is in the list, and if it is then it	*
*   returns the offset of its loc otherwise it returns 0. This function *
*   is used in generating the segment for imports in an NE file.	*
************************************************************************/
dword gname::getoffsfromname(char *nm)
{ gnameitem *t;
  resetiterator();
  t=nextiterator();
  while(t!=NULL)
  { if(!lstrcmp(t->name,nm))
      return t->addr.offs;
    t=nextiterator();
  }
  return 0;
}