Exemple #1
0
 def setFunciones(self, strP, enteroP, floatP, boolP, enteroPT, floatPT,
                  pointerP):
     #crea memoria para la nueva funcion, modifica la memoria y la agrega al diccionario de funciones
     funcion = Memoria()
     funcion.setMemoria(int(strP), int(enteroP), int(floatP), int(boolP),
                        int(enteroPT), int(floatPT), int(pointerP))
     self.funciones[self.alcanceActual + 1] = funcion
Exemple #2
0
	def __init__(self):
			self.constante_entero = []
			self.constante_flotante = []
			self.constante_str = []
			self.apuntador = Pila()
			self.globales = Memoria()
			self.main = Memoria()
			self.alcanceActual = 0
			self.funciones = dict()
Exemple #3
0
 def __init__(self):
     self.constante_entero = []
     self.constante_flotante = []
     self.constante_str = []
     self.apuntador = Pila()
     self.globales = Memoria()
     self.main = Memoria()
     self.alcanceActual = 0
     self.funciones = dict()
    def __init__(self):

        self.programa = None
        self.memoria = Memoria()

        self.estrella = None
        self.screen = None
        self.turtle_activa = False

        self.pila_contextos = []
    def primer_mem(self):
        mem = Memoria()

        for tipo, cant in self.detalles.items():
            mem.llenarMemoria(tipo, cant)

        for index, const in self.constantes.items():
            mem.ponerValor(index, const)

        self.memorias.append(mem)
        self.memoriaActual = mem
    def __init__(self):
        print('\n\t\t\t🔵🔵🔵 Iniciando o Processo Gerenciador! 🔵🔵🔵\n')
        self.idProcesso = 0
        self.tempo = 0
        self.tempoCPU = 0
        self.estadoExec = 0
        self.CPU = CPU()
        self.estadoPronto = []
        self.estadoBloqueado = []
        self.tabelaProcesso = TabelaProcessos()

        self.memoriaPrimaria = Memoria(5)
        self.memoriaSecundaria = Memoria(0)
        self.memoriaVirtual = Memoria(0)

        self.tempoAlocNos = 0
        self.numAlocNos = 0
        self.alocFeitas = 0
        self.alocNegadas = 0

        # Definição da opção de escalonamento
        print('Como você gostaria que os processos fossem escalonados?')
        print('➡️  H - Escalonar por prioridade mais alta')
        print('➡️  X - Escalonar por número de instruções')

        while(True):
            self.modoDeEscalonamento = input('📌  Escolha uma opção: ').upper()
            if self.modoDeEscalonamento == 'H' or self.modoDeEscalonamento == 'X':
                break
            else:
                print('❌ Erro! Entrada inválida\n')
        print('\n')
        

        # Definição da opção de impressão
        print('Como você gostaria de imprimir o estado do sistema?')
        print('➡️  D - Impressão detalhada')
        print('➡️  S - Impressão simplificada')

        while(True):
            self.modoDeImpressao = input('📌  Escolha uma opção: ').upper()
            if self.modoDeImpressao == 'D' or self.modoDeImpressao == 'S':
                break
            else:
                print('❌ Erro! Entrada inválida\n')
        print('\n')

        self.criarProcessoSimulado(
            eProcessoInicial = True
        )
        print('🔵Gerenciador🔵 criou um 🟡Simulado🟡')
 def do_carrega(self, arg):
     """Carrega um arquivo trace"""
     trace = open(arg)
     self.total, self.virtual = map(int, trace.readline().split())
     self.memoria_fisica = Memoria(self.total, 'mem')
     self.memoria_virtual = Memoria(self.virtual, 'vir')
     for line in trace.readlines():
         info = match(r"(\d+) (\w+) (\d+) (\d+) (.+)", line)
         processo = dict(t0=int(info.group(1)), nome=info.group(2), tf=int(info.group(3)), b=int(info.group(4)),
                         posicao_tempo=[])
         for info in [match(r"(\d+) (\d+)", palavra) for palavra in findall(r"\d+ \d+", info.group(5))]:
             processo["posicao_tempo"].append([int(info.group(1)), int(info.group(2))])
         self.processos.append(processo)
     trace.close()
     self.gerenciador = Gerenciador(self.memoria_fisica, self.memoria_virtual)
    def __init__(self, info, player):
        self.nombre = info['name']
        self.posicion = info['position']
        self.game_name = info['game']['name']
        self.player = player

        # Inicializo los juegos dependiendo del objeto
        if self.game_name == 'Adivinanzas':
            self.game = Adivinanza(info['game'], player)
        elif self.game_name == 'sopa_letras':
            self.game = Sopita(info['game'], player)
        elif self.game_name == 'Preguntas sobre python':
            self.game = PreguntaPython(info['game'], player)
        elif self.game_name == 'ahorcado':
            self.game = Ahorcado(info['game'], player)
        elif self.game_name == 'Preguntas matemáticas':
            self.game = PregMate(info['game'], player)
        elif self.game_name == 'Criptograma':
            self.game = Criptograma(info['game'], player)
        elif self.game_name == 'Encuentra la lógica y resuelve':
            self.game = LogicaE(info['game'], player)
        elif self.game_name == 'Quizizz Cultura Unimetana':
            self.game = Quizizz(info['game'], player)
        elif self.game_name == 'memoria con emojis':
            self.game = Memoria(info['game'], player)
        elif self.game_name == 'Lógica Booleana':
            self.game = LogicaB(info['game'], player)
        elif self.game_name == 'Juego Libre':
            self.game = Pipes(info['game'], player)
        elif self.game_name == 'Palabra mezclada':
            self.game = PalabrasMezcladas(info['game'], player)
        elif self.game_name == 'escoge un número entre':
            self.game = EscogeNumero(info['game'], player)
Exemple #9
0
 def __init__(self, funcionGlobal="", funcionLocal=""):
     self.funcionGlobal = funcionGlobal
     self.funcionLocal = funcionLocal
     #Inicializa dir funcion
     self.dirFuncion = DirFuncion()
     #Inicializa cubo semantico
     self.cuboSemantico = CuboSemantico()
     #Inicializa memoria
     self.memoria = Memoria()
     #Variables temporales
     self.variablesTemp = []
     self.nombresParametros = []
     self.tiposParametros = []
     self.tiposArgumentos = []
     self.pilaOperandos = []
     self.pilaTipos = []
     self.pilaOperadores = []
     self.cuadruplos = []
     #Para los saltos tipo gotoF y gotoV
     self.saltos = []
     #Para los de regreso
     self.regresa = []
     #Empieza contador de cuadruplos
     self.numCuadruplo = 1
     #Sirve para ver si una funcion puede tener return o no
     self.tieneReturn = False
     #Sirve para crear el diccionario de arreglos
     self.arreglos = {}
     #Mete el arreglo para poder hacer su cuadruplo
     self.stackArreglos = []
 def ERA():
     # Crea un espacio en memoria donde guarda las variables locales y temporales de la funcion llamada
     funcionLlamada['funcion'] = self.dirFunciones.RegresaFuncion(
         dirOperandoIzquierdo)
     funcionLlamada['memoria'] = Memoria()
     self.parametroActual = 0
     self.MemoriaLocal(funcionLlamada)
     self.MemoriaTemporal(funcionLlamada)
     self.cantInstruccionesActuales += 1
def main():
    filaEntrada = inicilizarEntrada('entrada.txt')
    processosNovos = {'tempoReal': [], 'usuario': []}
    processosProntos = []
    processosProntosSuspenso = []
    processosBloqueados = []
    processosBloqueadosSuspenso = []  # Não ta sendo passado pra nenhuma função
    processosExecutando = []
    processosFinalizados = []

    so = SO()
    memoria = Memoria()
    gerenciaIO = GerenciaIO()

    totalProcessos = len(filaEntrada)

    while len(processosFinalizados) != totalProcessos:
        # Escalonador de longo prazo
        while len(filaEntrada) > 0 and filaEntrada[0].tempoChegada == so.tempoSistema:  # Isso vai dar certo?
            if filaEntrada[0].prioridade == 0:
                processosNovos['tempoReal'].append(filaEntrada.pop(0))
            else:
                processosNovos['usuario'].append(filaEntrada.pop(0))
        escalona_lp(so.gerenciadorIO, processosProntos, processosProntosSuspenso, processosBloqueados, processosBloqueadosSuspenso, processosNovos, memoria)

        # Escalonador de médio prazo (acho que não vai ser chamado explicitamente, só indiremantente pro swap)
        if (len(processosProntos) == 0 and len(processosProntosSuspenso) > 0) or (len(processosBloqueados) == 0 and len(processosBloqueadosSuspenso) > 0):
            escalonador_mp_ativa(gerenciaIO, processosProntos,processosProntosSuspenso,processosBloqueados, processosBloqueadosSuspenso, memoria)


        # Escalonador de curto prazo
        rodadaDeEscalonadorCurto(so.tempoSistema, memoria, so.gerenciadorIO, processosBloqueados, processosProntos,
                                                       processosExecutando, processosFinalizados, so.cpus)

        #moveBloqueadoParaExecutando(processosBloqueadosSuspenso,processosProntosSuspenso)
        # Espera um enter para entrar no próximo loop
        os.system('cls' if os.name == 'nt' else 'clear')
        so.imprimeSO()
        memoria.imprimeMemoria()
        imprimeFilas(processosProntos, processosProntosSuspenso, processosBloqueados, processosBloqueadosSuspenso, processosFinalizados)
        so.passagemDeTempo()

        input()
