Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » C/Visual C » intérprete(en que estoy mal en este código )

C/Visual C - intérprete(en que estoy mal en este código )

Volver
Nuevo Tema
<<>>
 
Vista:

intérprete(en que estoy mal en este código )

Publicado por Alma (2 intervenciones) el 24/09/2002 17:05:50
Me urge mejorar este código no he logrado estender bien el planteamiento y notengo mucho tiempo a qui va el problema a ver que opinan (si es posible prueben el código para ver que se le podría modificar)
INTERPRETE

El CPU ejecuta cada instrucción en una serie de pasaos que a grandes rasgos los pasos son:
1.- Buscar la siguiente instrucción de memoria y colocarla en el registro de instrucciones .
2.- Modificar el contador de programa, de modo que apunte a la siguiente. instrucción .
3.- Determinar el tipo de instrucción que se trajo.
4.- Si la instrucción utiliza una determinada instrucción de palabra determinar donde está.
5.- Buscar la palabra si es necesario y colocarla en un registro de la CPU.
6.-Ejecutar la instrucción.
7.-Volver al paso y comienza a a ejecutar la instrucción.
Esto es un ciclo de búsqueda_decodificación_ejecucion. Partiendo de esto es fácil armar
el pseudocódigo que tendríamos en C de la siguiente manera:

Interprete();
{
PC=dir_inicio_programa
while(haya_mas_instr && bit_ejecucion)
{
instr=memoria[PC];
PC=PC+1;
tipo_instr=obten_tipo_instr(instr );
pos_datos=encontrar_datos(inst,tipo_instr);
1*-1 si instr_no_requiere_datos+;
if(pos_datos>=0)
datos=memoria(pos_datos)
ejecutar
}
}
Para implementar el programa es necesario tener en cuenta lo siguiente:
Primero: tenemos una tabla donde al realizar la búsqueda podemos definir los datos.
PC instr tipo_instr pos_datos Datos
101 ADD 2 [X],[Y] X,Y
102 INC 1 [X] X
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Mejora del intérprete de instrucciones en C++

Publicado por Alejandro (913 intervenciones) el 24/03/2025 17:36:53
Para mejorar el código que has proporcionado y hacer que el intérprete funcione de manera más clara y eficiente, vamos a estructurarlo mejor y a implementar algunas mejoras. A continuación, te presento una versión mejorada del pseudocódigo que has compartido, seguido de una implementación en C++.

Pseudocódigo mejorado



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Interprete() {
    PC = dir_inicio_programa
    while (haya_mas_instr && bit_ejecucion) {
        instr = memoria[PC]; // Obtener la instrucción en la posición del contador de programa
        PC = PC + 1; // Incrementar el contador de programa
        tipo_instr = obtener_tipo_instr(instr); // Determinar el tipo de instrucción
        pos_datos = encontrar_datos(instr, tipo_instr); // Encontrar la posición de los datos
 
        if (pos_datos >= 0) {
            datos = memoria[pos_datos]; // Obtener los datos de memoria
        } else {
            datos = nullptr; // No se requieren datos
        }
 
        ejecutar(instr, datos); // Ejecutar la instrucción con los datos
    }
}

Implementación en C++



A continuación, te muestro una implementación básica en C++ que sigue el pseudocódigo mejorado. Esta implementación es un punto de partida y puede ser expandida según tus necesidades.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
 
using namespace std;
 
// Definición de la memoria y el contador de programa
vector<string> memoria = {
    "ADD [X], [Y]", // Instrucción en la dirección 101
    "INC [X]",      // Instrucción en la dirección 102
    // Otras instrucciones...
};
 
int PC = 0; // Contador de programa
bool bit_ejecucion = true; // Bandera de ejecución
 
// Función para obtener el tipo de instrucción
string obtener_tipo_instr(const string& instr) {
    if (instr.find("ADD") != string::npos) return "ADD";
    if (instr.find("INC") != string::npos) return "INC";
    return "UNKNOWN";
}
 
// Función para encontrar datos (simulación)
int encontrar_datos(const string& instr, const string& tipo_instr) {
    // Simulación de búsqueda de datos
    if (tipo_instr == "ADD") return 0; // Supongamos que los datos están en la posición 0
    if (tipo_instr == "INC") return 1; // Supongamos que los datos están en la posición 1
    return -1; // No se requieren datos
}
 
// Función para ejecutar la instrucción
void ejecutar(const string& instr, int pos_datos) {
    if (instr.find("ADD") != string::npos) {
        cout << "Ejecutando ADD con datos en posición: " << pos_datos << endl;
        // Lógica para la instrucción ADD
    } else if (instr.find("INC") != string::npos) {
        cout << "Ejecutando INC con datos en posición: " << pos_datos << endl;
        // Lógica para la instrucción INC
    } else {
        cout << "Instrucción desconocida: " << instr << endl;
    }
}
 
// Función principal del intérprete
void Interprete() {
    while (PC < memoria.size() && bit_ejecucion) {
        string instr = memoria[PC]; // Obtener la instrucción
        PC++; // Incrementar el contador de programa
        string tipo_instr = obtener_tipo_instr(instr); // Obtener el tipo de instrucción
        int pos_datos = encontrar_datos(instr, tipo_instr); // Encontrar datos
 
        // Ejecutar la instrucción
        ejecutar(instr, pos_datos);
    }
}
 
int main() {
    Interprete(); // Llamar al intérprete
    return 0;
}

Explicación de la implementación



1. Memoria: Se simula una memoria que contiene instrucciones. Puedes expandirla con más instrucciones según sea necesario.
2. Contador de programa (PC): Se inicializa en 0 y se incrementa después de cada instrucción.
3. Funciones:
- `obtener_tipo_instr`: Determina el tipo de instrucción a partir de la cadena.
- `encontrar_datos`: Simula la búsqueda de datos asociados a la instrucción.
- `ejecutar`: Ejecuta la instrucción y muestra un mensaje en la consola.
4. Ciclo principal: El ciclo `while` en `Interprete` continúa hasta que se hayan procesado todas las instrucciones o se detenga la ejecución.

Mejoras potenciales



- Manejo de errores: Agregar manejo de errores para instrucciones desconocidas o datos no encontrados.
- Soporte para más instrucciones: Expandir la lógica para soportar más tipos de instrucciones y operaciones.
- Ejecución real: Implementar la lógica real para cada instrucción en lugar de solo imprimir mensajes.

Esta implementación es un buen punto de partida y puedes expandirla según tus necesidades. ¡Buena suerte con tu proyecto, Alma!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar