/*
	Ficheiro:     TESTE.C
	Data:         08-05-96
        Alterado por: A.Esteves

Implementa a funcao teste() e funcoes auxiliares a esta que visam
testar a correccao dos modulos que simulam a CAM+PE. Esta funcao,
permite analisar o estado do chip (cam e registos), gravar esse
estado num ficheiro e carrega'-lo de um ficheiro. Caso o simbolo
"DEBUG" seja definido no ficheiro DATA.H, e' feito o include deste
ficheiro por PE.C. Sao tambem geradas instrucoes que irao obrigar
a uma execucao passo a passo invocando a funcao teste() antes e
depois da execucao de cada instrucao.
*/

/* Legenda dos bits da cam: */
char *c1 ="\n\n\nPE³63     56      48      40      32       24  ";
char *c2 ="    16      8       0³Subs CTS 01";

int MostraCam()
{
  int  linha;                              /* int devido do scanf */
  UWORD mascara, bit;
  signed char bloco, i, j, go, aux, offset;

  linha=0;
 /******************************************************************/
 /* O codigo que se segue depende do tamanho da palavra           */
 /******************************************************************/
    bloco  = (char)(linha / PALAVRA) ;
                  /* Determinar em que bloco se situa esta linha  */
    offset = (char)(linha % PALAVRA) ;
                  /* Determinar qual o offset dentro do bloco     */

    go  = 1;      /* Flag alterada pelo utilizador                */
    aux = 0;      /* Contador de linhas enviadas para o ecran     */
    printf("%s%s", c1, c2); /* Imprimir cabecalho */
    while ((bloco < SIZE)&&(go)) /* CICLO WHILE */
    {
              /* Percorrer o bloco a partir de offset ate' ao fim */
      for (i=offset; i < PALAVRA; i++) /* CICLO FOR_I */
      {
	     /* Retirar do bloco o bit da linha que nos interessa */
		  mascara = 0x80000000;
		  mascara >>= i;
		  printf("%2d³",COLUNCAM-1-(bloco*PALAVRA+i));
                                       /* No do PE (linha da cam) */
     /* Percorrer a linha de cam, mostrando todas as suas colunas */

	 #ifdef T32
		  for (j=COLUNCAM-1; j >= 0; j--)
			 {
			 bit = (cam[j][bloco] & mascara);
			 if (bit)
				bit = 1;
			 printf("%d",bit);
			 if (j == 32)
            			printf(" ");
			 }
		  printf("³");

		  for (j=BITSSUBSET-1; j >= 0; j--)
			 {
			 bit = (sub[j][bloco] & mascara);
			 if (bit) bit = 1;
				printf("%d",bit);
			 }
		  printf(" ");
		  bit = (cy[bloco] & mascara);   /* Carry */
		  if (bit) bit = 1;
		  printf("%d",bit);
		  bit = (tag[bloco] & mascara);  /* Tag   */
        	  if (bit) bit = 1;
		  printf("%d",bit);
		  bit = (ms[bloco] & mascara);   /* Ms    */
		  if (bit) bit = 1;
		  printf("%d",bit);
		  printf(" ");
		  bit = (md0[bloco] & mascara);  /* Md0   */
		  if (bit) bit = 1;
		  printf("%d",bit);
		  bit = (md1[bloco] & mascara);  /* Md1   */
		  if (bit) bit = 1;
		  printf("%d",bit);
	 #endif

	 #ifdef T16
		  for (j=COLUNCAM-1; j >= 0; j--)
			 {
			 bit = (cam[j][bloco] & mascara);
			 if (bit)
				bit = 1;
			 printf("%d",bit);
			 if (j == 32)
                               printf(" ");
			 }
		  printf("³");

		  for (j=BITSSUBSET-1; j >= 0; j--)
			 {
			 bit = (sub[j][bloco] & mascara);
			 if (bit) bit = 1;
				printf("%d",bit);
			 }
		  printf(" ");
		  bit = (cy[bloco] & mascara);   /* Carry */
		  if (bit) bit = 1;
		  printf("%d",bit);
		  bit = (tag[bloco] & mascara);  /* Tag   */
                  if (bit) bit = 1;
		  printf("%d",bit);
		  bit = (ms[bloco] & mascara);   /* Ms    */
		  if (bit) bit = 1;
		  printf("%d",bit);
		  printf(" ");
		  bit = (md0[bloco] & mascara);  /* Md0   */
		  if (bit) bit = 1;
		  printf("%d",bit);
		  bit = (md1[bloco] & mascara);  /* Md1   */
		  if (bit) bit = 1;
		  printf("%d",bit);
	 #endif

	 #ifdef PC
		  for (j=COLUNCAM-1; j >= 0; j--)
			 {
			 bit = (cam[j][bloco] & mascara);
			 if (bit)
				bit = 1;
			 printf("%ld",bit);
			 if (j == 32)
                               printf(" ");
			 }
		  printf("³");

		  for (j=BITSSUBSET-1; j >= 0; j--)
			 {
			 bit = (sub[j][bloco] & mascara);
			 if (bit) bit = 1;
			 printf("%ld",bit);
			 }
		  printf(" ");
		  bit = (cy[bloco] & mascara);   /* Carry */
		  if (bit) bit = 1;
		  printf("%ld",bit);
		  bit = (tag[bloco] & mascara);  /* Tag   */
                  if (bit) bit = 1;
		  printf("%ld",bit);
		  bit = (ms[bloco] & mascara);   /* Ms    */
		  if (bit) bit = 1;
		  printf("%ld",bit);
		  printf(" ");
		  bit = (md0[bloco] & mascara);  /* Md0   */
		  if (bit) bit = 1;
		  printf("%ld",bit);
		  bit = (md1[bloco] & mascara);  /* Md1   */
		  if (bit) bit = 1;
		  printf("%ld",bit);
	 #endif

        aux++;
        if (aux == 8) printf("%s%s", c1, c2); /*Imprimir cabecalho*/
        if ((aux > 15)&&((bloco*PALAVRA+i+1) != 64))
          {
             aux=0;
             printf("... Prima 0 para Terminar ou outra tecla para continuar...\n");

             #ifdef T32
		if (getkey()=='0')
	     #endif
	     #ifdef T16
		if (getkey()=='0')
	     #endif
             #ifdef PC
		if (getch()=='0')
	     #endif
                 {
                 printf("\n\n\n\n\n");
                 return(0);
					  }
             printf("%s%s", c1, c2);      /* Imprimir cabecalho   */
          }

      } /* FIM DO CICLO FOR_I */

    bloco++;     /* Continuar a percorrer a cam no proximo bloco. */
    offset = 0;

    } /* FIM DO CICLO WHILE */

    if (go)
    {
      printf("\tPrima qualquer tecla para terminar.\n");
      #ifdef T32
        getkey();
      #endif
      #ifdef T16
        getkey();
      #endif
      #ifdef PC
        getch();
      #endif
    printf("\n\n\n\n\n\n");
    }
  return(0);
}