def simular(tanda, tamañoMemoria: int, estrategia, tiempoSelecion: int,
            tiempoCarga: int, tiempoLiberacion: int):
    # SIMULAR
    simular = True
    memoria = Memoria(tamañoMemoria)

    admin = AdminMemoria(memoria, estrategia, tiempoSelecion, tiempoCarga,
                         tiempoLiberacion)

    # Estadistica
    logs = []
    tandaOriginal = []
    indiceFragmantacion = 0
    countFragamntacion = True
    tiemposRetorno = []
    tiempoMedioRetorno = 0
    # Contador
    T = 0
    # Ordenar tanda por tiempo de Arribo
    procesos = sorted(tanda, key=lambda proceso: proceso.arribo)
    txtIntro = "######################################################" + '\n'
    logs.append(txtIntro)
    print(txtIntro)

    txtIntro = "#################   SIMULADOR  #######################" + '\n'
    logs.append(txtIntro)
    print(txtIntro)

    txtIntro = "#########   ADMINISTRADOR DE MEMORIA  ################" + '\n'
    logs.append(txtIntro)
    print(txtIntro)

    txtIntro = "######################################################" + '\n'
    logs.append(txtIntro)
    print(txtIntro)

    txtTandaT = ('TANDA DE TRABAJO' + '\n')
    logs.append(txtTandaT)
    print(txtTandaT)

    for proceso in procesos:
        logs.append(str(proceso))
        print(proceso)

        tandaOriginal.append(proceso)

    txt = 'INICIAR SIMULACION\nT: 0 --> Inicializar Memoria\n'
    logs.append(txt)
    print(txt)

    txt = imprimirMemoria(admin.memoria)
    logs.append(txt)
    print(txt)

    T += 1
    admin.tiempo()
    while (simular):

        if ((len(procesos) != 0) or (len(admin.memoria.particiones) > 1)):

            # LIBERACION (Mientras existan procesos a liberar)
            estado = admin.liberacion()
            while (estado['exito']):
                Tliberacion = T
                for i in range(tiempoLiberacion):
                    txt = ('T: ' + str(Tliberacion) +
                           ':   --> Trabajando... ' + ' MemLib.: ' +
                           str(admin.memoria.libre) + '\n')
                    logs.append(txt)
                    print(txt)
                    Tliberacion += 1
                    admin.tiempo()
                    if (countFragamntacion):
                        indiceFragmantacion += admin.memoria.libre

                # Resta al indice la memoria contada como libre
                # en el ultimo ciclo.
                if (countFragamntacion):
                    indiceFragmantacion -= estado['proceso'].tamaño

                T += tiempoLiberacion
                txt = ('--- LIBERACION COMPLETADA ---\n')
                logs.append(txt)
                print(txt)
                tiemposRetorno.append({
                    'proceso': estado['proceso'].nombre,
                    'arribo': estado['proceso'].arribo,
                    'tiempoRetorno': T - 1
                })
                admin.arribos = True  #Permite nuevos arrivos
                estado = admin.liberacion()
                txt = (imprimirMemoria(admin.memoria))
                logs.append(txt)
                print(txt)

            # SELECCION
            if (len(procesos) != 0):
                proceso = procesos[0]
                # Verifica que esten permitidos los arribos y sea el turno del proceso
                if ((admin.arribos) and (proceso.arribo <= T)):
                    Tseleccion = T
                    for i in range(tiempoSelecion):
                        txt = ('T: ' + str(Tseleccion) +
                               ':   --> SELECCIONANDO PARTICION AL PROCESO: ' +
                               str(proceso) + ' MemLib: ' +
                               str(admin.memoria.libre) + '\n')
                        logs.append(txt)
                        print(txt)
                        Tseleccion += 1
                        admin.tiempo()
                        if (countFragamntacion):
                            indiceFragmantacion += admin.memoria.libre

                    T += tiempoSelecion

                    # ASIGNACION
                    procesoAsig = Proceso(proceso.nombre, proceso.arribo,
                                          proceso.tiempoTotal + tiempoCarga,
                                          proceso.tamaño)
                    memoriaLibreAsignacion = admin.memoria.libre
                    if (admin.arriboProceso(procesoAsig)):
                        Tasignacion = T
                        for i in range(tiempoCarga):
                            txt = ('T: ' + str(Tasignacion) +
                                   ':   --> CARGANDO PROCESO: ' +
                                   str(proceso.nombre) + ' MemLib: ' +
                                   str(memoriaLibreAsignacion) + '\n')
                            logs.append(txt)
                            print(txt)
                            Tasignacion += 1
                            admin.tiempo()
                            # Verifica | Si no es el ultimo proceso en arribar cuanta IndFrag / Detiene la cuenta.
                            indiceFragmantacion += memoriaLibreAsignacion

                        T += tiempoCarga

                        txt = imprimirMemoria(admin.memoria)
                        logs.append(txt)
                        print(txt)
                        procesos.pop(0)
                        if (len(procesos) == 0):
                            countFragamntacion = False
                    else:
                        if (proceso.tamaño > admin.memoria.tamaño):
                            txt = ('T: ' + str(T) + ':   --> EL PROCESO: ' +
                                   str(proceso.nombre) +
                                   ' EXEDE EL TAMAÑO DE LA MEMORIA' + '\n')
                            logs.append(txt)
                            print(txt)
                            procesos.pop(0)

                else:
                    txt = ('T: ' + str(T) + ':   --> Sin Arribos\n')
                    logs.append(txt)
                    print(txt)
                    # TIEMPO
                    T += 1
                    admin.tiempo()
                    if (countFragamntacion):
                        indiceFragmantacion += admin.memoria.libre
            else:
                txt = ('T: ' + str(T) +
                       ':   --> Sin Arribos - Tanda Completada' + '\n')
                logs.append(txt)
                print(txt)
                # TIEMPO
                T += 1
                admin.tiempo()
                tetx = imprimirMemoria(admin.memoria)
                logs.append(txt)
                print(txt)

        else:
            simular = False

    txtFin = "######################################################" + '\n'
    logs.append(txtFin)
    print(txtFin)

    txtFin = "#################   RESULTADO  #######################" + '\n'
    logs.append(txtFin)
    print(txtFin)

    txtFin = "######################################################" + '\n'
    logs.append(txtFin)
    print(txtFin)

    txtEstrageia = ('ESTRATEGIA: ' + admin.estrategia + '\n')
    logs.append(txtEstrageia)
    print(txtEstrageia)

    txtFragmentacion = ('FRAGMENTACION EXTERNA: ' + str(indiceFragmantacion) +
                        '\n')
    logs.append(txtFragmentacion)
    print(txtFragmentacion)

    txtTiempoRetorno = ('TIEMPO DE RETORNO | PROCESOS | ' + '\n')
    logs.append(txtTiempoRetorno)
    print(txtTiempoRetorno)

    for dato in tiemposRetorno:
        tiempoRetorno = dato['tiempoRetorno'] - dato['arribo']
        txtTR = ('| ' + str(dato['proceso']) + ' |' + ' Arribo: ' +
                 str(dato['arribo']) + ' Retorno: ' +
                 str(dato['tiempoRetorno']) + ' Tiempo Retorno: ' +
                 str(tiempoRetorno) + '\n')
        logs.append(txtTR)
        print(txtTR)

        tiempoMedioRetorno += tiempoRetorno

    # len(tiemposRetorno) retorn la cantidad de procesos
    tMedioRetorno = 0
    try:
        tMedioRetorno = tiempoMedioRetorno / len(tiemposRetorno)
    except ZeroDivisionError:
        pass

    tiempoRetornoTanda = 0
    try:
        tiempoRetornoTanda = tiemposRetorno.pop()['tiempoRetorno']
    except IndexError:
        pass

    txtTiempoMedioRetorno = ('TIEMPO MEDIO DE RETORNO: ' + str(tMedioRetorno) +
                             '\n')
    logs.append(txtTiempoMedioRetorno)
    print(txtTiempoMedioRetorno)

    txtTiempoRetornoTanda = ('TIEMPO DE RETORNO DE LA TANDA: ' +
                             str(tiempoRetornoTanda) + '\n')
    logs.append(txtTiempoRetornoTanda)
    print(txtTiempoRetornoTanda)

    return logs
# -*- coding: utf-8 -*-

from memoria import Memoria
from processo import Processo
from disco import Disco
from menu import menu 

if __name__ == "__main__":
    menu()
    mem = Memoria()
    disco = Disco()
    processo = Processo(escrita=True)
    processo2 = Processo(escrita=True)
    processo3 = Processo(escrita=True)
    processo4 = Processo(escrita=False)
    
    mem.init_Mem()
    disco.init_Disco()
    
    if mem.mapear_processo(processo):
        print("[+] O processo 1 foi mapeado para a memória")
    
    if mem.mapear_processo(processo2):
        print("[+] O processo 2 foi mapeado para a memória")
    
    if mem.unmmap_processo(processo, disco):
         print("[+] O processo 1 foi desmapeado da memória")
    
    if mem.mapear_processo(processo3):
        print("[+] O processo 3 foi mapeado para a memória")
    
class Simulador(Cmd):

    def __init__(self):
        Cmd.__init__(self)
        self.prompt = '[Ep2]: '
        self.total = None
        self.virtual = None
        self.memoria_fisica = None
        self.memoria_virtual = None
        self.processos = []
        self.inicio = 0
        self.gerenciador = None
        self.semaforo = Semaphore(1)

    def espere(self, t):
        s = t - int(time() - self.inicio)
        if s > 0:
            sleep(s)

    def processe(self, i, processo):
        # O processo fica dormindo até a hora de começar
        self.espere(processo["t0"])
        # O processo faz a solicitação de memória
        # Só um processo pode chamar a função fit por vez, controle de concorrência da memória implementado
        self.semaforo.acquire()
        base, tamanho_alocado = self.gerenciador.fit(processo["nome"], processo["b"])
        self.memoria_virtual.escreve(base, bytearray([i] * tamanho_alocado))
        self.semaforo.release()
        print processo["nome"]

        # Faz o acesso a memória
        for p, t in processo["posicao_tempo"]:
            self.espere(t)
            self.semaforo.acquire()
            print "Faz acesso a posição %d(%d) escrevendo %d" % (p, self.gerenciador.traduz_endereco(p + base), i)
            # self.gerenciador.traduz_endereco retorna a primeira posição do quadro da memória física
            self.memoria_fisica.escreve(self.gerenciador.traduz_endereco(p + base), bytearray([i] * 16))
            self.semaforo.release()

        # Esperar até a hora que o processo finaliza
        self.espere(processo["tf"])
        self.semaforo.acquire()
        self.gerenciador.remova(processo["nome"])
        self.semaforo.release()
        print "Tchau processo %s" % processo["nome"]

    def do_carrega(self, arg):
        """Carrega um arquivo trace"""
        trace = open(arg)
        self.total, self.virtual = map(int, trace.readline().split())
        self.memoria_fisica = Memoria(self.total, 'mem')
        self.memoria_virtual = Memoria(self.virtual, 'vir')
        for line in trace.readlines():
            info = match(r"(\d+) (\w+) (\d+) (\d+) (.+)", line)
            processo = dict(t0=int(info.group(1)), nome=info.group(2), tf=int(info.group(3)), b=int(info.group(4)),
                            posicao_tempo=[])
            for info in [match(r"(\d+) (\d+)", palavra) for palavra in findall(r"\d+ \d+", info.group(5))]:
                processo["posicao_tempo"].append([int(info.group(1)), int(info.group(2))])
            self.processos.append(processo)
        trace.close()
        self.gerenciador = Gerenciador(self.memoria_fisica, self.memoria_virtual)

    def do_espaco(self, arg):
        self.gerenciador.faz_fit(arg)

    def do_substitui(self, arg):
        self.gerenciador.faz_substituicao(arg)

    def do_executa(self, arg):
        print "executando intervalo %s" % arg
        self.inicio = time()
        for i, processo in enumerate(self.processos):
            Thread(target=self.processe, args=(i, processo)).start()
        while active_count() > 1:
            relogio = int(time() - self.inicio + 1)
            for i in range(len(self.gerenciador.contador)):
                if self.gerenciador.r_m[i] & 2 == 2:  # só vai incrementar o contador da página i se r for 1
                    self.gerenciador.contador[i] += 1
            if relogio % int(arg):  # De tempos em tempos eu zero o bit de referencia
                for i in range(len(self.gerenciador.r_m)):
                    self.gerenciador.r_m[i] &= 1
            print('-----------------------------memória física------------------------')
            print ":".join("{:02x}".format(ord(c)) for c in self.memoria_fisica.le(0, self.total))
            print('-----------------------------memória virtual------------------------')
            print ":".join("{:02x}".format(ord(c)) for c in self.memoria_virtual.le(0, self.virtual))

            lista = self.gerenciador.registro_zero
            print 'nome do processo: %s\nposição inicial: %d\ntamanho: %d\n\n' % (
                lista.valor['processo'], lista.valor['posicao inicial'], lista.valor['tamanho'])
            lista = lista.proximo
            while lista != self.gerenciador.registro_zero:
                print 'nome do processo: %s\nposição inicial: %d\ntamanho: %d\n\n' % (
                    lista.valor['processo'], lista.valor['posicao inicial'], lista.valor['tamanho'])
                lista = lista.proximo
            print "Relógio: %d" % relogio
            sleep(1)

    def do_sai(self, arg):
        return True
    def __init__(self):
        self.program = None
        self.memoria = Memoria()

        self.pila_contextos = []
