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

PROJECTO: EMULADOR DO GLiTCH

   Grupo de Engenharia de Computadores
   Departamento de Informática
   Universidade do Minho
   Braga - PORTUGAL

   Ficheiro: pblwrit2.c
   Linguagem: C
   Chip: Transputer
   Data de Inicio: 15/Abr/1992
   Data de Finalização: 29/Abr/1992
   Autor: João Miguel Lobo Fernandes

   Alteração: António J. A. Esteves
   Data Alteração: 17/Mar/1996

   Nota:
      Esta função contém parte dos "cases" da função PBLWRITE

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

#include "datadef.h"

/*################################################################*/
/*# Esta funcao escreve  determinados padroes na CAM e no subset #*/
/*# DEVOLVE: 1 (se nao executou um case)                         #*/
/*# DEVOLVE: 0 (se executou um case)                             #*/
/*################################################################*/
int parte1_pbl_write (void)
{
  int i, nao_executou_case=0;
  char c1, c2;

/*
iniciar pos1, patt1, pos2, patt2 e subset (5 param)
ZERO=01, UM=10, DCARE=11

+-------------------------------------+
| PE_SEL_1    PE_SEL_2    DATA_SELECT |
|   0 all       0 all       0 global  |
|   1 subset    1 tag       1 tag     |
|   2 notsub    2 carry     2 carry   |
|               3 nottag              |
|               4 notcy               |
+-------------------------------------+
*/
  switch (linhas)
  {

/******************************************************************/
    case   0: /* all all global*/
      for (i=0; i<8; i++)         /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]=cam[c1][1]=WORD_ZERO;
            break;
          case UM:
            cam[c1][0]=cam[c1][1]=WORD_UM;
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 000 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]=cam[c2][1]=WORD_ZERO;
            break;
          case UM:
            cam[c2][0]=cam[c2][1]=WORD_UM;
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 000 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)      /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]=sub[i][1]=WORD_ZERO;
            break;
          case UM:
            sub[i][0]=sub[i][1]=WORD_UM;
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 000 (padrao subset). \n");
            break;
        }
      }
      break;

/******************************************************************/
    case   1: /* all all tag */
      for (i=0; i<8; i++)         /* O 1.o padrao tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]=~tag[0];
            cam[c1][1]=~tag[1];
            break;
          case UM:
            cam[c1][0]=tag[0];
            cam[c1][1]=tag[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 001 (1o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)      /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]=~tag[0];
            sub[i][1]=~tag[1];
            break;
          case UM:
            sub[i][0]=tag[0];
            sub[i][1]=tag[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 001 (padrao subset). \n");
            break;
        }
      }
      break;

/******************************************************************/
    case   2: /* all all carry */
      for (i=0; i<8; i++)         /* O 1.o padrao tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]=~cy[0];
            cam[c1][1]=~cy[1];
            break;
          case UM:
            cam[c1][0]=cy[0];
            cam[c1][1]=cy[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 002 (1o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)      /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]=~cy[0];
            sub[i][1]=~cy[1];
            break;
          case UM:
            sub[i][0]=cy[0];
            sub[i][1]=cy[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 002 (padrao subset). \n");
            break;
        }
      }
      break;

/******************************************************************/
    case  10: /* all tag global*/
      for (i=0; i<8; i++)         /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=~tag[0];
            cam[c1][1]&=~tag[1];
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&~tag[0]) | tag[0];
            cam[c1][1]=(cam[c1][1]&~tag[1]) | tag[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 010 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=~tag[0];
            cam[c2][1]&=~tag[1];
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&~tag[0]) | tag[0];
            cam[c2][1]=(cam[c2][1]&~tag[1]) | tag[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 010 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)      /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]&=~tag[0];
            sub[i][1]&=~tag[1];
            break;
          case UM:
            sub[i][0]=(sub[i][0]&~tag[0]) | tag[0];
            sub[i][1]=(sub[i][1]&~tag[1]) | tag[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 010 (padrao subset). \n");
            break;
        }
      }
      break;

