/// <summary>Crea una instancia de la clase.</summary>
public PanelMemoria() : base(false, 0)
{
VBox vb = new VBox(false, 0);
Gtk.Table tabla = new Gtk.Table(MemoriaPrincipal.TAMANO, 5, true);
for (short i = 0; i < MemoriaPrincipal.TAMANO; i++)
{
direcciones[i] =
new Gtk.Label(Conversiones.ToHexString(i));
contenido[i] =
new Gtk.Label(Conversiones.ToHexString((short)0));
tabla.Attach(direcciones[i], 1, 2, (uint)i, (uint)i + 1);
tabla.Attach(contenido[i], 3, 4, (uint)i, (uint)i + 1);
}
vb.PackStart(tabla);
ScrolledWindow sw = new ScrolledWindow();
sw.AddWithViewport(vb);
Gtk.Table t2 = new Gtk.Table(4, 1, true);
t2.Attach(new Gtk.Label(Ventana.GetText("PMem_Contenido")),
0, 1, 0, 1);
t2.Attach(sw, 0, 1, 1, 3);
t2.Attach(new Gtk.Label(""), 0, 1, 3, 4);
this.PackStart(t2);
}
/// <summary>Se llama cuando cambia el contenido de un registro.
/// </summary>
/// <param name="registro">El registro que ha cambiado.</param>
/// <param name="newValue">El nuevo valor almacenado en
/// <c>registro</c>.</param>
public void RegisterChanged(int registro, short newValue)
{
if (registro != 3)
{
contenido[registro].Text =
Conversiones.ToHexString(newValue);
}
else
{
contenido[registro].Text =
Desensamblador.Desensamblar(newValue);
}
}
/// <summary>Activa los elementos activos durante el subciclo 3.
/// </summary>
/// <param name="mic">La microinstrucción en ejecución.</param>
/// <param name="vSH">El valor del registro SH.</param>
/// <param name="vMAR">El valor del registro MAR.</param>
/// <param name="vMBR">El valor del registro MBR.</param>
/// <param name="valorC">El valor de la salida C de la ALU.</param>
/// <param name="valorN">El valor de la salida N de la ALU.</param>
/// <param name="valorZ">El valor de la salida Z de la ALU.</param>
public void DibujarCiclo3
(MicroInstruccion mic, short vSH, short vMAR,
short vMBR, int valorC, int valorN, int valorZ)
{
PintarMicro(mic);
etiqueta_ciclos.SetText("Ciclo:" + instruccion + " Subciclo 3");
busA.Apagar();
busB.Apagar();
regs[mic.GetA()].Apagar();
regs[mic.GetB()].Apagar();
sh.Encender();
mbr.SetText("MBR " + Conversiones.ToHexString(vMBR));
mar.SetText("MAR " + Conversiones.ToHexString(vMAR));
sh.SetText("SH " + Conversiones.ToHexString(vSH));
et_s0.SetText("S2-S0 " +
Conversiones.ToBinaryString(mic.GetSH(), 3));
et_a0.SetText("A0 " +
Conversiones.ToBinaryString(mic.GetAMUX(), 1));
et_f0.SetText("F3-F0 " +
Conversiones.ToBinaryString(mic.GetALU(), 4));
et_c.SetText("C " + valorC);
et_n.SetText("N " + valorN);
et_z.SetText("Z " + valorZ);
if (mic.GetMAR() == 1)
{
//Activamos el cable que va de bufferB a MAR
mar.Encender();
cable_bufferB_mar.Encender();
}
if (mic.GetAMUX() == 1)
{
cable_mbr_mux.Encender();
mbr.Encender();
}
else
{
cable_bufferA_mux.Encender();
}
cable_bufferB_alu.Encender();
cable_alu_sh.Encender();
alu.Encender();
mux.Encender();
cable_mux_alu.Encender();
ActualizarTodo();
}
/// <summary>Se llama cuando cambia el contenido de un registro.
/// </summary>
/// <param name="registro">El registro que ha cambiado.</param>
/// <param name="newValue">El nuevo valor almacenado en
/// <c>registro</c>.</param>
public void RegisterChanged(int registro, short newValue)
{
regs[registro].SetText(
BancoRegistros.GetNombreRegistro(registro) + " " +
Conversiones.ToHexString(newValue));
if (registro == BancoRegistros.IR)
{
regs[registro].SetText(
BancoRegistros.GetNombreRegistro(registro) + " " +
Desensamblador.Desensamblar(newValue));
etiqueta_inst.SetText(
"Ejecutando:" + Desensamblador.Desensamblar(newValue));
}
}
/// <summary>Activa los elementos activos durante el subciclo 2.
/// </summary>
/// <param name="mic">La microinstrucción actualmente en ejecución.
/// Nos indica los registros de origen.</param>
/// <param name="regA">El contenido de BufferA.</param>
/// <param name="regB">El contenido de BufferB.</param>
public void DibujarCiclo2
(MicroInstruccion mic, short regA, short regB)
{
PintarMicro(mic);
etiqueta_ciclos.SetText("Ciclo:" + instruccion + " Subciclo 2");
busA.Encender(mic.GetA());
busB.Encender(mic.GetB());
regs[mic.GetA()].Encender();
regs[mic.GetB()].Encender();
bufferA.SetText("BufferA " + Conversiones.ToHexString(regA));
bufferB.SetText("BufferB " + Conversiones.ToHexString(regB));
bufferA.Encender();
bufferB.Encender();
ActualizarTodo();
}
/// <summary>Crea una instancia de la clase.</summary>
public PanelRegistros() : base(false, 0)
{
Gtk.Table tabla = new Gtk.Table(16, 5, true);
VBox vb = new VBox(false, 0);
for (int i = 0; i < 16; i++)
{
direcciones[i] =
new Gtk.Label(BancoRegistros.GetNombreRegistro(i));
contenido[i] =
new Gtk.Label(Conversiones.ToHexString((short)0));
tabla.Attach(direcciones[i], 1, 2, (uint)i, (uint)i + 1);
tabla.Attach(contenido[i], 3, 4, (uint)i, (uint)i + 1);
}
vb.PackStart(new Gtk.Label
(Ventana.GetText("PReg_Contenido")));
vb.PackStart(tabla);
vb.PackStart(new Gtk.Label(""));
this.PackStart(vb);
}
/// <summary>Activa los elementos activos durante el subciclo 4.
/// </summary>
/// <param name="mic">La microinstrucción en ejecución.</param>
/// <param name="vMBR">El valor del registro MBR.</param>S
public void DibujarCiclo4(MicroInstruccion mic, short vMBR)
{
PintarMicro(mic);
etiqueta_ciclos.SetText("Ciclo:" + instruccion + " Subciclo 4");
bufferA.Apagar();
bufferB.Apagar();
mar.Apagar();
mbr.Apagar();
mbr.SetText("MBR " + Conversiones.ToHexString(vMBR));
cable_bufferB_mar.Apagar();
cable_bufferB_alu.Apagar();
alu.Apagar();
mux.Apagar();
cable_bufferA_mux.Apagar();
cable_alu_sh.Apagar();
cable_mux_alu.Apagar();
cable_mbr_mux.Apagar();
//Escribir el dato de salida en la ALU.
//Activar los cables de salida necesarios.
if (mic.GetENC() == 1)
{
busC.Encender(mic.GetC());
regs[mic.GetC()].Encender();
}
if (mic.GetMBR() == 1)
{
//Activamos el cable que va de SH a MBR
cable_sh_mbr.Encender();
mbr.Encender();
}
if ((!(mic.GetENC() == 1)) && (!(mic.GetMBR() == 1)))
{
sh.Apagar();
}
else
{
cable_sh.Encender();
}
ActualizarTodo();
}
/// <summary>Ensambla el código y, si no hay errores, comienza
/// la simulación.</summary>
private void VentanaEjecutar()
{
//Compilamos
btnEjecutar.Sensitive = false;
itemEjecutar.Sensitive = false;
EnsambladorSimple2 e = new EnsambladorSimple2();
short[] ens = null;
try
{
ArrayList codigoLimpio =
e.PrimeraPasada(textoCodigo.Text);
ens = e.Ensamblar(codigoLimpio);
String res = "";
for (int i = 0; i < ens.Length; i++)
{
res += Conversiones.
ToHexString(ens[i]) + "(" +
(String)codigoLimpio[i] +
")\n";
}
textoResultado.Text = res;
textoErrores.Text = "";
String advert = e.GetAdvertencias();
if ((advert != "") &&
(Opciones.GetInstance().GetMostrarAdvertencias()))
{
textoErrores.Text += "\n" +
GetText("Ens_Advertencias") +
"\n\n" + e.GetAdvertencias();
}
}
catch (ErrorCodigoException ex)
{
textoErrores.Text = GetText("Ens_Errores") +
"\n" + ex.Message;
textoResultado.Text = "";
String advert = e.GetAdvertencias();
if ((advert != "") &&
(Opciones.GetInstance().GetMostrarAdvertencias()))
{
textoErrores.Text += " \n" +
GetText("Ens_Advertencias") + "\n\n" + advert;
}
btnEjecutar.Sensitive = true;
itemEjecutar.Sensitive = true;
PonerMensajeStatusbar(GetText("Ventana_Error_Ensamblar"));
notebook.Page = 0;
return;
}
//Si la compilación ha salido bien, entondes ejecutamos.
MemoriaControl mc = new MemoriaControl();
if (!Opciones.GetInstance().GetUsarMemoriaDefecto())
{
try
{
mc = MemoriaControl.CreateFromString(
Fichero.CargarTexto(
Opciones.GetInstance().GetMemoriaAlternativa()
)
);
}
catch (Exception)
{
//Hilo.Sleep(50);
}
}
SecuenciadorMicroprograma mic =
new SecuenciadorMicroprograma(ens, mc);
mic.AddMemoryChangeListener(panelMemoria);
mic.AddRegisterChangeListener(panelRegistros);
RepresentacionRDD repRDD = new RepresentacionRDD(dArea);
mic.SetRepresentacionRDD(repRDD);
mic.AddRegisterChangeListener(repRDD);
notebook.Page = 2;
//Hilo.Sleep (100);
PonerMensajeStatusbar(GetText("Ventana_Simulacion_Curso"));
hiloEjecucion = new HiloEjecucion(mic);
hiloEjecucion.SetTSubciclo(Opciones.GetInstance().GetTSubciclo());
hiloEjecucion.Start();
Hilo hiloespera = new HiloEspera();
hiloespera.Start();
}
/// <summary>Se llama cuando cambia una posición de la memoria.
/// </summary>
/// <param name="dir">La dirección que ha cambiado.</param>
/// <param name="newValue">El nuevo valor de la posición de
/// memoria <c>dir</c>.</param>
public void MemoryChanged(int dir, short newValue)
{
contenido[dir].Text = Conversiones.ToHexString(newValue);
}
public void TestInt()
{
Assert.AreEqual("00000000", Conversiones.ToHexString((int)0));
Assert.AreEqual("FFFFFFFF", Conversiones.ToHexString(unchecked ((int)0xFFFFFFFF)));
}