Exemple #16
0
from memoria import Memoria

LETRAS = set(ascii_uppercase)

parser = argparse.ArgumentParser()
parser.add_argument("unidades",
                    help="Unidades de memoria que tiene el sistema",
                    type=int,
                    nargs='?',
                    default=30)
args = parser.parse_args()

print('Simulación de asignación y liberación de procesos en memoria.')
print('Tamaño: %i unidades.' % args.unidades)
operacion = -1
mem = Memoria(args.unidades)
while not operacion == 2:
    print('\nEstado actual: \n\t', end='')
    mem.imprime_mem()
    operacion = int(
        input('Operación a realizar (0 : asignar, 1 : liberar, 2: salir): '))
    if (operacion == 0):
        lista_procesos = sorted(
            LETRAS -
            set(mem.procesosEnMemoria))  # Quitamos las letras que ya usamos
        proceso = lista_procesos[0]
        u_requeridas = int(input('Nuevo proceso (%s): ' % proceso))
        mem.asignar(proceso, u_requeridas)
    elif (operacion == 1):
        strpem = ''.join(
            mem.procesosEnMemoria)  # Cadena de procesos en memoria
class ProcessoGerenciador:

    def __init__(self):
        print('\n\t\t\t🔵🔵🔵 Iniciando o Processo Gerenciador! 🔵🔵🔵\n')
        self.idProcesso = 0
        self.tempo = 0
        self.tempoCPU = 0
        self.estadoExec = 0
        self.CPU = CPU()
        self.estadoPronto = []
        self.estadoBloqueado = []
        self.tabelaProcesso = TabelaProcessos()

        self.memoriaPrimaria = Memoria(5)
        self.memoriaSecundaria = Memoria(0)
        self.memoriaVirtual = Memoria(0)

        self.tempoAlocNos = 0
        self.numAlocNos = 0
        self.alocFeitas = 0
        self.alocNegadas = 0

        # Definição da opção de escalonamento
        print('Como você gostaria que os processos fossem escalonados?')
        print('➡️  H - Escalonar por prioridade mais alta')
        print('➡️  X - Escalonar por número de instruções')

        while(True):
            self.modoDeEscalonamento = input('📌  Escolha uma opção: ').upper()
            if self.modoDeEscalonamento == 'H' or self.modoDeEscalonamento == 'X':
                break
            else:
                print('❌ Erro! Entrada inválida\n')
        print('\n')
        

        # Definição da opção de impressão
        print('Como você gostaria de imprimir o estado do sistema?')
        print('➡️  D - Impressão detalhada')
        print('➡️  S - Impressão simplificada')

        while(True):
            self.modoDeImpressao = input('📌  Escolha uma opção: ').upper()
            if self.modoDeImpressao == 'D' or self.modoDeImpressao == 'S':
                break
            else:
                print('❌ Erro! Entrada inválida\n')
        print('\n')

        self.criarProcessoSimulado(
            eProcessoInicial = True
        )
        print('🔵Gerenciador🔵 criou um 🟡Simulado🟡')


    # * Método relacionado aos comandos recebidos do processo controle através do pipe
    def recebeComandoDoControle(self, comandoRecebido):
        # Comando U: Fim de uma unidade de tempo. O tempo passa quando o U é recebido.
        if(comandoRecebido == 'U'):
            self.executarProcessoSimulado()
            self.tempo+=1
            print('\n⏰ O tempo foi incrementado. Tempo Atual: ' + str(self.tempo))
            print('\n'+('-'*84))

        # Comando L: Desbloqueia o primeiro processo simulado na fila bloqueada.
        elif(comandoRecebido == 'L'): 
            idProcesso = self.processoBloqueadoParaPronto()
            variaveisDoProcesso = self.memoriaSecundaria.removerProcesso(idProcesso)

            inicio = time.time()
            memoriaTemEspaco = self.memoriaPrimaria.algoritmoWorstFit(variaveisDoProcesso)
            fim = time.time()

            self.tempoAlocNos+= (fim - inicio)
            self.numAlocNos+=1

            if(not memoriaTemEspaco):
                self.memoriaPrimaria.inserirSecundariaVect(variaveisDoProcesso)
            print('🔵Gerenciador🔵 desbloqueou o primeiro processo da fila de bloqueados\n')

        # Comando I: Imprime o estado atual do sistema.
        elif(comandoRecebido == 'I'):
            print('🔵Gerenciador🔵 irá criar o 🟢Impressão🟢\n')

            # Pipe -> r para leitura e w para escrita
            rpipe, wpipe = os.pipe()
            idProcesso = os.fork()

            # Processo pai: Processo Gerenciador
            if idProcesso != 0:
                os.write(wpipe, self.modoDeImpressao.encode())
                os.wait() # Espera pelo processo filho

            # Processo filho: Processo Impressão
            if idProcesso == 0:
                self.modoDeImpressao = os.read(rpipe, 32)
                self.modoDeImpressao = self.modoDeImpressao.decode()

                processoImpressao = ProcessoImpressao()

                if(self.modoDeImpressao == 'D'):
                    processoImpressao.impressaoDetalhada(self.tabelaProcesso)
                elif(self.modoDeImpressao == 'S'):
                    processoImpressao.impressaoSimplificada(self.tabelaProcesso)

                print('\n📗 Memória Primária ', end='')
                self.memoriaPrimaria.imprimeMemoria()

                print('📗 Memória Virtual: ', end='')
                self.memoriaPrimaria.imprimeMemoriaVirtual()

                print('📗 Memória Secundária: ', end='')
                self.memoriaSecundaria.imprimeTodaMemoria()

                print('📊 Parâmetros de Desempenho:')
                self.imprimeResultadosMemoria()
                
                print('\n\t\t\t🟢🟢🟢 Finalizando o Processo Impressão! 🟢🟢🟢\n')
                print(('-'*84))
                exit()

        # Comando M: Imprime o tempo médio do ciclo e finaliza o sistema.
        elif(comandoRecebido == 'M'):
            # tempo médio = (soma do tempo de cpu de todos os processos não finalizados) / (todos os processos)
            tempoMedio = float(self.tempoCPU/self.idProcesso)
            print('⏰ Tempo de CPU: %.4f' % (self.tempoCPU))
            print('⏰ Numero total de processos: %d' % (self.idProcesso))
            print('⏰ Tempo Médio do Ciclo: %.4f' % (tempoMedio))
            print('\n👋 Encerrando Sistema!')
            print('\n\t\t\t🔵🔵🔵 Finalizando o Processo Gerenciador! 🔵🔵🔵\n')
            exit()


    # * Funções do Processo Gerenciador:
    # * Função 1: Criar um novo processo simulado
    def criarProcessoSimulado(self, eProcessoInicial, contadorAtual=0):
        if eProcessoInicial:
            self.processoSimulado = ProcessoSimulado(
                idProcesso = self.idProcesso, 
                contadorPrograma = 0,
                tempoInicio = 0
            )
            arquivo = open('init.txt', 'r') # Processo simulado inicial
            for instrucao in arquivo:
                self.processoSimulado.adicionarInstrucao(instrucao.replace("\n",""))
            arquivo.close()

            self.tabelaProcesso.adicionarProcesso(self.processoSimulado)
            self.inserirNaListaDeProntos(self.processoSimulado)
        else:
            processoSimulado = ProcessoSimulado(
                idProcesso = self.idProcesso, 
                contadorPrograma = contadorAtual,
                tempoInicio = self.tempo, 
                idPai = self.processoSimulado.idProcesso, 
                estado = 1, # Pronto
                prioridade = self.processoSimulado.prioridade
            )
            variaveisPai = deepcopy(self.memoriaPrimaria.buscarVariavelDoProcesso(self.processoSimulado.idProcesso))

            for i in variaveisPai:
                self.alocFeitas+=1
                i.idProcesso = processoSimulado.idProcesso

            inicio = time.time()
            resultadoInsercao = self.memoriaPrimaria.algoritmoWorstFit(variaveisPai)
            fim = time.time()

            self.tempoAlocNos+= (fim - inicio)
            self.numAlocNos+=1

            if not resultadoInsercao:
                #self.alocNegadas+= len(variaveisPai)
                self.memoriaPrimaria.inserirSecundariaVect(variaveisPai)

            processoSimulado.instrucoes = self.processoSimulado.instrucoes.copy()
            self.tabelaProcesso.adicionarProcesso(processoSimulado)
            self.inserirNaListaDeProntos(processoSimulado)

        self.idProcesso += 1


    # * Função 2: Substituir a imagem atual de um processo simualdo por uma nova imagem
    def substituirImagemProcessoAtual(self, arquivo, processoSimulado):
        processoSimulado.contadorPrograma = 0
        processoSimulado.instrucoes = []
        #processoSimulado.variaveis = {}

        self.memoriaPrimaria.removerProcesso(processoSimulado.idProcesso)
        self.memoriaSecundaria.removerProcesso(processoSimulado.idProcesso)

        with open(arquivo) as file:
            for line in file:
                processoSimulado.adicionarInstrucao(line.replace("\n",""))


    # * Função 3: Gerenciar a transição de estados do processo
    def inserirNaListaDeProntos(self, processoSimulado):
        processoSimulado.estado = 1
        if processoSimulado.idProcesso in self.estadoPronto:
            self.estadoPronto.append(processoSimulado.idProcesso)

    def processoBloqueadoParaPronto(self):
        if len(self.estadoBloqueado) > 0:
            idProcesso = self.estadoBloqueado.pop(0)
            self.estadoPronto.append(idProcesso)
            self.tabelaProcesso.atualizarEstadoProcessoPorIndice(
                idProcesso = idProcesso,
                estado = 1 # Pronto
            )
            return idProcesso

    def processoProntoParaBloqueado(self, processoSimulado):
        if len(self.estadoPronto) > 0:
            self.estadoBloqueado.insert(self.estadoPronto.pop(0))
            processoSimulado.estado = 0


    # * Função 4: Escalonar os processos
    def escalonadorDeProcessos(self):
        if(self.modoDeEscalonamento == 'H'):
            self.estadoPronto = self.tabelaProcesso.ordenarProcessosProntos()
        elif(self.modoDeEscalonamento == 'X'):
            self.estadoPronto = self.tabelaProcesso.ordenarNumeroInstrucoes()

        if self.estadoPronto == []:
            self.processoSimulado = None
        else:
            print('✴️  Escalonamento realizado. Proximo processo: %d' % self.estadoPronto[0])
            self.processoSimulado = self.tabelaProcesso.buscarProcesso(self.estadoPronto[0])
            self.CPU.quantumUsado = 0
            self.trocaDeContexto(self.processoSimulado)


    # * Função 5: Realizar a troca de contexto
    def trocaDeContexto(self, processoSimulado):
        self.tabelaProcesso.defineProcessoEmExecucao(processoSimulado)


    # * Método relacionado a execução do processo simulado
    def executarProcessoSimulado(self):
        if self.processoSimulado == None and len(self.estadoPronto) > 0:
            self.escalonadorDeProcessos()

        if self.processoSimulado != None:
            self.CPU.executarProcesso(self.processoSimulado)
            self.processoSimulado = self.CPU.processoEmExecucao
            print('\n🟡 Executando o processo de ID: ' + str(self.processoSimulado.idProcesso))
            if self.processoSimulado.instrucoes != []:
                self.processoSimulado.estado = 2 # Em execução

                print('📑 Instruções do processo atual: ', end='')
                for i in self.processoSimulado.instrucoes:
                    print (i, end='; ')

                instrucao = self.processoSimulado.instrucoes.pop(0)
                print('\n📑 Instrução que será executada: '+ instrucao + ';')

                instrucaoDividida = instrucao.split()
                comando = instrucaoDividida[0]

                # ​1. Comando N: número de variáveis que serão declaradas neste processo simulado
                if comando == 'N':
                    numDeVariveis = int(instrucaoDividida[1])
                    self.alocFeitas+= numDeVariveis
                    variaveisDoProcesso = []
                    for i in range(numDeVariveis):
                        variavel = VariavelProcesso(self.processoSimulado.idProcesso)
                        variaveisDoProcesso.append(variavel)

                    inicio = time.time()
                    memoriaTemEspaco = self.memoriaPrimaria.algoritmoWorstFit(variaveisDoProcesso)
                    fim = time.time()

                    self.tempoAlocNos+= (fim - inicio)
                    self.numAlocNos+=1

                    if(not memoriaTemEspaco):
                        self.memoriaPrimaria.inserirSecundariaVect(variaveisDoProcesso)

                # 2. Comando D: Declara uma variável inteira X, valor inicial igual a 0
                elif comando == 'D':
                    nomeVar = int(instrucaoDividida[1])
                    variavel = self.memoriaPrimaria.preencherVariavel(self.processoSimulado.idProcesso,nomeVar,0)

                # 3. Comando V: Define o valor da variável inteira x
                elif comando == 'V':
                    nome = int(instrucaoDividida[1]) 
                    valor = int(instrucaoDividida[2])
                    variavel = self.memoriaPrimaria.mudarValor(self.processoSimulado.idProcesso,nome,valor)

                # 4. Comando A: Adiciona n ao valor da variável inteira x
                elif comando == 'A':
                    indice = int(instrucaoDividida[1]) 
                    valor = int(instrucaoDividida[2])
                    variavel = self.memoriaPrimaria.buscaVariavelIndice(self.processoSimulado.idProcesso,indice)
                    self.CPU.somaValor(variavel,valor)

                # 5. Comando S: Subtrai n do valor da variável inteira x
                elif comando == 'S':
                    indice = int(instrucaoDividida[1]) 
                    valor = int(instrucaoDividida[2])
                    variavel = self.memoriaPrimaria.buscaVariavelIndice(self.processoSimulado.idProcesso,indice)
                    self.CPU.somaValor(variavel,-valor)

                # 6. Comando B: Bloqueia esse processo simulado
                elif comando == 'B':
                    varPrimarias = self.memoriaPrimaria.removerProcesso(self.processoSimulado.idProcesso)
                    self.memoriaSecundaria.inserirSecundariaVect(varPrimarias)
                    self.processoSimulado.estado = 0 # Bloqueado
                    self.estadoBloqueado.append(self.processoSimulado.idProcesso)
                    self.estadoPronto.remove(self.processoSimulado.idProcesso)

                # 7. Comando T: Termina o processo simulado
                elif comando == 'T':
                    self.memoriaPrimaria.removerProcesso(self.processoSimulado.idProcesso)
                    self.estadoPronto.remove(self.processoSimulado.idProcesso)
                    self.tabelaProcesso.removerProcesso(self.processoSimulado)
                    self.processoSimulado = None

                # 8. Comando F: Cria um novo processo simulado filho
                elif comando == 'F':
                    self.criarProcessoSimulado(
                        eProcessoInicial = False,
                        contadorAtual = int(instrucaoDividida[1]),
                    )

                # 9.​ Comando R: Substitui o programa do processo pelo programa no arquivo
                elif comando == 'R':
                    self.substituirImagemProcessoAtual(str(instrucaoDividida[1]), self.processoSimulado)

            self.tempoCPU += 1

            if comando != 'T':
                self.processoSimulado.tempoCPU += 1
                self.tabelaProcesso.atualizarProcesso(self.processoSimulado)

                if self.processoSimulado.instrucoes == []:
                    # As instruções do processo foram concluídas, remover o processo
                    self.estadoPronto.remove(self.processoSimulado.idProcesso)
                    self.tabelaProcesso.removerProcesso(self.processoSimulado)
                    self.processoSimulado = None
                    self.memoriaPrimaria.removerProcesso(self.processoSimulado.idProcesso)
                    self.passarSecundariaParaPrimaria()

                if self.CPU.passarQuantum() and self.processoSimulado.instrucoes != []:
                    # Processo gastou o quantum disponível
                    self.processoSimulado.incrementarPrioridade()
                    self.tabelaProcesso.atualizarProcesso(self.processoSimulado)
                    self.escalonadorDeProcessos()

                if comando == 'B':
                    self.tabelaProcesso.atualizarProcesso(self.processoSimulado)
                    self.escalonadorDeProcessos()


    # * Método que imprime o estado da memória
    def imprimeResultadosMemoria(self):
        # O percentual de vezes que uma requisição de alocação é negada. Neste caso o processo
        print("🔅 Percentual de vezes que uma requisição foi negada: %.2f" % float(100*(self.alocNegadas/self.alocFeitas)))
        
        # Tempo médio de alocação em termos de número médio de nós percorridos na alocação;
        print("🔅 Tempo Médio de Alocação: "+str(self.tempoAlocNos/self.numAlocNos))
        
        # Número médio de fragmentos externos. Fragmentação externa é quando um espaço de memória
        # que possui espaço para alocar um processo é ignorado, e um outro é utilizado deixando um
        # espaço vago entre os processos na memoria. Exemplo: [x,x,w,0,z,z,a,a]
        print("🔅 Numero de Fragmentos Externos na Memoria Primaria: "+str(self.memoriaPrimaria.numFrag))


    # * Método que passa da memória secundária para a memória primária
    def passarSecundariaParaPrimaria(self):
        if len(self.memoriaSecundaria) != 0:
            variaveis = self.memoriaSecundaria.removerProcesso(self.memoriaSecundaria.primeiroProcessoSec())
            inicio = time.time()
            resultadoInsercao = self.memoriaPrimaria.algoritmoWorstFit(variaveis)
            fim = time.time()
            self.tempoAlocNos+= (fim - inicio)
            self.numAlocNos+=1

            if not resultadoInsercao:
                self.alocNegadas+= len(variaveis)
                self.memoriaSecundaria.inserirSecundariaVect(variaveis)
