halsimuv.h

一个免费的SMART CARD OS系统。

		~idataVar() {
				delSimuVar(name,SIMUVAR_IDATA);
			}

		jword	location() { return mloc; }

	private:
		char*	name;
		int		msize;
		jword	mloc;
};

#ifdef DEFINE
#define GLOBAL_IDATA_ARRAY(ctyp,cvar,nelt)\
			idataVar	idataVar##cvar(#cvar,sizeof(ctyp)*nelt);\
			ctyp*		cvar = (ctyp*) (gIDATA.cells()+idataVar##cvar.location());

#define GLOBAL_IDATA(ctyp,cvar)\
			idataVar	idataVar##cvar(#cvar,sizeof(ctyp));\
			ctyp&		cvar = (ctyp&) *(gIDATA.cells()+idataVar##cvar.location());

#define GLOBAL_BIT(cvar)\
			idataVar	idataVar##cvar(#cvar,-1);\
			jbool		cvar;

#define GLOBAL_IDATA_ARRAY_AT(ctyp,cvar,nelt,loc)\
			idataVar	idataVar##cvar(loc,#cvar,sizeof(ctyp)*nelt);\
			ctyp*		cvar = (ctyp*) (gIDATA.cells()+loc);

#define GLOBAL_IDATA_AT(ctyp,cvar,loc)\
			idataVar	idataVar##cvar(loc,#cvar,sizeof(ctyp));\
			ctyp&		cvar = (ctyp&) *(gIDATA.cells()+loc);

#define GLOBAL_BIT_AT(cvar,loc)\
			idataVar	idataVar##cvar(loc,#cvar,-1);\
			jbool		cvar;
#else
#define GLOBAL_IDATA_ARRAY(ctyp,cvar,nelt)\
			extern ctyp*	cvar;

#define GLOBAL_IDATA(ctyp,cvar)\
			extern ctyp&	cvar;

#define GLOBAL_BIT(cvar)\
			extern jbool	cvar;

#define GLOBAL_IDATA_ARRAY_AT(ctyp,cvar,nelt,loc)\
			extern ctyp*	cvar;

#define GLOBAL_IDATA_AT(ctyp,cvar,loc)\
			extern ctyp&	cvar;

#define GLOBAL_BIT_AT(cvar,loc)\
			extern jbool	cvar;
#endif

#define IPTR(ofs)   	((jbyte*) (gIDATA.cells()+ofs))
#define IOFFSET(ptr)	((jword)(((jbyte*)ptr) - gIDATA.cells()))

/* =========================================================================
	LOCAL in DATAGROUP
   ========================================================================= */

class localVar {

	public:
		localVar(char * s,int siz) {
				name=s; msize=siz;
				if (LOG_ISENABLED("SIMUDATA")) { printf("SIMUDATA: local::init() %s ",name); }
				if (msize>0) {
					mloc = gIDATA.getFree_DATAGROUP(msize); gIDATA.setInUse_DATAGROUP(mloc,msize);
				} else {
					mloc = gIDATA.getFree_BDATA(); gIDATA.setInUse_BDATA(mloc);
				}
				if (LOG_ISENABLED("SIMUDATA")) { printf("\n"); }
			}
		~localVar() {
				if (LOG_ISENABLED("SIMUDATA")) { printf("SIMUDATA: local::done() %s",name); }
				if (msize>0) {
					gIDATA.setFree_DATAGROUP(mloc,msize);
				} else {
					gIDATA.setFree_BDATA(mloc);
				}
				if (LOG_ISENABLED("SIMUDATA")) { printf("\n"); }
			}

		jword	location() { return mloc; }

	private:
		char*	name;
		int		msize;
		jword	mloc;
};

#define LOCAL_ARRAY(ctyp,cvar,nelt)\
			localVar	localVar##cvar(#cvar,sizeof(ctyp)*nelt);\
			ctyp*		cvar = (ctyp*) (gIDATA.cells()+localVar##cvar.location());

#define LOCAL(ctyp,cvar)\
			localVar	localVar##cvar(#cvar,sizeof(ctyp));\
			ctyp&		cvar = (ctyp&) *(gIDATA.cells()+localVar##cvar.location());

#define LOCAL_BIT(cvar)\
			localVar	localVar##cvar(#cvar,-1);\
			jbool		cvar;

/* =========================================================================
	XDATA MEMORY MAP
   ========================================================================= */

class XDATA {
	public:
		XDATA() {
			LOG_DISABLE("SIMUDATA");	/* by default this module doesn't log */
			LOG_DISABLE("SimuVar");	/* by default this module doesn't log */
			resetAll(jtrue);
		}

		void resetAll(jbool bFull)
		{
			for (int i=0;i<SIZE_OF_XDATA;i++) {
				if (bFull) m_mem[i] = 0x55;	/* garbage at initialisation */
				m_color[i] = 0x00;	/* not use for now */

				/* init usage for a 8051 based component */
				if ((i>=ADDR_OF_XDATAGROUP) && (i<=(ADDR_OF_XDATAGROUP+SIZE_OF_XDATAGROUP))) {
					m_usage[i] = XDATA_USAGE_XDATAGROUP;
				#ifdef ADDR_OF_XSTACK
				} else
				if ((i>=ADDR_OF_XSTACK) && (i<=(ADDR_OF_XSTACK+SIZE_OF_XSTACK))) {
					m_usage[i] = XDATA_USAGE_XSTACK;
				#endif
				} else {
					m_usage[i] = XDATA_USAGE_FREE;
				}
			}
			#ifdef ADDR_OF_XSTACK
			LOG("SIMUDATA","*** XDATA / XDATAGROUP and XSTACK initialized");
			#else
			LOG("SIMUDATA","*** XDATA and XDATAGROUP initialized");
			#endif
		}

		void setInUse_XDATA(jword adr,jbyte nsize) {
			for (jbyte n=0;n<nsize;n++) {
				if (m_usage[adr+n]!=XDATA_USAGE_FREE) {
					if (m_usage[adr+n]==XDATA_USAGE_XDATAGROUP) {
						fprintf(stderr,"*** xdatagroup conflict at %Xh !\n",adr+n);
						simu_exit(1);
					}
					if (m_usage[adr+n]==XDATA_USAGE_XSTACK) {
						fprintf(stderr,"*** xstack conflict at %Xh !\n",adr+n);
						simu_exit(1);
					}
					if (m_usage[adr+n]==XDATA_USAGE_COPROCESSOR) {
						LOG1("SIMUDATA","*** coprocessor overlay at %Xh !",adr+n);
					}
				}
				if (m_color[adr+n]!=0x00) {
					LOG1("SIMUDATA","*** overlay at %Xh",adr+n);
				}
				m_color[adr+n] = 0xFF;
			}
			if (nsize>1) {
				if (LOG_ISENABLED("SIMUDATA")) { printf("*** XDATA %Xh-%Xh ",adr,adr+nsize-1); }
			} else {
				if (LOG_ISENABLED("SIMUDATA")) { printf("*** XDATA %Xh ",adr); }
			}
		}

		void setInUse_XDATAGROUP(jword adr,jbyte nsize) {
			if ((adr<ADDR_OF_XDATAGROUP) || (((adr+nsize)>(ADDR_OF_XDATAGROUP+SIZE_OF_XDATAGROUP)))) {
				fprintf(stderr,"*** address out of range (%Xh) in XDATAGROUP !\n",adr+nsize);
				simu_exit(1);
			}
			for (jbyte n=0;n<nsize;n++) {
				if (m_color[adr+n]!=0x00) {
					fprintf(stderr,"*** xdatagroup conflict at %Xh !\n",adr+n);
					simu_exit(1);
				}
				m_color[adr+n] = 0xFF;
			}
			if (nsize>1) {
				if (LOG_ISENABLED("SIMUDATA")) { printf("*** XDATAGROUP %Xh-%Xh ",adr,adr+nsize-1); }
			} else {
				if (LOG_ISENABLED("SIMUDATA")) { printf("*** XDATAGROUP %Xh ",adr); }
			}
		}

		jword getFree_XDATA(jbyte nsize) {
			jword	n;
			jbyte	j;
			int		ok;

			n=0;
			while (n<(SIZE_OF_XDATA-nsize)) {
				ok = 1;
				for (j=0;j<nsize;j++) {
					if (m_usage[n+j]!=XDATA_USAGE_FREE) { ok = 0; }
					if (m_color[n+j]!=0x00) { ok = 0; }
				}
				if (ok) return n;
				n++;
			}
			fprintf(stderr,"*** can't found space for %d bytes in XDATA global area\n",nsize);
			simu_exit(1);
			return 0;
		}

		jword getFree_XDATAGROUP(jbyte nsize) {
			jword	n;
			jbyte	j;
			int		ok;

			n=ADDR_OF_XDATAGROUP;
			while (n<(ADDR_OF_XDATAGROUP+SIZE_OF_XDATAGROUP-nsize)) {
				ok = 1;
				for (j=0;j<nsize;j++) {
					if (m_color[n+j]!=0x00) { ok = 0; }
				}
				if (ok) return n;
				n++;
			}
			fprintf(stderr,"*** can't found space for %d bytes in XDATAGROUP area\n",nsize);
			simu_exit(1);
			return 0;
		}

		void setFree_XDATAGROUP(jword adr,jbyte nsize) {
			if ((adr<ADDR_OF_XDATAGROUP) || (((adr+nsize)>(ADDR_OF_XDATAGROUP+SIZE_OF_XDATAGROUP)))) {
				fprintf(stderr,"*** setFree address out of range (%Xh) in XDATAGROUP !\n",adr+nsize);
				simu_exit(1);
			}
			for (jbyte n=0;n<nsize;n++) {
				if (m_color[adr+n]!=0xFF) {
					fprintf(stderr,"*** xdatagroup conflict at %Xh !\n",adr+n);
					simu_exit(1);
				}
				m_color[adr+n] = 0x00;
			}
			if (nsize>1) {
				if (LOG_ISENABLED("SIMUDATA")) { printf("*** free XDATAGROUP %Xh-%Xh",adr,adr+nsize-1); }
			} else {
				if (LOG_ISENABLED("SIMUDATA")) { printf("*** free XDATAGROUP %Xh",adr); }
			}
		}

		jbyte*	cells() { return m_mem; }

	private:
		/* memory cells content */
		jbyte	m_mem[SIZE_OF_XDATA];

		/* memory cells type of usage */
		jbyte	m_usage[SIZE_OF_XDATA];

		/* =0 free cell, =FF inuse cell */
		jbyte	m_color[SIZE_OF_XDATA];
};

#ifdef DEFINE
XDATA	gXDATA;
#else
extern XDATA	gXDATA;
#endif

/* =========================================================================
	variable inside the XDATA map
   ========================================================================= */

class xdataVar {

	public:
		xdataVar(char * s,int siz) {
				name=s; msize=siz;
				if (LOG_ISENABLED("SIMUDATA")) { printf("SIMUDATA: xdata::init() %s size=%d",name,siz); }
				mloc = gXDATA.getFree_XDATA(msize); gXDATA.setInUse_XDATA(mloc,msize);
				if (siz!=-1) addSimuVar(s,mloc,siz,SIMUVAR_XDATA);
				if (LOG_ISENABLED("SIMUDATA")) { printf("\n"); }
			}
		xdataVar(jword adr,char * s,int siz) {
				name=s; msize=siz; mloc=adr;
				if (LOG_ISENABLED("SIMUDATA")) { printf("SIMUDATA: xdata::init() %s at 0x%.4X size=%d ",name,adr,siz); }
				gXDATA.setInUse_XDATA(mloc,msize);
				if (siz!=-1) addSimuVar(s,mloc,siz,SIMUVAR_XDATA);
				if (LOG_ISENABLED("SIMUDATA")) { printf("\n"); }
			}
		~xdataVar() {
				delSimuVar(name,SIMUVAR_XDATA);
			}

		jword	location() { return mloc; }

	private:
		char*	name;
		int		msize;
		jword	mloc;
};

#ifdef DEFINE
#define GLOBAL_XDATA_ARRAY(ctyp,cvar,nelt)\
			xdataVar	xdataVar##cvar(#cvar,sizeof(ctyp)*nelt);\
			ctyp*		cvar = (ctyp*) (gXDATA.cells()+xdataVar##cvar.location());

#define GLOBAL_XDATA(ctyp,cvar)\
			xdataVar	xdataVar##cvar(#cvar,sizeof(ctyp));\
			ctyp&		cvar = (ctyp&) *(gXDATA.cells()+xdataVar##cvar.location());

#define GLOBAL_XDATA_ARRAY_AT(ctyp,cvar,nelt,loc)\
			xdataVar	xdataVar##cvar(loc,#cvar,sizeof(ctyp)*nelt);\
			ctyp*		cvar = (ctyp*) (gXDATA.cells()+loc);

#define GLOBAL_XDATA_AT(ctyp,cvar,loc)\
			xdataVar	xdataVar##cvar(loc,#cvar,sizeof(ctyp));\
			ctyp&		cvar = (ctyp&) *(gXDATA.cells()+loc);
#else
#define GLOBAL_XDATA_ARRAY(ctyp,cvar,nelt)\
			extern	ctyp*		cvar;

#define GLOBAL_XDATA(ctyp,cvar)\
			extern	ctyp&		cvar;

#define GLOBAL_XDATA_ARRAY_AT(ctyp,cvar,nelt,loc)\
			extern	ctyp*		cvar;

#define GLOBAL_XDATA_AT(ctyp,cvar,loc)\
			extern	ctyp&		cvar;
#endif

#define XPTR(ofs)   	((jbyte*) (gXDATA.cells()+ofs))
#define XOFFSET(ptr)	((jword)(((jbyte*)ptr) - gXDATA.cells()))

/* =========================================================================
	Current baudrate
   ========================================================================= */

#ifdef JAYACFG_CONTACTLESS_BAUDRATE
GLOBAL_XDATA(jbyte,simu_baudrate_from_card);
GLOBAL_XDATA(jbyte,simu_baudrate_to_card);
#endif

/* ========================================================================= */

#endif
/* defined HALSIMUV__H */