/******************************************************************/
    case  20: /* all carry global*/
      for (i=0; i<8; i++)         /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=~cy[0];
            cam[c1][1]&=~cy[1];
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&~cy[0]) | cy[0];
            cam[c1][1]=(cam[c1][1]&~cy[1]) | cy[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 010 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=(~cy[0]);
            cam[c2][1]&=(~cy[1]);
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&~cy[0]) | cy[0];
            cam[c2][1]=(cam[c2][1]&~cy[1]) | cy[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 020 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)       /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]=(sub[i][0]&~cy[0]);
            sub[i][1]=(sub[i][1]&~cy[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&~cy[0]) | cy[0];
            sub[i][1]=(sub[i][1]&~cy[1]) | cy[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 020 (padrao subset). \n");
            break;
        }
      }
      break;

/******************************************************************/
    case  30: /* all nottag global*/
      for (i=0; i<8; i++)         /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=tag[0];
            cam[c1][1]&=tag[1];
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&tag[0]) | ~tag[0];
            cam[c1][1]=(cam[c1][1]&tag[1]) | ~tag[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 030 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=tag[0];
            cam[c2][1]&=tag[1];
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&tag[0]) | ~tag[0];
            cam[c2][1]=(cam[c2][1]&tag[1]) | ~tag[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 030 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)       /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]&=tag[0];
            sub[i][1]&=tag[1];
            break;
          case UM:
            sub[i][0]=(sub[i][0]&tag[0]) | ~tag[0];
            sub[i][1]=(sub[i][1]&tag[1]) | ~tag[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 030 (padrao subset). \n");
            break;
        }
      }
      break;

/******************************************************************/
    case  40: /* all notcy global */
      for (i=0; i<8; i++)         /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=cy[0];
            cam[c1][1]&=cy[1];
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&cy[0]) | ~cy[0];
            cam[c1][1]=(cam[c1][1]&cy[1]) | ~cy[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 040 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=cy[0];
            cam[c2][1]&=cy[1];
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&cy[0]) | ~cy[0];
            cam[c2][1]=(cam[c2][1]&cy[1]) | ~cy[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 040 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)       /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]&=cy[0];
            sub[i][1]&=cy[1];
            break;
          case UM:
            sub[i][0]=(sub[i][0]&cy[0]) | ~cy[0];
            sub[i][1]=(sub[i][1]&cy[1]) | ~cy[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 040 (padrao subset). \n");
            break;
        }
      }
      break;

/******************************************************************/
    case 100: /* subset all global*/
      for (i=0; i<8; i++)         /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=~ms[0];
            cam[c1][1]&=~ms[1];
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&~ms[0]) | ms[0];
            cam[c1][1]=(cam[c1][1]&~ms[1]) | ms[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 100 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=~ms[0];
            cam[c2][1]&=~ms[1];
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&~ms[0]) | ms[0];
            cam[c2][1]=(cam[c2][1]&~ms[1]) | ms[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 100 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)       /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]&=~ms[0];
            sub[i][1]&=~ms[1];
            break;
          case UM:
            sub[i][0]=(sub[i][0]&~ms[0]) | ms[0];
            sub[i][1]=(sub[i][1]&~ms[1]) | ms[1];
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 100 (padrao subset). \n");
            break;
        }
      }

      break;

/******************************************************************/
    case 101: /* subset all tag */
      for (i=0; i<8; i++)         /* O 1.o padrao tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]=(cam[c1][0]&~ms[0]) | (~tag[0]&ms[0]);
            cam[c1][1]=(cam[c1][1]&~ms[1]) | (~tag[1]&ms[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&~ms[0]) | (tag[0]&ms[0]);
            cam[c1][1]=(cam[c1][1]&~ms[1]) | (tag[1]&ms[1]);
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 101 (1o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)       /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]=(sub[i][0]&~ms[0]) | (~tag[0]&ms[0]);
            sub[i][1]=(sub[i][1]&~ms[1]) | (~tag[1]&ms[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&~ms[0]) | (tag[0]&ms[0]);
            sub[i][1]=(sub[i][1]&~ms[1]) | (tag[1]&ms[1]);
          case DCARE:
            break;
          default:
            erro ("\nErro na funcao pbl_write() // caso 101 (padrao subset). \n");
            break;
        }
      }
      break;

/******************************************************************/
   default:
      nao_executou_case=1;
      break;
/******************************************************************/

   } /* fim do switch */

if(nao_executou_case==1)
    return(1);
else
    return(0);
}