from stack import Stack
from memoria import Memoria
import sys
import six

#Inicializacion de directorio de funciones, los cuadruplos a leer
dir_func = {}
dir_quadruples = {}

#Stack para saber desde donde se llama una funcion y de los niveles de memoria.
llamadas = Stack()
memorias = Stack()

#Memoria global
memoria_global = Memoria()

#Stack usada para manejo de funciones
this_func = Stack()
param_stack = Stack()

#memory ranges
#global 0 - 9999
top_limit_global = 10000
#local 10000- 19999
top_limit_local = 20000
#constants 20000- 29999
top_limit_cte = 30000

#pointers 30000-+++

Exemple #19
0
class AdminMemoria:

	def __init__(self):
			self.constante_entero = []
			self.constante_flotante = []
			self.constante_str = []
			self.apuntador = Pila()
			self.globales = Memoria()
			self.main = Memoria()
			self.alcanceActual = 0
			self.funciones = dict()
		
	def constTamano(self, sizeE, sizeF, sizeS):
	#modifica la memoria necesaria por las constantes
			self.constante_entero = [0] * sizeE
			self.constante_flotante = [0.0] * sizeF
			self.constante_str = [0] * sizeS
		
	def setMemoriaPrinc(self, strP, enteroP, floatP, boolP, enteroPT, floatPT, pointerP):
	#modifica la memoria del main
			self.main.setMemoria(int(strP), int(enteroP), int(floatP), int(boolP), int(enteroPT), int(floatPT), int(pointerP))
		
	def setMemoriaGlobales(self, strP, enteroP, floatP, boolP, enteroPT, floatPT, pointerP):
	#modifica la memoria de las globales
			self.globales.setMemoria(int(strP), int(enteroP), int(floatP), int(boolP), int(enteroPT), int(floatPT), int(pointerP))
		
	def setFunciones(self, strP, enteroP, floatP, boolP, enteroPT, floatPT, pointerP):
	#crea memoria para la nueva funcion, modifica la memoria y la agrega al diccionario de funciones
			funcion = Memoria()
			funcion.setMemoria(int(strP), int(enteroP), int(floatP), int(boolP), int(enteroPT), int(floatPT), int(pointerP))
			self.funciones[self.alcanceActual+1] = funcion
		
	def cambiaAlcance(self):
	#cambia el alcance actual al siguiente
			self.alcanceActual += 1
		
	def borrar_funcion(self):
	#destruye la memoria asignada para la funcion y regresa al alcance anterior
			self.funciones[self.alcanceActual].dejarMemoria()
			del self.funciones[self.alcanceActual]
			self.alcanceActual -= 1
		
	def escribeValor(self, dirV, valor):
	#escribe el valor de la direccion dada, si la direccion es un apuntador primero recupera la direccion real
			if dirV[1] == '7':
				dirV = int(dirV)
				if((dirV-10000) < 10000):
				#valores globales
					dirV = self.globales.leerValor(dirV-10000)
				elif((dirV-20000) < 10000):
				#valores del main
					dirV = self.main.leerValor(dirV-20000)
				elif((dirV-30000) < 10000):
				#valores de funciones
					dirV = self.funciones[self.alcanceActual].leerValor(dirV-30000)
				dirV = str(dirV)
			dirV = int(dirV)
		#imprime la direccion, dirV
			if((dirV-10000) < 10000):
			#valores globales
				dirV = dirV-10000
				self.globales.escribeValor(dirV, valor)
				return
			if((dirV-20000) < 10000):
			#valores del main
				dirV = dirV-20000
				self.main.escribeValor(dirV, valor)
				return
			if((dirV-30000) < 10000):
			#valores de funciones
				dirV = dirV-30000
				self.funciones[self.alcanceActual].escribeValor(dirV, valor)
				return
			if((dirV-40000) < 10000):
			#constantes
				dirV = dirV-40000
				if(dirV < 1000):
					self.constante_entero[dirV] = int(valor)
				elif(dirV < 2000):
					self.constante_flotante[dirV-1000] = float(valor)
				else:
					self.constante_str[dirV-2000] = str(valor)
				return
			
	def escribeValorS(self, dirV, valor):
	#escribe valores que solo son usados como por patamentros 
			if dirV[1] == '7':
				dirV = int(dirV)
				if((dirV-10000) < 10000):
				#valores globales
					dirV = self.globales.leerValor(dirV-10000)
				elif((dirV-20000) < 10000):
				#valores del main
					dirV = self.main.leerValor(dirV-20000)
				elif((dirV-30000) < 10000):
				#valores de funciones
					dirV = self.funciones[self.alcanceActual+1].leerValor(dirV-30000)
				dirV = str(dirV)
			dirV = int(dirV)
		#imprime la direccion, dirV
			if((dirV-10000) < 10000):
			#valores globales
				dirV = dirV-10000
				self.globales.escribeValor(dirV, valor)
				return
			if((dirV-20000) < 10000):
			#valores del main
				dirV = dirV-20000
				self.main.escribeValor(dirV, valor)
				return
			if((dirV-30000) < 10000):
			#valores de funciones
				dirV = dirV-30000
				self.funciones[self.alcanceActual+1].escribeValor(dirV, valor)
				return
		
	def getValor(self, dirV):
	#recupera el valor de la direccion dada, en caso de que sea un apuntador primero obtiene la direccion real
			if dirV[1] == '7':
		# si la diereccion es un apuntador se recuperar la direccion actual
				dirV = int(dirV)
				if((dirV-10000) < 10000):
				#valores globales
					dirV = self.globales.leerValor(dirV-10000)
				elif((dirV-20000) < 10000):
				#valores del main
					dirV = self.main.leerValor(dirV-20000)
				elif((dirV-30000) < 10000):
				#valores de funciones
					dirV = self.funciones[self.alcanceActual].leerValor(dirV-30000)
				dirV = str(dirV)
			dirV = int(dirV)
		#imprime la direccion, dirV
			if((dirV-10000) < 10000):
			#valores globales
				dirV = dirV-10000
				return self.globales.leerValor(dirV)
			if((dirV-20000) < 10000):
			#valores del main
				dirV = dirV-20000
				return self.main.leerValor(dirV)
			if((dirV-30000) < 10000):
			#valores de funciones
				dirV = dirV-30000
				return self.funciones[self.alcanceActual].leerValor(dirV)
			if((dirV-40000) < 10000):
			#constantes
				dirV = dirV-40000
				if(dirV < 1000):
					return int(self.constante_entero[dirV])
				elif(dirV < 2000):
					return float(self.constante_flotante[dirV-1000])
				else:
					return str(self.constante_str[dirV-2000])
	
	def escribeValorApuntado(self, dirV, valor, alcance):
	#para almacenar el valor en un apuntador
			dirV = int(dirV)
			if((dirV-10000) < 10000):
			#valores globales
				dirV = dirV-10000
				self.globales.escribeValor(dirV, valor)
				return
			if((dirV-20000) < 10000):
			#valores del main
				dirV = dirV-20000
				self.main.escribeValor(dirV, valor)
				return
			if((dirV-30000) < 10000):
			#valores de funciones
				dirV = dirV-30000
				self.funciones[self.alcanceActual+alcance].escribeValor(dirV, valor)
				return
			
	def getValorApuntado(self, dirV):
	#para leer el valor de un apuntador
			dirV = int(dirV)
			if((dirV-10000) < 10000):
			#valores globales
				dirV = dirV-10000
				return self.globales.leerValor(dirV)
			if((dirV-20000) < 10000):
			#valores del main
				dirV = dirV-20000
				return self.main.leerValor(dirV)
			if((dirV-30000) < 10000):
			#valores de funciones
				dirV = dirV-30000
				return self.funciones[self.alcanceActual].leerValor(dirV)
	
	def imprimeFunciones(self):
			print self.alcanceActual
		
	def imprimePrinc(self):
			self.main.imprimeInfo()
		
	def imprimeGlobales(self):
			self.globales.imprimeInfo()
		
	def imprimeConstantes(self):
			print self.constante_entero, " ", self.constante_flotante
		
	def push_apuntador(self, valor):
			self.apuntador.push(valor)
		
	def pop_apuntador(self):
			return self.apuntador.pop()
