menu_memory.c

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

/*
 File        : menu_memory.c

 Author      : Sergiy Uvarov - Copyright (C) 2001

 Description : This is the file to create windows of memory.

 Copyright notice:

 avr_simulator - A GNU/Linux simulator for the Atmel AVR series
 of microcontrollers. Copyright (C) 2001 Sergiy Uvarov

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 Sergiy Uvarov

 E-mail : [e-mail]
*/

#include <stdio.h>
#include <inttypes.h>
#include <stdlib.h>
#include <libintl.h>
#include <X11/StringDefs.h>
#include <X11/Intrinsic.h>
#include <X11/Shell.h>
#include <Xm/XmAll.h>
#include "types.h"
#include "global.h"
#include "menu_memory.h"

#define _(x) gettext(x)
#define N_(x) (x)
#define MAX_SRAM_LINES    20
#define MAX_EEPROM_LINES  20
#define MAX_IO_PORT_LINES 30

int type_gpr_window=HEX,type_sram_window=HEX,
  type_eeprom_window=HEX,
  address_sram=0,          /* address of start point of sram_window      */
  nlines_sram=8,           /* number of lines in sram_window             */
  nlines_sram_old=8,       /* need only for tip window in sram_window    */
  nlines_io=10,            /* number of lines in io_window               */
  nlines_eeprom=4,         /* number of lines in eeprom_window           */
  nlines_eeprom_old=4,     /* need only for tip window in eeprom_window  */
  address_eeprom=0,        /* address in eeprom_window                   */
  address_io=0,            /* address of start point of io_window        */
  address_io_old=0,         /* need only for tip window in io_window      */
  type_micro_old,          /* need only for tip windows                  */    
  height_min_io_window,    /* height of io_window without port lines     */
  height_min_sram_window,  /* height of sram_window without data lines   */
  height_min_eeprom_window,/* height of eeprom_window without data lines */
  eeprom_window_step,      /* number of incr. pixels of eeprom_window    */
  sram_window_step,        /* number of incr. pixels of sram_window      */
  io_window_step;          /* number of incr. pixels of io_window        */
  
Widget *field=NULL,        /* edit field in gpr_window                */
  *field_sram=NULL,        /* edit field in sram_window               */
  vscr_sram_bar,           /* scrollbar in sram_window                */
  *label_sram=NULL,        /* array of labels(address) in sram_window */
  vscr_io_bar,             /* scrollbar in io_window                  */
  *label_io=NULL,          /* array of labels in io_window            */
  **bit_button=NULL,       /* array of bit buttons                    */
  *label_io_val=NULL,      /* array of values in io_window            */
  *label_io_addr=NULL,     /* aray of address labels on io_window     */
  dataform_io,             /* form io_widget to place data            */
  dataform_sram,           /* form sram_widget to place data          */
  dataform_eeprom,         /* form eeprom_widget to place data        */
  *field_eeprom=NULL,      /* edit field in eeprom_window             */
  vscr_eeprom_bar,         /* scrollbar in eeprom_window              */
  *label_eeprom=NULL;      /* array of labels(address) in eeprom_window */

char **gpr_tip_str=NULL;
char **sram_tip_str=NULL;
char **eeprom_tip_str=NULL;

Widget gpr_window,io_window,sram_window,eeprom_window,memory_window=0;

char *memory_type_str[]={
  N_("Registers"),N_("I/O registers"),N_("Ext I/O Registers"),N_("SRAM"),
  N_("Data"),N_("EEPROM")};

void update_gpr_window();
void update_sram_window();
void update_eeprom_window();
void update_io_window();
void full_update_io_window();
void full_update_sram_window();
void full_update_eeprom_window();
void switch_button_gpr();
void switch_button_sram();
void switch_button_eeprom();
void close_button_gpr();
void close_button_sram();
void close_button_io();
void close_button_eeprom();
void scroll_bar_io_callback();
void scroll_bar_sram_callback();
void scroll_bar_eeprom_callback();
void get_focus_field_callback();
void get_focus_field_sram_callback();
void get_focus_field_eeprom_callback();
void lose_focus_field_callback();
void lose_focus_field_sram_callback();
void lose_focus_field_eeprom_callback();
void field_changed_callback(); 
void field_sram_changed_callback();
void field_eeprom_changed_callback();
void set_size_sram_window();
void set_size_io_window();
void set_size_eeprom_window();
void bit_button_callback();
void resize_io();
void resize_sram();
void resize_eeprom();
void create_io_ports_line();
void create_sram_line();
void create_eeprom_line();