/*################################################################*/

void GravaChip()
{
  signed char bloco, i, j;
  char nome[20];
  int mascara, bit;
  FILE *fp;

    printf("\n\nGrava Chip:\n\tIntroduza o nome do ficheiro -> ");
    scanf("%s",nome);
    fp = fopen(nome,"w");
    if(!fp)
    {
      printf("\nERRO. Qualquer tecla para continuar.");
      #ifdef T32
         getkey();
      #endif
      #ifdef T16
         getkey();
      #endif
      #ifdef PC
        getch();
      #endif
      return;
    }
    bloco = 0;
    while (bloco < SIZE)
    {
      for (i=0; i < PALAVRA; i++)            /* Percorrer o bloco */
      {
        mascara = 1;
        mascara <<= 31;
             /* Retirar do bloco o bit da linha que nos interessa */
        mascara >>= i;
      /* Percorrer a linha de cam, gravando todas as suas colunas */
        for (j=COLUNCAM-1; j >= 0; j--)
          {
             bit = (cam[j][bloco] & mascara);
             if (bit) bit = 1;
             fputc( bit+'0', fp);
          }
          fputc(' ',fp);
          for (j=BITSSUBSET-1; j >= 0; j--)
          {
           bit = (sub[j][bloco] & mascara);
           if (bit) bit = 1;
           fputc(bit+'0', fp);
          }
	  fputc(' ', fp);                /* Espaco */
          bit = (cy[bloco] & mascara);   /* Carry  */
          if (bit) bit = 1;
          fputc(bit+'0',fp);
          bit = (tag[bloco] & mascara);  /* Tag    */
          if (bit) bit = 1;
          fputc(bit+'0',fp);
          bit = (ms[bloco] & mascara);   /* Ms     */
          if (bit) bit = 1;
          fputc(bit+'0',fp);
	  fputc(' ', fp);                /* Espaco */
          bit = (md0[bloco] & mascara);  /* Md0    */
          if (bit) bit = 1;
          fputc(bit+'0', fp);
          bit = (md1[bloco] & mascara);  /* Md1    */
          if (bit) bit = 1;
          fputc(bit+'0', fp);
          fputc(10, fp);           /* Carriage return + line feed */
      }
									         /* Continuar a percorrer a cam no proximo bloco. */
    bloco++;
    }
  fputc(26, fp);                                 /* Fin da file */
  fclose(fp);
}

/*################################################################*/