Exemple #20
0
class AdminMemoria:
    def __init__(self):
        self.constante_entero = []
        self.constante_flotante = []
        self.constante_str = []
        self.apuntador = Pila()
        self.globales = Memoria()
        self.main = Memoria()
        self.alcanceActual = 0
        self.funciones = dict()

    def constTamano(self, sizeE, sizeF, sizeS):
        #modifica la memoria necesaria por las constantes
        self.constante_entero = [0] * sizeE
        self.constante_flotante = [0.0] * sizeF
        self.constante_str = [0] * sizeS

    def setMemoriaPrinc(self, strP, enteroP, floatP, boolP, enteroPT, floatPT,
                        pointerP):
        #modifica la memoria del main
        self.main.setMemoria(int(strP), int(enteroP), int(floatP), int(boolP),
                             int(enteroPT), int(floatPT), int(pointerP))

    def setMemoriaGlobales(self, strP, enteroP, floatP, boolP, enteroPT,
                           floatPT, pointerP):
        #modifica la memoria de las globales
        self.globales.setMemoria(int(strP), int(enteroP), int(floatP),
                                 int(boolP), int(enteroPT), int(floatPT),
                                 int(pointerP))

    def setFunciones(self, strP, enteroP, floatP, boolP, enteroPT, floatPT,
                     pointerP):
        #crea memoria para la nueva funcion, modifica la memoria y la agrega al diccionario de funciones
        funcion = Memoria()
        funcion.setMemoria(int(strP), int(enteroP), int(floatP), int(boolP),
                           int(enteroPT), int(floatPT), int(pointerP))
        self.funciones[self.alcanceActual + 1] = funcion

    def cambiaAlcance(self):
        #cambia el alcance actual al siguiente
        self.alcanceActual += 1

    def borrar_funcion(self):
        #destruye la memoria asignada para la funcion y regresa al alcance anterior
        self.funciones[self.alcanceActual].dejarMemoria()
        del self.funciones[self.alcanceActual]
        self.alcanceActual -= 1

    def escribeValor(self, dirV, valor):
        #escribe el valor de la direccion dada, si la direccion es un apuntador primero recupera la direccion real
        if dirV[1] == '7':
            dirV = int(dirV)
            if ((dirV - 10000) < 10000):
                #valores globales
                dirV = self.globales.leerValor(dirV - 10000)
            elif ((dirV - 20000) < 10000):
                #valores del main
                dirV = self.main.leerValor(dirV - 20000)
            elif ((dirV - 30000) < 10000):
                #valores de funciones
                dirV = self.funciones[self.alcanceActual].leerValor(dirV -
                                                                    30000)
            dirV = str(dirV)
        dirV = int(dirV)
        #imprime la direccion, dirV
        if ((dirV - 10000) < 10000):
            #valores globales
            dirV = dirV - 10000
            self.globales.escribeValor(dirV, valor)
            return
        if ((dirV - 20000) < 10000):
            #valores del main
            dirV = dirV - 20000
            self.main.escribeValor(dirV, valor)
            return
        if ((dirV - 30000) < 10000):
            #valores de funciones
            dirV = dirV - 30000
            self.funciones[self.alcanceActual].escribeValor(dirV, valor)
            return
        if ((dirV - 40000) < 10000):
            #constantes
            dirV = dirV - 40000
            if (dirV < 1000):
                self.constante_entero[dirV] = int(valor)
            elif (dirV < 2000):
                self.constante_flotante[dirV - 1000] = float(valor)
            else:
                self.constante_str[dirV - 2000] = str(valor)
            return

    def escribeValorS(self, dirV, valor):
        #escribe valores que solo son usados como por patamentros
        if dirV[1] == '7':
            dirV = int(dirV)
            if ((dirV - 10000) < 10000):
                #valores globales
                dirV = self.globales.leerValor(dirV - 10000)
            elif ((dirV - 20000) < 10000):
                #valores del main
                dirV = self.main.leerValor(dirV - 20000)
            elif ((dirV - 30000) < 10000):
                #valores de funciones
                dirV = self.funciones[self.alcanceActual + 1].leerValor(dirV -
                                                                        30000)
            dirV = str(dirV)
        dirV = int(dirV)
        #imprime la direccion, dirV
        if ((dirV - 10000) < 10000):
            #valores globales
            dirV = dirV - 10000
            self.globales.escribeValor(dirV, valor)
            return
        if ((dirV - 20000) < 10000):
            #valores del main
            dirV = dirV - 20000
            self.main.escribeValor(dirV, valor)
            return
        if ((dirV - 30000) < 10000):
            #valores de funciones
            dirV = dirV - 30000
            self.funciones[self.alcanceActual + 1].escribeValor(dirV, valor)
            return

    def getValor(self, dirV):
        #recupera el valor de la direccion dada, en caso de que sea un apuntador primero obtiene la direccion real
        if dirV[1] == '7':
            # si la diereccion es un apuntador se recuperar la direccion actual
            dirV = int(dirV)
            if ((dirV - 10000) < 10000):
                #valores globales
                dirV = self.globales.leerValor(dirV - 10000)
            elif ((dirV - 20000) < 10000):
                #valores del main
                dirV = self.main.leerValor(dirV - 20000)
            elif ((dirV - 30000) < 10000):
                #valores de funciones
                dirV = self.funciones[self.alcanceActual].leerValor(dirV -
                                                                    30000)
            dirV = str(dirV)
        dirV = int(dirV)
        #imprime la direccion, dirV
        if ((dirV - 10000) < 10000):
            #valores globales
            dirV = dirV - 10000
            return self.globales.leerValor(dirV)
        if ((dirV - 20000) < 10000):
            #valores del main
            dirV = dirV - 20000
            return self.main.leerValor(dirV)
        if ((dirV - 30000) < 10000):
            #valores de funciones
            dirV = dirV - 30000
            return self.funciones[self.alcanceActual].leerValor(dirV)
        if ((dirV - 40000) < 10000):
            #constantes
            dirV = dirV - 40000
            if (dirV < 1000):
                return int(self.constante_entero[dirV])
            elif (dirV < 2000):
                return float(self.constante_flotante[dirV - 1000])
            else:
                return str(self.constante_str[dirV - 2000])

    def escribeValorApuntado(self, dirV, valor, alcance):
        #para almacenar el valor en un apuntador
        dirV = int(dirV)
        if ((dirV - 10000) < 10000):
            #valores globales
            dirV = dirV - 10000
            self.globales.escribeValor(dirV, valor)
            return
        if ((dirV - 20000) < 10000):
            #valores del main
            dirV = dirV - 20000
            self.main.escribeValor(dirV, valor)
            return
        if ((dirV - 30000) < 10000):
            #valores de funciones
            dirV = dirV - 30000
            self.funciones[self.alcanceActual + alcance].escribeValor(
                dirV, valor)
            return

    def getValorApuntado(self, dirV):
        #para leer el valor de un apuntador
        dirV = int(dirV)
        if ((dirV - 10000) < 10000):
            #valores globales
            dirV = dirV - 10000
            return self.globales.leerValor(dirV)
        if ((dirV - 20000) < 10000):
            #valores del main
            dirV = dirV - 20000
            return self.main.leerValor(dirV)
        if ((dirV - 30000) < 10000):
            #valores de funciones
            dirV = dirV - 30000
            return self.funciones[self.alcanceActual].leerValor(dirV)

    def imprimeFunciones(self):
        print self.alcanceActual

    def imprimePrinc(self):
        self.main.imprimeInfo()

    def imprimeGlobales(self):
        self.globales.imprimeInfo()

    def imprimeConstantes(self):
        print self.constante_entero, " ", self.constante_flotante

    def push_apuntador(self, valor):
        self.apuntador.push(valor)

    def pop_apuntador(self):
        return self.apuntador.pop()
Exemple #21
0
        if ((posDer <= (len(particiones) - 1))
                and (particiones[posDer].libre)):
            memoriaTotal += particiones[posDer].tamaño
            posTope = posDer
            posDer += 1

        print('-- Desde: ' + str(posBase) + '  Hasta: ' + str(posTope))
        # RECALCULAR TAMAÑO DE LA NUEVA PARTICION LIBRE
        newPartUnif = Particion(tamaño=memoriaTotal, libre=True)
        self.memoria.insertarEntre(newPartUnif, posBase, posTope)
        pass


