def __init__(self, size):
self.pila = Pila()
self.pila.push('$')
self.pila.push('0')
self.columna = 0
self.cantidad = size
self.accion = ""
def invertir_Pila(pila_a_invertir):
aux_Pila = Pila()
while (not pila_a_invertir.pila_vacia()):
aux_Pila.apilar(pila_a_invertir.desapilar())
return aux_Pila
def palindromo(cola):
piladerecha = Pila()
pilaizquierda = Pila()
t = cola.tamanio
cont = 0
mitad = (t // 2)
while (not cola_vacia(cola)):
a = atencion(cola)
cont += 1
if (t % 2 == 0):
if (cont <= mitad):
apilar(piladerecha, a)
elif (cont >= mitad + 1):
apilar(pilaizquierda, a)
else:
if (cont <= mitad):
apilar(piladerecha, a)
elif (cont >= mitad + 2):
apilar(pilaizquierda, a)
print(piladerecha.datos)
print(invertirPila(pilaizquierda).datos)
if (compararpilas(pilaizquierda, piladerecha) == True):
print("La palabra es palindroma.")
else:
print("La palabra no es palindroma.")
class Semantico():
def __init__(self):
self.tmp_index = 0
self.pila = Pila()
self.codigo = []
self.archivo = 'codigo.3ac'
def gen_temp(self):
tmp = "_tmp" + str(self.tmp_index)
self.tmp_index += 1
return tmp
def push(self, item):
self.pila.push(item)
def pop(self):
return self.pila.pop()
def agregar_linea_3ac(self, linea):
self.codigo.append(linea)
def generar_archivo_3ac(self):
with open(self.archivo, 'w') as f:
for line in self.codigo:
f.write('{}\n'.format(line))
def __init__(self, elemento):
"""
Inicializa el iterador a partir del nodo
parametrizado.
"""
self.actual = elemento
self.anteriores = Pila()
def apilarGenero(cola, genero):
pila = Pila()
while (cola.es_vacia() != True):
pelicula = cola.desencolar()
if (pelicula.genero == genero):
pila.apilar(pelicula)
return pila
def orden_topologico_dfs(grafo):
visitados = set()
pila = Pila()
for v in grafo:
if v not in visitados:
_orden_topologico_dfs(grafo, v, pila, visitados)
return pila.convertir_a_lista()
def dijkstra(self, ver_origen, ver_destino):
"""Algoritmo de Dijkstra para hallar el camino mas corto."""
no_visitados = HeapMin()
camino = Pila()
aux = 0
while (aux < self.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
vertice_aux = self.inicio.obtener_elemento(aux)
vertice_aux['anterior'] = None
if (vertice_aux['info'] == vertice['info']):
no_visitados.arribo([vertice_aux['info'], None], 0)
else:
no_visitados.arribo([vertice_aux['info'], None], inf)
aux += 1
while (not no_visitados.vacio()):
dato = no_visitados.atencion()
camino.apilar(dato)
pos_aux = self.buscar_vertice(dato[1][0])
vertice_aux = self.inicio.obtener_elemento(pos_aux)
aristas = 0
while (aristas < vertice_aux['aristas'].tamanio()):
arista = vertice_aux['aristas'].obtener_elemento(aristas)
pos_heap = no_visitados.busqueda(arista['destino'])
if (pos_heap is not None
and no_visitados.elementos[pos_heap][0] >
dato[0] + arista['peso']):
no_visitados.elementos[pos_heap][1][1] = dato[1][0]
nuevo_peso = dato[0] + arista['peso']
no_visitados.cambiar_prioridad(pos_heap, nuevo_peso)
aristas += 1
# print(no_visitados.elementos)
return camino
def ejercicio_24():
Mat = None
Vector = None
obj_Personajes_Marvel_Pila = Pila()
# MCU = [['Black Widow', 'Avengers Confidential', 'Iron Man: Rise of Technovore', 'Avengers: Infinity War'],
# ['Iron Man', 'Iron Man I', 'Iron Man II','Avengers Confidential', 'Iron Man: Rise of Technovore', 'The Invincible Iron Man', 'Avengers: Infinity War'],
# ['Hulk', 'Avengers Confidential', 'Hulk vs Thor', 'Avengers: Infinity War'],
# ['Hawkeye', 'Avengers Confidential'],
# ['Thor', 'Hulk vs Thor', 'Avengers: Infinity War'],
# ['Groot', 'Infinity War']
# ['Rocket Raccoon', 'Infinity War']]
MCU = [['Black Widow', 1, 3, 4, 5, 2, 4], ['Rocket Raccoon', 3, 7],
['Iron Man', 1, 3, 4, 5, 2, 4, 7, 9], ['Hulk', 9, 3, 4, 6],
['Hawkeye', 3], ['Groot', 2], ['Thor', 3, 4, 2, 1]]
for i in range(0, len(MCU)):
obj_Personajes_Marvel_Pila.apilar(MCU[i])
#A
print('\nPosicion de Groot y Rocket en la pila\n')
print(
get_mensaje_Posicion_De_Groot_And_Rocket(
get_Pos_Groot_And_Roket(obj_Personajes_Marvel_Pila)))
#B
print('\nPersonajes que aparecen en mas de 5 peliculas')
Mat = get_Personajes_Que_Aparecen_En_Mas_De_5_Peliculas_And_La_Cantidad(
obj_Personajes_Marvel_Pila)
if ((len(Mat) - 1) > 0):
for i in range(0, (len(Mat) - 1)):
print('\nNombre: ', Mat[i][0], '\nTotal Peliculas: ', Mat[i][1])
else:
print(
'\nNingun personaje de MCU en la pila que aparezca en mas de 5 peliculas'
)
#C
print('\nCantidad de peliculas en las que aparece Black Widow')
print(
'\n',
get_Mensaje_Black_Widow(
get_Cantidad_Peliculas_En_La_Que_Aparece_Black_Widow(
obj_Personajes_Marvel_Pila)))
#D
print('\nPersonajes que empiecen con C, D o G')
Vector = get_Nombres_Que_Empiezan_Con_C_D_And_G(obj_Personajes_Marvel_Pila)
if ((len(Vector) - 1) > 0):
for i in range(0, (len(Vector) - 1)):
print('\nNombre: ', Vector[i])
else:
print(
'\nNo hay personajes de MCU en la pila que empiecen con C, D o G')
#-------------------------FIN#-------------------------
def ejercicio_5():
obj_Pila = Pila()
palabra = input('Ingrese una palabra: ')
for letra in palabra:
obj_Pila.apilar(letra)
print(es_Palindromo(obj_Pila))
def test_push(self):
"Chequea que el elemento pusheado sea efectivamente el tope de la pila"
y="2"
x=1
pila1=Pila()
pila1.push(x)
pila1.push(y)
self.assertEqual(pila1.body[0],y)
def ejercicio_3():
obj_Pila = Pila()
for i in range(0, 100):
num = randint(1, 10)
obj_Pila.apilar(num)
obj_Pila = sacar_Ocurrencias_De_La_Pila(obj_Pila)
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,size):
self.pila = Pila()
self.pila.push('$')
self.pila.push('0')
self.columna = 0
self.cantidad = size
self.accion = ""
self.list_tmp = list()
self.arbol = []
def test_array(self):
"Chequea que el array de la pila solo puede tener listas"
pila1 = Pila()
pila1.body="aaaa"
self.assertTrue(type(pila1.body)==list)
pila1.body=(1,2,3)
self.assertTrue(type(pila1.body)==list)
pila1.body=[1,2,3]
self.assertTrue(type(pila1.body)==list)
def main():
libros = Pila()
for datos in readFile('libros.csv'):
libros.apilar(Libro(datos[0], datos[1], datos[2]))
print(libros.items)
print(len(libros.items))
print(buscar(libros, 'Anna Llenas'))
print(len(libros.items))
def __init__(self, lista_enlazada): """ Crea un iterador para una lista enlazada. Pre: recibe una lista enlazada. """ self.lista = lista_enlazada self.anterior = None self.actual = lista_enlazada.prim self.pila_anteriores = Pila() self.posicion = 0
def sacar_Impares_De_Pila(datos_pila):
aux_Pila = Pila()
while (not datos_pila.pila_vacia()):
elemento = datos_pila.desapilar()
if (elemento % 2 == 0):
aux_Pila.apilar(elemento)
return aux_Pila
def ejercicio_1():
obj_pila = Pila()
for i in range(0, 100):
num = randint(1, 10)
obj_pila.apilar(num)
numero = int(input('ingrese un numero: '))
print(retornar_Numero_De_Ocurrencias(obj_pila, numero))
def __init__(self, lista_canciones=[]):
""" Recibe una lista de objetos de clase Cancion con las canciones que se quieren
reproducir."""
lista = ListaEnlazada()
for cancion in lista_canciones:
lista.insert(cancion)
self.lista_canciones = lista
self.acciones_tomadas = Pila()
self.acciones_deshechas = Pila()
self.actual = 0
def invertir(cola):
pila1 = Pila()
pilaInvertida = Pila()
while not (cola_vacia(cola)):
a = atencion(cola)
apilar(pila1, a)
while not (pila_vacia(pila1)):
a = desapilar(pila1)
apilar(pilaInvertida, a)
return pilaInvertida
def generar_lista_partes():
""""No recibe nada. Devuelve una lista de partes random"""
partes = {}
for tipo_parte in TIPOS_PARTE:
pila_tipo_parte = Pila()
for _ in range(CANTIDAD_PARTES):
parte = Parte(tipo_parte)
agregar_armas_parte(parte)
pila_tipo_parte.apilar(parte)
partes[tipo_parte] = pila_tipo_parte
return partes
def movimientos_pista(estado):
'''Apila los movimientos de la solucion'''
pistas = Pila()
try:
resuelto, solucion = buscar_solucion(estado)
except:
return pistas
if resuelto:
for movimiento in solucion:
pistas.apilar(movimiento)
return pistas
def generar_lista_armas():
"""Devuelve una lista de armas random."""
armas={}
tipos_arma=(Arma.MELEE,Arma.RANGO)
tipos_municion=(Arma.MUNICION_FISICA,Arma.MUNICION_HADRON,Arma.MUNICION_LASER)
for tipo_arma in tipos_arma:
pila_tipo_arma=Pila()
for _ in range(CANTIDAD_DE_ARMAS):
pila_tipo_arma.apilar(Arma(random.choice(CLASES_ARMA),tipo_arma,random.choice(tipos_municion)))
armas[tipo_arma]=pila_tipo_arma
return armas
def __init__(self, estadoInicial, estadoAceptacion, simboloInicial):
self.estadoInicial = estadoInicial
self.estadoFinal = estadoAceptacion
self.edges = None
self.pila = Pila()
self.pilas = []
self.proceso = [] # 1 para meter, 0 para sacar
if simboloInicial != None:
self.pila.apilar(simboloInicial)
self.proceso.append([simboloInicial, 1, "", ""])
print(self.pila.verTope())
def sacar_Ocurrencias_De_La_Pila(datos_pila):
aux_Pila = Pila()
aux_Conjunto = list()
while (not datos_pila.pila_vacia()):
elemento = datos_pila.desapilar()
if (not (elemento in aux_Pila)):
aux_Conjunto.append(elemento)
aux_Pila.apilar(elemento)
return aux_Pila
def cfc(grafo):
visitados = set()
orden = {}
p = Pila()
s = Pila()
cfcs = []
en_cfs = set()
for v in grafo:
if v not in visitados:
orden[v] = 0
dfs_cfc(grafo, v, visitados, orden, p, s, cfcs, en_cfs)
return cfcs
def calculadora_polaca(elementos):
""" Dada una lista de elementos que representan las componentes de una expresion en
notacion polaca inversa, evalua dicha expresion.
Si la expresion esta mal formada, levanta ValueError """
p = Pila()
for elemento in elementos:
print(f"\nDEBUG: entra {elemento}")
# Intenta convertirlo a numero
try:
numero = float(elemento)
p.apilar(numero)
print(f"DEBUG: apila {numero}")
# si no se puede convertir, deberia ser un operando
except ValueError:
if elemento not in ('+', '-', '/', '*'):
raise ValueError("Operando inválido")
# Si es un operando válido, intenta desapilar y operar
try:
a1 = p.desapilar()
print(f"\nDEBUG: desapila {a1}")
a2 = p.desapilar()
print(f"\nDEBUG: desapila {a2}")
except IndexError:
raise ValueError("Faltan operandos..")
if elemento == "+":
resultado = a2 + a1
if elemento == "-":
resultado = a2 - a1
if elemento == "/":
resultado = a2 / a1
if elemento == "*":
resultado = a2 * a1
print(f"\nDEBUG: apila {resultado}")
p.apilar(resultado)
# Al final el resultado debe ser lo unico en la pila
resultado = p.desapilar()
if not p.esta_vacia():
raise ValueError("Sobran operandos")
return resultado
def es_Palindromo(palabra_pila):
pila_Inversa = Pila()
pila_Inversa = invertir_Pila_Sin_Perder_Elementos(palabra_pila)
while ((not palabra_pila.pila_vacia())
and (palabra_pila.elemento_cima() == pila_Inversa.elemento_cima())):
palabra_pila.desapilar()
pila_Inversa.desapilar()
if (palabra_pila.pila_vacia()):
return True
else:
return False
def invertir_Pila_Sin_Perder_Elementos(pila_a_invertir):
pila_Inversa = Pila()
aux_Pila = Pila()
#me da la pila invertida
while (not pila_a_invertir.pila_vacia()):
elemento = pila_a_invertir.desapilar()
pila_Inversa.apilar(elemento)
aux_Pila.apilar(elemento)
#le devuelvo los elementos que desapile a la pila original
while (not aux_Pila.pila_vacia()):
pila_a_invertir.apilar(aux_Pila.desapilar())
return pila_Inversa
def orden_topologico(grafo):
"""Devuelve una lista con el orden topologico con el que se debe
recorrer el grafo pasado por parametro. En caso de no existir
devuelve None."""
if not grafo:
return None
visitados = set()
pila = Pila()
for vertice in grafo.obtener_vertices():
if vertice not in visitados:
orden_topologico_dfs(grafo, vertice, pila, visitados)
return pila.pila_a_lista()
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.temp_booleano = 4000
self.temp_entero = 5000
self.temp_flotante = 6000
self.temp_dir = 7000
self.Bloque = 0
self.OPila = Pila()
self.TPila = Pila()
self.OpPila = Pila()
self.salto = Pila()
self.numCuad = 0
self.funcCuad = 0
self.cuad = []
self.DPila = Pila()
self.IDPila = Pila()
self.alcanceF = Pila()
self.alcance = ''
self.RT = ''
self.cubo_semantico = {
'=': {
'entero': {
'entero': 'entero',
'flotante': 'flotante'
},
'flotante': {
'entero': 'error',
'flotante': 'flotante'
}
},
'>': {
'entero': {
'entero': 'bool',
'flotante': 'bool'
},
'flotante': {
'entero': 'bool',
'flotante': 'bool'
}
},
'<': {
'entero': {
'entero': 'bool',
'flotante': 'bool'
},
'flotante': {
'entero': 'bool',
'flotante': 'bool'
}
},
'>=': {
'entero': {
'entero': 'bool',
'flotante': 'bool'
},
'flotante': {
'entero': 'bool',
'flotante': 'bool'
}
},
'<=': {
'entero': {
'entero': 'bool',
'flotante': 'bool'
},
'flotante': {
'entero': 'bool',
'flotante': 'bool'
}
},
'!=': {
'entero': {
'entero': 'bool',
'flotante': 'bool'
},
'flotante': {
'entero': 'bool',
'flotante': 'bool'
}
},
'==': {
'entero': {
'entero': 'bool',
'flotante': 'bool'
},
'flotante': {
'entero': 'bool',
'flotante': 'bool'
}
},
'+': {
'entero': {
'entero': 'entero',
'flotante': 'flotante'
},
'flotante': {
'entero': 'flotante',
'flotante': 'flotante'
}
},
'-': {
'entero': {
'entero': 'entero',
'flotante': 'flotante'
},
'flotante': {
'entero': 'flotante',
'flotante': 'flotante'
}
},
'*': {
'entero': {
'entero': 'entero',
'flotante': 'flotante'
},
'flotante': {
'entero': 'flotante',
'flotante': 'flotante'
}
},
'/': {
'entero': {
'entero': 'entero',
'flotante': 'flotante'
},
'flotante': {
'entero': 'flotante',
'flotante': 'flotante'
}
},
'$': {
'dir': {
'-1': 'dir'
}
}
}
class avail:
cubo_semantico = None
def __init__(self):
self.temp_booleano = 4000
self.temp_entero = 5000
self.temp_flotante = 6000
self.temp_dir = 7000
self.Bloque = 0
self.OPila = Pila()
self.TPila = Pila()
self.OpPila = Pila()
self.salto = Pila()
self.numCuad = 0
self.funcCuad = 0
self.cuad = []
self.DPila = Pila()
self.IDPila = Pila()
self.alcanceF = Pila()
self.alcance = ''
self.RT = ''
self.cubo_semantico = {
'=': {
'entero': {
'entero': 'entero',
'flotante': 'flotante'
},
'flotante': {
'entero': 'error',
'flotante': 'flotante'
}
},
'>': {
'entero': {
'entero': 'bool',
'flotante': 'bool'
},
'flotante': {
'entero': 'bool',
'flotante': 'bool'
}
},
'<': {
'entero': {
'entero': 'bool',
'flotante': 'bool'
},
'flotante': {
'entero': 'bool',
'flotante': 'bool'
}
},
'>=': {
'entero': {
'entero': 'bool',
'flotante': 'bool'
},
'flotante': {
'entero': 'bool',
'flotante': 'bool'
}
},
'<=': {
'entero': {
'entero': 'bool',
'flotante': 'bool'
},
'flotante': {
'entero': 'bool',
'flotante': 'bool'
}
},
'!=': {
'entero': {
'entero': 'bool',
'flotante': 'bool'
},
'flotante': {
'entero': 'bool',
'flotante': 'bool'
}
},
'==': {
'entero': {
'entero': 'bool',
'flotante': 'bool'
},
'flotante': {
'entero': 'bool',
'flotante': 'bool'
}
},
'+': {
'entero': {
'entero': 'entero',
'flotante': 'flotante'
},
'flotante': {
'entero': 'flotante',
'flotante': 'flotante'
}
},
'-': {
'entero': {
'entero': 'entero',
'flotante': 'flotante'
},
'flotante': {
'entero': 'flotante',
'flotante': 'flotante'
}
},
'*': {
'entero': {
'entero': 'entero',
'flotante': 'flotante'
},
'flotante': {
'entero': 'flotante',
'flotante': 'flotante'
}
},
'/': {
'entero': {
'entero': 'entero',
'flotante': 'flotante'
},
'flotante': {
'entero': 'flotante',
'flotante': 'flotante'
}
},
'$': {
'dir': {
'-1': 'dir'
}
}
}
#regresa el tipo de la operacion
def get_tipo(self, argOper, uno, dos):
esperado = self.cubo_semantico.get(argOper)
if esperado != None:
esperado = esperado.get(uno)
if esperado != None:
esperado = esperado.get(dos)
return esperado
print 'error'
#se crea un nuevo valor temporal en base al resultado del cubo semantico
def get_temporal(self, argOper, uno, dos):
tempoTipo = self.get_tipo(argOper, uno, dos)
if tempoTipo == 'entero':
res = self.temp_entero
self.temp_entero += 1
elif tempoTipo == 'flotante':
res = self.temp_flotante
self.temp_flotante += 1
elif tempoTipo == 'bool':
res = self.temp_booleano
self.temp_booleano += 1
elif uno == 'dir':
res = self.temp_dir
self.temp_dir += 1
res += (self.Bloque * 10000)
return [res, self.get_tipo(argOper, uno, dos)]
#regresa el bloque actual
def getBloque(self):
return self.Bloque
#resetea la memoria para el siguiente bloque
def setBloque(self, Bloque):
self.Bloque = Bloque
self.temp_booleano = 4000
self.temp_entero = 5000
self.temp_flotante = 6000
self.temp_dir = 7000
#regresa la memoria necesaria para las temporales
def get_temporal_dirs(self):
return [(self.temp_booleano-4000), (self.temp_entero-5000), (self.temp_flotante-6000), (self.temp_dir-7000)]
#si hay una expresion para resolver
def expresion(self):
if(self.OpPila.size() > 0):
if(self.OpPila.peek() == '>' or self.OpPila.peek() == '<' or self.OpPila.peek() == '!=' or self.OpPila.peek() == '==' or self.OpPila.peek() == '<=' or self.OpPila.peek() == '>='):
self.quad()
#si hay una operacion se suma o resta
def sum_res(self):
if(self.OpPila.size() > 0):
if(self.OpPila.peek() == '+' or self.OpPila.peek() == '-'):
self.quad()
#si hay una operacion de multiplicacion o division
def mult_div(self):
if(self.OpPila.size() > 0):
if(self.OpPila.peek() == '*' or self.OpPila.peek() == '/'):
self.quad()
#crea una asignacion
def asign(self, dato):
if(self.OPila.size() > 0):
self.numCuad += 1
cuads = [101, self.OPila.pop(), -1, dato]
self.cuad.append(cuads)
#saca uno de los valores de la temporal
def rep_salto(self, primDir, dirInic):
valT = self.OPila.pop()
cuads = ['-', valT, primDir, valT]
self.numCuad += 1
self.cuad.append(cuads)
salto = self.salto.pop()
aux = self.get_temporal('==', self.TPila.pop(), 'entero')
cuads = ['==', valT, dirInic, aux[0]]
self.numCuad += 1
self.cuad.append(cuads)
cuads = ['GOTOF', aux[0], -1, salto]
self.numCuad += 1
self.cuad.append(cuads)
#al inicio de una condicion se crea un gotof y se almacena el num de cuadruplo en la pila de saltos
def condicion(self):
estCondic = self.OPila.pop()
tipoCondicion = self.TPila.pop()
if(tipoCondicion != "bool"):
print "Error, el tipo no coincide"
sys.error(0)
else:
cuads = ['GOTOF', estCondic, -1, -1]
self.cuad.append(cuads)
self.numCuad += 1
self.salto.push(self.numCuad)
#al final de una condicion llena el ultimo goto que fue creado con el cuadruplo actual
def condicion_inicio(self):
if(self.salto.size() > 0):
salto = self.salto.pop() - 1
cuads = self.cuad[salto]
cuads[3] = self.numCuad
self.cuad[salto] = cuads
#si hay un else, se debe llenar el goto del if y crear un nuevo goto
def condition_else(self):
salto = self.salto.pop() -1
cuads = self.cuad[salto]
cuads[3] = self.numCuad +1
self.cuad[salto] = cuads
cuads = ['GOTO', -1, -1, -1]
self.cuad.append(cuads)
self.numCuad += 1
self.salto.push(self.numCuad)
#revisa si la funcion regreso, si no crea un cuadruplo en la pila de operadores
def funcion_return(self, vacio, valDireccion):
if(vacio):
cuads = ['RETURN',-1, -1, -1]
self.numCuad += 1
self.cuad.append(cuads)
return False
else:
cuads = ['RETURN', self.OPila.pop(), -1, valDireccion]
self.numCuad += 1
self.cuad.append(cuads)
return True
#final del cuadruplo
def function_end(self):
cuads = ['ENDPROC', 1, -1, 1]
self.numCuad += 1
self.cuad.append(cuads)
#checa los parametros de las funciones de acuerdo al orden
def function_param(self, varParametro):
numParams = len(varParametro)
if self.OPila.size() < numParams:
print "Faltan paramentros de la funcion"
sys.exit(0)
lista = []
numParams = len(varParametro) -1
while numParams >= 0:
for key in varParametro:
if numParams == varParametro[key][1]:
cuads = ['PARAMETRO', self.OPila.pop(), -1, varParametro[key][2]]
print cuads
numParams -= 1
self.numCuad += 1
self.cuad.append(cuads)
#cuadruplo que contiene el nombre de la funcion la cual se esta llamando
def llama_funcion(self, param):
cuads = ['ERA', -1, -1, param]
self.numCuad += 1
self.cuad.append(cuads)
self.OpPila.push('(')
#se hace un go sub a la funcion de la gual se hizo el go, se hace una asignacion en caso de que se regrese un valor en una temporal
def llama_funcion_final(self,param, valDire, valTempo):
cuads = ['GOSUB', -1, -1, param]
self.numCuad += 1
self.cuad.append(cuads)
cuads = ['101', valDire, -1, valTempo]
self.OPila.push(valTempo)
self.numCuad += 1
self.cuad.append(cuads)
self.OpPila.pop()
#crea una copia del numero que representa las veces que el bloque fue creado, y almacena el valor en la pila
def rep(self):
aux = self.get_temporal('-', self.TPila.peek(), self.TPila.pop())
valT = aux[0]
cuads = [101, self.OPila.pop(), -1, valT]
self.numCuad += 1
self.cuad.append(cuads)
self.salto.push(self.numCuad)
self.OPila.push(valT)
self.TPila.push(aux[1])
#para los arreglos, crea un cuad que checa que el valor ente en el rango
def dim(self, tamDim, vapunta):
cuads = ['DIM', tamDim, vapunta, -1]
self.numCuad += 1
self.cuad.append(cuads)
self.numCuad += 1
aux = self.get_temporal('$', 'dir', -1)
valT = aux[0]
cuads = ['DIR', self.OPila.pop(), vapunta, valT]
self.cuad.append(cuads)
self.OPila.push(valT)
#para las matrices, pointer representa las filas
def dmT(self, tamDim, vapunta):
aux = self.get_temporal('+', 'entero', 'entero')
valT = aux[0]
cuads = ['*', vapunta, '40002', valT]
self.cuad.append(cuads)
vapunta = valT
cuads = ['DIM', tamDim, vapunta, -1]
self.cuad.append(cuads)
aux = self.get_temporal('$', 'dir', -1)
valT = aux[0]
saleRes = self.OPila.pop()
cuads = ['DIR', saleRes, vapunta, valT]
uno = valT
self.cuad.append(cuads)
aux = self.get_temporal('+', 'entero', 'entero')
valT = aux[0]
cuads = ['+', vapunta, '40000', valT]
self.cuad.append(cuads)
self.OPila.push(valT)
aux = self.get_temporal('$', 'dir', -1)
valT = aux[0]
cuads = ['DIR', saleRes, self.OPila.pop(), valT]
self.cuad.append(cuads)
tempo = self.OPila.pop()
self.OPila.push(valT)
self.OPila.push(tempo)
self.OPila.push(uno)
self.numCuad += 4
#al inicializar una matriz, revisa la dimension, crea un apuntador para que asigne algo al siguiente valor
def dmTP(self, valDire, casilla, valTam):
casilla *= 2
cuads = ['DIMC', valTam, casilla, -1]
self.cuad.append(cuads)
aux = self.get_temporal('$', 'dir', -1)
valT = aux[0]
cuads = ['DIRC', valDire, (casilla+1), valT]
self.cuad.append(cuads)
self.asign(valT)
aux = self.get_temporal('$', 'dir', -1)
valT = aux[0]
cuads = ['DIRC', valDire, casilla, valT]
self.cuad.append(cuads)
self.asign(valT)
self.numCuad += 3
#checa la dimension, obtiene la direccion del puntero, cuad que genera la direccion actual
def dmP(self, valDire, casilla, valTam):
cuads = ['DIMC', valTam, casilla, -1]
self.cuad.append(cuads)
aux = self.get_temporal('$', 'dir', -1)
valT = aux[0]
cuads = ['DIRC', valDire, casilla, valT]
self.cuad.append(cuads)
self.asign(valT)
self.numCuad += 2
#crea el goto al main, gurda el numero de cuadruplo en la pila de saltos
def princ(self):
cuads = ['GOTO', -1, -1, -1]
self.cuad.append(cuads)
self.salto.push(self.numCuad)
self.numCuad += 1
#hace el goto al programa principal
def princ_goto(self):
salto = self.salto.pop()
cuads = self.cuad[salto]
cuads[3] = self.numCuad
self.cuad[salto] = cuads
#concatena los cuadruplos
def append_quad(self, cuadruplo):
self.numCuad += 1
self.cuad.append(cuadruplo)
#usado por las funciones que solo tienen un parametro
def append_quad_uno(self, unoFuncion):
self.numCuad += 1
cuads = [unoFuncion, self.OPila.pop(), -1, -1]
self.TPila.pop()
self.cuad.append(cuads)
#usado por funciones que tienen dos parametros
def append_quad_dos(self, dosFuncion):
self.numCuad += 1
dosParam = self.OPila.pop()
self.TPila.pop()
cuads = [dosFuncion, self.OPila.pop(),dosParam, -1]
self.TPila.pop()
self.cuad.append(cuads)
#usado por funciones con tres parametros
def append_quad_tres(self, tresFuncion):
self.numCuad += 1
uno = self.OPila.pop()
self.TPila.pop()
dos = self.OPila.pop()
self.TPila.pop()
cuads = [tresFuncion, self.OPila.pop(), dos, uno]
self.TPila.pop()
self.cuad.append(cuads)
#usado por la funcion del triangulo
def append_quad_tri(self, triaFuncion):
self.numCuad += 2
y3 = self.OPila.pop()
self.TPila.pop()
x3 = self.OPila.pop()
self.TPila.pop()
y2 = self.OPila.pop()
self.TPila.pop()
x2 = self.OPila.pop()
self.TPila.pop()
y = self.OPila.pop()
self.TPila.pop()
x = self.OPila.pop()
self.TPila.pop()
spQuad = [triaFuncion, x, y, -1]
self.cuad.append(spQuad)
spQuad = [x2, y2, x3, y3]
self.cuad.append(spQuad)
#lo utilizan las expresiones para crear cuadruplos
def quad(self):
self.numCuad += 1
aux = self.get_temporal(self.OpPila.peek(), self.TPila.pop(), self.TPila.pop())
valT = aux[0]
operando2 = self.OPila.pop()
cuads = [self.OpPila.pop(), self.OPila.pop(), operando2, valT]
self.cuad.append(cuads)
self.OPila.push(valT)
self.TPila.push(aux[1])
#imprime info
def printS(self):
print self.OPila.printi()
#crea un apuntador a una direccion
def get_temporal_point(self):
aux = self.get_temporal('$', 'dir', -1)
return aux[0]
def OpPila_pop(self):
self.OpPila.pop()
def OpPila_push(self, op):
self.OpPila.push(op)
def TPila_push(self, op):
self.TPila.push(op)
def TPila_pop(self, ):
self.TPila.pop()
def OPila_push(self, op):
self.OPila.push(op)
def OPila_pop(self):
return self.OPila.pop()
def OPila_peek(self):
return self.OPila.peek()
def DPila_push(self, op):
self.DPila.push(op)
def DPila_pop(self):
return self.DPila.pop()
def IDPila_push(self, op):
self.IDPila.push(op)
def IDPila_pop(self):
return self.IDPila.pop()
def print_cuad(self):
print self.cuad
def get_cuad(self):
return self.cuad
def setalcance(self, alcance):
self.alcance = alcance
def getalcance(self):
return self.alcance
def setFuncalcance(self, alcance):
self.alcanceF.push(alcance)
def delFuncalcance(self):
self.alcanceF.pop()
def getFuncalcance(self):
return self.alcanceF.peek()
def setRT(self, RT):
self.RT = RT
def getRT(self):
return self.RT
def setfuncCuad(self):
self.funcCuad = self.numCuad
def getfuncCuad(self):
return self.funcCuad
class ColaDeReproduccion:
"""Clase que representa la cola de reproduccion del reproductor. Permite agregar y remover
canciones, ademas de poder hacer y deshacer estas acciones. Las canciones se guardan en la
cola como objetos de clase Cancion."""
AGREGADA = 1
REMOVIDA = 0
def __init__(self, lista_canciones=[]):
""" Recibe una lista de objetos de clase Cancion con las canciones que se quieren
reproducir."""
lista = ListaEnlazada()
for cancion in lista_canciones:
lista.insert(cancion)
self.lista_canciones = lista
self.acciones_tomadas = Pila()
self.acciones_deshechas = Pila()
self.actual = 0
def cancion_actual(self):
""" Devuelve un objeto de clase Cancion que corresponde a la cancion actual, o None si no
hay canciones cargadas en la cola."""
if self.lista_canciones.esta_vacia():
return None
try:
cancion = self.lista_canciones.get_elemento(self.actual)
except IndexError:
return
return cancion
def cancion_siguiente(self):
""" Devuelve un objeto de clase Cancion que corresponde a la cancion siguiente en la cola,
o None si no hay mas canciones."""
if len(self.lista_canciones) < 1:
return None
try:
cancion = self.lista_canciones.get_elemento(self.actual + 1)
self.actual += 1
except IndexError:
return
return cancion
def cancion_anterior(self):
""" Devuelve un objeto de clase Cancion que corresponde a la cancion anterior en la cola,
o None si no hay canciones en la misma o la actual es la primera de la cola."""
if len(self.lista_canciones) < 1:
return None
try:
cancion = self.lista_canciones.get_elemento(self.actual - 1)
self.actual -= 1
except IndexError: #No hay cancion anterior
return
return cancion
def agregar_cancion(self, ruta_cancion):
""" Agrega una Cancion a la cola a partir de su ruta. Devuelve True si se agrego
correctamente, False en caso contrario. Esta accion puede deshacerse y rehacerse."""
try:
self.agregar_cancion_sin_guardar(ruta_cancion)
self.guardar_accion(ruta_cancion, self.AGREGADA)
return True
except (TinyTagException, LookupError, OSError):
return False
def remover_cancion(self, ruta_cancion):
""" Remueve una Cancion de la cola a partir de su ruta. Devuelve True si se removio
correctamente, False en caso contrario. Esta accion puede deshacerse y rehacerse."""
try:
resultado = self.remover_cancion_sin_guardar(ruta_cancion)
self.guardar_accion(ruta_cancion, self.REMOVIDA)
return resultado
except (TinyTagException, LookupError, OSError):
return False
def deshacer_modificacion(self):
""" Deshace la ultima accion realizada. Devuelve True si pudo deshacerse, False en caso
contrario."""
try:
ruta_ultima_cancion, ultima_accion = self.acciones_tomadas.desapilar()
if ultima_accion == self.AGREGADA:
self.remover_cancion_sin_guardar(ruta_ultima_cancion)
self.acciones_deshechas.apilar((ruta_ultima_cancion, self.AGREGADA))
return True
self.agregar_cancion_sin_guardar(ruta_ultima_cancion)
self.acciones_deshechas.apilar((ruta_ultima_cancion, self.REMOVIDA))
return True
except (ValueError, IndexError):
return False
def rehacer_modificacion(self):
""" Rehace la ultima accion que se deshizo. Devuelve True si pudo rehacerse, False en caso
contrario."""
try:
ruta_ultima_cancion, ultima_accion = self.acciones_deshechas.desapilar()
if ultima_accion == self.AGREGADA:
self.agregar_cancion_sin_guardar(ruta_ultima_cancion)
self.acciones_tomadas.apilar((ruta_ultima_cancion, self.AGREGADA))
return True
self.remover_cancion_sin_guardar(ruta_ultima_cancion)
self.acciones_tomadas.apilar((ruta_ultima_cancion, self.REMOVIDA))
return True
except (ValueError, IndexError):
return False
def obtener_n_siguientes(self, n_canciones):
""" Devuelve una lista con las siguientes n canciones. Si en la cola de reproduccion
quedan menos canciones que las pedidas, la lista contendra menos elementos que los
pedidos."""
if self.lista_canciones.esta_vacia():
return None
lista = []
for i in range(n_canciones):
try:
lista.append(self.lista_canciones.get_elemento(self.actual + 1 + i))
except IndexError:
return lista
return lista
def __str__(self):
return str(self.lista_canciones)
def guardar_accion(self, ruta_cancion, accion):
"""Guarda la accion como una tupla (ruta_cancion, accion)."""
self.acciones_tomadas.apilar((ruta_cancion, accion))
def agregar_cancion_sin_guardar(self, ruta_cancion):
"""Agrega la cancion a la lista de reproduccion."""
cancion = Cancion(ruta_cancion)
self.lista_canciones.insert(cancion)
def remover_cancion_sin_guardar(self, ruta_cancion):
"""Remueve la cancion de la lista de reproduccion.
Devuelve True en caso que sea exitoso y False en caso contrario."""
cancion = Cancion(ruta_cancion)
posicion = self.lista_canciones.index(cancion)
if posicion:
self.lista_canciones.pop(posicion)
return True
return False
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()
def setUp(self):
self.pila = Pila()
self.d1 = 'dummy1'
self.d2 = 'dummy2'
self.d3 = 'dummy3'
self.d4 = 'dummy4'
class TestPila(unittest.TestCase):
def setUp(self):
self.pila = Pila()
self.d1 = 'dummy1'
self.d2 = 'dummy2'
self.d3 = 'dummy3'
self.d4 = 'dummy4'
def test_inicio(self):
self.assertIsInstance(self.pila._datos, ListaConPyLista)
def test_poner(self):
self.pila.poner(self.d1)
expected = str([self.d1])
self.assertEqual(expected, str(self.pila))
self.pila.poner(self.d2)
expected = str([self.d1, self.d2])
self.assertEqual(expected, str(self.pila))
self.pila.poner(self.d3)
expected = str([self.d1, self.d2, self.d3])
self.assertEqual(expected, str(self.pila))
self.pila.poner(self.d4)
expected = str([self.d1, self.d2, self.d3, self.d4])
self.assertEqual(expected, str(self.pila))
def test_sacar(self):
self.pila.poner(self.d1)
self.pila.poner(self.d2)
self.pila.poner(self.d3)
self.pila.poner(self.d4)
self.assertEqual(self.d4, self.pila.sacar())
self.assertEqual(self.d3, self.pila.sacar())
self.assertEqual(self.d2, self.pila.sacar())
self.assertEqual(self.d1, self.pila.sacar())
self.assertRaises(IndexError, self.pila.sacar)
def test_tope(self):
self.pila.poner(self.d1)
self.assertEqual(self.d1, self.pila.tope())
self.pila.poner(self.d2)
self.assertEqual(self.d2, self.pila.tope())
self.pila.poner(self.d3)
self.assertEqual(self.d3, self.pila.tope())
self.pila.poner(self.d4)
self.assertEqual(self.d4, self.pila.tope())
def test_EsVacia_si(self):
self.assertTrue(self.pila.esVacia())
self.pila.poner(self.d1)
elem = self.pila.sacar()
self.assertTrue(self.pila.esVacia())
def test_EsVacia_no(self):
self.pila.poner(self.d1)
self.assertFalse(self.pila.esVacia())
self.pila.poner(self.d2)
self.assertFalse(self.pila.esVacia())
elem = self.pila.sacar()
self.assertFalse(self.pila.esVacia())
def __init__(self, s=""):
self.__tokens = Pila()
self.__string = s + " "
self.__busqueda = -1
self.__actual = 0
class Lexico():
def __init__(self, s=""):
self.__tokens = Pila()
self.__string = s + " "
self.__busqueda = -1
self.__actual = 0
def getTokens(self):
return self.__tokens
def dame(self):
self.__busqueda += 1
if self.__busqueda >= len(self.__string):
return ""
else:
return self.__string [self.__busqueda]
def falla(self):
self.__busqueda = self.__actual - 1
def retraer(self):
self.__busqueda -= 1
def aceptar(self):
self.__actual = self.__busqueda + 1
def getValor(self):
return self.__string[self.__actual:self.__busqueda]
def instalar(self, tipo, valor):
tkn = {}
tkn["type"] = tipo
tkn["value"] = valor
if tipo == "ID":
if valor == "V" or valor == "F":
tkn["type"] = "Logico"
elif valor == "EVAL" or valor == "SI" or valor == "MIENTRAS"\
or valor == "IMPRIMIR" or valor == "LEER":
tkn["type"] = "Res"
self.__tokens.push(tkn)
def esLetra(self, x):
return "a" <= x <= "z" or "A" <= x <= "Z" or x == "_"
def esDigito(self, x):
return "0" <= x <= "9"
def esOperadorMatematico(self, x):
return x in ['+', '-', '*', '/', '%','=', '!', '>', '<', '|', '&']
def esEspacio(self, x):
return x in [" ", "\n"]
def esSigno(self, x):
return x in ['+', '-']
def esDesconocido(self, x):
return not (self.esDigito(x) or self.esOperadorMatematico(x) or \
self.esEspacio(x) or x == "" or self.esLetra(x) or self.esSigno(x) \
or x ==":" or x == ";")
def analizar(self):
while self.__actual < len(self.__string):
c = self.dame()
if c == ":":
cont = True
b = 1
while cont:
c = self.dame()
if c == ":":
b += 1
elif c == ";":
b -= 1
if b == 0:
cont = False
self.dame()
self.instalar("Bloque", self.getValor())
self.retraer()
self.aceptar()
else:
self.falla()
c = self.dame()
if self.esDigito(c) or self.esSigno(c):
if self.esSigno(c):
c = self.dame()
if self.esDigito(c):
while self.esDigito(c):
c = self.dame()
if c == ".":
c = self.dame()
if self.esDigito(c):
while self.esDigito(c):
c = self.dame()
self.instalar("Flotante", float(self.getValor()))
self.retraer()
self.aceptar()
else:
self.instalar("Entero", int(self.getValor()))
self.retraer()
self.aceptar()
else:
self.falla()
else:
self.falla()
c = self.dame()
if self.esLetra(c):
while self.esLetra(c) or self.esDigito(c):
c = self.dame()
self.instalar("ID", self.getValor())
self.retraer()
self.aceptar()
else:
self.falla()
c = self.dame()
if self.esOperadorMatematico(c):
while self.esOperadorMatematico(c):
c = self.dame()
self.instalar("Op", self.getValor())
self.retraer()
self.aceptar()
else:
self.falla()
c = self.dame()
if self.esEspacio(c):
while self.esEspacio(c):
c = self.dame()
self.retraer()
self.aceptar()
else:
self.falla()
c = self.dame()
if c == "":
self.instalar("Fin", "")
else:
self.falla()
c = self.dame()
if self.esDesconocido(c):
self.instalar("Error", "%s -> %d"%(c, self.__busqueda))
self.aceptar()
else:
self.falla()
