avr_simulator.c

linux上实现的多种型号的AVR模拟器

    }
  io_pointer=&gpr_pointer[controllers[type_micro].size_gpr];
  
  /* check absent of sram */
  if(controllers[type_micro].size_sram==0)
    { 
      XtVaSetValues(menu[MEMORY_MENU].sub_menu[SRAM_BUTTON].button,XmNset,
		    XmUNSET,NULL);
      XtSetSensitive(menu[MEMORY_MENU].sub_menu[SRAM_BUTTON].button,False);
      sram_pointer=NULL;
    }
  else
    {
      sram_pointer=&io_pointer[controllers[type_micro].size_io_reg];
      XtSetSensitive(menu[MEMORY_MENU].sub_menu[SRAM_BUTTON].button,True);
    }
  
  /* allocate EEPROM memory*/
  if((eeprom_pointer=malloc(controllers[type_micro].size_eeprom))==NULL)
    {
      puts("init(): can't allocate memory for 'eeprom_pointer'");
      exit(1);
    }
  clean_memory();
  
  /* for more fast searching of data */
  for(n=0;n<MAX_CODE_PORTS;n++) index_ports[n]=-1;
  for(n=0;n<MAX_CODE_PINS;n++) index_pins[n]=-1;
  for(n=0;n<MAX_CODE_FLAGS;n++) index_flags[n]=-1;

  for(n=0;controllers[type_micro].io_registers[n].code!=-1;n++)
    index_ports[controllers[type_micro].io_registers[n].code]=n;
  for(n=0;controllers[type_micro].pins[n].code!=-1;n++)
    index_pins[controllers[type_micro].pins[n].code]=n;
  for(n=0;controllers[type_micro].flags[n].flag_code!=-1;n++)
    index_flags[controllers[type_micro].flags[n].flag_code]=n;
  
  hardware_init();

  init_windows_memory();

  update_gpr_window();
  full_update_io_window();
  full_update_sram_window();
  full_update_eeprom_window();

  window=XtWindow(drawarea.draw);
  drawarea.foreground=BlackPixel(display,scr_num);
  drawarea.background=WhitePixel(display,scr_num);
  values.foreground=drawarea.foreground;
  values.background=drawarea.background;
  drawarea.gc=XCreateGC(display,window,GCForeground|GCBackground,&values);
  if((font_struct=XQueryFont(display,XGContextFromGC(drawarea.gc)))==NULL)
    puts("font error.");
  drawarea.font_width=font_struct->max_bounds.width;
  drawarea.font_height=font_struct->ascent+font_struct->descent;

  XFreeFontInfo(NULL,font_struct,0);
  drawarea.width=29*drawarea.font_width;
  XtVaSetValues(drawarea.draw,XmNwidth,drawarea.width,
		XmNheight,drawarea.font_height*20,NULL);
  XtVaGetValues(drawarea.draw,XmNheight,&drawarea.height,NULL);
  
  /* configure toplevel */
  XtVaGetValues(toplevel,XmNheight,&toplevel_height,XmNwidth,&toplevel_width,
		NULL);
  toplevel_height=toplevel_height-16*drawarea.font_width;
  XtVaSetValues(toplevel,XmNheightInc,drawarea.font_height,
		XmNminHeight,toplevel_height,XmNminWidth,toplevel_width,
		XmNallowShellResize,False,NULL);
  
  pixmap=CreatePixmap(window,drawarea.width,drawarea.height,
		      WhitePixel(display,scr_num));
  XtAddCallback(drawarea.draw,XmNexposeCallback,(XtCallbackProc)refresh,
		NULL);
  XtAddCallback(drawarea.draw,XmNresizeCallback,(XtCallbackProc)resize,
		NULL);

  /*pixmaps */  
/*    if((errno=XpmCreatePixmapFromData(display,window,breakpoint_xpm, */
/*  				    &temp_p,NULL,NULL))) */
/*      fprintf(stderr,"%s\n",XpmGetErrorString(errno)); */