if __name__ == "__main__":
    import random
    M = Memoria(256)
    # AdmMem = AdminMemoria(M,'first-fit',15,2,2)
    AdmMem = AdminMemoria(M, 'next-fit', 15, 2, 2)

    for i in range(6):
        P = Proceso(nombre='P-' + str(i),
                    arribo=random.randrange(60) + 1,
                    tiempoTotal=random.randrange(50) + 1,
                    tamaño=random.randrange(10) + 35)
        AdmMem.arriboProceso(P)

    print('NUEVA TANDA')
    imprimirMemoria(AdmMem.memoria)
    # AdmMem.eliminarProceso(0)
    AdmMem.eliminarProceso(1)
    AdmMem.eliminarProceso(3)
def run():
    global memoria_global, param_stack, memorias, llamadas, pila_returns, this_func
    #añadiendo ctes y apuntadores a memoria.
    save_ctes()
    tracker = 0
    while tracker < len(dir_quadruples):
        #print("contador " + str(tracker))
        curr_quad = dir_quadruples[tracker]
        instr = curr_quad[0]
        el2 = curr_quad[1]
        el3 = curr_quad[2]
        el4 = curr_quad[3]

        if instr == 'Goto':
            tracker = el4

        elif instr == 'print':
            if (el4 >= top_limit_cte):
                aux = get_value(el4)
            else:
                aux = el4
            print(get_value(aux))
            tracker += 1

        elif instr == 'read':
            # agregar el leer variable
            aux = input()
            if (el4 >= top_limit_cte):
                aux1 = get_value(el4)
            else:
                aux1 = el4

            set_value(aux1, aux)
            tracker += 1

        elif instr == '+' or instr == '-' or instr == '*' or instr == '/' or instr == '<' or instr == '<=' or instr == '>' or instr == '>=' or instr == '==' or instr == '<>' or instr == '&' or instr == '|':
            if (el2 >= top_limit_cte):
                aux1 = get_value(el2)
            else:
                aux1 = el2
            if (el3 >= top_limit_cte):
                aux2 = get_value(el3)
            else:
                aux2 = el3
            p1 = getParam(aux1)
            p2 = getParam(aux2)
            value = calculate(p1, instr, p2)
            set_value(el4, value)
            tracker += 1

        elif instr == '=':
            if (el2 >= top_limit_cte):
                aux1 = get_value(el2)
            else:
                aux1 = el2
            aux1 = get_value(aux1)

            if (el4 >= top_limit_cte):
                aux = get_value(el4)
            else:
                aux = el4
            set_value(aux, aux1)
            tracker += 1

        elif instr == 'ENDFUNC':
            #liberar memoria actual
            #recuperar dir ret
            #regresar a la mem anterior
            if (not memorias.isEmpty()):
                memorias.pop()
            tracker = llamadas.pop()

        elif instr == 'GotoF':
            evaluar = getParam(el2)
            if (evaluar == False):
                tracker = el4
            else:
                tracker += 1

        elif instr == 'ERA':
            #Allocates memory
            #aux = Memoria()
            #memorias.push(aux)
            tracker += 1

        elif instr == 'PARAM':
            #aux = Memoria()
            #aux = memorias.pop()
            val = get_value(el2)
            #memorias.push(aux)
            #set_value(el4, val)
            param_stack.push(val)
            param_stack.push(el4)
            tracker += 1

        elif instr == 'GOSUB':
            aux = Memoria()
            memorias.push(aux)
            #if(not param_stack.isEmpty()):
            this_func.push(el2)
            while (not param_stack.isEmpty()):
                set_value(param_stack.pop(), param_stack.pop())
            llamadas.push(tracker + 1)
            tracker = el4

        elif instr == 'RETURN':
            aux_val = get_value(el4)
            memorias.pop()
            tracker = llamadas.pop()
            if isinstance(this_func.peek(), str):
                this_func.pop()
            set_value(this_func.pop(), aux_val)

        elif instr == 'VERIFY':
            if getParam(el2) < getParam(el4):
                tracker += 1
            else:
                print('Error en el acceso a un arreglo, fuera de dimension')
                sys.exit()

        else:
            #lets hope this does not get called
            print('error en cuadruplos')
            sys.exit()
