def p_add_For_2(p):
	'''add_For_2 : empty '''
	auxExp1 = PilaO.pop()
	p
	auxID = PilaO.pop()
	PilaO.append(auxID)
	add_quadruple('=', auxID, -1, auxExp1, -1, 0)

def p_add_For_4(p):
	'''add_For_4 : empty '''
	auxID = PilaO.pop()
	add_quadruple('+', auxID, -1, auxID, -1, 0)
	retorno = PSaltos.pop()
	add_quadruple('GOTO', retorno, -1, -1, -1, 0)
	rellenar_cuadruplo(retorno+1)

def p_add_While_3(p):
	'''add_While_3 : empty '''
	if (PSaltos):
		falso = PSaltos.pop()
		retorno = PSaltos.pop()
		add_quadruple('GOTO', retorno, -1, -1, -1, 0) #se genera cuadruplos GOTO, no tiene operandos nulos y una casilla vacia
		rellenar_cuadruplo(falso)

def p_add_Lectura2(p):
	'''add_Lectura2 :  empty'''
	#PilaO.append()				# Se otiene el ID directamente y se manda a la pila
	#operandoTEMPORAL = PilaO.pop()  # Se obtiene operando y se genera el cuadruplo
	operandoTEMPORAL = PilaO.pop()

	add_quadruple('INPUT',  operandoTEMPORAL, -1, -1, -1, 0) #se genera cuadruplos INPUT

def p_add_Regresa(p):
	''' add_Regresa : empty '''
	if(PilaO):
		tipoTEMPORAL = PTipos.pop()
		operandoTEMPORAL = PilaO.pop()
		#print(operandoTEMPORAL)
		add_quadruple('RETURN', operandoTEMPORAL, -1, -1, -1, 0) #se genera cuadruplos REGRESA

def p_add_Main_3(p):
	'''add_Main_3 : empty'''
	proc_brackList.pop()
	while(var_brackList):
		var_brackList.pop()
	directorio_Activo['local'] = {} #Se libera la tabla de variables locales
	add_quadruple('END', -1, -1, -1, -1, 0) #se genera cuadrplo de fin de programa

def p_add_For_2(p):
	'''add_For_2 : empty '''
	auxExp1 = PilaO.pop()
	#print("Imprimiendo auxExp1: ", auxExp1)
	auxID = PilaO.pop()
	#print("Imprimiendo auxID: ", auxID)
	PilaO.append(auxID)
	add_quadruple('=', auxID, -1, auxExp1, -1, 0)

def p_add_Escritura(p):
	'''add_Escritura : empty'''
	#PilaO.append(p[-1])				# Se otiene el ID directamente y se manda a la pila
	#print("imprimiendo esto: ", PilaO)

	operandoTEMPORAL = PilaO.pop()  # Se obtiene operando y se genera el cuadruplo
	#print(operandoTEMPORAL)

	add_quadruple('OUTPUT', operandoTEMPORAL, -1, -1, -1, 0) #se genera cuadruplos OUTPUT

def p_add_Llamada_Factor_1(p):
	'''add_Llamada_Factor_1 :  empty'''
	if (proc_exists_in_list(p[-1])):
		funcion_id.append(p[-1])	#Se guarda el nombre de la funcion que inicio la llamada en una lista = funcion_id
		add_quadruple('ERA', p[-1], -1, -1, -1, 0)  #Se genera el cuadruplo ERA, tiene expansion del registro activacion de acuerdo al tamano definido
		contador_k = [0]  # Se inicializa el contador k en 1
		POper.append('[')	#Agregando el fondo falso
	else:
		print ('<---[UNDECLARED_FUNCTION][Llamada_Factor]; Procedimiento "{0}" no se encuentra previamente declarado--->'.format(p[-1]))
		exit(1)