/*    XCopyArea(display,temp_p,stop_pixmap,temp_gc,0,0,1,1,0,0); */
/*    if((errno=XpmCreatePixmapFromData(display,window,current_xpm, */
/*  				    &current_pixmap,NULL,NULL))) */
/*      fprintf(stderr,"%s\n",XpmGetErrorString(errno)); */

  if((stop_pixmap=XmGetPixmap(XtScreen(toplevel),"xpm/breakpoint.xpm",
			      drawarea.foreground,drawarea.background
			      ))==XmUNSPECIFIED_PIXMAP) 
    fprintf(stderr," Pixmap problem with file breakpoint.xpm\n");
  if((current_pixmap=XmGetPixmap(XtScreen(toplevel),"xpm/current.xpm",
				 drawarea.foreground,drawarea.background
				 ))==XmUNSPECIFIED_PIXMAP) 
    fprintf(stderr," Pixmap problem with file current.xpm\n");
  
  if(pthread_attr_init(&attr_thread))
    {perror("pthread_attr_init:");exit(1);}
  if(pthread_attr_setdetachstate(&attr_thread,PTHREAD_CREATE_DETACHED))
    {perror("pthread_attr_setdetachstate:");exit(1);}
  
  XtSetSensitive(buttons[RELOAD].widget,False);
  XtSetSensitive(buttons[TRACE_INTO].widget,False);
  XtSetSensitive(buttons[STEP_OVER].widget,False);
  XtSetSensitive(buttons[STEP_OUT].widget,False);
  XtSetSensitive(buttons[MULTI_STEP].widget,False);
  XtSetSensitive(buttons[AUTO_STEP].widget,False);
  XtSetSensitive(buttons[RUN].widget,False);
  XtSetSensitive(buttons[STOP].widget,False);
  XtSetSensitive(buttons[RESET_].widget,False);
  XtSetSensitive(menu[DEBUG_MENU].button,False);

}

/* -1 command not found */
int create_listing(FILE *file)
{
  int com,address,found,n,num_line,result;

  drawarea.num_commands=num_line=0;
  for(address=0;address<controllers[type_micro].size_flash;address++)
    {
      list_commands[address].function_command=nop_command;
      list_commands[address].number_line=-1;
    }
  while((result=read_word(&com,&address,file))==2)
    {
      if(address>=controllers[type_micro].size_flash)
	{
	  sprintf(error_message,
		  _("Size of progarm is bigger then size of flash"));
	  return 1;
	}
      n=-1;found=FALSE;
      drawarea.num_commands++;
      drawarea.display_lines[num_line]=address;
      list_commands[address].number_line=num_line++;
      list_commands[address].code=com;
      list_commands[address].flags=0;
      while(commands[++n].mnemocode[0]!=0)
	{
	  if((com&commands[n].mask)==commands[n].code)
	    {
	      strcpy(list_commands[address].mnemocode,
		     commands[n].mnemocode);
	      list_commands[address].function_command=commands[n].command;
	      list_commands[address].num_words=commands[n].num_words;
	      if(commands[n].num_words==2)
		{
		  read_word(&com,&address,file);
		  list_commands[address].code=com;
		  list_commands[address-1].arg1=
		    commands[n].arg1(list_commands[address-1].mnemocode,
				     list_commands[address-1].code,address-1);
		  strcat(list_commands[address-1].mnemocode,",");
		  list_commands[address-1].arg2=
		    commands[n].arg2(list_commands[address-1].mnemocode,
				     list_commands[address-1].code,address-1);
		}
	      else
		{
		  list_commands[address].arg1=
		    commands[n].arg1(list_commands[address].mnemocode,
				     com,address);
		  strcat(list_commands[address].mnemocode,",");
		  list_commands[address].arg2=
		    commands[n].arg2(list_commands[address].mnemocode,
				     com,address);
		}
	      found=TRUE;
	      break;
	    }
	}
      
      if(found==FALSE) 
	{
	  sprintf(error_message,"command not found: %X (address: %X)",com,
		  address);
	  return 1;
	} 
    }
  if(drawarea.num_commands==0||result==1)
    {
      sprintf(error_message,"Bad format of the file");
      return 1;
    }
  return 0;
}

/* returned value 2 is 'OK', 1 is 'ERROR' */
int read_word_gen(int *command,int *address,FILE *file)
{
  return fscanf(file,"%x:%x",address,command);
}

int read_word_intel(int *command,int *address,FILE *file)
{
  char buf[256];
  int size_buf,n;
  static char word[7]="0x0000";
  static int addr=0,position=0,size_buf2=0,buf2[128];
  
  if(position<size_buf2)
    {
      *command=buf2[position++];
      *address=addr++;
      return 2;
    }
  else
    {
      if(fgets(buf,256,file)==NULL)
	return EOF;
      size_buf=strlen(buf);
      if(buf[size_buf-1]=='\n')
	buf[--size_buf]=0;
      if(buf[size_buf-1]=='\r')
	buf[--size_buf]=0;
      if(buf[0]==':'&&size_buf>=11)
	{
	  word[2]=buf[1];word[3]=buf[2];word[4]=0;
	  size_buf2=strtoul(word,NULL,16)/2;
	  if(size_buf2*4!=strlen(buf)-11)
	    return 1;
	  strncpy(&word[2],&buf[3],4);
	  addr=strtoul(word,NULL,16)/2;
	  position=0;
	  if(buf[8]=='0')
	    {
	      for(n=0;n<size_buf2;n++)
		{
		  strncpy(&word[4],&buf[n*4+9],2);
		  strncpy(&word[2],&buf[n*4+11],2);
		  buf2[n]=strtoul(word,NULL,16);
		}
	      return read_word_intel(command,address,file);
	    }
	  else
	    {
	      size_buf2=position=0;
	      return read_word_intel(command,address,file);
	    }
	}
      return 1;
    }
}