void init_windows_memory(void)
{
  int n;

  /* allocate memory for 'mem_file_changed' */
  if(mem_file_changed!=NULL) free(mem_file_changed);
  size_mem_file=(controllers[type_micro].size_gpr+
		 controllers[type_micro].size_io_reg+
		 controllers[type_micro].size_sram)/8+1;
  
  if((mem_file_changed=malloc(size_mem_file))==NULL)
    {
      puts("init_windows_memory(): can't allocate memory for 'mem_file_changed'");
      exit(1);
     }
  memset(mem_file_changed,0,size_mem_file);

  /* allocate memory for 'mem_file_changed' */
  if(eeprom_changed!=NULL) free(eeprom_changed);
  size_eeprom=controllers[type_micro].size_eeprom;
  
  if((eeprom_changed=malloc(size_eeprom))==NULL)
    {
      puts("init_windows_memory(): can't allocate memory for 'eeprom_changed'");
      exit(1);
    }
  memset(eeprom_changed,0,size_eeprom);
  
  /* set parameters of scrollbar of eeprom window */
  if(controllers[type_micro].size_sram)
    {
      XtVaSetValues(vscr_sram_bar,XmNsliderSize,nlines_sram,
		    XmNmaximum,controllers[type_micro].size_sram/16,
		    XmNvalue,0,NULL);
      address_sram=0;
    }
  else
    XtUnmanageChild(sram_window);
  
  /* set parameters of scrollbar of eeprom window */
  XtVaSetValues(vscr_eeprom_bar,XmNsliderSize,nlines_eeprom,
		XmNmaximum,controllers[type_micro].size_eeprom/16,
		XmNvalue,0,NULL);
  address_eeprom=0;

  /* set parameters of scrollbar of io window */
  for(n=0;controllers[type_micro].io_registers[n].code!=-1;n++);
  XtVaSetValues(vscr_io_bar,XmNmaximum,n,XmNsliderSize,nlines_io,NULL);
}

char *conv_to_bin(int number,char *buf)
{
  int n;
  
  if(buf==NULL)
    {
      puts("conv_to_bin(): buf==NULL");
      return NULL;
    }
  for(n=0;n<9;n++)
    {
      if(n==4) {buf[n]=' ';n++;}
      if(number%2)
	buf[8-n]='1';
      else
	buf[8-n]='0';
      number/=2;
    }
  buf[n]=0;
  return buf;
}

