import jazz.circuit.*;
import jazz.circuit.Net.*;

// Décodeur d'instructions

device DECODEUR {
  public input
    instruction : Net[16];

  public output
    reg_ecriture : Net[4],
    reg_lecture1 :  Net[4],
    reg_lecture2 : Net[4],
    constante : Net[16],
    codop_alu : Net[3],
    codeshift : Net,
    coderetenue : Net,
    write_mem : Net,
    write_reg : Net,
    write_ovfl_egal : Net,
    test_mov1_alu0 : Net,
    cond_overfl : Net,
    cond_egal : Net,
    cond_tout : Net,
    freeze : Net,
    indiceio : Net[4],
    write_io : Net,
    in_cste : Net,
    cste_RAM : Net,
    cste : Net; //A enlever
;

  write_ovfl_egal=instruction[0];

  constante=instruction;

  reg_ecriture=gmux(4)(cste,ancien_reg_ecriture,instruction[8..11]);
  reg_lecture1=instruction[8..11];
  reg_lecture2=instruction[12..15];

  indiceio=instruction[12..15];

  test_mov1_alu0=~cste&instruction[2]&~instruction[0]&((~instruction[1]&instruction[3])|(instruction[1]&~instruction[3]));

  write_io=~cste&(instruction[0]&instruction[1]&~instruction[2]&instruction[3]&instruction[7]);

  freeze=~cste&(~instruction[0]&~instruction[1]&~instruction[2]&~instruction[3]&instruction[7]);

  write_mem=~cste&(~instruction[0]&~instruction[1]&instruction[2]&~instruction[3]);
  write_reg=cste|(~((~instruction[0]&~instruction[2]&~instruction[3])|(instruction[0]&instruction[3]&((~instruction[1]&instruction[2])|(instruction[1]&~instruction[2]&instruction[7])))));

  codeshift=instruction[0]&~instruction[1]&instruction[2]&~instruction[3]&~instruction[7];

  coderetenue=instruction[7];

  cond_overfl=instruction[5];
  cond_egal=instruction[4];

  cond_tout=cste|instruction[0]|~instruction[1]|~instruction[2]|instruction[3];

  codop_alu[0]=~instruction[1];
  codop_alu[1]=(instruction[1]&(instruction[6]^instruction[7]))|(~instruction[1]&~instruction[3]);
  codop_alu[2]=(instruction[1]&instruction[7])|(~instruction[1]&instruction[2]);

  cste=reg((~instruction[0]&instruction[1]&~instruction[2]&~instruction[3])&~cste);

  in_cste=cste|(instruction[0]&instruction[1]&~instruction[2]&instruction[3]);
  cste_RAM=cste|(~instruction[0]&~instruction[1]&~instruction[2]&instruction[3]);

  for (k<4)
  ancien_reg_ecriture[k]=reg(reg_ecriture[k]);

//  for (k<4) 
//    reg_ecriture[k] = enable ( reg (instruction[8+k]) , ~cste);

  
};

export DECODEUR();

fun gmux(m) (cond:Net,a:Net[m],b:Net[m]) = (s:Net[m])
{
  for (k<m)
  s[k]=mux(cond,a[k],b[k]);
}
;

// comment gere-t-on la conservation des bits d'egalite et d'ovf quand l'alu fait un tas d'operations bidons?


// indiceio=reg_lecture2 à simplifier

// autre proposition pour reg_ecriture

// attention pour cste: le registre d'ecriture est le premier et non le second comme indique dans l'assembleur initial

// dans les registres: qu'est controle_abs_activation_RI  ?