class MaquinaVirtual:
    def __init__(self):
        self.program = None
        self.memoria = Memoria()

        self.pila_contextos = []
    
    '''
        Procesa la informacion del json con informacion del codigo intermedio
        :param program -> nombre de programa
    '''
    def process(self, program):
        compiled = f"pruebas/{program}_comp.cuac"
        
        compiled_file = open(compiled, 'r')

        compiled_data = json.load(compiled_file)

        self.pila_contextos.append('main')
        self.program = program

        self.process_consts(compiled_data['Constantes'])
        self.process_quads(compiled_data['Quads'], compiled_data['FuncsDir'])
    
    '''
        Procesa las constantes y las guarda en memoria
        :param consts -> constantes
    '''
    def process_consts(self, consts):
        for const in consts: 
            dir = const[0]
            val = const[1]

            self.memoria.mem_constantes[dir] = val

    '''
        Obtiene las memorias de cada parametro
        :param left_operand
        :param right_operand
        :param result
    '''
    def get_memories(self, left_operand, right_operand, result):
        return self.get_memory(left_operand), self.get_memory(right_operand), self.get_memory(result)
    
    '''
        Obtiene el tipo dependiendo de la direccion
        :param address -> direccion
    '''
    def get_type(self, address):
        if 1000 <= address < 5000 or 21000 <= address < 25000:
            return int
        elif 5000 <= address < 9000 or 25000 <= address < 29000:
            return float
        elif 9000 <= address < 13000 or 29000 <= address < 33000:
            return str
        elif address >= 41000:
            return type(self.memoria.mem_constantes[address])
        else:
            return bool
    
    '''
        Obtiene la memoria dependiendo de la direccion
        :param address -> direccion
    '''
    def get_memory(self, address):
        if address is None:
            return None
        elif 1000 <= address < 21000:
            return self.memoria.mem_global
        elif 21000 <= address < 41000:
            return self.memoria.active.mem_local if self.memoria.active is not None else self.memoria.mem_local
        else: 
            return self.memoria.mem_constantes
    
    '''
        Obiene el contenido de los apuntadores a memoria
        :param address -> direccion
    '''
    def get_content(self, address):
        aux_address = int(address[1:-1])
        mem_address = self.get_memory(aux_address)
        arr_addr = mem_address[aux_address]
        return arr_addr

    '''
        Procesa los cuadruplos dependiendo del operador
        :param quads -> Cuadruplos
        :param funcs_dir -> Tabla de Funciones
        :param next -> Contador del siguiente cuadruplo a ejecutar
    '''
    def process_quads(self, quads, funcs_dir, next=0):

        params = []
        returned = None


        while True:
            operator = quads[next][0]
            left_operand = quads[next][1]
            right_operand = quads[next][2]
            result = quads[next][3]

            if isinstance(left_operand, str) and left_operand[0] == '(':
                left_operand = self.get_content(left_operand)
            if isinstance(right_operand, str) and right_operand[0] == '(':
                right_operand = self.get_content(right_operand)
                

            if operator == '=':
                if isinstance(result, str) and result[0] == '(':
                    aux_address = int(result[1:-1])
                    mem_address = self.get_memory(aux_address)
                    mem1 = self.get_memory(left_operand)
                    arr_address = mem_address[aux_address]
                    mem_arr_addr = self.get_memory(arr_address)
                    mem_arr_addr[arr_address] = mem1[left_operand]
                else:
                    mem1, mem2, mem_r = self.get_memories(left_operand, right_operand, result)
                    result_type = self.get_type(result)
                    mem_r[result] = (mem1[left_operand])

                next+=1

            elif operator == '+':
                if isinstance(result, str) and result[0] == '(':
                    aux_address = int(result[1:-1])
                    mem_address = self.get_memory(aux_address)
                    mem1 = self.get_memory(left_operand)
                    mem_address[aux_address] = int(mem1[left_operand]) + int(right_operand)
                else:
                    mem1, mem2, mem_r = self.get_memories(left_operand, right_operand, result)
                    if(isinstance(mem1[left_operand], str) and not isinstance(mem2[right_operand], str)) or (isinstance(mem2[right_operand],str) and not isinstance(mem1[left_operand],str)):
                        mem_r[result] = str(mem1[left_operand]) + str(mem2[right_operand])
                    else:
                        mem_r[result] = mem1[left_operand] + mem2[right_operand]
                
                next+=1
            
            elif operator == '-':
                mem1, mem2, mem_r = self.get_memories(left_operand, right_operand, result)
                mem_r[result] = mem1[left_operand] - mem2[right_operand]
                next += 1

            elif operator == '*':
                mem1, mem2, mem_r = self.get_memories(left_operand, right_operand, result)
                mem_r[result] = mem1[left_operand] * mem2[right_operand]
                next += 1
            
            elif operator == '/':
                mem1, mem2, mem_r = self.get_memories(left_operand, right_operand, result)

                if mem2[right_operand] == 0:
                    raise TypeError(f"Error: No se puede dividir entre 0")

                mem_r[result] = float(mem1[left_operand] / mem2[right_operand])
                next += 1
            
            elif operator == '>':
                mem1, mem2, mem_r = self.get_memories(left_operand, right_operand, result)
                mem_r[result] = mem1[left_operand] > mem2[right_operand]
                next +=1
            
            elif operator == '<':
                mem1, mem2, mem_r = self.get_memories(left_operand, right_operand, result)
                mem_r[result] = mem1[left_operand] < mem2[right_operand]
                next +=1
            
            elif operator == '<=':
                mem1, mem2, mem_r = self.get_memories(left_operand, right_operand, result)
                mem_r[result] = mem1[left_operand] <= mem2[right_operand]
                next +=1
            
            elif operator == '>=':
                mem1, mem2, mem_r = self.get_memories(left_operand, right_operand, result)
                mem_r[result] = mem1[left_operand] >= mem2[right_operand]
                next +=1
            
            elif operator == '==':
                mem1, mem2, mem_r = self.get_memories(left_operand, right_operand, result)
                mem_r[result] = mem1[left_operand] == mem2[right_operand]
                next +=1
            
            elif operator == '!=':
                mem1, mem2, mem_r = self.get_memories(left_operand, right_operand, result)
                mem_r[result] = mem1[left_operand] != mem2[right_operand]
                next +=1
            
            elif operator == '&&':
                mem1, mem2, mem_r = self.get_memories(left_operand, right_operand, result)
                mem_r[result] = mem1[left_operand] and mem2[right_operand]
                next +=1
            
            elif operator == '||':
                mem1, mem2, mem_r = self.get_memories(left_operand, right_operand, result)
                mem_r[result] = mem1[left_operand] or mem2[right_operand]
                next +=1
            
            elif operator == 'VERIF':
                mem1 = self.get_memory(left_operand)

                if not(0 <= mem1[left_operand] < int(result)):
                    raise TypeError("Fuera de los limites")
                
                next += 1
            
            elif operator == 'ESCRIBE':
                if isinstance(result, str) and result[0] == '(':
                    try:
                        
                        dir = self.get_content(result)
                        mem = self.get_memory(dir) 
                        print(mem[dir])
                    except:
                        print("NULL")
                        break
                else:
                    mem = self.get_memory(result)
                    print(mem[result])
                next +=1
            
            elif operator == 'LEER':
                if isinstance(result, str) and result[0] == '(':
                    aux_address = int(result[1:-1])
                    mem_address = self.get_memory(aux_address)
                    mem1 = self.get_memory(left_operand)
                    arr_address = mem_address[aux_address]
                    mem_arr_addr = self.get_memory(arr_address)
                    arr_type = self.get_type(arr_address)
                    try:
                        mem_arr_addr[arr_address] = arr_type(input())
                    except:
                        print("ERROR: El dato de entrada no es del mismo tipo de dato que la variable a leer")
                        break
                else:
                    result_type = self.get_type(result)
                    mem = self.get_memory(result)
                    try:
                        input_result = result_type(input())
                    except:
                        print("ERROR: El dato de entrada no es del mismo tipo de dato que la variable a leer")
                        break
                
                    mem[result] = input_result
                next+=1
            
            elif operator == 'GOTOF':
                mem_b = self.get_memory(left_operand)
                if not mem_b[left_operand]:
                    next = int(result) - 1
                else:
                    next += 1

            elif operator == 'GOTOV':
                mem_b = self.get_memory(left_operand)
                if mem_b[left_operand]:
                    next = int(result) - 1
                else:
                    next += 1        

            elif operator == 'GOTO':
                next = int(result) - 1
            
            elif operator == 'ERA':
                if self.memoria.active is not None:
                    superior = self.memoria.active
                else:
                    superior = self.memoria
                self.memoria.mem_func(superior, int(result))
                next += 1
            
            elif operator == 'GOSUB':
                self.memoria.active = self.memoria.mem_ejec[list(self.memoria.mem_ejec.keys())[-1]]

                self.pila_contextos.append(result)

                self.memoria.active.assign_params(params)
                params = []
                value = self.process_quads(quads, funcs_dir, int(result) - 1)

                if value is not None:
                    mem = self.get_memory(left_operand)
                    mem[left_operand] = value
                next += 1
            
            elif operator == 'REGRESA':
                mem = self.get_memory(result)
                returned = mem[result]

                self.memoria.remove_scope()
                self.pila_contextos.pop()

                return returned
                next+=1

            elif operator == 'PARAM':
                mem = self.get_memory(left_operand)
                params.append(mem[left_operand])

                next += 1
            
            elif operator == 'ENDFUNC':
                self.memoria.remove_scope()
                self.pila_contextos.pop()
                break
            
            elif operator == 'END':
                self.memoria.remove_scope()
                self.pila_contextos.pop()
                break
            
            #OPERACIONES MATRICIALES

            elif operator == '$':
                size = int(left_operand[0]) * int(left_operand[1])

                mem_arr = self.get_memory(right_operand)
                arr_type = self.get_type(right_operand)

                if arr_type not in [int, float]:
                    raise TypeError("Para usar el determinante es necesario que la matriz sea de tipo flotante o entero")
                
                dims = []
                aux = []
                arr_addr = int(right_operand)

                for i in range(size):
                    try:
                        val = mem_arr[arr_addr + i]
                    except:
                        raise TypeError('Elemento del arreglo no inicializado')
                    aux.append(val)
                    if (i+1)%left_operand[0] == 0:
                        dims.append(aux)
                        aux = []

                matrix = np.array(dims)  
                
                determinant = np.linalg.det(matrix)

                mem_r = self.get_memory(result)
                mem_r[result] = determinant

                next+=1
            
            elif operator == '!':
                size = int(left_operand[0]) * int(left_operand[1])

                mem_arr = self.get_memory(right_operand)
                arr_type = self.get_type(right_operand)

                dims = []
                aux = []
                arr_addr = int(right_operand)

                for i in range(size):
                    try:
                        val = mem_arr[arr_addr + i]
                    except:
                        raise TypeError('Elemento del arreglo no inicializado')
                    aux.append(val)
                    if (i+1)%left_operand[0] == 0:
                        dims.append(aux)
                        aux = []

                matrix = np.array(dims)  
                
                transpose = matrix.transpose()

                mem_r = self.get_memory(result)
                mem_r[result] = transpose

                next+=1
            
            elif operator == '?':
                size = int(left_operand[0]) * int(left_operand[1])

                mem_arr = self.get_memory(right_operand)
                arr_type = self.get_type(right_operand)

                dims = []
                aux = []
                arr_addr = int(right_operand)

                for i in range(size):
                    try:
                        val = mem_arr[arr_addr + i]
                    except:
                        raise TypeError('Elemento del arreglo no inicializado')
                    aux.append(val)
                    if (i+1)%left_operand[0] == 0:
                        dims.append(aux)
                        aux = []

                matrix = np.array(dims)
                try:
                    inverse = np.linalg.inv(matrix)
                except:
                    print("No se puede determinar la inversa de una matriz con determinante de 0")
                    break

                mem_r = self.get_memory(result)
                mem_r[result] = inverse

                next+=1
            
            elif operator == '+arr':
                size = int(left_operand[1][0]) * int(left_operand[1][1])

                mem = self.get_memory(result)

                dims1 = []
                dims2 = []

                aux1 = []
                aux2 = []

                arr_addr_1 = int(left_operand[0])
                arr_addr_2 = int(right_operand[0])
 
                for i in range(size):
                    try:
                        val1 = mem[arr_addr_1 + i]
                        val2 = mem[arr_addr_2 + i]
                    except:
                        raise TypeError('Elemento del arreglo no inicializado')

                    aux1.append(val1)
                    aux2.append(val2)

                    if (i+1)%left_operand[1][0] == 0:
                        dims1.append(aux1)
                        aux1 = []

                        dims2.append(aux2)
                        aux2 = []

                arr1 = np.array(dims1) 
                arr2 = np.array(dims2)

                mem[result] = np.add(arr1, arr2)

                next += 1

            elif operator == '-arr':
                size = int(left_operand[1][0]) * int(left_operand[1][1])

                mem = self.get_memory(result)

                dims1 = []
                dims2 = []

                aux1 = []
                aux2 = []

                arr_addr_1 = int(left_operand[0])
                arr_addr_2 = int(right_operand[0])
 
                for i in range(size):
                    try:
                        val1 = mem[arr_addr_1 + i]
                        val2 = mem[arr_addr_2 + i]
                    except:
                        raise TypeError('Elemento del arreglo no inicializado')

                    aux1.append(val1)
                    aux2.append(val2)

                    if (i+1)%left_operand[1][0] == 0:
                        dims1.append(aux1)
                        aux1 = []

                        dims2.append(aux2)
                        aux2 = []

                arr1 = np.array(dims1) 
                arr2 = np.array(dims2)

                mem[result] = np.subtract(arr1, arr2)

                next += 1
            
            elif operator == '*arr':
                size1 = int(left_operand[1][0]) * int(left_operand[1][1])
                size2 = int(right_operand[1][0]) * int(right_operand[1][1])

                mem = self.get_memory(result)

                dims1 = []
                dims2 = []

                aux1 = []
                aux2 = []

                arr_addr_1 = int(left_operand[0])
                arr_addr_2 = int(right_operand[0])
 
                for i in range(size1):
                    try:
                        val1 = mem[arr_addr_1 + i]
                    except:
                        raise TypeError('Elemento del arreglo no inicializado')

                    aux1.append(val1)

                    if (i+1)%left_operand[1][1] == 0:
                        dims1.append(aux1)
                        aux1 = []
                
                for i in range(size2):
                    try:
                        val2 = mem[arr_addr_2 + i]
                    except:
                        raise TypeError('Elemento del arreglo no inicializado')

                    aux2.append(val2)

                    if (i+1)%left_operand[1][1] == 0:
                        dims2.append(aux2)
                        aux2 = []

                arr1 = np.array(dims1) 
                arr2 = np.array(dims2)

                mem[result] = np.multiply(arr1, arr2)

                next += 1
            
            



                


                

                

                        
                    
Exemple #24
0
	def setFunciones(self, strP, enteroP, floatP, boolP, enteroPT, floatPT, pointerP):
	#crea memoria para la nueva funcion, modifica la memoria y la agrega al diccionario de funciones
			funcion = Memoria()
			funcion.setMemoria(int(strP), int(enteroP), int(floatP), int(boolP), int(enteroPT), int(floatPT), int(pointerP))
			self.funciones[self.alcanceActual+1] = funcion