int read_word_motorola(int *command,int *address,FILE *file)
{
  char buf[256];
  int size_buf,n;
  static char word[7]="0x0000";
  static int addr=0,position=0,size_buf2=0,buf2[128];
  
  if(position<size_buf2)
    {
      *command=buf2[position++];
      *address=addr++;
      return 2;
    }
  else
    {
      if(fgets(buf,256,file)==NULL)
	return EOF;
      size_buf=strlen(buf);
      if(buf[size_buf-1]=='\n')
	buf[--size_buf]=0;
      if(buf[size_buf-1]=='\r')
	buf[--size_buf]=0;
      if((!strncmp(buf,"S1",2))&&size_buf>10)
	{
	  word[2]=buf[2];word[3]=buf[3];word[4]=0;
	  size_buf2=strtoul(word,NULL,16);
	  if(size_buf2*2!=strlen(buf)-4)
	    return 1;
	  strncpy(&word[2],&buf[4],4);
	  addr=strtoul(word,NULL,16)/2;
	  position=0;size_buf2=(size_buf2-3)/2;
	  for(n=0;n<size_buf2;n++)
	    {
	      strncpy(&word[4],&buf[n*4+8],2);
	      strncpy(&word[2],&buf[n*4+10],2);
	      buf2[n]=strtoul(word,NULL,16);
	    }
	  return read_word_motorola(command,address,file);
	}
      else
	return read_word_motorola(command,address,file);
    }
}


void fill_zero(char *string,int number_sym)
{
  char buf[10];
  int n;
  
  if(number_sym<strlen(string)) return;
  strcpy(buf,string);
  for(n=0;n<number_sym-strlen(buf);n++) string[n]='0';
  strcpy(&string[n],buf);
  return;
}

void manage(Widget w,XtPointer client_data,XtPointer call_data)
{
  XtManageChild(*((Widget *)client_data));
}

void unmanage(Widget w,XtPointer client_data, XtPointer call_data)
{
  XtUnmanageChild(*((Widget *)client_data));
}

void quit_callback(Widget w,XtPointer client_data, XtPointer call_data)
{
  XFreeGC(display,drawarea.gc);
  XFreePixmap(display,pixmap);
  XtFree(filename);
  /*  free(label); */
/*    free(field_sram); */
/*    free(label_io); */
  exit(0);
};

void file_selection_ok(Widget w,XtPointer client_data, XtPointer call_data)
{
  char *filename;
  
  XtUnmanageChild(*((Widget *)client_data));
  filename=XmCvtXmStringToCT(((XmFileSelectionBoxCallbackStruct *)
			      call_data)->value);
  switch(load_memory){
  case FLASH:  
    if(load_flash(filename)) show_error();
    break;
  case EEPROM: 
    if(load_eeprom(filename)) show_error();
  }
  XtFree(filename);
}

void resize(Widget w,XtPointer client_data, XtPointer call_data)
{
  if(drawarea.num_commands)
    {
      XtVaGetValues(drawarea.draw,XmNheight,&drawarea.height,NULL);
      draw();
      XtVaSetValues(drawarea.v_scrb,XmNsliderSize,
		    drawarea.height/drawarea.font_height,
		    XmNmaximum,drawarea.num_commands,NULL);
    }
  else
    XtVaSetValues(drawarea.v_scrb,XmNminimum,0,XmNvalue,0,XmNsliderSize,1,
		  XmNmaximum,1,NULL);
}

void refresh(Widget w,XtPointer client_data, XtPointer call_data)
{
  XEvent *event;
  
  event=((XmDrawingAreaCallbackStruct *)call_data)->event;
  if(event->type==Expose)  
      {    
        if(event->xexpose.window==window) 
          XCopyArea(display,pixmap,window,drawarea.gc,event->xexpose.x,
                    event->xexpose.y,event->xexpose.width,
                    event->xexpose.height,event->xexpose.x,event->xexpose.y); 
      }     
  
}

int load_flash(char *name)
{
  static char *filename;
  static FILE *file;
  
  if(name!=NULL)
    { /* new file */
      if((filename=malloc(strlen(name)+1))==NULL)
	{
	  puts("load_flash(): can't allocate memory for 'name'");
	  exit(1);
	}
      strcpy(filename,name);
    }
  if(filename==NULL) return 0;
  if(file!=NULL) fclose(file);