/************************************************/
/*                                              */
/* File        : ./tclrock.c                    */
/* Description : tcl command interpreter        */
/*                                              */
/* Command     : rock                           */
/* Comment     : ROCK library tcl interface     */
/*                                              */
/* Note : This file was created from a tl file. */
/*        Do not modify by hand.                */
/*                                              */
/* Created : Wed 23. Apr 1997 13:14:51          */
/*                                              */
/************************************************/

#include <tcl.h>
#include <stdlib.h>
#include <tlforms.h>
#include <tlstable.h>

#include "./tclrock.h"
#include "./userrock.h"

/* find name in STable */
int findhash_rock(char *name, void *STable)
{
 int nr,result;
 char *tmpstr;

 result = STableFind(STable,name,(void * *) &nr);
 if (result==ST_OK)
	return nr; /* found case sensitive */

 /* search for case insensitive */
 tmpstr = ST2insensitive( name );
 result = STableFind(STable,tmpstr,(void * *) &nr);
 free(tmpstr);
 if (result==ST_OK)
	return nr; /* found case insensitive */

 return -1; /* not found */
}

	/* define set/iset hash tables */
void *hash_rock_set_3;
void *hash_rock_set_2;
void *hash_rock_set_1;
void *hash_rock_set_0;

/* initialize set/iset hash tables */
void Init_hash_rock_set( void )
{
 int *setnrs;

 setnrs = (int *) malloc(95*sizeof(int));

 /* init hash_rock_set_3 */
 hash_rock_set_3 = STableNew(211,0);	/* case insensitive */
 setnrs[0] = 76;
 STableAdd(hash_rock_set_3,"cintf",(void *) &(setnrs[0]));
 setnrs[1] = 77;
 STableAdd(hash_rock_set_3,"xintf",(void *) &(setnrs[1]));
 setnrs[2] = 78;
 STableAdd(hash_rock_set_3,"tfifo",(void *) &(setnrs[2]));
 setnrs[3] = 79;
 STableAdd(hash_rock_set_3,"efifo",(void *) &(setnrs[3]));
 setnrs[4] = 80;
 STableAdd(hash_rock_set_3,"dfifo",(void *) &(setnrs[4]));
 setnrs[5] = 81;
 STableAdd(hash_rock_set_3,"auxrst",(void *) &(setnrs[5]));
 setnrs[6] = 82;
 STableAdd(hash_rock_set_3,"intrst",(void *) &(setnrs[6]));
 setnrs[7] = 83;
 STableAdd(hash_rock_set_3,"fltrst",(void *) &(setnrs[7]));
 setnrs[8] = 84;
 STableAdd(hash_rock_set_3,"watchdog",(void *) &(setnrs[8]));
 setnrs[9] = 85;
 STableAdd(hash_rock_set_3,"efmode",(void *) &(setnrs[9]));
 setnrs[10] = 86;
 STableAdd(hash_rock_set_3,"boe",(void *) &(setnrs[10]));
 setnrs[11] = 87;
 STableAdd(hash_rock_set_3,"tkndis",(void *) &(setnrs[11]));
 setnrs[12] = 88;
 STableAdd(hash_rock_set_3,"inttrg",(void *) &(setnrs[12]));
 setnrs[13] = 89;
 STableAdd(hash_rock_set_3,"diag",(void *) &(setnrs[13]));
 setnrs[14] = 90;
 STableAdd(hash_rock_set_3,"elapsed",(void *) &(setnrs[14]));
 setnrs[15] = 91;
 STableAdd(hash_rock_set_3,"wscale",(void *) &(setnrs[15]));
 setnrs[16] = 92;
 STableAdd(hash_rock_set_3,"test",(void *) &(setnrs[16]));
 setnrs[17] = 93;
 STableAdd(hash_rock_set_3,"last",(void *) &(setnrs[17]));
 setnrs[18] = 94;
 STableAdd(hash_rock_set_3,"cradd",(void *) &(setnrs[18]));
 setnrs[19] = 95;
 STableAdd(hash_rock_set_3,"goldenref",(void *) &(setnrs[19]));

 /* init hash_rock_set_2 */
 hash_rock_set_2 = STableNew(211,0);	/* case insensitive */
 setnrs[20] = 22;
 STableAdd(hash_rock_set_2,"cintf",(void *) &(setnrs[20]));
 setnrs[21] = 23;
 STableAdd(hash_rock_set_2,"xintf",(void *) &(setnrs[21]));
 setnrs[22] = 24;
 STableAdd(hash_rock_set_2,"tfifo",(void *) &(setnrs[22]));
 setnrs[23] = 25;
 STableAdd(hash_rock_set_2,"efifo",(void *) &(setnrs[23]));
 setnrs[24] = 26;
 STableAdd(hash_rock_set_2,"dfifo",(void *) &(setnrs[24]));
 setnrs[25] = 27;
 STableAdd(hash_rock_set_2,"auxrst",(void *) &(setnrs[25]));
 setnrs[26] = 28;
 STableAdd(hash_rock_set_2,"intrst",(void *) &(setnrs[26]));
 setnrs[27] = 29;
 STableAdd(hash_rock_set_2,"fltrst",(void *) &(setnrs[27]));
 setnrs[28] = 30;
 STableAdd(hash_rock_set_2,"dff",(void *) &(setnrs[28]));
 setnrs[29] = 31;
 STableAdd(hash_rock_set_2,"dhf",(void *) &(setnrs[29]));
 setnrs[30] = 32;
 STableAdd(hash_rock_set_2,"def",(void *) &(setnrs[30]));
 setnrs[31] = 33;
 STableAdd(hash_rock_set_2,"eff",(void *) &(setnrs[31]));
 setnrs[32] = 34;
 STableAdd(hash_rock_set_2,"ehf",(void *) &(setnrs[32]));
 setnrs[33] = 35;
 STableAdd(hash_rock_set_2,"eef",(void *) &(setnrs[33]));
 setnrs[34] = 36;
 STableAdd(hash_rock_set_2,"tef",(void *) &(setnrs[34]));
 setnrs[35] = 37;
 STableAdd(hash_rock_set_2,"tff",(void *) &(setnrs[35]));
 setnrs[36] = 38;
 STableAdd(hash_rock_set_2,"watchdog",(void *) &(setnrs[36]));
 setnrs[37] = 39;
 STableAdd(hash_rock_set_2,"efmode",(void *) &(setnrs[37]));
 setnrs[38] = 40;
 STableAdd(hash_rock_set_2,"boe",(void *) &(setnrs[38]));
 setnrs[39] = 41;
 STableAdd(hash_rock_set_2,"tkndis",(void *) &(setnrs[39]));
 setnrs[40] = 42;
 STableAdd(hash_rock_set_2,"inttrg",(void *) &(setnrs[40]));
 setnrs[41] = 43;
 STableAdd(hash_rock_set_2,"diag",(void *) &(setnrs[41]));
 setnrs[42] = 44;
 STableAdd(hash_rock_set_2,"tknin",(void *) &(setnrs[42]));
 setnrs[43] = 45;
 STableAdd(hash_rock_set_2,"tknout",(void *) &(setnrs[43]));
 setnrs[44] = 46;
 STableAdd(hash_rock_set_2,"coeb",(void *) &(setnrs[44]));
 setnrs[45] = 47;
 STableAdd(hash_rock_set_2,"cerr",(void *) &(setnrs[45]));
 setnrs[46] = 48;
 STableAdd(hash_rock_set_2,"crst",(void *) &(setnrs[46]));
 setnrs[47] = 49;
 STableAdd(hash_rock_set_2,"crngt",(void *) &(setnrs[47]));
 setnrs[48] = 50;
 STableAdd(hash_rock_set_2,"cbusy",(void *) &(setnrs[48]));
 setnrs[49] = 51;
 STableAdd(hash_rock_set_2,"ctrgv",(void *) &(setnrs[49]));
 setnrs[50] = 52;
 STableAdd(hash_rock_set_2,"efwren",(void *) &(setnrs[50]));
 setnrs[51] = 53;
 STableAdd(hash_rock_set_2,"auxon",(void *) &(setnrs[51]));
 setnrs[52] = 54;
 STableAdd(hash_rock_set_2,"timeout",(void *) &(setnrs[52]));
 setnrs[53] = 55;
 STableAdd(hash_rock_set_2,"elapsed",(void *) &(setnrs[53]));
 setnrs[54] = 56;
 STableAdd(hash_rock_set_2,"wscale",(void *) &(setnrs[54]));
 setnrs[55] = 57;
 STableAdd(hash_rock_set_2,"elapsedtime",(void *) &(setnrs[55]));
 setnrs[56] = 58;
 STableAdd(hash_rock_set_2,"halt",(void *) &(setnrs[56]));
 setnrs[57] = 59;
 STableAdd(hash_rock_set_2,"busy",(void *) &(setnrs[57]));
 setnrs[58] = 60;
 STableAdd(hash_rock_set_2,"synchf",(void *) &(setnrs[58]));
 setnrs[59] = 61;
 STableAdd(hash_rock_set_2,"xbusy",(void *) &(setnrs[59]));
 setnrs[60] = 62;
 STableAdd(hash_rock_set_2,"xberr",(void *) &(setnrs[60]));
 setnrs[61] = 63;
 STableAdd(hash_rock_set_2,"qtrg",(void *) &(setnrs[61]));
 setnrs[62] = 64;
 STableAdd(hash_rock_set_2,"cstate",(void *) &(setnrs[62]));
 setnrs[63] = 65;
 STableAdd(hash_rock_set_2,"ptrg",(void *) &(setnrs[63]));
 setnrs[64] = 66;
 STableAdd(hash_rock_set_2,"sof",(void *) &(setnrs[64]));
 setnrs[65] = 67;
 STableAdd(hash_rock_set_2,"eof",(void *) &(setnrs[65]));
 setnrs[66] = 68;
 STableAdd(hash_rock_set_2,"syncrespf",(void *) &(setnrs[66]));
 setnrs[67] = 69;
 STableAdd(hash_rock_set_2,"rocksfail",(void *) &(setnrs[67]));
 setnrs[68] = 70;
 STableAdd(hash_rock_set_2,"slvsfail",(void *) &(setnrs[68]));
 setnrs[69] = 71;
 STableAdd(hash_rock_set_2,"lwadd",(void *) &(setnrs[69]));
 setnrs[70] = 72;
 STableAdd(hash_rock_set_2,"xadd",(void *) &(setnrs[70]));
 setnrs[71] = 73;
 STableAdd(hash_rock_set_2,"last",(void *) &(setnrs[71]));
 setnrs[72] = 74;
 STableAdd(hash_rock_set_2,"cradd",(void *) &(setnrs[72]));
 setnrs[73] = 75;
 STableAdd(hash_rock_set_2,"goldenref",(void *) &(setnrs[73]));

 /* init hash_rock_set_1 */
 hash_rock_set_1 = STableNew(211,0);	/* case insensitive */
 setnrs[74] = 15;
 STableAdd(hash_rock_set_1,"reset",(void *) &(setnrs[74]));
 setnrs[75] = 16;
 STableAdd(hash_rock_set_1,"watchdog",(void *) &(setnrs[75]));
 setnrs[76] = 17;
 STableAdd(hash_rock_set_1,"CSR0",(void *) &(setnrs[76]));
 setnrs[77] = 18;
 STableAdd(hash_rock_set_1,"CSR2",(void *) &(setnrs[77]));
 setnrs[78] = 19;
 STableAdd(hash_rock_set_1,"trigger",(void *) &(setnrs[78]));
 setnrs[79] = 20;
 STableAdd(hash_rock_set_1,"golden",(void *) &(setnrs[79]));
 setnrs[80] = 21;
 STableAdd(hash_rock_set_1,"EDFIFO",(void *) &(setnrs[80]));

 /* init hash_rock_set_0 */
 hash_rock_set_0 = STableNew(211,0);	/* case insensitive */
 setnrs[81] = 1;
 STableAdd(hash_rock_set_0,"reset",(void *) &(setnrs[81]));
 setnrs[82] = 2;
 STableAdd(hash_rock_set_0,"FIFO",(void *) &(setnrs[82]));
 setnrs[83] = 3;
 STableAdd(hash_rock_set_0,"watchdog",(void *) &(setnrs[83]));
 setnrs[84] = 4;
 STableAdd(hash_rock_set_0,"CSR0",(void *) &(setnrs[84]));
 setnrs[85] = 5;
 STableAdd(hash_rock_set_0,"CSR1",(void *) &(setnrs[85]));
 setnrs[86] = 6;
 STableAdd(hash_rock_set_0,"CSR2",(void *) &(setnrs[86]));
 setnrs[87] = 7;
 STableAdd(hash_rock_set_0,"elapsed",(void *) &(setnrs[87]));
 setnrs[88] = 8;
 STableAdd(hash_rock_set_0,"trigger",(void *) &(setnrs[88]));
 setnrs[89] = 9;
 STableAdd(hash_rock_set_0,"tque",(void *) &(setnrs[89]));
 setnrs[90] = 10;
 STableAdd(hash_rock_set_0,"tnow",(void *) &(setnrs[90]));
 setnrs[91] = 11;
 STableAdd(hash_rock_set_0,"rockinfo",(void *) &(setnrs[91]));
 setnrs[92] = 12;
 STableAdd(hash_rock_set_0,"golden",(void *) &(setnrs[92]));
 setnrs[93] = 13;
 STableAdd(hash_rock_set_0,"EFIFO",(void *) &(setnrs[93]));
 setnrs[94] = 14;
 STableAdd(hash_rock_set_0,"DFIFO",(void *) &(setnrs[94]));

 return;
}
int Tcl_rock_00(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_01(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_02(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_03(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_04(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_05(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_06(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_07(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_08(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_09(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);

	/* Symbol Table of Tcl_rock_0 */
void *hash_rock_0;

void Init_hash_rock_00( void );
void Init_hash_rock_01( void );
void Init_hash_rock_02( void );
void Init_hash_rock_03( void );
void Init_hash_rock_04( void );
void Init_hash_rock_05( void );
void Init_hash_rock_06( void );
void Init_hash_rock_07( void );
void Init_hash_rock_08( void );
void Init_hash_rock_09( void );
	/* initialize hash_rock_0 */
void Init_hash_rock_0( void )
{
 hash_rock_0 = STableNew(211,1); /* create case sensitive hash */

	/* case sensitive */
 STableAdd(hash_rock_0,
           "\001ispresent\001",
           (void *) 0);

	/* case sensitive */
 STableAdd(hash_rock_0,
           "\001open\001",
           (void *) 1);

	/* case sensitive */
 STableAdd(hash_rock_0,
           "\001close\001",
           (void *) 2);

	/* case sensitive */
 STableAdd(hash_rock_0,
           "\001raw\001",
           (void *) 3);

	/* case sensitive */
 STableAdd(hash_rock_0,
           "\001get\001",
           (void *) 4);

	/* case sensitive */
 STableAdd(hash_rock_0,
           "\001set\001",
           (void *) 5);

	/* case sensitive */
 STableAdd(hash_rock_0,
           "\001read\001",
           (void *) 6);

	/* case sensitive */
 STableAdd(hash_rock_0,
           "\001write\001",
           (void *) 7);

	/* case sensitive */
 STableAdd(hash_rock_0,
           "\001readpage\001",
           (void *) 8);

	/* case sensitive */
 STableAdd(hash_rock_0,
           "\001readfifo\001",
           (void *) 9);

 Init_hash_rock_00();
 Init_hash_rock_01();
 Init_hash_rock_02();
 Init_hash_rock_03();
 Init_hash_rock_04();
 Init_hash_rock_05();
 Init_hash_rock_06();
 Init_hash_rock_07();
 Init_hash_rock_08();
 Init_hash_rock_09();

 return;
}

/* select: rock */
int Tcl_rock_0(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 int i;

 if (argc==0)
	{ /* command name expected */
	 Tcl_SetResult(interp,"rock: Command name expected.",TCL_VOLATILE);

	 return TCL_ERROR;
	}

	/* search for next command name */
 i = findhash_rock(argv[0],hash_rock_0);

 switch( i )
 { /* select appropriate funcion */
  case 0:
	return Tcl_rock_00(cdata, interp, argc-1, &(argv[1]));
	break;
  case 1:
	return Tcl_rock_01(cdata, interp, argc-1, &(argv[1]));
	break;
  case 2:
	return Tcl_rock_02(cdata, interp, argc-1, &(argv[1]));
	break;
  case 3:
	return Tcl_rock_03(cdata, interp, argc-1, &(argv[1]));
	break;
  case 4:
	return Tcl_rock_04(cdata, interp, argc-1, &(argv[1]));
	break;
  case 5:
	return Tcl_rock_05(cdata, interp, argc-1, &(argv[1]));
	break;
  case 6:
	return Tcl_rock_06(cdata, interp, argc-1, &(argv[1]));
	break;
  case 7:
	return Tcl_rock_07(cdata, interp, argc-1, &(argv[1]));
	break;
  case 8:
	return Tcl_rock_08(cdata, interp, argc-1, &(argv[1]));
	break;
  case 9:
	return Tcl_rock_09(cdata, interp, argc-1, &(argv[1]));
	break;
  default: /* error */
	Tcl_SetResult(interp,"rock: Invalid command name.",TCL_VOLATILE);

	return TCL_ERROR;
	break;
 }
} /* end Tcl_rock_0 */

	/* Symbol Table of Tcl_rock_00 */
void *hash_rock_00;

	/* initialize hash_rock_00 */
void Init_hash_rock_00( void )
{
 hash_rock_00 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock ispresent */
int Tcl_rock_00(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_ispresent data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=2) && (argc<=2) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock ispresent: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.chain=0;
 data.crate=0;
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2nat(argv[curarg],&( data.chain ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[78];
   	 sprintf(errorstr,"rock ispresent arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2nat(argv[curarg],&( data.crate ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[78];
   	 sprintf(errorstr,"rock ispresent arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_ispresent(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+78);
	 sprintf(errorstr,"rock ispresent: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[78];

	 sprintf(errorstr,"rock ispresent: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* nboolean */
	  char outstr[4];

	  nbool2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 ;
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_00 */

	/* Symbol Table of Tcl_rock_01 */
void *hash_rock_01;

	/* initialize hash_rock_01 */
void Init_hash_rock_01( void )
{
 hash_rock_01 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock open */
int Tcl_rock_01(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_open data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=2) && (argc<=2) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock open: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.chain=0;
 data.crate=0;
 data.result=NULL;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2nat(argv[curarg],&( data.chain ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[73];
   	 sprintf(errorstr,"rock open arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2nat(argv[curarg],&( data.crate ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[73];
   	 sprintf(errorstr,"rock open arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_open(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+73);
	 sprintf(errorstr,"rock open: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[73];

	 sprintf(errorstr,"rock open: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* pointer */
	  char outstr[32];

	  pointer2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 ;
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_01 */

	/* Symbol Table of Tcl_rock_02 */
void *hash_rock_02;

	/* initialize hash_rock_02 */
void Init_hash_rock_02( void )
{
 hash_rock_02 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock close */
int Tcl_rock_02(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_close data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock close: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[74];
   	 sprintf(errorstr,"rock close arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_close(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+74);
	 sprintf(errorstr,"rock close: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[74];

	 sprintf(errorstr,"rock close: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* integer */
	  char outstr[32];

	  int2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_02 */

int Tcl_rock_030(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_031(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_032(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_033(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);

	/* Symbol Table of Tcl_rock_03 */
void *hash_rock_03;

void Init_hash_rock_030( void );
void Init_hash_rock_031( void );
void Init_hash_rock_032( void );
void Init_hash_rock_033( void );
	/* initialize hash_rock_03 */
void Init_hash_rock_03( void )
{
 hash_rock_03 = STableNew(211,1); /* create case sensitive hash */

	/* case sensitive */
 STableAdd(hash_rock_03,
           "\001open\001",
           (void *) 0);

	/* case sensitive */
 STableAdd(hash_rock_03,
           "\001read\001",
           (void *) 1);

	/* case sensitive */
 STableAdd(hash_rock_03,
           "\001write\001",
           (void *) 2);

	/* case sensitive */
 STableAdd(hash_rock_03,
           "\001readpage\001",
           (void *) 3);

 Init_hash_rock_030();
 Init_hash_rock_031();
 Init_hash_rock_032();
 Init_hash_rock_033();

 return;
}

/* select: rock raw */
int Tcl_rock_03(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 int i;

 if (argc==0)
	{ /* command name expected */
	 Tcl_SetResult(interp,"rock raw: Command name expected.",TCL_VOLATILE);

	 return TCL_ERROR;
	}

	/* search for next command name */
 i = findhash_rock(argv[0],hash_rock_03);

 switch( i )
 { /* select appropriate funcion */
  case 0:
	return Tcl_rock_030(cdata, interp, argc-1, &(argv[1]));
	break;
  case 1:
	return Tcl_rock_031(cdata, interp, argc-1, &(argv[1]));
	break;
  case 2:
	return Tcl_rock_032(cdata, interp, argc-1, &(argv[1]));
	break;
  case 3:
	return Tcl_rock_033(cdata, interp, argc-1, &(argv[1]));
	break;
  default: /* error */
	Tcl_SetResult(interp,"rock raw: Invalid command name.",TCL_VOLATILE);

	return TCL_ERROR;
	break;
 }
} /* end Tcl_rock_03 */

	/* Symbol Table of Tcl_rock_030 */
void *hash_rock_030;

	/* initialize hash_rock_030 */
void Init_hash_rock_030( void )
{
 hash_rock_030 = STableNew(211,1); /* create case sensitive hash */

	/* case sensitive */
 STableAdd(hash_rock_030,
           "\001vmeam\001",
           (void *) 0);

	/* case sensitive */
 STableAdd(hash_rock_030,
           "\001vmesize\001",
           (void *) 1);

	/* case sensitive */
 STableAdd(hash_rock_030,
           "\001offset\001",
           (void *) 2);

 return;
}

/* data: rock raw open */
int Tcl_rock_030(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_raw_open data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && ((argc&1)==1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock raw open: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.vme_addr=0;
 data.vme_am=0;
 data.vme_am_present=0;
 data.vme_size=0;
 data.vme_size_present=0;
 data.offs=0;
 data.offs_present=0;
 data.result=NULL;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2nat(argv[curarg],&( data.vme_addr ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[77];
   	 sprintf(errorstr,"rock raw open arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 /* option */
 while ((comresult==TCL_OK) &&
        (curarg<(argc-1)))	/* no indent */
 { /* read 2 by 2 */
  int i;

  if (argv[curarg][0]=='-')
  	i = findhash_rock((argv[curarg]+sizeof(char)),hash_rock_030);
  else
  	i=-1; /* error */

  curarg++;

  switch( i )
  { /* select appropriate option */
    case 0:	/* vmeam */
	/* free previous data */
	;
	/* convert data */
	{ /* a simple type */
	 int result;

	 result = str2integer(argv[curarg],&( data.vme_am ));
	 if (result!=TLF_OK)
	 	{
	 	 char errorstr[77];
	 	 sprintf(errorstr,"rock raw open arg %i: Invalid type.",curarg+1);
	 	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 	 comresult = TCL_ERROR;
	 	}
	 else
	 	comresult = TCL_OK;
	}
	data.vme_am_present = 1;
	break;
    case 1:	/* vmesize */
	/* free previous data */
	;
	/* convert data */
	{ /* a simple type */
	 int result;

	 result = str2integer(argv[curarg],&( data.vme_size ));
	 if (result!=TLF_OK)
	 	{
	 	 char errorstr[77];
	 	 sprintf(errorstr,"rock raw open arg %i: Invalid type.",curarg+1);
	 	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 	 comresult = TCL_ERROR;
	 	}
	 else
	 	comresult = TCL_OK;
	}
	data.vme_size_present = 1;
	break;
    case 2:	/* offset */
	/* free previous data */
	;
	/* convert data */
	{ /* a simple type */
	 int result;

	 result = str2integer(argv[curarg],&( data.offs ));
	 if (result!=TLF_OK)
	 	{
	 	 char errorstr[77];
	 	 sprintf(errorstr,"rock raw open arg %i: Invalid type.",curarg+1);
	 	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 	 comresult = TCL_ERROR;
	 	}
	 else
	 	comresult = TCL_OK;
	}
	data.offs_present = 1;
	break;
    default: /* error */
	{
	 char errorstr[77];
	 sprintf(errorstr,"rock raw open arg %i: Invalid option.",curarg);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
	break;
  } /* end switch */
  curarg++;
 } /* end option while */

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_raw_open(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+77);
	 sprintf(errorstr,"rock raw open: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[77];

	 sprintf(errorstr,"rock raw open: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* pointer */
	  char outstr[32];

	  pointer2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 ;
 ;
 ;
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_030 */

	/* Symbol Table of Tcl_rock_031 */
void *hash_rock_031;

	/* initialize hash_rock_031 */
void Init_hash_rock_031( void )
{
 hash_rock_031 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock raw read */
int Tcl_rock_031(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_read data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=2) && (argc<=2) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock raw read: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.reg.str=NULL;
 data.rid=NULL;
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* set/iset */
   int *iwitc;
   
   if (STableFind(hash_rock_set_0,argv[curarg],(void **) &iwitc)==ST_OK)
   	{
   	 data.reg.nr=*iwitc;
   	 data.reg.str = (char *) malloc(strlen(argv[curarg])+1);
   	 strcpy(data.reg.str,argv[curarg]);
   	 comresult = TCL_OK;
   	}
   else
   	{
   	 char errorstr[77];
   	 sprintf(errorstr,"rock raw read arg %i: Invalid type. (set)",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[77];
   	 sprintf(errorstr,"rock raw read arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_read(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+77);
	 sprintf(errorstr,"rock raw read: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[77];

	 sprintf(errorstr,"rock raw read: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* natural */
	  char outstr[32];

	  nat2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 if (data.reg.str!=NULL)	/*dispose set/iset*/
 	free(data.reg.str);
 ;
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_031 */

	/* Symbol Table of Tcl_rock_032 */
void *hash_rock_032;

	/* initialize hash_rock_032 */
void Init_hash_rock_032( void )
{
 hash_rock_032 = STableNew(211,1); /* create case sensitive hash */

	/* case sensitive */
 STableAdd(hash_rock_032,
           "\001or\001",
           (void *) 0);

	/* case sensitive */
 STableAdd(hash_rock_032,
           "\001and\001",
           (void *) 1);

 return;
}

/* data: rock raw write */
int Tcl_rock_032(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_write data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=3) && ((argc&1)==1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock raw write: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.reg.str=NULL;
 data.rid=NULL;
 data.value=0;
 data.or=0;
 data.or_present=0;
 data.and=0;
 data.and_present=0;
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* set/iset */
   int *iwitc;
   
   if (STableFind(hash_rock_set_1,argv[curarg],(void **) &iwitc)==ST_OK)
   	{
   	 data.reg.nr=*iwitc;
   	 data.reg.str = (char *) malloc(strlen(argv[curarg])+1);
   	 strcpy(data.reg.str,argv[curarg]);
   	 comresult = TCL_OK;
   	}
   else
   	{
   	 char errorstr[78];
   	 sprintf(errorstr,"rock raw write arg %i: Invalid type. (set)",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[78];
   	 sprintf(errorstr,"rock raw write arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2nat(argv[curarg],&( data.value ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[78];
   	 sprintf(errorstr,"rock raw write arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 /* option */
 while ((comresult==TCL_OK) &&
        (curarg<(argc-1)))	/* no indent */
 { /* read 2 by 2 */
  int i;

  if (argv[curarg][0]=='-')
  	i = findhash_rock((argv[curarg]+sizeof(char)),hash_rock_032);
  else
  	i=-1; /* error */

  curarg++;

  switch( i )
  { /* select appropriate option */
    case 0:	/* or */
	/* free previous data */
	;
	/* convert data */
	{ /* a simple type */
	 int result;

	 result = str2nat(argv[curarg],&( data.or ));
	 if (result!=TLF_OK)
	 	{
	 	 char errorstr[78];
	 	 sprintf(errorstr,"rock raw write arg %i: Invalid type.",curarg+1);
	 	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 	 comresult = TCL_ERROR;
	 	}
	 else
	 	comresult = TCL_OK;
	}
	data.or_present = 1;
	break;
    case 1:	/* and */
	/* free previous data */
	;
	/* convert data */
	{ /* a simple type */
	 int result;

	 result = str2nat(argv[curarg],&( data.and ));
	 if (result!=TLF_OK)
	 	{
	 	 char errorstr[78];
	 	 sprintf(errorstr,"rock raw write arg %i: Invalid type.",curarg+1);
	 	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 	 comresult = TCL_ERROR;
	 	}
	 else
	 	comresult = TCL_OK;
	}
	data.and_present = 1;
	break;
    default: /* error */
	{
	 char errorstr[78];
	 sprintf(errorstr,"rock raw write arg %i: Invalid option.",curarg);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
	break;
  } /* end switch */
  curarg++;
 } /* end option while */

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_write(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+78);
	 sprintf(errorstr,"rock raw write: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[78];

	 sprintf(errorstr,"rock raw write: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* integer */
	  char outstr[32];

	  int2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 if (data.reg.str!=NULL)	/*dispose set/iset*/
 	free(data.reg.str);
 ;
 ;
 ;
 ;
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_032 */

int Tcl_rock_0330(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0331(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);

	/* Symbol Table of Tcl_rock_033 */
void *hash_rock_033;

void Init_hash_rock_0330( void );
void Init_hash_rock_0331( void );
	/* initialize hash_rock_033 */
void Init_hash_rock_033( void )
{
 hash_rock_033 = STableNew(211,1); /* create case sensitive hash */

	/* case sensitive */
 STableAdd(hash_rock_033,
           "\001internal\001",
           (void *) 0);

	/* case sensitive */
 STableAdd(hash_rock_033,
           "\001info\001",
           (void *) 1);

 Init_hash_rock_0330();
 Init_hash_rock_0331();

 return;
}

/* select: rock raw readpage */
int Tcl_rock_033(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 int i;

 if (argc==0)
	{ /* command name expected */
	 Tcl_SetResult(interp,"rock raw readpage: Command name expected.",TCL_VOLATILE);

	 return TCL_ERROR;
	}

	/* search for next command name */
 i = findhash_rock(argv[0],hash_rock_033);

 switch( i )
 { /* select appropriate funcion */
  case 0:
	return Tcl_rock_0330(cdata, interp, argc-1, &(argv[1]));
	break;
  case 1:
	return Tcl_rock_0331(cdata, interp, argc-1, &(argv[1]));
	break;
  default: /* error */
	Tcl_SetResult(interp,"rock raw readpage: Invalid command name.",TCL_VOLATILE);

	return TCL_ERROR;
	break;
 }
} /* end Tcl_rock_033 */

	/* Symbol Table of Tcl_rock_0330 */
void *hash_rock_0330;

	/* initialize hash_rock_0330 */
void Init_hash_rock_0330( void )
{
 hash_rock_0330 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock raw readpage internal */
int Tcl_rock_0330(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_readpage_internal data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock raw readpage internal: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.reset=0;
  data.result.fifo=0;
  data.result.watchdog=0;
  data.result.csr0=0;
  data.result.csr1=0;
  data.result.csr2=0;
  data.result.elapsed=0;
  data.result.trigger=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[90];
   	 sprintf(errorstr,"rock raw readpage internal arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_readpage_internal(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+90);
	 sprintf(errorstr,"rock raw readpage internal: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[90];

	 sprintf(errorstr,"rock raw readpage internal: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_0;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_0);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.reset,outstr);
	    Tcl_DStringAppend(&( swotc_0 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_0.string);

	   Tcl_DStringFree(&swotc_0);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_0);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.fifo,outstr);
	    Tcl_DStringAppend(&( swotc_0 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_0.string);

	   Tcl_DStringFree(&swotc_0);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_0);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.watchdog,outstr);
	    Tcl_DStringAppend(&( swotc_0 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_0.string);

	   Tcl_DStringFree(&swotc_0);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_0);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.csr0,outstr);
	    Tcl_DStringAppend(&( swotc_0 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_0.string);

	   Tcl_DStringFree(&swotc_0);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_0);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.csr1,outstr);
	    Tcl_DStringAppend(&( swotc_0 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_0.string);

	   Tcl_DStringFree(&swotc_0);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_0);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.csr2,outstr);
	    Tcl_DStringAppend(&( swotc_0 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_0.string);

	   Tcl_DStringFree(&swotc_0);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_0);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.elapsed,outstr);
	    Tcl_DStringAppend(&( swotc_0 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_0.string);

	   Tcl_DStringFree(&swotc_0);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_0);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.trigger,outstr);
	    Tcl_DStringAppend(&( swotc_0 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_0.string);

	   Tcl_DStringFree(&swotc_0);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0330 */

	/* Symbol Table of Tcl_rock_0331 */
void *hash_rock_0331;

	/* initialize hash_rock_0331 */
void Init_hash_rock_0331( void )
{
 hash_rock_0331 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock raw readpage info */
int Tcl_rock_0331(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_readpage_info data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock raw readpage info: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.tque=0;
  data.result.tnow=0;
  data.result.rockinfo=0;
  data.result.golden=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[86];
   	 sprintf(errorstr,"rock raw readpage info arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_readpage_info(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+86);
	 sprintf(errorstr,"rock raw readpage info: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[86];

	 sprintf(errorstr,"rock raw readpage info: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_1;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_1);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tque,outstr);
	    Tcl_DStringAppend(&( swotc_1 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_1.string);

	   Tcl_DStringFree(&swotc_1);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_1);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tnow,outstr);
	    Tcl_DStringAppend(&( swotc_1 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_1.string);

	   Tcl_DStringFree(&swotc_1);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_1);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.rockinfo,outstr);
	    Tcl_DStringAppend(&( swotc_1 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_1.string);

	   Tcl_DStringFree(&swotc_1);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_1);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.golden,outstr);
	    Tcl_DStringAppend(&( swotc_1 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_1.string);

	   Tcl_DStringFree(&swotc_1);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0331 */

	/* Symbol Table of Tcl_rock_04 */
void *hash_rock_04;

	/* initialize hash_rock_04 */
void Init_hash_rock_04( void )
{
 hash_rock_04 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock get */
int Tcl_rock_04(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_get data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=2) && (argc<=2) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock get: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.bit.str=NULL;
 data.rid=NULL;
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* set/iset */
   int *iwitc;
   
   if (STableFind(hash_rock_set_2,argv[curarg],(void **) &iwitc)==ST_OK)
   	{
   	 data.bit.nr=*iwitc;
   	 data.bit.str = (char *) malloc(strlen(argv[curarg])+1);
   	 strcpy(data.bit.str,argv[curarg]);
   	 comresult = TCL_OK;
   	}
   else
   	{
   	 char errorstr[72];
   	 sprintf(errorstr,"rock get arg %i: Invalid type. (set)",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[72];
   	 sprintf(errorstr,"rock get arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_get(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+72);
	 sprintf(errorstr,"rock get: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[72];

	 sprintf(errorstr,"rock get: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* natural */
	  char outstr[32];

	  nat2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 if (data.bit.str!=NULL)	/*dispose set/iset*/
 	free(data.bit.str);
 ;
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_04 */

	/* Symbol Table of Tcl_rock_05 */
void *hash_rock_05;

	/* initialize hash_rock_05 */
void Init_hash_rock_05( void )
{
 hash_rock_05 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock set */
int Tcl_rock_05(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_set data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=3) && (argc<=3) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock set: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.bit.str=NULL;
 data.rid=NULL;
 data.value=0;
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* set/iset */
   int *iwitc;
   
   if (STableFind(hash_rock_set_3,argv[curarg],(void **) &iwitc)==ST_OK)
   	{
   	 data.bit.nr=*iwitc;
   	 data.bit.str = (char *) malloc(strlen(argv[curarg])+1);
   	 strcpy(data.bit.str,argv[curarg]);
   	 comresult = TCL_OK;
   	}
   else
   	{
   	 char errorstr[72];
   	 sprintf(errorstr,"rock set arg %i: Invalid type. (set)",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[72];
   	 sprintf(errorstr,"rock set arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2nat(argv[curarg],&( data.value ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[72];
   	 sprintf(errorstr,"rock set arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_set(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+72);
	 sprintf(errorstr,"rock set: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[72];

	 sprintf(errorstr,"rock set: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* integer */
	  char outstr[32];

	  int2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 if (data.bit.str!=NULL)	/*dispose set/iset*/
 	free(data.bit.str);
 ;
 ;
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_05 */

int Tcl_rock_0600(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0601(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0602(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0603(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0604(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0605(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0606(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0607(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0608(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0609(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0610(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0611(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0612(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_0613(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);

	/* Symbol Table of Tcl_rock_06 */
void *hash_rock_06;

void Init_hash_rock_0600( void );
void Init_hash_rock_0601( void );
void Init_hash_rock_0602( void );
void Init_hash_rock_0603( void );
void Init_hash_rock_0604( void );
void Init_hash_rock_0605( void );
void Init_hash_rock_0606( void );
void Init_hash_rock_0607( void );
void Init_hash_rock_0608( void );
void Init_hash_rock_0609( void );
void Init_hash_rock_0610( void );
void Init_hash_rock_0611( void );
void Init_hash_rock_0612( void );
void Init_hash_rock_0613( void );
	/* initialize hash_rock_06 */
void Init_hash_rock_06( void )
{
 hash_rock_06 = STableNew(211,1); /* create case sensitive hash */

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001reset\001",
           (void *) 0);

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001fifo\001",
           (void *) 1);

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001watchdog\001",
           (void *) 2);

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001csr0\001",
           (void *) 3);

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001csr1\001",
           (void *) 4);

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001csr2\001",
           (void *) 5);

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001elapsed\001",
           (void *) 6);

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001trigger\001",
           (void *) 7);

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001tque\001",
           (void *) 8);

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001tnow\001",
           (void *) 9);

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001rockinfo\001",
           (void *) 10);

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001golden\001",
           (void *) 11);

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001efifo\001",
           (void *) 12);

	/* case sensitive */
 STableAdd(hash_rock_06,
           "\001dfifo\001",
           (void *) 13);

 Init_hash_rock_0600();
 Init_hash_rock_0601();
 Init_hash_rock_0602();
 Init_hash_rock_0603();
 Init_hash_rock_0604();
 Init_hash_rock_0605();
 Init_hash_rock_0606();
 Init_hash_rock_0607();
 Init_hash_rock_0608();
 Init_hash_rock_0609();
 Init_hash_rock_0610();
 Init_hash_rock_0611();
 Init_hash_rock_0612();
 Init_hash_rock_0613();

 return;
}

/* select: rock read */
int Tcl_rock_06(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 int i;

 if (argc==0)
	{ /* command name expected */
	 Tcl_SetResult(interp,"rock read: Command name expected.",TCL_VOLATILE);

	 return TCL_ERROR;
	}

	/* search for next command name */
 i = findhash_rock(argv[0],hash_rock_06);

 switch( i )
 { /* select appropriate funcion */
  case 0:
	return Tcl_rock_0600(cdata, interp, argc-1, &(argv[1]));
	break;
  case 1:
	return Tcl_rock_0601(cdata, interp, argc-1, &(argv[1]));
	break;
  case 2:
	return Tcl_rock_0602(cdata, interp, argc-1, &(argv[1]));
	break;
  case 3:
	return Tcl_rock_0603(cdata, interp, argc-1, &(argv[1]));
	break;
  case 4:
	return Tcl_rock_0604(cdata, interp, argc-1, &(argv[1]));
	break;
  case 5:
	return Tcl_rock_0605(cdata, interp, argc-1, &(argv[1]));
	break;
  case 6:
	return Tcl_rock_0606(cdata, interp, argc-1, &(argv[1]));
	break;
  case 7:
	return Tcl_rock_0607(cdata, interp, argc-1, &(argv[1]));
	break;
  case 8:
	return Tcl_rock_0608(cdata, interp, argc-1, &(argv[1]));
	break;
  case 9:
	return Tcl_rock_0609(cdata, interp, argc-1, &(argv[1]));
	break;
  case 10:
	return Tcl_rock_0610(cdata, interp, argc-1, &(argv[1]));
	break;
  case 11:
	return Tcl_rock_0611(cdata, interp, argc-1, &(argv[1]));
	break;
  case 12:
	return Tcl_rock_0612(cdata, interp, argc-1, &(argv[1]));
	break;
  case 13:
	return Tcl_rock_0613(cdata, interp, argc-1, &(argv[1]));
	break;
  default: /* error */
	Tcl_SetResult(interp,"rock read: Invalid command name.",TCL_VOLATILE);

	return TCL_ERROR;
	break;
 }
} /* end Tcl_rock_06 */

	/* Symbol Table of Tcl_rock_0600 */
void *hash_rock_0600;

	/* initialize hash_rock_0600 */
void Init_hash_rock_0600( void )
{
 hash_rock_0600 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read reset */
int Tcl_rock_0600(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_reset data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read reset: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.fltrst=0;
  data.result.intrst=0;
  data.result.auxrst=0;
  data.result.dfifo=0;
  data.result.efifo=0;
  data.result.xintf=0;
  data.result.tfifo=0;
  data.result.cintf=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[79];
   	 sprintf(errorstr,"rock read reset arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_reset(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+79);
	 sprintf(errorstr,"rock read reset: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[79];

	 sprintf(errorstr,"rock read reset: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_2;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_2);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.fltrst,outstr);
	    Tcl_DStringAppend(&( swotc_2 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_2.string);

	   Tcl_DStringFree(&swotc_2);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_2);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.intrst,outstr);
	    Tcl_DStringAppend(&( swotc_2 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_2.string);

	   Tcl_DStringFree(&swotc_2);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_2);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.auxrst,outstr);
	    Tcl_DStringAppend(&( swotc_2 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_2.string);

	   Tcl_DStringFree(&swotc_2);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_2);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.dfifo,outstr);
	    Tcl_DStringAppend(&( swotc_2 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_2.string);

	   Tcl_DStringFree(&swotc_2);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_2);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.efifo,outstr);
	    Tcl_DStringAppend(&( swotc_2 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_2.string);

	   Tcl_DStringFree(&swotc_2);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_2);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.xintf,outstr);
	    Tcl_DStringAppend(&( swotc_2 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_2.string);

	   Tcl_DStringFree(&swotc_2);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_2);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tfifo,outstr);
	    Tcl_DStringAppend(&( swotc_2 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_2.string);

	   Tcl_DStringFree(&swotc_2);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_2);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.cintf,outstr);
	    Tcl_DStringAppend(&( swotc_2 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_2.string);

	   Tcl_DStringFree(&swotc_2);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0600 */

	/* Symbol Table of Tcl_rock_0601 */
void *hash_rock_0601;

	/* initialize hash_rock_0601 */
void Init_hash_rock_0601( void )
{
 hash_rock_0601 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read FIFO */
int Tcl_rock_0601(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_fifo data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read FIFO: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.dff=0;
  data.result.dhf=0;
  data.result.def=0;
  data.result.eff=0;
  data.result.ehf=0;
  data.result.eef=0;
  data.result.tef=0;
  data.result.tff=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[78];
   	 sprintf(errorstr,"rock read FIFO arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_fifo(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+78);
	 sprintf(errorstr,"rock read FIFO: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[78];

	 sprintf(errorstr,"rock read FIFO: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_3;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_3);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.dff,outstr);
	    Tcl_DStringAppend(&( swotc_3 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_3.string);

	   Tcl_DStringFree(&swotc_3);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_3);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.dhf,outstr);
	    Tcl_DStringAppend(&( swotc_3 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_3.string);

	   Tcl_DStringFree(&swotc_3);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_3);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.def,outstr);
	    Tcl_DStringAppend(&( swotc_3 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_3.string);

	   Tcl_DStringFree(&swotc_3);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_3);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.eff,outstr);
	    Tcl_DStringAppend(&( swotc_3 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_3.string);

	   Tcl_DStringFree(&swotc_3);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_3);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.ehf,outstr);
	    Tcl_DStringAppend(&( swotc_3 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_3.string);

	   Tcl_DStringFree(&swotc_3);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_3);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.eef,outstr);
	    Tcl_DStringAppend(&( swotc_3 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_3.string);

	   Tcl_DStringFree(&swotc_3);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_3);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tef,outstr);
	    Tcl_DStringAppend(&( swotc_3 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_3.string);

	   Tcl_DStringFree(&swotc_3);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_3);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tff,outstr);
	    Tcl_DStringAppend(&( swotc_3 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_3.string);

	   Tcl_DStringFree(&swotc_3);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0601 */

	/* Symbol Table of Tcl_rock_0602 */
void *hash_rock_0602;

	/* initialize hash_rock_0602 */
void Init_hash_rock_0602( void )
{
 hash_rock_0602 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read Watchdog */
int Tcl_rock_0602(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_watchdog data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read Watchdog: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[82];
   	 sprintf(errorstr,"rock read Watchdog arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_watchdog(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+82);
	 sprintf(errorstr,"rock read Watchdog: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[82];

	 sprintf(errorstr,"rock read Watchdog: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* natural */
	  char outstr[32];

	  nat2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0602 */

	/* Symbol Table of Tcl_rock_0603 */
void *hash_rock_0603;

	/* initialize hash_rock_0603 */
void Init_hash_rock_0603( void )
{
 hash_rock_0603 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read CSR0 */
int Tcl_rock_0603(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_csr0 data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read CSR0: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.efmode=0;
  data.result.boe=0;
  data.result.tkndis=0;
  data.result.inttrg=0;
  data.result.diag=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[78];
   	 sprintf(errorstr,"rock read CSR0 arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_csr0(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+78);
	 sprintf(errorstr,"rock read CSR0: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[78];

	 sprintf(errorstr,"rock read CSR0: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_4;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_4);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.efmode,outstr);
	    Tcl_DStringAppend(&( swotc_4 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_4.string);

	   Tcl_DStringFree(&swotc_4);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_4);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.boe,outstr);
	    Tcl_DStringAppend(&( swotc_4 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_4.string);

	   Tcl_DStringFree(&swotc_4);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_4);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tkndis,outstr);
	    Tcl_DStringAppend(&( swotc_4 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_4.string);

	   Tcl_DStringFree(&swotc_4);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_4);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.inttrg,outstr);
	    Tcl_DStringAppend(&( swotc_4 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_4.string);

	   Tcl_DStringFree(&swotc_4);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_4);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.diag,outstr);
	    Tcl_DStringAppend(&( swotc_4 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_4.string);

	   Tcl_DStringFree(&swotc_4);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0603 */

	/* Symbol Table of Tcl_rock_0604 */
void *hash_rock_0604;

	/* initialize hash_rock_0604 */
void Init_hash_rock_0604( void )
{
 hash_rock_0604 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read CSR1 */
int Tcl_rock_0604(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_csr1 data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read CSR1: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.tknin=0;
  data.result.tknout=0;
  data.result.ceob=0;
  data.result.cerr=0;
  data.result.crst=0;
  data.result.crngt=0;
  data.result.cbusy=0;
  data.result.ctrgv=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[78];
   	 sprintf(errorstr,"rock read CSR1 arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_csr1(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+78);
	 sprintf(errorstr,"rock read CSR1: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[78];

	 sprintf(errorstr,"rock read CSR1: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_5;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_5);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tknin,outstr);
	    Tcl_DStringAppend(&( swotc_5 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_5.string);

	   Tcl_DStringFree(&swotc_5);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_5);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tknout,outstr);
	    Tcl_DStringAppend(&( swotc_5 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_5.string);

	   Tcl_DStringFree(&swotc_5);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_5);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.ceob,outstr);
	    Tcl_DStringAppend(&( swotc_5 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_5.string);

	   Tcl_DStringFree(&swotc_5);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_5);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.cerr,outstr);
	    Tcl_DStringAppend(&( swotc_5 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_5.string);

	   Tcl_DStringFree(&swotc_5);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_5);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.crst,outstr);
	    Tcl_DStringAppend(&( swotc_5 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_5.string);

	   Tcl_DStringFree(&swotc_5);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_5);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.crngt,outstr);
	    Tcl_DStringAppend(&( swotc_5 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_5.string);

	   Tcl_DStringFree(&swotc_5);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_5);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.cbusy,outstr);
	    Tcl_DStringAppend(&( swotc_5 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_5.string);

	   Tcl_DStringFree(&swotc_5);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_5);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.ctrgv,outstr);
	    Tcl_DStringAppend(&( swotc_5 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_5.string);

	   Tcl_DStringFree(&swotc_5);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0604 */

	/* Symbol Table of Tcl_rock_0605 */
void *hash_rock_0605;

	/* initialize hash_rock_0605 */
void Init_hash_rock_0605( void )
{
 hash_rock_0605 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read CSR2 */
int Tcl_rock_0605(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_csr2 data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read CSR2: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.efwren=0;
  data.result.auxon=0;
  data.result.timeout=0;
  data.result.elapsed=0;
  data.result.wscale=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[78];
   	 sprintf(errorstr,"rock read CSR2 arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_csr2(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+78);
	 sprintf(errorstr,"rock read CSR2: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[78];

	 sprintf(errorstr,"rock read CSR2: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_6;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_6);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.efwren,outstr);
	    Tcl_DStringAppend(&( swotc_6 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_6.string);

	   Tcl_DStringFree(&swotc_6);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_6);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.auxon,outstr);
	    Tcl_DStringAppend(&( swotc_6 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_6.string);

	   Tcl_DStringFree(&swotc_6);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_6);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.timeout,outstr);
	    Tcl_DStringAppend(&( swotc_6 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_6.string);

	   Tcl_DStringFree(&swotc_6);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_6);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.elapsed,outstr);
	    Tcl_DStringAppend(&( swotc_6 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_6.string);

	   Tcl_DStringFree(&swotc_6);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_6);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.wscale,outstr);
	    Tcl_DStringAppend(&( swotc_6 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_6.string);

	   Tcl_DStringFree(&swotc_6);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0605 */

	/* Symbol Table of Tcl_rock_0606 */
void *hash_rock_0606;

	/* initialize hash_rock_0606 */
void Init_hash_rock_0606( void )
{
 hash_rock_0606 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read Elapsed */
int Tcl_rock_0606(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_elapsed data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read Elapsed: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[81];
   	 sprintf(errorstr,"rock read Elapsed arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_elapsed(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+81);
	 sprintf(errorstr,"rock read Elapsed: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[81];

	 sprintf(errorstr,"rock read Elapsed: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* natural */
	  char outstr[32];

	  nat2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0606 */

	/* Symbol Table of Tcl_rock_0607 */
void *hash_rock_0607;

	/* initialize hash_rock_0607 */
void Init_hash_rock_0607( void )
{
 hash_rock_0607 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read Trigger */
int Tcl_rock_0607(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_trigger data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read Trigger: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.halt=0;
  data.result.busy=0;
  data.result.synchf=0;
  data.result.xbusy=0;
  data.result.xberr=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[81];
   	 sprintf(errorstr,"rock read Trigger arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_trigger(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+81);
	 sprintf(errorstr,"rock read Trigger: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[81];

	 sprintf(errorstr,"rock read Trigger: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_7;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_7);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.halt,outstr);
	    Tcl_DStringAppend(&( swotc_7 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_7.string);

	   Tcl_DStringFree(&swotc_7);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_7);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.busy,outstr);
	    Tcl_DStringAppend(&( swotc_7 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_7.string);

	   Tcl_DStringFree(&swotc_7);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_7);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.synchf,outstr);
	    Tcl_DStringAppend(&( swotc_7 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_7.string);

	   Tcl_DStringFree(&swotc_7);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_7);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.xbusy,outstr);
	    Tcl_DStringAppend(&( swotc_7 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_7.string);

	   Tcl_DStringFree(&swotc_7);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_7);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.xberr,outstr);
	    Tcl_DStringAppend(&( swotc_7 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_7.string);

	   Tcl_DStringFree(&swotc_7);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0607 */

	/* Symbol Table of Tcl_rock_0608 */
void *hash_rock_0608;

	/* initialize hash_rock_0608 */
void Init_hash_rock_0608( void )
{
 hash_rock_0608 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read TQUE */
int Tcl_rock_0608(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_tque data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read TQUE: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.tff=0;
  data.result.link=0;
  data.result.qtrg=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[78];
   	 sprintf(errorstr,"rock read TQUE arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_tque(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+78);
	 sprintf(errorstr,"rock read TQUE: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[78];

	 sprintf(errorstr,"rock read TQUE: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_8;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_8);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tff,outstr);
	    Tcl_DStringAppend(&( swotc_8 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_8.string);

	   Tcl_DStringFree(&swotc_8);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_8);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.link,outstr);
	    Tcl_DStringAppend(&( swotc_8 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_8.string);

	   Tcl_DStringFree(&swotc_8);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_8);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.qtrg,outstr);
	    Tcl_DStringAppend(&( swotc_8 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_8.string);

	   Tcl_DStringFree(&swotc_8);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0608 */

	/* Symbol Table of Tcl_rock_0609 */
void *hash_rock_0609;

	/* initialize hash_rock_0609 */
void Init_hash_rock_0609( void )
{
 hash_rock_0609 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read TNOW */
int Tcl_rock_0609(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_tnow data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read TNOW: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.cstate=0;
  data.result.ptrg=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[78];
   	 sprintf(errorstr,"rock read TNOW arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_tnow(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+78);
	 sprintf(errorstr,"rock read TNOW: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[78];

	 sprintf(errorstr,"rock read TNOW: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_9;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_9);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.cstate,outstr);
	    Tcl_DStringAppend(&( swotc_9 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_9.string);

	   Tcl_DStringFree(&swotc_9);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_9);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.ptrg,outstr);
	    Tcl_DStringAppend(&( swotc_9 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_9.string);

	   Tcl_DStringFree(&swotc_9);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0609 */

	/* Symbol Table of Tcl_rock_0610 */
void *hash_rock_0610;

	/* initialize hash_rock_0610 */
void Init_hash_rock_0610( void )
{
 hash_rock_0610 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read Rockinfo */
int Tcl_rock_0610(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_rockinfo data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read Rockinfo: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.sof=0;
  data.result.eof=0;
  data.result.syncrespf=0;
  data.result.rocksfail=0;
  data.result.slvsfail=0;
  data.result.lwadd=0;
  data.result.xadd=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[82];
   	 sprintf(errorstr,"rock read Rockinfo arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_rockinfo(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+82);
	 sprintf(errorstr,"rock read Rockinfo: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[82];

	 sprintf(errorstr,"rock read Rockinfo: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_10;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_10);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.sof,outstr);
	    Tcl_DStringAppend(&( swotc_10 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_10.string);

	   Tcl_DStringFree(&swotc_10);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_10);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.eof,outstr);
	    Tcl_DStringAppend(&( swotc_10 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_10.string);

	   Tcl_DStringFree(&swotc_10);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_10);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.syncrespf,outstr);
	    Tcl_DStringAppend(&( swotc_10 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_10.string);

	   Tcl_DStringFree(&swotc_10);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_10);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.rocksfail,outstr);
	    Tcl_DStringAppend(&( swotc_10 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_10.string);

	   Tcl_DStringFree(&swotc_10);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_10);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.slvsfail,outstr);
	    Tcl_DStringAppend(&( swotc_10 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_10.string);

	   Tcl_DStringFree(&swotc_10);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_10);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.lwadd,outstr);
	    Tcl_DStringAppend(&( swotc_10 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_10.string);

	   Tcl_DStringFree(&swotc_10);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_10);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.xadd,outstr);
	    Tcl_DStringAppend(&( swotc_10 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_10.string);

	   Tcl_DStringFree(&swotc_10);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0610 */

	/* Symbol Table of Tcl_rock_0611 */
void *hash_rock_0611;

	/* initialize hash_rock_0611 */
void Init_hash_rock_0611( void )
{
 hash_rock_0611 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read Golden */
int Tcl_rock_0611(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_golden data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read Golden: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.last=0;
  data.result.cradd=0;
  data.result.goldenref=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[80];
   	 sprintf(errorstr,"rock read Golden arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_golden(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+80);
	 sprintf(errorstr,"rock read Golden: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[80];

	 sprintf(errorstr,"rock read Golden: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_11;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_11);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.last,outstr);
	    Tcl_DStringAppend(&( swotc_11 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_11.string);

	   Tcl_DStringFree(&swotc_11);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_11);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.cradd,outstr);
	    Tcl_DStringAppend(&( swotc_11 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_11.string);

	   Tcl_DStringFree(&swotc_11);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_11);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.goldenref,outstr);
	    Tcl_DStringAppend(&( swotc_11 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_11.string);

	   Tcl_DStringFree(&swotc_11);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0611 */

	/* Symbol Table of Tcl_rock_0612 */
void *hash_rock_0612;

	/* initialize hash_rock_0612 */
void Init_hash_rock_0612( void )
{
 hash_rock_0612 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read EFIFO */
int Tcl_rock_0612(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_efifo data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read EFIFO: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.nvd=0;
  data.result.ff=0;
  data.result.hf=0;
  data.result.ef=0;
  data.result.fifodata=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[79];
   	 sprintf(errorstr,"rock read EFIFO arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_efifo(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+79);
	 sprintf(errorstr,"rock read EFIFO: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[79];

	 sprintf(errorstr,"rock read EFIFO: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_12;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_12);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.nvd,outstr);
	    Tcl_DStringAppend(&( swotc_12 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_12.string);

	   Tcl_DStringFree(&swotc_12);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_12);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.ff,outstr);
	    Tcl_DStringAppend(&( swotc_12 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_12.string);

	   Tcl_DStringFree(&swotc_12);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_12);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.hf,outstr);
	    Tcl_DStringAppend(&( swotc_12 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_12.string);

	   Tcl_DStringFree(&swotc_12);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_12);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.ef,outstr);
	    Tcl_DStringAppend(&( swotc_12 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_12.string);

	   Tcl_DStringFree(&swotc_12);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_12);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.fifodata,outstr);
	    Tcl_DStringAppend(&( swotc_12 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_12.string);

	   Tcl_DStringFree(&swotc_12);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0612 */

	/* Symbol Table of Tcl_rock_0613 */
void *hash_rock_0613;

	/* initialize hash_rock_0613 */
void Init_hash_rock_0613( void )
{
 hash_rock_0613 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock read DFIFO */
int Tcl_rock_0613(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decode_dfifo data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock read DFIFO: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.nvd=0;
  data.result.ff=0;
  data.result.hf=0;
  data.result.ef=0;
  data.result.fifodata=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[79];
   	 sprintf(errorstr,"rock read DFIFO arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decode_dfifo(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+79);
	 sprintf(errorstr,"rock read DFIFO: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[79];

	 sprintf(errorstr,"rock read DFIFO: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_13;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_13);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.nvd,outstr);
	    Tcl_DStringAppend(&( swotc_13 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_13.string);

	   Tcl_DStringFree(&swotc_13);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_13);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.ff,outstr);
	    Tcl_DStringAppend(&( swotc_13 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_13.string);

	   Tcl_DStringFree(&swotc_13);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_13);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.hf,outstr);
	    Tcl_DStringAppend(&( swotc_13 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_13.string);

	   Tcl_DStringFree(&swotc_13);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_13);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.ef,outstr);
	    Tcl_DStringAppend(&( swotc_13 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_13.string);

	   Tcl_DStringFree(&swotc_13);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_13);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.fifodata,outstr);
	    Tcl_DStringAppend(&( swotc_13 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_13.string);

	   Tcl_DStringFree(&swotc_13);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_0613 */

int Tcl_rock_070(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_071(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_072(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_073(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_074(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_075(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);

	/* Symbol Table of Tcl_rock_07 */
void *hash_rock_07;

void Init_hash_rock_070( void );
void Init_hash_rock_071( void );
void Init_hash_rock_072( void );
void Init_hash_rock_073( void );
void Init_hash_rock_074( void );
void Init_hash_rock_075( void );
	/* initialize hash_rock_07 */
void Init_hash_rock_07( void )
{
 hash_rock_07 = STableNew(211,1); /* create case sensitive hash */

	/* case sensitive */
 STableAdd(hash_rock_07,
           "\001reset\001",
           (void *) 0);

	/* case sensitive */
 STableAdd(hash_rock_07,
           "\001watchdog\001",
           (void *) 1);

	/* case sensitive */
 STableAdd(hash_rock_07,
           "\001csr0\001",
           (void *) 2);

	/* case sensitive */
 STableAdd(hash_rock_07,
           "\001csr2\001",
           (void *) 3);

	/* case sensitive */
 STableAdd(hash_rock_07,
           "\001trigger\001",
           (void *) 4);

	/* case sensitive */
 STableAdd(hash_rock_07,
           "\001golden\001",
           (void *) 5);

 Init_hash_rock_070();
 Init_hash_rock_071();
 Init_hash_rock_072();
 Init_hash_rock_073();
 Init_hash_rock_074();
 Init_hash_rock_075();

 return;
}

/* select: rock write */
int Tcl_rock_07(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 int i;

 if (argc==0)
	{ /* command name expected */
	 Tcl_SetResult(interp,"rock write: Command name expected.",TCL_VOLATILE);

	 return TCL_ERROR;
	}

	/* search for next command name */
 i = findhash_rock(argv[0],hash_rock_07);

 switch( i )
 { /* select appropriate funcion */
  case 0:
	return Tcl_rock_070(cdata, interp, argc-1, &(argv[1]));
	break;
  case 1:
	return Tcl_rock_071(cdata, interp, argc-1, &(argv[1]));
	break;
  case 2:
	return Tcl_rock_072(cdata, interp, argc-1, &(argv[1]));
	break;
  case 3:
	return Tcl_rock_073(cdata, interp, argc-1, &(argv[1]));
	break;
  case 4:
	return Tcl_rock_074(cdata, interp, argc-1, &(argv[1]));
	break;
  case 5:
	return Tcl_rock_075(cdata, interp, argc-1, &(argv[1]));
	break;
  default: /* error */
	Tcl_SetResult(interp,"rock write: Invalid command name.",TCL_VOLATILE);

	return TCL_ERROR;
	break;
 }
} /* end Tcl_rock_07 */

	/* Symbol Table of Tcl_rock_070 */
void *hash_rock_070;

	/* initialize hash_rock_070 */
void Init_hash_rock_070( void )
{
 hash_rock_070 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock write reset */
int Tcl_rock_070(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_encode_reset data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=2) && (argc<=2) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock write reset: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.value.fltrst=0;
  data.value.intrst=0;
  data.value.auxrst=0;
  data.value.dfifo=0;
  data.value.efifo=0;
  data.value.xintf=0;
  data.value.tfifo=0;
  data.value.cintf=0;
 }
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[80];
   	 sprintf(errorstr,"rock write reset arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* record */
   int nrargs;
   char **listargs;

   comresult = Tcl_SplitList(interp,argv[curarg],&nrargs,&listargs);
   if ((comresult==TCL_OK) && (nrargs==8))
   	{
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[0],&( data.value.fltrst ));

   	  if ((result==TLF_OK) && (
   	      (data.value.fltrst==0) ||
   	      (data.value.fltrst==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[80];
   	  	 sprintf(errorstr,"rock write reset arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[1],&( data.value.intrst ));

   	  if ((result==TLF_OK) && (
   	      (data.value.intrst==0) ||
   	      (data.value.intrst==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[80];
   	  	 sprintf(errorstr,"rock write reset arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[2],&( data.value.auxrst ));

   	  if ((result==TLF_OK) && (
   	      (data.value.auxrst==0) ||
   	      (data.value.auxrst==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[80];
   	  	 sprintf(errorstr,"rock write reset arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[3],&( data.value.dfifo ));

   	  if ((result==TLF_OK) && (
   	      (data.value.dfifo==0) ||
   	      (data.value.dfifo==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[80];
   	  	 sprintf(errorstr,"rock write reset arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[4],&( data.value.efifo ));

   	  if ((result==TLF_OK) && (
   	      (data.value.efifo==0) ||
   	      (data.value.efifo==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[80];
   	  	 sprintf(errorstr,"rock write reset arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[5],&( data.value.xintf ));

   	  if ((result==TLF_OK) && (
   	      (data.value.xintf==0) ||
   	      (data.value.xintf==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[80];
   	  	 sprintf(errorstr,"rock write reset arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[6],&( data.value.tfifo ));

   	  if ((result==TLF_OK) && (
   	      (data.value.tfifo==0) ||
   	      (data.value.tfifo==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[80];
   	  	 sprintf(errorstr,"rock write reset arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[7],&( data.value.cintf ));

   	  if ((result==TLF_OK) && (
   	      (data.value.cintf==0) ||
   	      (data.value.cintf==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[80];
   	  	 sprintf(errorstr,"rock write reset arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 free(listargs);
   	}
   else if (comresult==TCL_OK)
   	{ /* split ok, erroneous nr. of els. */
   	 char errorstr[80];
   	 free(listargs);
   	 comresult = TCL_ERROR;
   	 sprintf(errorstr,"rock write reset arg %i: Invalid type. (record)",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	}
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_encode_reset(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+80);
	 sprintf(errorstr,"rock write reset: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[80];

	 sprintf(errorstr,"rock write reset: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* integer */
	  char outstr[32];

	  int2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
 }
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_070 */

	/* Symbol Table of Tcl_rock_071 */
void *hash_rock_071;

	/* initialize hash_rock_071 */
void Init_hash_rock_071( void )
{
 hash_rock_071 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock write Watchdog */
int Tcl_rock_071(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_encode_watchdog data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=2) && (argc<=2) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock write Watchdog: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 data.value=0;
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[83];
   	 sprintf(errorstr,"rock write Watchdog arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2nat(argv[curarg],&( data.value ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[83];
   	 sprintf(errorstr,"rock write Watchdog arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_encode_watchdog(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+83);
	 sprintf(errorstr,"rock write Watchdog: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[83];

	 sprintf(errorstr,"rock write Watchdog: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* integer */
	  char outstr[32];

	  int2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 ;
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_071 */

	/* Symbol Table of Tcl_rock_072 */
void *hash_rock_072;

	/* initialize hash_rock_072 */
void Init_hash_rock_072( void )
{
 hash_rock_072 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock write CSR0 */
int Tcl_rock_072(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_encode_csr0 data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=2) && (argc<=2) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock write CSR0: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.value.efmode=0;
  data.value.boe=0;
  data.value.tkndis=0;
  data.value.inttrg=0;
  data.value.diag=0;
 }
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[79];
   	 sprintf(errorstr,"rock write CSR0 arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* record */
   int nrargs;
   char **listargs;

   comresult = Tcl_SplitList(interp,argv[curarg],&nrargs,&listargs);
   if ((comresult==TCL_OK) && (nrargs==5))
   	{
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[0],&( data.value.efmode ));

   	  if ((result==TLF_OK) && (
   	      ((data.value.efmode>=0) && (data.value.efmode<=3))
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[79];
   	  	 sprintf(errorstr,"rock write CSR0 arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[1],&( data.value.boe ));

   	  if ((result==TLF_OK) && (
   	      (data.value.boe==0) ||
   	      (data.value.boe==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[79];
   	  	 sprintf(errorstr,"rock write CSR0 arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[2],&( data.value.tkndis ));

   	  if ((result==TLF_OK) && (
   	      (data.value.tkndis==0) ||
   	      (data.value.tkndis==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[79];
   	  	 sprintf(errorstr,"rock write CSR0 arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[3],&( data.value.inttrg ));

   	  if ((result==TLF_OK) && (
   	      (data.value.inttrg==0) ||
   	      (data.value.inttrg==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[79];
   	  	 sprintf(errorstr,"rock write CSR0 arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[4],&( data.value.diag ));

   	  if ((result==TLF_OK) && (
   	      (data.value.diag==0) ||
   	      (data.value.diag==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[79];
   	  	 sprintf(errorstr,"rock write CSR0 arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 free(listargs);
   	}
   else if (comresult==TCL_OK)
   	{ /* split ok, erroneous nr. of els. */
   	 char errorstr[79];
   	 free(listargs);
   	 comresult = TCL_ERROR;
   	 sprintf(errorstr,"rock write CSR0 arg %i: Invalid type. (record)",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	}
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_encode_csr0(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+79);
	 sprintf(errorstr,"rock write CSR0: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[79];

	 sprintf(errorstr,"rock write CSR0: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* integer */
	  char outstr[32];

	  int2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
 }
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_072 */

	/* Symbol Table of Tcl_rock_073 */
void *hash_rock_073;

	/* initialize hash_rock_073 */
void Init_hash_rock_073( void )
{
 hash_rock_073 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock write CSR2 */
int Tcl_rock_073(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_encode_csr2 data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=2) && (argc<=2) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock write CSR2: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.value.elapsed=0;
  data.value.wscale=0;
 }
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[79];
   	 sprintf(errorstr,"rock write CSR2 arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* record */
   int nrargs;
   char **listargs;

   comresult = Tcl_SplitList(interp,argv[curarg],&nrargs,&listargs);
   if ((comresult==TCL_OK) && (nrargs==2))
   	{
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[0],&( data.value.elapsed ));

   	  if ((result==TLF_OK) && (
   	      (data.value.elapsed==0) ||
   	      (data.value.elapsed==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[79];
   	  	 sprintf(errorstr,"rock write CSR2 arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[1],&( data.value.wscale ));

   	  if ((result==TLF_OK) && (
   	      ((data.value.wscale>=0) && (data.value.wscale<=7))
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[79];
   	  	 sprintf(errorstr,"rock write CSR2 arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 free(listargs);
   	}
   else if (comresult==TCL_OK)
   	{ /* split ok, erroneous nr. of els. */
   	 char errorstr[79];
   	 free(listargs);
   	 comresult = TCL_ERROR;
   	 sprintf(errorstr,"rock write CSR2 arg %i: Invalid type. (record)",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	}
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_encode_csr2(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+79);
	 sprintf(errorstr,"rock write CSR2: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[79];

	 sprintf(errorstr,"rock write CSR2: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* integer */
	  char outstr[32];

	  int2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
 }
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_073 */

	/* Symbol Table of Tcl_rock_074 */
void *hash_rock_074;

	/* initialize hash_rock_074 */
void Init_hash_rock_074( void )
{
 hash_rock_074 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock write Trigger */
int Tcl_rock_074(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_encode_trigger data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=2) && (argc<=2) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock write Trigger: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 data.value=0;
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[82];
   	 sprintf(errorstr,"rock write Trigger arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2nat(argv[curarg],&( data.value ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[82];
   	 sprintf(errorstr,"rock write Trigger arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_encode_trigger(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+82);
	 sprintf(errorstr,"rock write Trigger: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[82];

	 sprintf(errorstr,"rock write Trigger: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* integer */
	  char outstr[32];

	  int2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 ;
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_074 */

	/* Symbol Table of Tcl_rock_075 */
void *hash_rock_075;

	/* initialize hash_rock_075 */
void Init_hash_rock_075( void )
{
 hash_rock_075 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock write Golden */
int Tcl_rock_075(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_encode_golden data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=2) && (argc<=2) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock write Golden: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.value.last=0;
  data.value.cradd=0;
  data.value.goldenref=0;
 }
 data.result=0;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[81];
   	 sprintf(errorstr,"rock write Golden arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 {
  { /* record */
   int nrargs;
   char **listargs;

   comresult = Tcl_SplitList(interp,argv[curarg],&nrargs,&listargs);
   if ((comresult==TCL_OK) && (nrargs==3))
   	{
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[0],&( data.value.last ));

   	  if ((result==TLF_OK) && (
   	      (data.value.last==0) ||
   	      (data.value.last==1)
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[81];
   	  	 sprintf(errorstr,"rock write Golden arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[1],&( data.value.cradd ));

   	  if ((result==TLF_OK) && (
   	      ((data.value.cradd>=0) && (data.value.cradd<=7))
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[81];
   	  	 sprintf(errorstr,"rock write Golden arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 if (comresult==TCL_OK) /* no indent */
   	 { /* irange */
   	  int result;

   	  result = str2integer(listargs[2],&( data.value.goldenref ));

   	  if ((result==TLF_OK) && (
   	      ((data.value.goldenref>=0) && (data.value.goldenref<=4095))
   	                          ))
   	  	comresult = TCL_OK;
   	  else
   	  	{
   	  	 char errorstr[81];
   	  	 sprintf(errorstr,"rock write Golden arg %i: Invalid type. (irange)",curarg+1);
   	  	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	  	 comresult = TCL_ERROR;
   	  	}
   	 }

   	 free(listargs);
   	}
   else if (comresult==TCL_OK)
   	{ /* split ok, erroneous nr. of els. */
   	 char errorstr[81];
   	 free(listargs);
   	 comresult = TCL_ERROR;
   	 sprintf(errorstr,"rock write Golden arg %i: Invalid type. (record)",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	}
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_encode_golden(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+81);
	 sprintf(errorstr,"rock write Golden: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[81];

	 sprintf(errorstr,"rock write Golden: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* integer */
	  char outstr[32];

	  int2str(data.result,outstr);
	  Tcl_DStringAppend(&( tclstr ),outstr,-1);
	  comresult = TCL_OK;
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
 }
 ;
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_075 */

int Tcl_rock_080(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_081(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);

	/* Symbol Table of Tcl_rock_08 */
void *hash_rock_08;

void Init_hash_rock_080( void );
void Init_hash_rock_081( void );
	/* initialize hash_rock_08 */
void Init_hash_rock_08( void )
{
 hash_rock_08 = STableNew(211,1); /* create case sensitive hash */

	/* case sensitive */
 STableAdd(hash_rock_08,
           "\001internal\001",
           (void *) 0);

	/* case sensitive */
 STableAdd(hash_rock_08,
           "\001info\001",
           (void *) 1);

 Init_hash_rock_080();
 Init_hash_rock_081();

 return;
}

/* select: rock readpage */
int Tcl_rock_08(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 int i;

 if (argc==0)
	{ /* command name expected */
	 Tcl_SetResult(interp,"rock readpage: Command name expected.",TCL_VOLATILE);

	 return TCL_ERROR;
	}

	/* search for next command name */
 i = findhash_rock(argv[0],hash_rock_08);

 switch( i )
 { /* select appropriate funcion */
  case 0:
	return Tcl_rock_080(cdata, interp, argc-1, &(argv[1]));
	break;
  case 1:
	return Tcl_rock_081(cdata, interp, argc-1, &(argv[1]));
	break;
  default: /* error */
	Tcl_SetResult(interp,"rock readpage: Invalid command name.",TCL_VOLATILE);

	return TCL_ERROR;
	break;
 }
} /* end Tcl_rock_08 */

	/* Symbol Table of Tcl_rock_080 */
void *hash_rock_080;

	/* initialize hash_rock_080 */
void Init_hash_rock_080( void )
{
 hash_rock_080 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock readpage internal */
int Tcl_rock_080(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decodepage_internal data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock readpage internal: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.fltrst=0;
  data.result.intrst=0;
  data.result.auxrst=0;
  data.result.dfifo=0;
  data.result.efifo=0;
  data.result.xintf=0;
  data.result.tfifo=0;
  data.result.cintf=0;
  data.result.dff=0;
  data.result.dhf=0;
  data.result.def=0;
  data.result.eff=0;
  data.result.ehf=0;
  data.result.eef=0;
  data.result.tef=0;
  data.result.tff=0;
  data.result.watchdog=0;
  data.result.efmode=0;
  data.result.boe=0;
  data.result.tkndis=0;
  data.result.inttrg=0;
  data.result.diag=0;
  data.result.tknin=0;
  data.result.tknout=0;
  data.result.ceob=0;
  data.result.cerr=0;
  data.result.crst=0;
  data.result.crngt=0;
  data.result.cbusy=0;
  data.result.ctrgv=0;
  data.result.efwren=0;
  data.result.auxon=0;
  data.result.timeout=0;
  data.result.elapsed=0;
  data.result.wscale=0;
  data.result.elapsedtime=0;
  data.result.halt=0;
  data.result.busy=0;
  data.result.synchf=0;
  data.result.xbusy=0;
  data.result.xberr=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[86];
   	 sprintf(errorstr,"rock readpage internal arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decodepage_internal(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+86);
	 sprintf(errorstr,"rock readpage internal: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[86];

	 sprintf(errorstr,"rock readpage internal: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_14;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.fltrst,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.intrst,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.auxrst,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.dfifo,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.efifo,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.xintf,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tfifo,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.cintf,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.dff,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.dhf,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.def,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.eff,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.ehf,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.eef,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tef,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tff,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.watchdog,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.efmode,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.boe,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tkndis,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.inttrg,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.diag,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tknin,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tknout,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.ceob,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.cerr,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.crst,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.crngt,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.cbusy,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.ctrgv,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.efwren,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.auxon,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.timeout,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.elapsed,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.wscale,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.elapsedtime,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.halt,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.busy,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.synchf,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.xbusy,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_14);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.xberr,outstr);
	    Tcl_DStringAppend(&( swotc_14 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_14.string);

	   Tcl_DStringFree(&swotc_14);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_080 */

	/* Symbol Table of Tcl_rock_081 */
void *hash_rock_081;

	/* initialize hash_rock_081 */
void Init_hash_rock_081( void )
{
 hash_rock_081 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock readpage info */
int Tcl_rock_081(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_decodepage_info data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=1) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock readpage info: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 { /* record */
  data.result.tff=0;
  data.result.link=0;
  data.result.qtrg=0;
  data.result.cstate=0;
  data.result.ptrg=0;
  data.result.sof=0;
  data.result.eof=0;
  data.result.syncrespf=0;
  data.result.rocksfail=0;
  data.result.slvsfail=0;
  data.result.lwadd=0;
  data.result.xadd=0;
  data.result.last=0;
  data.result.cradd=0;
  data.result.goldenref=0;
 }
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[82];
   	 sprintf(errorstr,"rock readpage info arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_decodepage_info(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+82);
	 sprintf(errorstr,"rock readpage info: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[82];

	 sprintf(errorstr,"rock readpage info: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* record */
	  Tcl_DString swotc_15;	/* internal type string */

	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.tff,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.link,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.qtrg,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.cstate,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.ptrg,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.sof,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.eof,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.syncrespf,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.rocksfail,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.slvsfail,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.lwadd,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.xadd,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.last,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.cradd,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	  if (comresult==TCL_OK)
	  {
	   Tcl_DStringInit(&swotc_15);

	   { /* natural */
	    char outstr[32];

	    nat2str(data.result.goldenref,outstr);
	    Tcl_DStringAppend(&( swotc_15 ),outstr,-1);
	    comresult = TCL_OK;
	   }
	   if (comresult==TCL_OK)
	  	Tcl_DStringAppendElement(&( tclstr ),swotc_15.string);

	   Tcl_DStringFree(&swotc_15);
	  }

	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 { /* dispose record */
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
  ;
 }
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_081 */

int Tcl_rock_090(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);
int Tcl_rock_091(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[]);

	/* Symbol Table of Tcl_rock_09 */
void *hash_rock_09;

void Init_hash_rock_090( void );
void Init_hash_rock_091( void );
	/* initialize hash_rock_09 */
void Init_hash_rock_09( void )
{
 hash_rock_09 = STableNew(211,1); /* create case sensitive hash */

	/* case sensitive */
 STableAdd(hash_rock_09,
           "\001efifo\001",
           (void *) 0);

	/* case sensitive */
 STableAdd(hash_rock_09,
           "\001dfifo\001",
           (void *) 1);

 Init_hash_rock_090();
 Init_hash_rock_091();

 return;
}

/* select: rock readfifo */
int Tcl_rock_09(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 int i;

 if (argc==0)
	{ /* command name expected */
	 Tcl_SetResult(interp,"rock readfifo: Command name expected.",TCL_VOLATILE);

	 return TCL_ERROR;
	}

	/* search for next command name */
 i = findhash_rock(argv[0],hash_rock_09);

 switch( i )
 { /* select appropriate funcion */
  case 0:
	return Tcl_rock_090(cdata, interp, argc-1, &(argv[1]));
	break;
  case 1:
	return Tcl_rock_091(cdata, interp, argc-1, &(argv[1]));
	break;
  default: /* error */
	Tcl_SetResult(interp,"rock readfifo: Invalid command name.",TCL_VOLATILE);

	return TCL_ERROR;
	break;
 }
} /* end Tcl_rock_09 */

	/* Symbol Table of Tcl_rock_090 */
void *hash_rock_090;

	/* initialize hash_rock_090 */
void Init_hash_rock_090( void )
{
 hash_rock_090 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock readfifo EFIFO */
int Tcl_rock_090(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_readefifo data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=2) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock readfifo EFIFO: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 data.size=0;
 data.size_present=0;
 data.result=NULL;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[83];
   	 sprintf(errorstr,"rock readfifo EFIFO arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 /* optparam */
 if ((comresult==TCL_OK) &&
     ((argc&1)==0))	/* no indent */
 {
  { /* a simple type */
   int result;

   result = str2nat(argv[curarg],&( data.size ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[83];
   	 sprintf(errorstr,"rock readfifo EFIFO arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  data.size_present = 1;
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_readefifo(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+83);
	 sprintf(errorstr,"rock readfifo EFIFO: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[83];

	 sprintf(errorstr,"rock readfifo EFIFO: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* list */
	  Tcl_DString swotc_16;	/* internal type string */
	  _STR_natural *iwotc_16;

	  for (iwotc_16=data.result;
	       iwotc_16!=NULL;
	       iwotc_16=iwotc_16->next)
	  	{
	  	 Tcl_DStringInit(&swotc_16);
	  	 { /* natural */
	  	  char outstr[32];

	  	  nat2str(iwotc_16->element,outstr);
	  	  Tcl_DStringAppend(&( swotc_16 ),outstr,-1);
	  	  comresult = TCL_OK;
	  	 }
	  	 if (comresult==TCL_OK)
	  		Tcl_DStringAppendElement(&( tclstr ),swotc_16.string);
	  	 else break; /* exit for */
	  	 Tcl_DStringFree(&swotc_16);
	  	}
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 ;
 while (data.result!=NULL)	/*dispose list*/
 	{
 	 void *tmp;
 	 ;
 	 tmp = (void *) data.result;
 	 data.result=data.result->next;
 	 free(tmp);
 	}
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_090 */

	/* Symbol Table of Tcl_rock_091 */
void *hash_rock_091;

	/* initialize hash_rock_091 */
void Init_hash_rock_091( void )
{
 hash_rock_091 = STableNew(211,1); /* create case sensitive hash */

 return;
}

/* data: rock readfifo DFIFO */
int Tcl_rock_091(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{
 rockt_t_readdfifo data;	/* data structure */
 int comresult;	/* Used by type conversion */
 int curarg;	/* current argument read */

 if ( (argc>=1) && (argc<=2) )
 	comresult = TCL_OK;
 else
 	{
 	 Tcl_SetResult(interp,"rock readfifo DFIFO: Invalid argument number.",TCL_VOLATILE);
 	 comresult = TCL_ERROR;
 	 return TCL_ERROR;
 	}

 /* initialise data */
 data.rid=NULL;
 data.size=0;
 data.size_present=0;
 data.result=NULL;
 data.errorstr=NULL;


 curarg = 0;	/* start with the first argument */

 /* params */
 if (comresult==TCL_OK) /* no indent */
 {
  { /* a simple type */
   int result;

   result = str2pointer(argv[curarg],&( data.rid ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[83];
   	 sprintf(errorstr,"rock readfifo DFIFO arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  curarg++;
 }

 /* optparam */
 if ((comresult==TCL_OK) &&
     ((argc&1)==0))	/* no indent */
 {
  { /* a simple type */
   int result;

   result = str2nat(argv[curarg],&( data.size ));
   if (result!=TLF_OK)
   	{
   	 char errorstr[83];
   	 sprintf(errorstr,"rock readfifo DFIFO arg %i: Invalid type.",curarg+1);
   	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
   	 comresult = TCL_ERROR;
   	}
   else
   	comresult = TCL_OK;
  }
  data.size_present = 1;
  curarg++;
 }

 if (comresult==TCL_OK) /* no indent */
 { /* call user function */
  int result;

  result = rockt_tl_readdfifo(&data);

  if (result !=TL_OK)
   if (data.errorstr!=NULL)
	{ /* error in user function */
	 char *errorstr;

	 errorstr = (char *) malloc(strlen(data.errorstr)+83);
	 sprintf(errorstr,"rock readfifo DFIFO: Func. error (%i) %s.",result,data.errorstr);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	 free(errorstr);
	}
   else /* no errorstr */
	{
	 char errorstr[83];

	 sprintf(errorstr,"rock readfifo DFIFO: Func. error (%i).",result);
	 Tcl_SetResult(interp,errorstr,TCL_VOLATILE);
	 comresult = TCL_ERROR;
	}
  else /* no error */
	{ /* convert data */
	 Tcl_DString tclstr;

	 Tcl_DStringInit(&tclstr);

	 { /* list */
	  Tcl_DString swotc_17;	/* internal type string */
	  _STR_natural *iwotc_17;

	  for (iwotc_17=data.result;
	       iwotc_17!=NULL;
	       iwotc_17=iwotc_17->next)
	  	{
	  	 Tcl_DStringInit(&swotc_17);
	  	 { /* natural */
	  	  char outstr[32];

	  	  nat2str(iwotc_17->element,outstr);
	  	  Tcl_DStringAppend(&( swotc_17 ),outstr,-1);
	  	  comresult = TCL_OK;
	  	 }
	  	 if (comresult==TCL_OK)
	  		Tcl_DStringAppendElement(&( tclstr ),swotc_17.string);
	  	 else break; /* exit for */
	  	 Tcl_DStringFree(&swotc_17);
	  	}
	 }

	 if (comresult==TCL_OK)
		Tcl_DStringResult(interp,&tclstr);	/* save result */
	 else
		Tcl_DStringFree(&tclstr);	/* error, free structure */
	}
 }

 /* dispose data */
 ;
 ;
 while (data.result!=NULL)	/*dispose list*/
 	{
 	 void *tmp;
 	 ;
 	 tmp = (void *) data.result;
 	 data.result=data.result->next;
 	 free(tmp);
 	}
 if (data.errorstr!=NULL)
	free(data.errorstr);

 return comresult;
} /* end Tcl_rock_091 */

int Tcl_rock_main(ClientData cdata, Tcl_Interp *interp, int argc, char *argv[])
{ /* skip first word */
 return Tcl_rock_0(cdata, interp, argc-1, &(argv[1]));
}

/* tcl interpreter for command rock */

int tl_rock_Tcl_Init(Tcl_Interp *interp)
{
 Tcl_CreateCommand(interp, "rock", Tcl_rock_main, NULL, NULL);
 Init_hash_rock_0();
 Init_hash_rock_set();

 return TCL_OK;
}