class MaquinaVirtual:
    def __init__(self):

        self.programa = None
        self.memoria = Memoria()

        self.estrella = None
        self.screen = None
        self.turtle_activa = False

        self.pila_contextos = []

    def agarra_datos(self, program):
        '''
        Recibe archivos con cuádruplos y el directorio de funciones y constantes
        :param program: Nombre del programa compilado
        '''

        compilado = f"pruebas/{program}_comp.ta"

        arch_compilado = open(compilado, 'r')

        todito = json.load(arch_compilado)

        self.pila_contextos.append('star')
        self.programa = program

        self.haz_constantes(todito['tConstantes'])
        self.haz_quads(todito['Quads'], todito['FunDir'])

    # dnb
    def haz_quads(self, quads, fun_dir, sig=0):
        '''
        Procesar cada cuadruplo de la lista de Quads recibida hasta que encuentre END
        :param quads: Lista con todos los quads
        :param fun_dir: Directorio de funciones
        :param sig: Apuntador al siguiente cuádruplo
        '''

        # parametros que estamos mandando
        parametros = []
        retornado = None

        while True:
            operador = quads[sig][0]
            op_izq = quads[sig][1]
            op_der = quads[sig][2]
            res = quads[sig][3]

            # checamos que si traen ( ) y vamos por su valor
            if isinstance(op_izq, str) and op_izq[0] == '(':
                op_izq = self.dame_contenido(op_izq)
            if isinstance(op_der, str) and op_der[0] == '(':
                op_der = self.dame_contenido(op_der)
            if isinstance(res, str) and res[0] == '(':
                res = self.dame_contenido(res)

            if operador == '=':
                mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
                tipo_res = self.dame_tipo(res)

                mem_r[res] = tipo_res(mem1[op_izq])
                sig += 1

            elif operador == '+':

                mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)

                # suma de un string con algo más
                if (isinstance(mem1[op_izq], str)
                        and not isinstance(mem2[op_der], str)) or (
                            isinstance(mem2[op_der], str)
                            and not isinstance(mem1[op_izq], str)):
                    mem_r[res] = str(mem1[op_izq]) + str(mem2[op_der])
                else:

                    mem_r[res] = mem1[op_izq] + mem2[op_der]
                sig += 1

            elif operador == '-':
                mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
                mem_r[res] = mem1[op_izq] - mem2[op_der]
                sig += 1

            elif operador == '*':
                mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
                mem_r[res] = mem1[op_izq] * mem2[op_der]
                sig += 1

            elif operador == '/':
                mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
                tipo_res = self.dame_tipo(res)

                if mem2[op_der] == 0:
                    raise TypeError(f"Error: No se puede dividir entre 0")

                mem_r[res] = tipo_res(mem1[op_izq] / mem2[op_der])
                sig += 1

            elif operador == '>':
                mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
                mem_r[res] = mem1[op_izq] > mem2[op_der]
                sig += 1

            elif operador == '<':
                mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)

                mem_r[res] = mem1[op_izq] < mem2[op_der]
                sig += 1

            elif operador == '>=':
                mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
                mem_r[res] = mem1[op_izq] >= mem2[op_der]
                sig += 1

            elif operador == '<=':
                mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
                mem_r[res] = mem1[op_izq] <= mem2[op_der]
                sig += 1

            elif operador == '!=':
                mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
                mem_r[res] = mem1[op_izq] != mem2[op_der]

                sig += 1

            elif operador == '==':
                mem1, mem2, mem_r = self.dame_memorias(op_izq, op_der, res)
                mem_r[res] = mem1[op_izq] == mem2[op_der]

                sig += 1

            elif operador == 'print':
                mem = self.dame_mem(res)
                # no borrar este print
                print(mem[res])
                sig += 1

            elif operador == 'read':
                mem = self.dame_mem(res)
                mem[res] = input()
                sig += 1

            elif operador == 'GotoF':
                # memoria de valor booleano
                mem_b = self.dame_mem(op_izq)
                if not mem_b[op_izq]:
                    sig = int(res) - 1
                else:
                    sig += 1

            elif operador == 'GotoV':
                mem_b = self.dame_mem(op_izq)
                if mem_b[op_izq]:
                    sig = int(res) - 1
                else:
                    sig += 1

            elif operador == 'Goto_main' or operador == 'Goto':
                sig = int(res) - 1
                # activamos memoria star

            elif operador == 'END':

                self.memoria.cuello()
                self.pila_contextos.pop()
                # tenemos que borrar algo más ?
                break

            #################################### GRAPH STATEMENTS ####################################
            # 0 exp
            elif operador == 'hand_down':
                if not self.turtle_activa:
                    self.activa_tortuga()

                self.estrella.pd()
                sig += 1

            elif operador == 'hand_up':
                if not self.turtle_activa:
                    self.activa_tortuga()

                self.estrella.pu()
                sig += 1

            elif operador == 'hide_star':
                if not self.turtle_activa:
                    self.activa_tortuga()

                self.estrella.hideturtle()
                sig += 1

            elif operador == 'show_star':
                if not self.turtle_activa:
                    self.activa_tortuga()

                self.estrella.showturtle()
                sig += 1

            elif operador == 'exitonclick':
                if not self.turtle_activa:
                    self.activa_tortuga()

                self.screen.exitonclick()
                sig += 1

            elif operador == 'clear':
                if not self.turtle_activa:
                    self.activa_tortuga()

                self.screen.clear()
                sig += 1

            elif operador == 'begin_fill':
                if not self.turtle_activa:
                    self.activa_tortuga()

                self.estrella.begin_fill()
                sig += 1

            elif operador == 'end_fill':
                if not self.turtle_activa:
                    self.activa_tortuga()

                self.estrella.end_fill()
                sig += 1

            # 1 exp
            elif operador == 'circle':
                mem = self.dame_mem(op_izq)
                if not self.turtle_activa:
                    self.activa_tortuga()

                self.estrella.circle(mem[op_izq])
                sig += 1

            elif operador == 'left':
                mem = self.dame_mem(op_izq)
                angle = float(mem[op_izq])
                if not self.turtle_activa:
                    self.activa_tortuga()

                if angle > 360:
                    raise TypeError(f"Valor no debe exceder 360 grados")
                self.estrella.lt(angle)
                sig += 1

            elif operador == 'right':
                mem = self.dame_mem(op_izq)
                angle = float(mem[op_izq])
                if not self.turtle_activa:
                    self.activa_tortuga()

                if angle > 360:
                    raise TypeError(f"Valor no debe exceder 360 grados")
                self.estrella.rt(angle)
                sig += 1

            elif operador == 'back':
                mem = self.dame_mem(op_izq)
                if not self.turtle_activa:
                    self.activa_tortuga()

                self.estrella.bk(mem[op_izq])
                sig += 1

            elif operador == 'go':
                mem = self.dame_mem(op_izq)
                if not self.turtle_activa:
                    self.activa_tortuga()

                self.estrella.fd(mem[op_izq])
                sig += 1

            elif operador == 'square':
                mem = self.dame_mem(op_izq)

                if not self.turtle_activa:
                    self.activa_tortuga()

                # grafica cuadrado
                self.estrella.forward(mem[op_izq])
                self.estrella.left(90)
                self.estrella.forward(mem[op_izq])
                self.estrella.left(90)
                self.estrella.forward(mem[op_izq])
                self.estrella.left(90)
                self.estrella.forward(mem[op_izq])
                self.estrella.left(90)
                sig += 1

            elif operador == 'rectangle':
                mem1 = self.dame_mem(op_izq)  # base
                mem2 = self.dame_mem(op_der)  # altura

                base = mem1[op_izq]
                altura = mem2[op_der]

                if not self.turtle_activa:
                    self.activa_tortuga()

                # grafica rectangulo
                self.estrella.fd(base)
                self.estrella.lt(90)
                self.estrella.fd(altura)
                self.estrella.lt(90)
                self.estrella.fd(base)
                self.estrella.lt(90)
                self.estrella.fd(altura)
                self.estrella.lt(90)
                sig += 1

            elif operador == 'triangle':
                mem = self.dame_mem(op_izq)

                if not self.turtle_activa:
                    self.activa_tortuga()

                # dibuja triangulo equilatero de base ingresada
                self.estrella.fd(mem[op_izq])

                self.estrella.lt(120)
                self.estrella.fd(mem[op_izq])

                self.estrella.lt(120)
                self.estrella.fd(mem[op_izq])

                sig += 1

            elif operador == 'speed':
                mem = self.dame_mem(op_izq)

                if not self.turtle_activa:
                    self.activa_tortuga()
                speed = mem[op_izq]
                if self.dame_tipo(op_izq) is not str:
                    if not 1 <= speed <= 10:
                        raise TypeError(
                            f"Valor de la velocidad debe estar entre 0 y 10.")
                elif speed not in [
                        'fastest', 'fast', 'normal', 'slow', 'slowest'
                ]:
                    raise TypeError(f"Velocidad {speed} no válida.")
                self.estrella.speed(mem[op_izq])
                sig += 1

            elif operador == 'color_star':
                mem = self.dame_mem(op_izq)

                if not self.turtle_activa:
                    self.activa_tortuga()
                color = mem[op_izq]
                self.estrella.color(color)
                sig += 1

            elif operador == 'size_star':
                mem = self.dame_mem(op_izq)

                if not self.turtle_activa:
                    self.activa_tortuga()

                size = mem[op_izq]
                self.estrella.pensize(size)
                sig += 1

            # 2 exp
            elif operador == 'position':
                mem1 = self.dame_mem(op_izq)
                mem2 = self.dame_mem(op_der)

                if not self.turtle_activa:
                    self.activa_tortuga()

                self.estrella.setpos(mem1[op_izq], mem2[op_der])
                sig += 1

            elif operador == 'arc':
                # arc(angulo,radio)
                mem1 = self.dame_mem(op_izq)
                mem2 = self.dame_mem(op_der)

                if not self.turtle_activa:
                    self.activa_tortuga()

                self.estrella.circle(mem2[op_der], mem1[op_izq])
                sig += 1

            ##########################################################################################

            elif operador == 'VER':

                mem1 = self.dame_mem(op_izq)
                mem2 = self.dame_mem(op_der)
                if not (0 <= mem1[op_izq] < mem2[op_der]):
                    raise TypeError(f"OUT OF BOUNDS")

                sig += 1

            ############ FUNCIONES ############

            elif operador == 'ERA':
                fun = fun_dir[res]

                if self.memoria.activa is not None:
                    superior = self.memoria.activa
                else:
                    superior = self.memoria
                self.memoria.record_activacion(superior, fun['vars'])
                sig += 1

            elif operador == 'GOSUB':
                self.memoria.activa = self.memoria.mem_ejec[list(
                    self.memoria.mem_ejec.keys())[-1]]

                self.pila_contextos.append(res)

                self.memoria.activa.matcheo(parametros)
                parametros.clear()
                val = self.haz_quads(quads, fun_dir, int(res) - 1)

                # return
                if val is not None:
                    mem = self.dame_mem(op_izq)
                    mem[op_izq] = val

                sig += 1

            elif operador == 'RETURN':
                mem = self.dame_mem(res)

                retornado = mem[res]

                sig += 1

            elif operador == 'param':
                mem = self.dame_mem(res)
                parametros.append(mem[res])

                sig += 1

            elif operador == 'ENDPROC':

                self.memoria.cuello()
                self.pila_contextos.pop()

                if retornado is not None:
                    return retornado
                else:
                    break

    def haz_constantes(self, t):
        '''
        Genera tabla de constantes y las carga a memoria
        :param t: Tabla de constantes
        '''
        for const in t:
            dir = const[0]
            val = const[1]
            self.memoria.mem_constantes[dir] = val
        '''
        GLOBAL
        i [1000  -  5999]
        f [6000  - 10999]
        s [11000 - 15999]
        b [16000 - 20999]


        LOCAL
        i [21000 - 25999]
        f [26000 - 30999]
        s [31000 - 35999]
        b [36000 - 40999]

        CONSTANTES
        c [41000 - 51999]
        '''

    def dame_memorias(self, op_i, op_d, res):
        '''
        Regresa las direcciones de memoria a las que pertenecen los elementos de un cuádruplo a excepción del operador
        :param op_i: Operador izquierdo del quad
        :param op_d: Operador derecho del quad
        :param res: Resultado del quad
        :return: Memoria correspondiente
        '''
        return self.dame_mem(op_i), self.dame_mem(op_d), self.dame_mem(res)

    def dame_mem(self, dir):
        '''
        Regresa la dirección a la que pertenece la variable global, local o de constantes
        :param dir: Dirección de variable
        '''

        if dir is None:
            return None
        elif 1000 <= dir < 21000:
            return self.memoria.mem_global
        elif 21000 <= dir < 41000:
            return self.memoria.activa.mem_local if self.memoria.activa is not None else self.memoria.mem_local
        else:
            return self.memoria.mem_constantes

    def dame_tipo(self, dir):
        '''
        Regresa el tipo de variable
        :param dir: Dirección de variable
        '''
        if 1000 <= dir < 6000 or 21000 <= dir < 26000:
            return int
        elif 6000 <= dir < 11000 or 26000 <= dir < 31000:
            return float
        elif 11000 <= dir < 16000 or 31000 <= dir < 36000:
            return str
        elif dir >= 41000:
            return type(self.memoria.mem_constantes[dir])
        else:
            return bool

    def activa_tortuga(self):
        self.turtle_activa = True

        s = Turtle()
        self.screen = Screen()
        self.dibuja_estrella(s)

        self.screen.title(self.programa)
        self.screen.clear()
        self.estrella = Turtle(shape="estrella")

    def dibuja_estrella(self, lapiz):
        '''
        Define una figura de estrella como el lapiz que dibujará
        '''

        fig = Shape("compound")
        lapiz.setx(0)
        lapiz.sety(4)

        lapiz.begin_poly()
        lapiz.goto(1, 1)
        lapiz.goto(3.5, 1)
        lapiz.goto(1.5, -0.5)
        lapiz.goto(2.5, -3)
        lapiz.goto(0, 1.5)
        lapiz.goto(-2.5, -3)
        lapiz.goto(-1.5, -0.5)
        lapiz.goto(-3.5, 1)
        lapiz.goto(-1, 1)
        lapiz.end_poly()

        fig.addcomponent(lapiz.get_poly(), "purple", "purple")
        self.screen.register_shape("estrella", fig)
        lapiz.reset()

    def dame_contenido(self, dir):

        dir_aux = int(dir[1:-1])
        dir_mem = self.dame_mem(dir_aux)
        return dir_mem[dir_aux]