emem8051.c

一個單晶片8051模擬軟體,可以查看模擬的內部外部RAM資料及暫存器資料,並設置斷點 windows 平台下執行

//********************************************//
//            memory system emulation         //
//********************************************//
//
#define STRICT
#define WIN32_LEAN_AND_MEAN
#ifndef WIN32
#define WIN32        // ??? //
#endif
#pragma warning( disable : 4201 4214 4514 4115 4018)
#include <windows.h>
#include "resourc2.h"
//
#include <stdlib.h>
#include <stdio.h>
//#include <string.h>
//
#include "dllintf.h"
//
//*****************************//
//
typedef struct tagBANK{
   int size;
   char*data;
   }BANK;
//
typedef struct tagMECH{
   int baseBank;
   int magicLocation;
   int mask;
   int shift;
   }MECH,(*MECHARRAY)[];
//
typedef struct tagMEM_STR{
   int model;
   int numBanks;
   int bankSize;
   int magicBank;
   int addMask;
   int addShift;
   int numDataMechs;
   int numCodeMechs;
   MECHARRAY dataMechs;
   MECHARRAY codeMechs;
   BANK(*banks)[];
   }MEM_STR;
//
//********************************************//
//
#define NEW(TYPE,ptr)   TYPE*ptr=(TYPE*)calloc(1,sizeof(TYPE))
//
#define UNDEFINED_MODEL 0 
#define TINY_MODEL      1   // 65k of memory is all you get
#define SMALL_MODEL     2   // 65k of code / 65k of data
#define LARGE_MODEL     3   // something else
//
#define BANK_TINY_CODE_DATA   0     // bank 0 is data/code in tiny model
#define BANK_SMALL_DATA       0     // bank 0 is data in small model
#define BANK_SMALL_CODE       1     // bank 1 is code in small model
//
//********************************************//
//
static BOOL CALLBACK CfgMemProc(HWND hwndDlg,UINT uMsg,WPARAM wParam,LPARAM lParam);   
static int  GetMechs(char*cp,MECHARRAY*mp,void ErrorMessage(char*,int));
static void FreeMechs(MEM_STR*memStr);
static void FreeBanks(MEM_STR*memStr);
static void FreeMemStruct(MEM_STR*memStr);
static void BuildMechsString(MECHARRAY mechArray,int numMechs,char buff[]);
static BOOL SameMemStructs(MEM_STR*newMemStr,MEM_STR*memStr);
//
//********************************************//
// get source/dest memory bank# & offset-within-bank //
static void GetPhysicalAddress(MEM_STR*memStr,int isCode,int address,int*bankNumPtr,int*offsetPtr){
   int bankNum;
   //
   if(memStr->model == TINY_MODEL ){
      bankNum = BANK_TINY_CODE_DATA;}
   else if(memStr->model == SMALL_MODEL){
      bankNum = isCode ? BANK_SMALL_CODE : BANK_SMALL_DATA;}
   else {
      int mechIndex = (unsigned short)address >> memStr->addShift;
      MECH*mech = &(isCode ? (*memStr->codeMechs) : (*memStr->dataMechs))[mechIndex];
      int rawMagicValue = (*memStr->banks)[memStr->magicBank].data[mech->magicLocation];
      bankNum = ((rawMagicValue >> mech->shift) & mech->mask) + mech->baseBank;
      if(bankNum >= memStr->numBanks)bankNum %= memStr->numBanks;}
   *bankNumPtr = bankNum;
   *offsetPtr = address & memStr->addMask;}
//
// get code memory at given index //
char GetCode(MEM_STR*memStr,int index){
   int bankNum,offset;
   GetPhysicalAddress(memStr,1,index,&bankNum,&offset);
   return (*memStr->banks)[bankNum].data[offset];}
//
// get memory for "MOVX" //
char GetXdata(MEM_STR*memStr,int index){
   int bankNum,offset;
   GetPhysicalAddress(memStr,0,index,&bankNum,&offset);
   return (*memStr->banks)[bankNum].data[offset];}
//
// put memory for "MOVX" //
void PutXdata(MEM_STR*memStr,int index,char val){
   int bankNum,offset;
   GetPhysicalAddress(memStr,0,index,&bankNum,&offset);
   (*memStr->banks)[bankNum].data[offset] = val;}
//
// for data-display/edit windows
char GetDataFromBankAndOffset(MEM_STR*memStr,int bankNum,int offset){
   // protection against explosion //
   if(bankNum >= memStr->numBanks)bankNum = 0;
   if(offset  >= (*memStr->banks)[bankNum].size)offset = 0;
   //
   return (*memStr->banks)[bankNum].data[offset];}
