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 __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.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)
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 = []
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-+++
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()
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()
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
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]