/* GPR window */
void create_gpr_window(void)
{
  
  char buf[5];
  Widget *label,button,shell,frame,gpr_form;
  int n,num,m,max=controllers[type_micro].size_gpr;
  XmString string;
  Arg args[19];
  
  if((label=malloc(max*sizeof(Widget)))==NULL)
    {
      puts("create_gpr_window(): can't allocate memory for 'label'");
      exit(1);
    }
  if((field=malloc(max*sizeof(Widget)))==NULL)
    {
      puts("create_gpr_window(): can't allocate memory for 'field'");
      exit(1);
    } 
  if((gpr_tip_str=malloc(max*sizeof(char *)))==NULL)
    {
      puts("create_gpr_window(): can't allocate memory for 'gpr_tip_str'");
      exit(1);
    }
  
  for(n=0;n<max;n++)
    {
      if((gpr_tip_str[n]=malloc(10*sizeof(char)))==NULL)
	{
	  printf("create_gpr_window(): \
can't allocate memory for 'gpr_tip_str[%d]'",n);
	  exit(1);
	}
      gpr_tip_str[n][0]=0;
    }


  shell=XtVaCreateWidget("Shell",xmDialogShellWidgetClass,toplevel,
			 XmNtitle,_("General Registers"),NULL);
  gpr_window=XtVaCreateWidget("form",xmFormWidgetClass,shell,
			      XmNautoUnmanage,False,
			      XmNdialogStyle,XmDIALOG_MODELESS,
			      XmNresizePolicy,XmRESIZE_NONE,
			      XmNfractionBase,5,NULL);
  
  frame=XtVaCreateManagedWidget("frame",xmFrameWidgetClass,gpr_window,
				XmNtopAttachment,XmATTACH_FORM,
				XmNtopOffset,5,
				XmNleftAttachment,XmATTACH_FORM,
				XmNleftOffset,5,
				XmNrightAttachment,XmATTACH_FORM,
				XmNrightOffset,5,NULL);
  gpr_form=XtVaCreateManagedWidget("form",xmFormWidgetClass,frame,NULL);

  XtSetArg(args[m=0],XmNleftAttachment,XmATTACH_WIDGET);m++;
  XtSetArg(args[m],XmNtopOffset,6);m++;
  XtSetArg(args[m],XmNleftOffset,0);m++;
  XtSetArg(args[m],XmNcolumns,3);m++;
  XtSetArg(args[m],XmNmaxLength,2);m++;
  XtSetArg(args[m],XmNvalue,"0");m++;
  XtSetArg(args[m],XmNcursorPositionVisible,False);m++;
  
  for(n=0;n<max;n++)
    {
      num=m;
      sprintf(buf,"r%-2d:",n);
      string=XmStringGenerate(buf,XmFONTLIST_DEFAULT_TAG,
			      XmCHARSET_TEXT,_MOTIF_DEFAULT_LOCALE);
      label[n]=XtVaCreateManagedWidget("r",xmLabelGadgetClass,gpr_form,
				       XmNlabelString,string,
				       XmNtopOffset,8,XmNleftOffset,6,NULL);
      XmStringFree(string);

      XtSetArg(args[num],XmNleftWidget,label[n]);num++;
      
      if(n%4==0) 
	XtVaSetValues(label[n],XmNleftAttachment,XmATTACH_FORM,NULL);
      else
	XtVaSetValues(label[n],XmNleftAttachment,XmATTACH_WIDGET,
		      XmNleftWidget,field[n-1],NULL);
      if((n+1)%4==0)
	{
	  XtSetArg(args[num],XmNrightAttachment,XmATTACH_FORM);num++;
	  XtSetArg(args[num],XmNrightOffset,6);num++;
	}
	
      if(n<4)
	{
	  XtSetArg(args[num],XmNtopAttachment,XmATTACH_FORM);num++;
	  XtVaSetValues(label[n],XmNtopAttachment,XmATTACH_FORM,NULL);
	}
      else
	{
	  XtSetArg(args[num],XmNtopAttachment,XmATTACH_WIDGET);num++;
	  XtSetArg(args[num],XmNtopWidget,field[n-4]);num++;
	  XtVaSetValues(label[n],XmNtopAttachment,XmATTACH_WIDGET,
			XmNtopWidget,field[n-4],NULL);
	}

      if(max-n<5)
	{
	  XtSetArg(args[num],XmNbottomAttachment,XmATTACH_FORM);num++;
	  XtSetArg(args[num],XmNbottomOffset,6);num++;
	}
	
      field[n]=XtCreateManagedWidget("field",xmTextFieldWidgetClass,gpr_form,
				     args,num);
      xs_widget_tip(field[n],gpr_tip_str[n]);
      XtAddCallback(field[n],XmNfocusCallback,(XtCallbackProc)
		    get_focus_field_callback,NULL);
      XtAddCallback(field[n],XmNlosingFocusCallback,(XtCallbackProc)
		    lose_focus_field_callback,NULL);
    }

  string=XmStringGenerate(_("Decimal"),XmFONTLIST_DEFAULT_TAG,
			  XmCHARSET_TEXT,_MOTIF_DEFAULT_LOCALE);
  button=XtVaCreateManagedWidget("Dec",xmPushButtonGadgetClass,
				 gpr_window,XmNtopAttachment,XmATTACH_WIDGET,
				 XmNtopOffset,6,XmNtopWidget,frame,
				 XmNleftAttachment,XmATTACH_POSITION,
				 XmNleftPosition,1,XmNlabelString,string,
				 XmNrightAttachment,XmATTACH_POSITION,
				 XmNrightPosition,2,
				 XmNbottomAttachment,XmATTACH_FORM,
				 XmNbottomOffset,6,NULL);
  
  XtAddCallback(button,
		XmNactivateCallback,(XtCallbackProc)switch_button_gpr,NULL);
  XmStringFree(string);
  
  string=XmStringGenerate(_("Close"),XmFONTLIST_DEFAULT_TAG,
			  XmCHARSET_TEXT,_MOTIF_DEFAULT_LOCALE);
  button=XtVaCreateManagedWidget("Close",xmPushButtonGadgetClass,
				 gpr_window,XmNtopAttachment,XmATTACH_WIDGET,
				 XmNtopOffset,6,XmNtopWidget,frame,
				 XmNleftAttachment,XmATTACH_POSITION,
				 XmNleftPosition,3,
				 XmNrightAttachment,XmATTACH_POSITION,
				 XmNrightPosition,4,XmNlabelString,string,
				 XmNbottomAttachment,XmATTACH_FORM,
				 XmNbottomOffset,6,NULL);
  
  XtAddCallback(button,
		XmNactivateCallback,(XtCallbackProc)close_button_gpr,NULL);
  XmStringFree(string);
  
  XtAddCallback(shell,XmNpopupCallback,(XtCallbackProc)set_size_static_window,
		NULL);
  free(label);
}