def p_add_For_4(p):
	'''add_For_4 : empty '''
	print(PilaO)
	auxID = PilaO.pop()
	print(PilaO)
	#add_quadruple('+', auxID, -1, auxID, -1, 0)
	resultado_cuadruplo = add_quadruple('+', auxID, -1, 1, -1, 0)  #PREGUNTAR A NERI SI ESTO DEBE SER, O EL DE ARRIBA
	add_quadruple('=', auxID, -1, resultado_cuadruplo, -1, 0)  #PREGUNTAR A NERI SI ESTO DEBE SER, O EL DE ARRIBA
	retorno = PSaltos.pop()
	add_quadruple('GOTO', retorno, -1, -1, -1, 0)
	rellenar_cuadruplo(retorno+1)

def p_add_While_3(p):
	'''add_While_3 : empty '''
	if (PSaltos):
		falso = PSaltos.pop()
		retorno = PSaltos.pop()
		add_quadruple('GOTO', retorno, -1, -1, -1, 0) #se genera cuadruplos GOTO, no tiene operandos nulos y una casilla vacia
		rellenar_cuadruplo(falso)
	#PSaltos.append(get_count_cuadruplos)  # meter cont en PSaltos

			
	auxID = 

def p_add_Llamada_1(p):
	'''add_Llamada_2 : empty '''
	#global contador_parametros
	print("Nombre funcion")
	print(p[-2])
	if (proc_exists_in_list(p[-2])):
		#print(p[-2])
		add_quadruple('ERA', p[-2], -1, -1, -1)  #Se genera el cuadruplo ERA, tiene expansion del registro activacion de acuerdo al tamano definido
		contador_k = [0]  # Se inicializa el contador k en 1		
	else:
		print ('<---[UNDECLARED_FUNCTION][Llamada]; Procedimiento "{0}" no se encuentra previamente declarado--->'.format(p[-2]))
		exit(1)

def p_add_Lectura1(p):
	'''add_Lectura1 :  empty'''
	#PilaO.append()				# Se otiene el ID directamente y se manda a la pila
	#operandoTEMPORAL = PilaO.pop()  # Se obtiene operando y se genera el cuadruplo
	nombre = proc_brackList.pop()
	proc_brackList.append(nombre)
	if(busca_variable_en_directorio(nombre, p[-1])):
	#print(operandoTEMPORAL)
		add_quadruple('INPUT',  p[-1], -1, -1, -1, 0) #se genera cuadruplos INPUT
	else:
		print ('<---[UNDECLARED_VARIABLE][Lectura]; Variable "{0}" no se encuentra previamente definida--->'.format( p[-1]))
		exit(1)		

def p_add_Funcion_3(p):
	'''add_Funcion_3 : empty'''
	add_quadruple('ENDPROC', -1, -1, -1, -1, 0) #se genera cuadrplo de fin de programa
	#print("Aqui estoy")
	#pp.pprint(directorio_Activo)
	proc_brackList.pop()
	while(var_brackList):
		var_brackList.pop()
	x.procsLocal.update(directorio_Activo['local'])
	#print("wow")
	#pp.pprint(directorio_Activo)
	#pp.pprint("ACTUALIZANDO X.PROCS")
	#pp.pprint(directorio_Activo)
	directorio_Activo['local'] = {} #Se libera la tabla de variables locales

def p_add_For_3(p):
	'''add_For_3 : empty '''
	auxExp2 = PilaO.pop()
	temp_Tf = auxExp2
	temp_Tx = 0
	resultado_Tf = add_quadruple('=', auxExp2, -1, temp_Tf, -1, 1)
	#pp.pprint(get_cuadruplos())
	auxID = PilaO.pop()
	PilaO.append(auxID)
	resultado_Tx = add_quadruple('<=', auxID, -1, resultado_Tf, -1, 0)
	
	add_quadruple('GOTOF', resultado_Tx, -1, -1, -1, 0) #se genera cuadruplo 
	#liberar Tx
	PSaltos.append(get_count_cuadruplos() - 2)