//
void PutDataFromBankAndOffset(MEM_STR*memStr,int bankNum,int offset,char val){
   // protection against explosion //
   if(bankNum >= memStr->numBanks)bankNum = 0;
   if(offset  >= (*memStr->banks)[bankNum].size)offset = 0;
   //
   (*memStr->banks)[bankNum].data[offset] = val;}
//
int BankSize(MEM_STR*memStr,int bankNum){
   // protection against explosion //
   if(bankNum >= memStr->numBanks)bankNum = 0;
   //
   return (*memStr->banks)[bankNum].size;}
//
int NumBanks(struct tagMEM_STR*memStr){
   return memStr->numBanks;}
//
// for data-display/edit windows (for underlining)
int GetTargetBank(MEM_STR*memStr,int isCode,int address){
   int bankNum,offset;
   GetPhysicalAddress(memStr,isCode,address,&bankNum,&offset);
   return bankNum;}
//
int GetTargetIndex(MEM_STR*memStr,int isCode,int address){
   int bankNum,offset;
   GetPhysicalAddress(memStr,isCode,address,&bankNum,&offset);
   return offset;}
//
// for loading hex files: store values in bank (bank found from isCode / fileBank / recordType / addHi)
void StoreFileValues(MEM_STR*memStr,int isCode,int fileBank,int recordType,int addHi,int numents,int address,char values[256]){
   int bankNum=0;
   //
   // what bank?
   if(memStr->model == TINY_MODEL){
      bankNum = BANK_TINY_CODE_DATA;}
   else if(memStr->model == SMALL_MODEL){
      bankNum = isCode ? BANK_SMALL_CODE : BANK_SMALL_DATA;}
   else {
      if(recordType < 2){
         bankNum = fileBank;}
      else {
         bankNum = addHi + fileBank;}}
   //
   if(bankNum >= memStr->numBanks)bankNum %= memStr->numBanks;
   //
   // store values
   {  int n;
      for(n=0;n<numents;n++,address++){
         if(address >= memStr->bankSize){
            bankNum = (bankNum + (address / memStr->bankSize)) % memStr->numBanks;
            address = address % memStr->bankSize;}
         (*memStr->banks)[bankNum].data[address] = values[n];}}}
//
// ******************************** //
// initialization
// ******************************** //
MEM_STR*CreateMem(void ReadMemoryProfileString(char*oname,char*value,int len)){
   char buff[256];
   //
   NEW(MEM_STR,memStr);
   //
   // default value //
   memStr->model    = UNDEFINED_MODEL;
   memStr->bankSize = 0x10000;
   memStr->addMask  = 0xffff;
   //
   buff[0]=0;ReadMemoryProfileString("MODE",buff,sizeof buff);
   if(buff[0]!=0){
      memStr->model = strtol(buff,0,0);
      if(memStr->model == TINY_MODEL){
         memStr->numBanks = 1;}
      else if(memStr->model == SMALL_MODEL){
         memStr->numBanks = 2;}
      else {
         buff[0]=0;ReadMemoryProfileString("NUMBANKS",buff,sizeof buff);
         memStr->numBanks = strtol(buff,0,0);
         if(memStr->numBanks == 0)memStr->numBanks = 1;     // safe anyway //
         //
         buff[0]=0;ReadMemoryProfileString("BANKSIZE",buff,sizeof buff);
         memStr->bankSize = strtol(buff,0,0);
         if(memStr->bankSize == 0)memStr->bankSize = 65536;     // safe anyway //
         //
         buff[0]=0;ReadMemoryProfileString("MAGICBANK",buff,sizeof buff);
         memStr->magicBank = strtol(buff,0,0);
         //
         buff[0]=0;ReadMemoryProfileString("CODEMECHS",buff,sizeof buff);
         memStr->numCodeMechs = GetMechs(buff,&memStr->codeMechs,0);
         //
         buff[0]=0;ReadMemoryProfileString("DATAMECHS",buff,sizeof buff);
         memStr->numDataMechs = GetMechs(buff,&memStr->dataMechs,0);
         //
         if(  memStr->model        != LARGE_MODEL
           || memStr->codeMechs    == 0
           || memStr->dataMechs    == 0
           || memStr->numCodeMechs == 0 
           || memStr->numCodeMechs != memStr->numDataMechs){
            // something's rotten .... //
            // go to small model - it's at least safe //
            FreeMechs(memStr);
            memStr->model    = SMALL_MODEL;
            memStr->bankSize = 0x10000;
            memStr->addMask  = 0xffff;}}}
   //
   return memStr;}