void update_gpr_window(void)
{
  int n;
  char buf[4];
  unsigned char value;
    
  XtVaGetValues(menu[MEMORY_MENU].sub_menu[GPR_BUTTON].button,
		XmNset,&value,NULL);
  if(value!=XmSET) return;
  
  for(n=0;n<controllers[type_micro].size_gpr;n++)
    {
      if(mem_file_changed[n/8]&(1<<n%8))
	{
	  if(type_gpr_window==HEX)
	    sprintf(buf,"%X",gpr_pointer[n]);
	  else sprintf(buf,"%u",gpr_pointer[n]);
	  XtVaSetValues(field[n],XmNvalue,buf,NULL);
	  delete_tip(field[n],gpr_tip_str[n]);
	  xs_widget_tip(field[n],
			conv_to_bin((int)gpr_pointer[n],gpr_tip_str[n]));
	}
    }
}

void switch_button_gpr(Widget w,XtPointer client_data,XtPointer call_data)
{
  XmString string;
  int n;
  char buf[4];

  if(type_gpr_window==HEX) 
    {
      type_gpr_window=DEC;
      string=XmStringGenerate(_("Hex"),XmFONTLIST_DEFAULT_TAG,
			      XmCHARSET_TEXT,_MOTIF_DEFAULT_LOCALE);
      XtVaSetValues(w,XmNlabelString,string,NULL);
      XmStringFree(string);
      for(n=0;n<controllers[type_micro].size_gpr;n++)
	XtVaSetValues(field[n],XmNmaxLength,3,NULL);
    }
  else
    {
      type_gpr_window=HEX;
      string=XmStringGenerate(_("Decimal"),XmFONTLIST_DEFAULT_TAG,
			      XmCHARSET_TEXT,_MOTIF_DEFAULT_LOCALE);
      XtVaSetValues(w,XmNlabelString,string,NULL);
      XmStringFree(string);
      for(n=0;n<controllers[type_micro].size_gpr;n++)
	XtVaSetValues(field[n],XmNmaxLength,2,NULL);
    }
  
  /* update */
  for(n=0;n<controllers[type_micro].size_gpr;n++)
    {
      if(type_gpr_window==HEX)
	sprintf(buf,"%X",gpr_pointer[n]);
      else sprintf(buf,"%u",gpr_pointer[n]);
      XtVaSetValues(field[n],XmNvalue,buf,NULL); 
    }
}