def p_add_While_3(p):
	'''add_While_3 : empty '''
	if (PSaltos):
		falso = PSaltos.pop()
		retorno = PSaltos.pop()
		add_quadruple('GOTO', retorno, -1, -1, -1, 0) #se genera cuadruplos GOTO, no tiene operandos nulos y una casilla vacia
		rellenar_cuadruplo(falso)
	#PSaltos.append(get_count_cuadruplos)  # meter cont en PSaltos

			
#def p_loopfor(p):
#	''' LoopFor : FOR PAR_I Asignacion PCOMA Expresion add_For_1 PCOMA Expresion add_For_2 PAR_D Bloque add_For_3 '''
	add_quadruple('=',auxExp1,-1,auxID, )
#	''' LoopFor : FOR PAR_I Asignacion PCOMA Expresion PCOMA Expresion PAR_D Bloque '''
	''' LoopFor : FOR ID add_For_1 EXP_EQ Expresion add_For_2 TO Expresion add_For_3 DO Bloque add_For_4 '''

def p_add_Llamada_3(p):
	'''add_Llamada_3 : empty '''
	valor_argumento = PilaO.pop() #aqui estamos obteniendo el 2.4
	tipo_argumento = PTipos.pop() #tipo de 2.4 = float
	
	#print()
	nombre_funcion = funcion_id.pop() 
	funcion_id.append(nombre_funcion)

	#print(funcion_id)
	count = contador_k.pop()
	#print(count)
	tipo2 = x.procsLocal[nombre_funcion]['Var_Table'].values()[count]['Tipo']
	#aux = x.procsLocal[nombre_funcion]['Var_Tables'].keys()
	#x.procsLocal[nombre_funcion]['Var_Table'].keys()[n]
	
	#print('Lado izquierdo "{0}" Lado derecho "{1}"'.format(tipo_argumento, valor_argumento))
	#print(PilaO)
	#pp.pprint(get_cuadruplos())	
	#tipo2 = vars_return_type(nombre_funcion, count)
	#print("El tipo1: "+tipo_argumento)
	#print("El tipo2: "+tipo2)
	#print(tipo_argumento)
	#pp.pprint(get_cuadruplos())
	if(tipo_argumento == tipo2):
		resultado_quadruple = add_quadruple('PARAMETER', valor_argumento, -1, ('Param' + str(count)), 0)  #Se genera el cuadruplo PARAMETER, tiene el k-esimo argumento
		contador_k.append(count)
		#PilaO.append(resultado_quadruple)
	else:
		print ('<---[ERROR_TYPE_MISMATCH][Llamada]; No se puede hacer la operacion con los tipos: "{0}" y "{1}"--->'.format(tipo2, tipo_argumento))
		exit(1)

def p_add_Llamada_Factor_3(p):
	'''add_Llamada_Factor_3 : empty '''
	valor_argumento = PilaO.pop() #
	tipo_argumento = PTipos.pop() #
	
	nombre_funcion = funcion_id.pop() 
	funcion_id.append(nombre_funcion)
	#print("Count: ", contador_k)
	count = contador_k.pop()
	#print('Lado izquierdo "{0}" Lado derecho "{1}"'.format(valor_argumento, tipo_argumento))
	
	max_Param = x.procsLocal[nombre_funcion]['#Params']

	print(x.procsLocal[nombre_funcion]['Var_Table'])
	print(x.procsLocal[nombre_funcion]['Var_Table'].keys()[count])
	print(x.procsLocal[nombre_funcion]['Var_Table'].values()[count]['Tipo'])
	if ( count < max_Param):
		tipo2 = x.procsLocal[nombre_funcion]['Var_Table'].values()[count]['Tipo']
	else:
		print ('<---[STACKOVERFLOW][Llamada_Factor]; Procedimiento "{0}" tiene "{1}" paraetros y se enviaron "{2}"--->'.format(nombre_funcion, max_Param, count))
		exit(1)
	#print('Lado izquierdo "{0}" Lado derecho "{1}"'.format(tipo_argumento, valor_argumento))
	#print(PilaO)
	#print("xprocs :", x.procsLocal[nombre_funcion]['Var_Table'].values()[count])
	if(tipo_argumento == tipo2):
		resultado_quadruple = add_quadruple('PARAMETER', valor_argumento, -1, ('Param' + str(count)), 0)  #Se genera el cuadruplo PARAMETER, tiene el k-esimo argumento
		contador_k.append(count)
		#print("parameter es:", resultado_quadruple)
		#PilaO.append(resultado_quadruple)
	else:
		print ('<---[ERROR_TYPE_MISMATCH][Llamada]; No se puede hacer la operacion con los tipos: "{0}" y "{1}"--->'.format(tipo2, tipo_argumento))
		exit(1)