//
int InitMem(MEM_STR*memStr,void ErrorMessage(char*,int),MEM_STR*oldMemStr){
   int n;
   if(memStr->model == UNDEFINED_MODEL){
      //
      // default tiny model?
      //memStr->model = TINY_MODEL;
      //memStr->numBanks = 1;
      //
      // default small model
      memStr->model = SMALL_MODEL;
      memStr->numBanks = 2;
      //
      memStr->bankSize = 0x10000;
      memStr->addMask  = 0xffff;}
   //
   if(memStr->model == LARGE_MODEL){
      if(memStr->codeMechs == 0 || memStr->dataMechs == 0){
         if(ErrorMessage!=0)ErrorMessage("Both '-mCODE' and '-mDATA' must be specified for large model\n",1);
         return 0;}
      if(memStr->numCodeMechs != memStr->numDataMechs){
         if(ErrorMessage!=0)ErrorMessage("Number of code-mapping-mechanisms must be same as number of data-mapping-mechanisms\n",1);
         return 0;}
      //
      {  int numMechs = memStr->numCodeMechs;
         int log=numMechs-1;
         //
         if(numMechs == 1 /* log=0 */ || numMechs == 2 /* log=1 */ || numMechs == 4 && (log=2,1) || numMechs == 8 && (log=3,1)){
            memStr->addShift = 16-log;
            memStr->addMask  = 0xffff >> log;}
         else {
            if(ErrorMessage!=0)ErrorMessage("Number of mapping-mechanisms must be 1,2,4 or 8\n",1);
            return 0;}}}
   //
   memStr->banks = calloc(memStr->numBanks,sizeof(BANK));
   for(n=0;n<memStr->numBanks;n++){
      (*memStr->banks)[n].size = memStr->bankSize;
      (*memStr->banks)[n].data = calloc((*memStr->banks)[n].size,1);
      // copy data from old memory system? //
      if(oldMemStr != 0 && oldMemStr->numBanks > n && (*oldMemStr->banks)[n].data != 0){
         int size = min(memStr->bankSize,oldMemStr->bankSize);
         memcpy((*memStr->banks)[n].data,(*oldMemStr->banks)[n].data,size);}}
   return 1;}
//
void ZeroMem(MEM_STR*memStr){
   int n;
   for(n=0;n<memStr->numBanks;n++){
      memset((*memStr->banks)[n].data,0,(*memStr->banks)[n].size);}}
//
MEM_STR*SetupMemorySystem(HWND hwnd,MEM_STR*memStr,void WriteMemoryProfileString(char*oname,char*value)){
   char buff[256];
   //
   HINSTANCE hInst   = LoadLibrary("Emem8051.dll");
   MEM_STR*newMemStr = (MEM_STR*)DialogBoxParam(hInst,"MEMORY_CFG",hwnd,CfgMemProc,(LONG)memStr);
   //
   if(newMemStr != 0){
      if(SameMemStructs(newMemStr,memStr)){
         FreeMemStruct(newMemStr);}       // don't destroy old data unless necessary
      else {
         InitMem(newMemStr,0,memStr);     // initialize memory blocks, using old blocks
         FreeMemStruct(memStr);           // remove old mem struct
         memStr = newMemStr;              // promote the new one
         //
         // write memory config to INI file //
         //
         sprintf(buff,"%d",memStr->model);
         WriteMemoryProfileString("MODE",buff);
         //
         sprintf(buff,"%d",memStr->numBanks);
         WriteMemoryProfileString("NUMBANKS",buff);
         //
         sprintf(buff,"%d",memStr->bankSize);
         WriteMemoryProfileString("BANKSIZE",buff);
         //
         sprintf(buff,"%d",memStr->magicBank);
         WriteMemoryProfileString("MAGICBANK",buff);
         //
         BuildMechsString(memStr->codeMechs,memStr->numCodeMechs,buff);
         WriteMemoryProfileString("CODEMECHS",buff);
         //
         BuildMechsString(memStr->dataMechs,memStr->numDataMechs,buff);
         WriteMemoryProfileString("DATAMECHS",buff);
         //
         }}
   return memStr;}
//
// ******************************** //
// argument processing
// ******************************** //
int ProcessUserArg(MEM_STR*memStr,char*cp,void ErrorMessage(char*,int)){
   //
   if(*cp=='-' || *cp=='/'){    
      char cmd = *++cp;
      if(cmd >= 'A' && cmd <= 'Z')cmd |= 0x20;
      cp++;
      switch(cmd){
         case 'm':{
            if(memicmp(cp,"TINY",4)==0){
               //if(memStr->model != UNDEFINED_MODEL){ ErrorMessage("Multiple model definition\n",0); return 0;}
               memStr->model = TINY_MODEL;
               FreeMechs(memStr);         // get rid of any mechs generated by CreateMem
               memStr->numBanks = 1;
               memStr->bankSize = 0x10000;
               memStr->addMask  = 0xffff;}