void LoadChip( fpstr )
char *fpstr;
{
  signed char bloco, i, j;
  int mascara, bit;
  char myprog[20];
  FILE *fp;

    if (!(*fpstr))
    {
      printf ("\nIntroduza o nome do ficheiro: ");
      scanf ("%s", myprog);
      strcat (myprog,".XIP");
    }
    else
      strcpy (myprog, fpstr);
    fp = fopen(myprog, "r");
    if(!fp)
    {
      printf("\nFicheiro %s:",myprog);
      printf("\nERRO. Qualquer tecla para continuar.");
      #ifdef T32
        getkey();
      #endif
      #ifdef T16
        getkey();
      #endif
      #ifdef PC
        getch();
      #endif
    return;
    }
    printf ("\nCarrega chip (%s)...", myprog);
    for (i=0; i < SIZE; i++)                   /* Pôr tudo a zero */
    {
      cy[i] = tag[i] = ms[i] = md0[i] = md1[i] = 0;
      for (j=0; j < COLUNCAM; j++)
        cam[j][i] = 0;
    }
    bloco = 0;
    while (bloco < SIZE)
    {
      /* Percorrer o bloco */
      for (i=0; i < PALAVRA; i++)
      {
        mascara = 1;
        mascara <<= 31;
                 /* Retirar do bloco o bit da linha que interessa */
        mascara >>= i;
         /* Percorrer a linha de cam, lendo todas as suas colunas */
        for (j=COLUNCAM-1; j >= 0; j--)
        {
          bit = getc(fp) - '0';
          if (bit)
            cam[j][bloco] = (cam[j][bloco] | mascara);
        }
        getc(fp);                                      /* Espaço */
        for (j=BITSSUBSET-1; j >= 0; j--)
        {
          bit = getc(fp) - '0';
          if (bit)
            sub[j][bloco] = (sub[j][bloco] | mascara);
        }
      getc(fp);                                         /* Espaço */
      bit = getc(fp) - '0';
      if (bit) cy[bloco] = (cy[bloco] | mascara);       /* Carry */
      bit = getc(fp) - '0';
      if (bit) tag[bloco] = (tag[bloco] | mascara);     /* Tag   */
      bit = getc(fp) - '0';
      if (bit) ms[bloco] = (ms[bloco] | mascara);       /* Ms    */
      getc(fp); /* Espaço */
      bit = getc(fp) - '0';
      if (bit) md0[bloco] = (md0[bloco] | mascara);      /* Md0   */
      bit = getc(fp) - '0';
      if (bit) md1[bloco] = (md1[bloco] | mascara);      /* Md1   */
      getc(fp);                    /* Carriage return + line feed */
      }
    bloco++;
                 /* Continuar a percorrer a cam no proximo bloco. */
    }
  fclose(fp);
  printf ("\r                                ");
}

/*################################################################*/

void MostraPblr ()
{
  int i=COLUNCAM-1;

  printf ("      63     56      48       40      32       24  ");
  printf ("    16       8       0");
  printf ("\nPBLR=");
  for (; i>=0; i--)
  {
    if (i%16==15) putchar (' ');
    putchar (pblr[i]);
  }
  putchar ('\n');
}

/*################################################################*/
int MenuDebug()
{
  char tecla;

  do
  {
    printf("\n----------------------------------------"\
           "---------------------------------------");
    printf("\n*** Instrucao que foi executada:\n%s",prev);
    printf("\n----------------------------------------"\
           "---------------------------------------\n");
    printf("*** Instrucao seguinte:\n%s\n",actual);
    printf("\n----------------------------------------"\
           "---------------------------------------");
    printf("\nOpcoes para Depuracao:\n");
    printf("   0 - Executar\n");
    printf("   1 - Visualizar conteudo da CAM, registos e flags\n");
    printf("   2 - Visualizar conteudo do PBLR\n");
    printf("   3 - Gravar chip em ficheiro\n");
    printf("   4 - Carregar chip de ficheiro\n");
    printf("   5 - Sair para o DOS\n");
    printf("\n... Seleccione Uma Opcao ...\n");

	 #ifdef T32
		tecla = getkey();
	 #endif
	 #ifdef T16
		tecla = getkey();
	 #endif
	 #ifdef PC
		tecla = getch();
	 #endif

	 tecla -= '0';
  } while ((tecla < 0) || (tecla > 5));

  if(tecla != 1)
	 printf("\n\n\n\n");
  printf("Seleccionou: %d\n",tecla);
  return((int)tecla);
}

/*################################################################*/

int teste(void)
{
  for (;;)
    switch( MenuDebug() )
    {
      case 1  : MostraCam();  break;
      case 2  : MostraPblr(); break;
      case 3  : GravaChip();  break;
      case 4  : LoadChip(""); break;
      case 5  : exit (0); break;
      default : return(0);
    }
}

/*################################################################*/