def p_add_Llamada_Factor_6(p):
	'''add_Llamada_Factor_6 : empty '''
	nombre_funcion = funcion_id.pop()  #Se obtiene el nombre de la funcion que activo la llamada
	tipo_funcion = procs_return_type(nombre_funcion)
	if(tipo_funcion != 'void'):
		#nombre_funcion = proc_brackList.pop()  #Se obtiene el nombre de la funcion
		operadorIzquierdo = PilaO.pop()
		#PilaO.append(operadorIzquierdo)
		#PilaO.append(nombre_funcion)

		#print("Nombre de funciones:")
		proc_brackList.append(nombre_funcion)
		#operacion_cuadruplos('=')
		resultado_quadruple = add_quadruple('=', operadorIzquierdo, -1, nombre_funcion, -1, 0) #se genera cuadruplos
		PilaO.append(resultado_quadruple)	#se devuelve el operando a la pila de operadores		
		
		#print("TE ESTOY IMPRIMIENO; ", procs_return_type(nombre_funcion))
		#pp.pprint( x.procsLocal)
		PTipos.append(procs_return_type(nombre_funcion))
		
		contador_k = [0]
		#print("add_Llamada_Factor_6", contador_k)
		#pp.pprint(get_cuadruplos())

	else:
		PTipos.append('void')

def p_add_Llamada_Factor_6(p):
	'''add_Llamada_Factor_6 : empty '''
	nombre_funcion = funcion_id.pop()  #Se obtiene el nombre de la funcion que activo la llamada
	tipo_funcion = procs_return_type(nombre_funcion)
	if(tipo_funcion != 'void'):
		#nombre_funcion = proc_brackList.pop()  #Se obtiene el nombre de la funcion
		operadorIzquierdo = PilaO.pop()
		#PilaO.append(operadorIzquierdo)
		#PilaO.append(nombre_funcion)
		
		#tipoDerecho = PilaO.pop()
		#print('Lado izquierdo "{0}" operador "{1}" Lado derecho "{2}"'.format(operadorIzquierdo, operadorIgual, operadorDerecho))
		#rint('Lado izquierdo "{0}" Lado derecho "{1}"'.format(operadorIzquierdo, operadorDerecho))
		#print(PilaO)
		#print(var_brackList)
		#if (vars_exists_in_list(operadorIzquierdo)):
		#pp.pprint(operadorIzquierdo)

		#print("Nombre de funciones:")
		proc_brackList.append(nombre_funcion)
		#operacion_cuadruplos('=')
		resultado_quadruple = add_quadruple('=', operadorIzquierdo, -1, nombre_funcion, -1, 0) #se genera cuadruplos
		PilaO.append(resultado_quadruple)	#se devuelve el operando a la pila de operadores		
		
		#print("TE ESTOY IMPRIMIENO; ", procs_return_type(nombre_funcion))
		#pp.pprint( x.procsLocal)
		PTipos.append(procs_return_type(nombre_funcion))
		
		
		#pp.pprint(get_cuadruplos())

	else:
		PTipos.append('void')