Expressao.hs

module Expressao where

import System.IO.Unsafe
import Variavel
import Funcao
import Mensagens
import Char
import Lexico


-- Executa as instruções da função de entrada.
executaFuncao :: Funcao -> [Variavel] -> [Funcao] -> String
executaFuncao (nome, retorno, argumentos, instrucoes) variaveis funcoes =
	let (saida, varsTmp, valor) = avalInstrucoes
									(instrucoes)
									(variaveis)
									(funcoes)
									(nome, retorno, argumentos, instrucoes)
									(nome)
									("") in
	saida


avalFuncao :: Funcao -> [Variavel] -> [Funcao] -> Valor
avalFuncao (nome, retorno, argumentos, instrucoes) variaveis funcoes =
	let (saida, varsTmp, valor) = avalInstrucoes
									(instrucoes)
									(variaveis)
									(funcoes)
									(nome, retorno, argumentos, instrucoes)
									(nome)
									("") in
	valor


{-
 - Avalia a lista de instrucoes que recebe. Se encontrar uma instrução 'return' então retorna o
 - valor seguinte a 'return'. Caso não encontre uma instrução 'return', então retorna 'Void'.
 -}
avalInstrucoes :: [String] -> [Variavel] -> [Funcao] -> Funcao -> String -> String -> (String, [Variavel], Valor)
avalInstrucoes instrucoes variaveis funcoes funcao escopo saida =
	let tmp = instrucoes in
	let	instrucoes = cauda tmp ; lexema = cabeca tmp in
	if lexema == "\0" then
		(  saida ,
		{-(  ( do x <- printVariaveis variaveis ;
				y <- putStr saida ;
				return x ;
				return y ) ,-}
		--(  ( do y <- putStr saida ;
		--		return y ) ,
		   variaveis ,
		   VoidV  )
	else if elem lexema tiposVar then
		let tipoVar = lexema ; tmp = instrucoes in
		let instrucoes = cauda tmp ; lexema = cabeca tmp in
		if isIdValido lexema variaveis funcoes tipos then
			let nomeVar = lexema ; tmp = instrucoes in
			let instrucoes = cauda tmp ; lexema = cabeca tmp in
			if lexema == ";" then
				avalInstrucoes
					( instrucoes )
					(  variaveis ++ [ (nomeVar, (stringToValor tipoVar), escopo) ]  )
					( funcoes )
					( funcao )
					( escopo )
					( saida )
			else
				exibeMsgErro (lexemaInesperado lexema)
		else
			exibeMsgErro (idInvalido lexema)
	else if lexema == "cout" then
		let tmp = instrucoes in
		let (_, instrAval, instrucoes) = retornaAte tmp [";"] in
		let cout = avalCout instrAval variaveis funcoes escopo in
		avalInstrucoes
					( instrucoes )
					( variaveis )
					( funcoes )
					( funcao )
					( escopo )
					( saida ++ cout )
	else if lexema == "cin" then
		-- instrucoes = [ ">>" , "a" , ">>", "b" ";","a", "=", "b" ]
		let tmp = instrucoes in
		let (_, instrAval, instrucoes) = retornaAte tmp [";"] in
		let variaveisCin = avalCin instrAval variaveis in
		avalInstrucoes
			( instrucoes )
			( variaveisCin )
			( funcoes )
			( funcao )
			( escopo )
			( saida )
	else if lexema == "if" then
		-- ( ... ) { ... } else { ... }
		let tmp = instrucoes in
		let (exprIf, instrucoes) = getExprIf tmp [] in
		let (saidaIf, vars) = avalIf exprIf variaveis funcoes funcao escopo in
		avalInstrucoes
			( instrucoes )
			( vars )
			( funcoes )
			( funcao )
			( escopo )
			( saida ++ saidaIf )
	else if lexema == "while" then
		let tmp = instrucoes in
		let (exprWhile, instrucoes) = getExprWhile tmp [] in
		let (saidaWhile, varsWhile) = avalWhile exprWhile variaveis funcoes funcao escopo "" in
		avalInstrucoes
			( instrucoes )
			( varsWhile )
			( funcoes )
			( funcao )
			( escopo )
			( saida ++ saidaWhile )
	else if lexema == "return" then
		let tmp = instrucoes in
		let (status, instrAval, instrucoes) = retornaAte tmp [";"] in
		if status == True then
			let tipoExpr = getTipoExpr instrAval variaveis funcoes in
			let tipoEsperado = getRetornoFuncao funcao in
			if equalsTipo tipoExpr tipoEsperado then
				let retorno = avalExpr tipoExpr instrAval variaveis funcoes in
				( saida , variaveis , retorno )
			else
				exibeMsgErro (tipoEsperadoExpr (tipoToString tipoExpr) (tipoToString tipoEsperado))
		else
			exibeMsgErro ("esperado lexema \';\'")
	else
		let (status, variavel, variaveisEsq, variaveisDir) =
				findVariavelByNome variaveis lexema in
		if status == True then
			let tmp = instrucoes in
			let instrucoes = cauda tmp ; lexema = cabeca tmp in
			if lexema == "=" then
				let tmp = instrucoes in
				let (_, instrAval, instrucoes) = retornaAte tmp [";"] in
				let tipoExpr = getTipoVariavel variavel in
				let valor = avalExpr tipoExpr instrAval variaveis funcoes in
				let tmpVar = ( getNomeVariavel variavel,
							   valor,
							   getEscopoVariavel variavel ) in
				let variavel = tmpVar in
				avalInstrucoes
					( instrucoes )
					(  variaveisEsq ++ ( variavel:variaveisDir )  )
					( funcoes )
					( funcao )
					( escopo )
					( saida )
			else
				exibeMsgErro (lexemaInesperadoEsperado lexema "=")
		else
			let (status, funcao) =
					findFuncaoByNome funcoes lexema in
			if status == True then
				let tmp = instrucoes in
				let lexema = cabeca tmp; instrucoes = cauda tmp in
				if (lexema == "(") then
					let tmp = instrucoes in
					let (expr, instrucoes) = getExprParentese tmp in
					if cabeca instrucoes == ";" then
						let args = getArgumentosFromParametros expr variaveis funcoes (getArgumentosFuncao funcao) in
						let saidaFuncao = executaFuncao funcao args funcoes in
						avalInstrucoes
							( cauda instrucoes )
							( variaveis )
							( funcoes )
							( funcao )
							( escopo )
							( saida ++ saidaFuncao )
					else
						exibeMsgErro (lexemaInesperadoEsperado (cabeca instrucoes) ";")
				else
					exibeMsgErro (lexemaInesperadoEsperado lexema "(")
			else
				exibeMsgErro (lexemaNaoDeclarado lexema)

-- Recebe uma lista de instrucoes e uma lista de lexemas. Quando encontrar um elemento x pertencente
-- a lexemas na lista de instrucoes, retorna uma dupla (A,B), onde (A ++ [x] ++ B) == instrucoes.
retornaAte instrucoes lexemas =
	retornaAteRecur [] instrucoes lexemas
	
retornaAteRecur :: [String] -> [String] -> [String] -> (Bool,[String], [String])
retornaAteRecur x [] lexemas = (False,x,[])
retornaAteRecur x (h:t) lexemas =
	if elem h lexemas then
		(True, x, t)
	else
		retornaAteRecur (x ++ [h]) t lexemas


avalCout instrucoes variaveis funcoes escopo =
	let tmp = instrucoes in
	let lexema = cabeca tmp ; instrucoes = cauda tmp in
	if lexema == "<<" then
		if instrucoes == [] then
			exibeMsgErro (esperadoArgumentoCout)
		else
			avalCoutAux instrucoes variaveis funcoes escopo
	else
		exibeMsgErro (lexemaInesperadoEsperado lexema "<<")


avalCoutAux instrucoes variaveis funcoes escopo =
	let tmp = instrucoes in
	let (status, instrAval, instTail) = retornaAte tmp ["<<"] in
	if status == True then
		let instrucoes = ["<<"] ++ instTail in
		if instrAval == [] then
			""
		else
			let tipoExpr = getTipoExpr instrAval variaveis funcoes in
			let val = avalExpr tipoExpr instrAval variaveis funcoes in
			if equalsTipo tipoExpr Bool then
				( show (getValorBool val) ) ++ (avalCout instrucoes variaveis funcoes escopo)
			else if equalsTipo tipoExpr Char then
				( show (getValorChar val) ) ++ (avalCout instrucoes variaveis funcoes escopo)
			else if equalsTipo tipoExpr Int then
				( show (getValorInt val) ) ++ (avalCout instrucoes variaveis funcoes escopo)
			else if equalsTipo tipoExpr Float then
				( show (getValorFloat val) ) ++ (avalCout instrucoes variaveis funcoes escopo)
			else -- if equalsTipo tipoExpr String then
				(getValorString val)  ++ (avalCout instrucoes variaveis funcoes escopo)
	else
		let instrucoes = instTail in
		if instrAval == [] then
			""
		else
			let tipoExpr = getTipoExpr instrAval variaveis funcoes in
			let val = avalExpr tipoExpr instrAval variaveis funcoes in
			if equalsTipo tipoExpr Bool then
				( show (getValorBool val) ) ++ (avalCoutAux instrucoes variaveis funcoes escopo)
			else if equalsTipo tipoExpr Char then
				( show (getValorChar val) ) ++ (avalCoutAux instrucoes variaveis funcoes escopo)
			else if equalsTipo tipoExpr Int then
				( show (getValorInt val) ) ++ (avalCoutAux instrucoes variaveis funcoes escopo)
			else if equalsTipo tipoExpr Float then
				( show (getValorFloat val) ) ++ (avalCoutAux instrucoes variaveis funcoes escopo)
			else -- if equalsTipo tipoExpr String then
				(getValorString val)  ++ (avalCoutAux instrucoes variaveis funcoes escopo)


--let variaveisCin = avalCin instrAval variaveis in
-- ">> a >> b"
--avalCin :: [String] -> [Variavel] -> (IO (), [Variavel])
avalCin instrucoes variaveis =
	let tmp = instrucoes in
	let instrucoes = cauda tmp ; lexema = cabeca tmp in
	if lexema == ">>" then
		if instrucoes == [] then
			exibeMsgErro (esperadoArgumentoCin)
		else
			avalCinAux instrucoes variaveis
	else
		exibeMsgErro (lexemaInesperadoEsperado lexema ">>")


leituraTecladoInt =
	do
		x <- readVal
		return x
    where readVal :: IO Int
    	  readVal = readLn

leituraTecladoChar =
	do
		x <- readVal
		return x
    where readVal :: IO Char
    	  readVal = readLn

leituraTecladoFloat =
	do
		x <- readVal
		return x
    where readVal :: IO Float
    	  readVal = readLn

leituraTecladoString =
	do
		x <- readVal
		return x
    where readVal :: IO String
    	  readVal = readLn

leituraTecladoBool =
	do
		x <- readVal
		return x
    where readVal :: IO Bool
    	  readVal = readLn
		  

-- "a >> b"
--avalCinAux :: [String] -> [Variavel] -> IO Int
avalCinAux (h:t) variaveis =
	let (status, variavel, ladoEsq, ladoDir) = findVariavelByNome variaveis h in
	if status == True then
		if equalsTipo Int (getTipoVariavel variavel) then
			let val = unsafePerformIO (leituraTecladoInt) in
			ladoEsq ++ [(h, (IntV val), (getEscopoVariavel variavel))] ++ ladoDir
		else if equalsTipo Float (getTipoVariavel variavel) then
			let val = unsafePerformIO (leituraTecladoFloat) in
			ladoEsq ++ [(h, (FloatV val), (getEscopoVariavel variavel))] ++ ladoDir
		else if equalsTipo Char (getTipoVariavel variavel) then
			let val = unsafePerformIO (leituraTecladoChar) in
			ladoEsq ++ [(h, (CharV val), (getEscopoVariavel variavel))] ++ ladoDir
		else if equalsTipo String (getTipoVariavel variavel) then
			let val = unsafePerformIO (leituraTecladoString) in
			ladoEsq ++ [(h, (StringV val), (getEscopoVariavel variavel))] ++ ladoDir
		else if equalsTipo Bool (getTipoVariavel variavel) then
			let val = unsafePerformIO (leituraTecladoBool) in
			ladoEsq ++ [(h, (BoolV val), (getEscopoVariavel variavel))] ++ ladoDir
		else
			exibeMsgErro ("AVJIASDIAS")
	else
		exibeMsgErro (lexemaNaoDeclarado h)


getExprIf (h:t) expr =
	if h /= "{" then
		getExprIf t (expr ++ [h])
	else
		let (exprIf, tmp) = getExprChaves t in
		if cabeca tmp == "else" then
			let (exprElse, instr) = getExprChaves (cauda (cauda tmp)) in
			((expr ++ ["{"] ++ exprIf ++ ["}","else","{"] ++ exprElse ++ ["}"]), instr)
		else
			exibeMsgErro (lexemaInesperadoEsperado (cabeca tmp) "else")

getExprWhile (h:t) expr =
	if h /= "{" then
		getExprWhile t (expr ++ [h])
	else
		let (exprWhile, tmp) = getExprChaves t in
		((expr ++ ["{"] ++ exprWhile ++ ["}"]), tmp)
	

{-
 - [(expr) { } else { }]
 -}
avalIf instrucoes variaveis funcoes funcao escopo =
	let tmp = instrucoes in
	let lexema = cabeca tmp ; instrucoes = cauda tmp in
	if lexema == "(" then
		let tmp = instrucoes in
		let (expr, instrucoes) = getExprParentese tmp in
		let aval = avalExprBool expr variaveis funcoes in
		if aval == True then
			let tmp = instrucoes in
			let lexema = cabeca tmp ; instrucoes = cauda tmp in
			if lexema == "{" then
				let tmp = instrucoes in
				let (expr, instrucoes) = getExprChaves tmp in
				let (saida, varsIf, _) = avalInstrucoes (expr ++ ["\0"]) variaveis funcoes funcao (escopo ++ ".if") "" in
				(saida, varsIf)
			else
				exibeMsgErro (lexemaInesperado lexema)
		else
			let tmp = instrucoes in
			let lexema = cabeca tmp ; instrucoes = cauda tmp in
			if lexema == "{" then
				let tmp = instrucoes in
				let (expr, instrucoes) = getExprChaves tmp in
				let tmp = instrucoes in
				let lexema = cabeca tmp ; instrucoes = cauda tmp in
				if lexema == "else" && (cabeca instrucoes) == "{" then
					let tmp = cauda instrucoes in
					let (expr, instrucoes) = getExprChaves tmp in
					let (saida, vars, _) = avalInstrucoes (expr ++ ["\0"]) variaveis funcoes funcao (escopo ++ ".else") "" in
					(saida, vars)
				else
					exibeMsgErro (lexemaInesperado lexema)
			else
				exibeMsgErro (lexemaInesperado lexema)
	else
		exibeMsgErro (lexemaInesperado lexema)


{-
 - ( ... ) { ... }
 -}
avalWhile instrucoes variaveis funcoes funcao escopo saida =
	let backupInstrucoes = instrucoes ; tmp = instrucoes in
	let lexema = cabeca tmp ; instrucoes = cauda tmp in
	if lexema == "(" then
		let tmp = instrucoes in
		let (expr, instrucoes) = getExprParentese tmp in -- ( expr ) instrucoes = { ...}
		let condicao = avalExprBool expr variaveis funcoes in
		if condicao then
			let tmp = instrucoes in
			let lexema = cabeca tmp ; instrucoes = cauda tmp in
			if lexema == "{" then
				let tmp = instrucoes in
				let (instrWhile, _) = getExprChaves tmp in
				let (saidaWhile, varsWhile, _) =
					avalInstrucoes (instrWhile ++ ["\0"]) variaveis funcoes funcao (escopo ++ ".while") "" in
				avalWhile backupInstrucoes varsWhile funcoes funcao escopo (saida ++ saidaWhile)
			else
				exibeMsgErro (lexemaInesperadoEsperado lexema "{")
		else
			(saida, variaveis)
	else
		exibeMsgErro (lexemaInesperadoEsperado lexema "(")


{-let teste = unsafePerformIO(print ("oi")) in
		if (teste ==()) then
		else
			"oiiii"
-}

-- Determina se o lexema é um id valido.
isIdValido :: String -> [Variavel] -> [Funcao] -> [String] -> Bool
isIdValido (h:t) variaveis funcoes tipos =
	if ( (isAlpha h) || (h == '_') ) && (isIdValidoRecur t) then
		if (  not ( elem (h:t) (projecaoFuncao funcoes getNomeFuncao) )  ) &&
		   (  not ( elem (h:t) (projecaoVariaveis variaveis getNomeVariavel) )  ) &&
		   (  not ( elem (h:t) tipos )  ) &&
		   (  not ( elem (h:t) palavrasReservadas )  ) then
			True
		else
			exibeMsgErro (nomeReservadoOuJaUsado (h:t))
	else
		False


-- Auxiliar recursiva para a função isIdValido.
isIdValidoRecur :: String -> Bool
isIdValidoRecur [] = True
isIdValidoRecur (h:t) =
	if ( (isAlphaNum h) || (h == '_') ) then
		isIdValidoRecur t
	else
		False


--(valor, instrucoes) = avalExpr tipoExpr instrucoes variaveis funcoes
avalExpr :: Tipo -> [String] -> [Variavel] -> [Funcao] -> Valor
avalExpr Int instrucoes variaveis funcoes = IntV (avalExprInt instrucoes variaveis funcoes False)
avalExpr Float instrucoes variaveis funcoes = FloatV (avalExprFloat instrucoes variaveis funcoes False)
avalExpr String instrucoes variaveis funcoes = StringV (avalExprString instrucoes variaveis funcoes)
avalExpr Bool instrucoes variaveis funcoes = BoolV (avalExprBool instrucoes variaveis funcoes)
avalExpr Char instrucoes variaveis funcoes = CharV (avalExprChar instrucoes variaveis funcoes)


-- reads "3422" :: [(Int, String)]
-- printValor (get1De2 (avalExprInt ["2","+","4",";"," ..."] [] []))
-- avalExprInt (stringToLexemas "funcao()") [] ["funcao",(Int),[],(stringToLexemas "return a;")]
avalExprInt :: [String] -> [Variavel] -> [Funcao] -> Bool -> Int
avalExprInt instrucoes variaveis funcoes flag =
	let tmp = instrucoes in
	let instrucoes = cauda tmp ; lexema = cabeca tmp in
	if isLiteralInt lexema then
		let literal = (read lexema)::Int in
		if flag then avalExprIntAux instrucoes variaveis funcoes (-literal) False
		else avalExprIntAux instrucoes variaveis funcoes (literal) False
	else
		let (status, variavel, _, _) = findVariavelByNome variaveis lexema in
		if status == True then
			let literal = getValorVariavelInt (variavel) in
			if flag then avalExprIntAux instrucoes variaveis funcoes (-literal) False
			else avalExprIntAux instrucoes variaveis funcoes (literal) False
		else
--avalFuncao ("funcao",(Int),[],(stringToLexemas "return 1+2;")) [] [("funcao",(Int),[],(stringToLexemas "return 1+2;"))]
--avalExprInt (stringToLexemas "funcao()") [] [("funcao",(Int),[],(stringToLexemas "return 1+2;"))]
			let (status, funcao) =
				findFuncaoByNome funcoes lexema in
			if status == True then
				if equalsTipo Int (getRetornoFuncao funcao) then
					let tmp = instrucoes in
					let lexema = cabeca tmp; instrucoes = cauda tmp in
					if (lexema == "(") then
						let tmp = instrucoes in
						let (expr, instrucoes) = getExprParentese tmp in
							let args = getArgumentosFromParametros expr variaveis funcoes (getArgumentosFuncao funcao) in
							let (IntV literal) = avalFuncao funcao args funcoes in
							if flag then avalExprIntAux instrucoes variaveis funcoes (-literal) False
							else avalExprIntAux instrucoes variaveis funcoes (literal) False
					else
						exibeMsgErro (lexemaInesperadoEsperado lexema "(")
				else
					exibeMsgErro ("tipo esperado \'int\'")
			else
				exibeMsgErro (lexemaNaoDeclarado lexema)


-- reads "3422" :: [(Int, String)]
-- printValor (get1De2 (avalExprIntRecur ["+","4",";"," ..."] [] []))
avalExprIntAux :: [String] -> [Variavel] -> [Funcao] -> Int -> Bool -> Int
avalExprIntAux [] _ _ literal flag = if flag then (-literal) else literal
avalExprIntAux instrucoes variaveis funcoes literal flag =
	let tmp = instrucoes in
	let instrucoes = cauda tmp ; lexema = cabeca tmp in
	if lexema == "+" then
		literal + avalExprInt instrucoes variaveis funcoes flag
	else if lexema == "-" then
		literal + avalExprInt instrucoes variaveis funcoes True
	else if elem lexema ["*","/"] then
		let op = lexema ; tmp = instrucoes in
		let instrucoes = cauda tmp ; lexema = cabeca tmp in
		if isLiteralInt lexema then
			let fator = (read lexema)::Int in
			if op == "*" then
				avalExprIntAux instrucoes variaveis funcoes (literal * fator) flag
			else
				avalExprIntAux instrucoes variaveis funcoes (div literal fator) flag
		else
			let (status, variavel, _, _) = findVariavelByNome variaveis lexema in
			if status == True then
				let fator = getValorVariavelInt (variavel) in
				if op == "*" then
					avalExprIntAux instrucoes variaveis funcoes (literal * fator) flag
				else
					avalExprIntAux instrucoes variaveis funcoes (div literal fator) flag
			else
				exibeMsgErro (lexemaInesperado lexema)
	else
		exibeMsgErro (lexemaInesperado lexema)


-- max_int = 2147483647
-- min_int = 2147483648
isLiteralInt (h:t) =
	if isDigit h then
		isLiteralIntRecur t
	else
		False


isLiteralIntRecur [] = True
isLiteralIntRecur (h:t) =
	if isDigit h then
		isLiteralIntRecur t
	else
		False


-- avalExprFloat (stringToLexemas "2*2 - 1 + 10") [] []
avalExprFloat :: [String] -> [Variavel] -> [Funcao] -> Bool -> Float
avalExprFloat instrucoes variaveis funcoes flag =
	let tmp = instrucoes in
	let instrucoes = cauda tmp ; lexema = cabeca tmp in
	if isLiteralFloat lexema then
		let literal = (read lexema)::Float in
		if flag then avalExprFloatAux instrucoes variaveis funcoes (-literal) False
		else avalExprFloatAux instrucoes variaveis funcoes literal False
	else
		let (status, variavel, _, _) = findVariavelByNome variaveis lexema in
		if status == True then
			let literal = getValorVariavelFloat (variavel) in
			if flag then avalExprFloatAux instrucoes variaveis funcoes (-literal) False
			else avalExprFloatAux instrucoes variaveis funcoes literal False
		else
			let (status, funcao) =
				findFuncaoByNome funcoes lexema in
			if status == True then
				if equalsTipo Float (getRetornoFuncao funcao) then
					let tmp = instrucoes in
					let lexema = cabeca tmp; instrucoes = cauda tmp in
					if (lexema == "(") then
						let tmp = instrucoes in
						let (expr, instrucoes) = getExprParentese tmp in
							let args = getArgumentosFromParametros expr variaveis funcoes (getArgumentosFuncao funcao) in
							let (FloatV literal) = avalFuncao funcao args funcoes in
							if flag then avalExprFloatAux instrucoes variaveis funcoes (-literal) False
							else avalExprFloatAux instrucoes variaveis funcoes (literal) False
					else
						exibeMsgErro (lexemaInesperadoEsperado lexema "(")
				else
					exibeMsgErro ("tipo esperado \'float\'")
			else
				exibeMsgErro (lexemaNaoDeclarado lexema)


avalExprFloatAux :: [String] -> [Variavel] -> [Funcao] -> Float -> Bool -> Float
avalExprFloatAux [] _ _ literal flag = if flag then -literal else literal
avalExprFloatAux instrucoes variaveis funcoes literal flag =
	let tmp = instrucoes in
	let instrucoes = cauda tmp ; lexema = cabeca tmp in
	if lexema == "+" then
		literal + (avalExprFloat instrucoes variaveis funcoes flag)
	else if lexema == "-" then
		literal + (avalExprFloat instrucoes variaveis funcoes True)
	else if elem lexema ["*","/"] then
		let op = lexema ; tmp = instrucoes in
		let instrucoes = cauda tmp ; lexema = cabeca tmp in
		if isLiteralFloat lexema then
			let fator = (read lexema)::Float in
			if op == "*" then
				avalExprFloatAux instrucoes variaveis funcoes (literal * fator) flag
			else
				avalExprFloatAux instrucoes variaveis funcoes (literal / fator) flag
		else
			let (status, variavel, _, _) = findVariavelByNome variaveis lexema in
			if status == True then
				let fator = getValorVariavelFloat (variavel) in
				if op == "*" then
					avalExprFloatAux instrucoes variaveis funcoes (literal * fator) flag
				else
					avalExprFloatAux instrucoes variaveis funcoes (literal / fator) flag
			else
				exibeMsgErro (lexemaInesperado lexema)
	else
		exibeMsgErro (lexemaInesperado lexema)


isLiteralFloat (h:t) =
	if (isDigit h) then
		isLiteralFloatBeforePonto t
	else
		False


isLiteralFloatBeforePonto [] = True
isLiteralFloatBeforePonto (h:t) =
	if (isDigit h) then
		isLiteralFloatBeforePonto t
	else if (h == '.') && (t /= []) then
		isLiteralFloatAfterPonto t
	else
		False


isLiteralFloatAfterPonto [] = True
isLiteralFloatAfterPonto (h:t) =
	if (isDigit h) then
		isLiteralFloatAfterPonto t
	else
		False


avalExprString :: [String] -> [Variavel] -> [Funcao] -> String
avalExprString instrucoes variaveis funcoes =
		let tmp = instrucoes in
		let lexema = cabeca tmp ; instrucoes = cauda tmp in
		if isString	lexema then -- Se for string "nome"
			if instrucoes == [] then
				removeAspasString lexema
			else
				exibeMsgErro (lexemaInesperado (cabeca instrucoes))
		else -- Se for uma variável
			let (status, variavel, _, _) = findVariavelByNome variaveis lexema in
			if status == True then
				getValorVariavelString (variavel)
			else
				exibeMsgErro (lexemaInesperado lexema)


avalExprChar :: [String] -> [Variavel] -> [Funcao] -> Char
avalExprChar instrucoes variaveis funcoes = 
		let tmp = instrucoes in
		let lexema = cabeca tmp ; instrucoes = cauda tmp in
		if isChar lexema then -- Se for Char 'a'
			if instrucoes == [] then
				read (lexema)::Char
			else
				exibeMsgErro (lexemaInesperado (cabeca instrucoes))
		else -- Se for uma variável
			let (status, variavel, _, _) = findVariavelByNome variaveis lexema in
			if status == True then
				getValorVariavelChar (variavel)
			else
				exibeMsgErro (lexemaInesperado lexema)


-- Lê uma expressão e retorna seu tipo.
getTipoExpr :: [String] -> [Variavel] -> [Funcao] -> Tipo
getTipoExpr instrucoes variaveis funcoes =
	if isExprString instrucoes variaveis funcoes then
		String
	else if isExprBool instrucoes variaveis funcoes then
		Bool
	else if isExprChar instrucoes variaveis funcoes then
		Char
	else
		let (status, tipo) = isExprAritmetica instrucoes variaveis funcoes in
		if status == True then
			if tipo == "int" then
				Int
			else
				Float
		else
			exibeMsgErro (expressaoInvalida)

isExprChar instrucoes variaveis funcoes =
	let tmp = instrucoes in
	let instrucoes = cauda tmp ; lexema = cabeca tmp in
	if isChar lexema then
		True
	else
		let (status, variavel, _, _) = findVariavelByNome variaveis lexema in
		if status == True then
			equalsTipo (getTipoVariavel variavel) Char
		else
			False -- TODO verificar funcao

			
isExprString instrucoes variaveis funcoes =
	let tmp = instrucoes in
	let instrucoes = cauda tmp ; lexema = cabeca tmp in
	if isString lexema then
		True
	else
		let (status, variavel, _, _) = findVariavelByNome variaveis lexema in
		if status == True then
			equalsTipo (getTipoVariavel variavel) String
		else
			--let (status, funcao) = findFuncaoByNome funcoes lexema in
			--if status == True then
			--	equalsTipo (getRetornoFuncao funcao) String
			--else
			False -- TODO verificar funcao


isString (h:t) = h == '"'

isChar (h:t) = h == '\''

removeAspasString (h:t) = removeAspasStringAux "" t
removeAspasStringAux esq (h:t) = if t == "" then esq else removeAspasStringAux (esq ++ [h]) t


isLiteralBool lexema = elem lexema ["true","false"]

{-
 - Possíveis operadores booleanos:
 -
 - bool [||,&&] bool
 - bool,int,float,char [==,!=] bool,int,float,char
 - ! bool
 - [int,float,char] [>,>=,<,<=] [int,float,char]
 -
 - Exemplos:
 - ! True != False --> False != False --> True
 - ! 5 > 6
 -}
avalExprBool :: [String] -> [Variavel] -> [Funcao] -> Bool
avalExprBool (h:t) variaveis funcoes =
	-- ! -> not (avalExprBool cauda ate axar a primeira expr booleana a frente)
	if h == "!" then
		let (lhs, rhs) = getFirstExprBool t variaveis funcoes in
		let result = not (avalExprBool lhs variaveis funcoes) in
		avalExprCmpBool rhs variaveis funcoes result
	else if h == "(" then
		let (lhs, rhs) = getExprParentese t in
		let result = avalExprBool lhs variaveis funcoes in
		avalExprCmpBool rhs variaveis funcoes result
	-- Literal booleano
	else if isLiteralBool h then
		if h == "false" then
			avalExprCmpBool t variaveis funcoes False
		else
			avalExprCmpBool t variaveis funcoes True
	-- Literal inteiro
	else if isLiteralFloat h then
		let (tipo, op1, op, op2, exprTail) =
				getFirstExprCmpBoolAritmetica (h:t) variaveis funcoes in
		if tipo == "int" then
			let avalOp1 = avalExprInt op1 variaveis funcoes False ;
				avalOp2 = avalExprInt op2 variaveis funcoes False in
			avalExprCmpBool exprTail variaveis funcoes (avalExprCmpInt avalOp1 op avalOp2)
		else -- tipo == "float"
			let avalOp1 = avalExprFloat op1 variaveis funcoes False ;
				avalOp2 = avalExprFloat op2 variaveis funcoes False in
			avalExprCmpBool exprTail variaveis funcoes (avalExprCmpFloat avalOp1 op avalOp2)
	else
		let (status, variavel, _, _) = findVariavelByNome variaveis h in
		if status == True then
			if equalsTipo Bool (getTipoVariavel variavel) then
				avalExprCmpBool t variaveis funcoes (getValorVariavelBool variavel)
			else if ( equalsTipo Int (getTipoVariavel variavel) ||
					  equalsTipo Float (getTipoVariavel variavel) ) then
				let (tipo, op1, op, op2, exprTail) =
						getFirstExprCmpBoolAritmetica (h:t) variaveis funcoes in
				if tipo == "int" then
					let avalOp1 = avalExprInt op1 variaveis funcoes False ;
						avalOp2 = avalExprInt op2 variaveis funcoes False in
					avalExprCmpBool exprTail variaveis funcoes (avalExprCmpInt avalOp1 op avalOp2)
				else -- tipo == "float"
					let avalOp1 = avalExprFloat op1 variaveis funcoes False ;
						avalOp2 = avalExprFloat op2 variaveis funcoes False in
					avalExprCmpBool exprTail variaveis funcoes (avalExprCmpFloat avalOp1 op avalOp2)
			else
				exibeMsgErro (tipoInvalidoOpAritmetica (tipoToString (getTipoVariavel variavel)))
		else
			let (status, funcao) =
				findFuncaoByNome funcoes h in
			if status == True then
				if equalsTipo Bool (getRetornoFuncao funcao) then
					let tmp = t in
					let lexema = cabeca tmp; instrucoes = cauda tmp in
					if (lexema == "(") then
						let tmp = instrucoes in
						let (expr, instrucoes) = getExprParentese tmp in
							let args = getArgumentosFromParametros expr variaveis funcoes (getArgumentosFuncao funcao) in
							let (BoolV literal) = avalFuncao funcao args funcoes in
							avalExprCmpBool instrucoes variaveis funcoes (literal)
					else
						exibeMsgErro (lexemaInesperadoEsperado h "(")
				else
					exibeMsgErro ("tipo esperado \'bool\'")
			else
				exibeMsgErro (lexemaNaoDeclarado h)


-- bool,int,float,char [==,!=] bool,int,float,char
-- ! bool
-- [int,float,char] [>,>=,<,<=] [int,float,char]
--avalExprCmp :: [String] -> [Variavel] -> [Funcao] -> Valor -> Valor
--avalExprCmp instrucoes variaveis funcoes (BoolV aval) =
--	BoolV (avalExprCmpBool instrucoes variaveis funcoes aval)

avalExprCmpBool :: [String] -> [Variavel] -> [Funcao] -> Bool -> Bool
avalExprCmpBool [] variaveis funcoes op1 = op1
avalExprCmpBool (h:t) variaveis funcoes op1 =
	if h == "==" then
		let (lhs, rhs) = getFirstExprBool t variaveis funcoes in
		let op2 = avalExprBool lhs variaveis funcoes in
		avalExprCmpBool rhs variaveis funcoes (op1 == op2)
	else if h == "!=" then
		let (lhs, rhs) = getFirstExprBool t variaveis funcoes in
		let op2 = avalExprBool lhs variaveis funcoes in
		avalExprCmpBool rhs variaveis funcoes (op1 /= op2)
	else if h == "&&" then
		let (lhs, rhs) = getFirstExprBool t variaveis funcoes in
		if (rhs /= []) && (cabeca rhs == "||") then
			let op2 = avalExprBool lhs variaveis funcoes in
			avalExprCmpBool rhs variaveis funcoes (op1 && op2)
		else
			op1 && (avalExprBool t variaveis funcoes)
	else if h == "||" then
		op1 || (avalExprBool t variaveis funcoes)
	else
		exibeMsgErro (lexemaInesperado h)


avalExprCmpInt :: Int -> String -> Int -> Bool
avalExprCmpInt op1 op op2 =
	if op == ">" then (op1 > op2)
	else if op == ">=" then (op1 >= op2)
	else if op == "<" then (op1 < op2)
	else if op == "<=" then (op1 <= op2)
	else if op == "==" then (op1 == op2)
	else (op1 /= op2) -- h == "!="


avalExprCmpFloat :: Float -> String -> Float -> Bool
avalExprCmpFloat op1 op op2 =
	if op == ">" then (op1 > op2)
	else if op == ">=" then (op1 >= op2)
	else if op == "<" then (op1 < op2)
	else if op == "<=" then (op1 <= op2)
	else if op == "==" then (op1 == op2)
	else (op1 /= op2) -- h == "!="


-- <operador> <bool>
avalExprBoolAux :: [String] -> [Variavel] -> [Funcao] -> Bool -> Bool
avalExprBoolAux [] variaveis funcoes aval = aval
--avalExprBoolAux (h:t) variaveis funcoes aval =


-- Retorna a primeira expressão booleana que encontrar na lista de lexemas.
-- true != false && 5 > 2
-- a != true
-- retorna: (FirstExprBool , LexemasRestantes)
getFirstExprBool :: [String] -> [Variavel] -> [Funcao] -> ([String],[String])
getFirstExprBool lexemas variaveis funcoes =
	getFirstExprBoolAux lexemas variaveis funcoes []


getFirstExprBoolAux :: [String] -> [Variavel] -> [Funcao] -> [String] -> ([String],[String])
getFirstExprBoolAux (h:t) variaveis funcoes expr =
	if h == "!" then
		getFirstExprBoolAux t variaveis funcoes (expr ++ ["!"])
	else if h == "(" then
		getExprParentese t
	else if isLiteralBool h then
		(expr ++ [h], t)
	else if isLiteralFloat h then
		let (tipo, op1, op, op2, exprTail) =
				getFirstExprCmpBoolAritmetica (h:t) variaveis funcoes in
		(expr ++ op1 ++ [op] ++ op2, exprTail)
		{-
		let (status, variavel, _, _) = findVariavelByNome variaveis h in
		if status == True then
			if equalsTipo Bool (getTipoVariavel variavel) then
				([h], t)
			else
				exibeMsgErro (tipoEsperadoBool h (tipoToString (getTipoVariavel variavel)))
		else-}
	else
		exibeMsgErro (lexemaInesperado h)


getFirstExprCmpBoolAritmetica :: [String] -> [Variavel] -> [Funcao] ->
								 (String,[String],String,[String],[String])
getFirstExprCmpBoolAritmetica expr variaveis funcoes =
	let (tipo1, op1, exprTail) = getFirstExprAritmetica expr variaveis funcoes in
	if elem (cabeca exprTail) [">",">=","<","<=","==","!="] then
		let (tipo2, op2, expr) = getFirstExprAritmetica (cauda exprTail) variaveis funcoes in
		if tipo1 == "int" && tipo2 == "int" then
			("int", op1, (cabeca exprTail), op2, expr)
		else if (tipo1 == "int" && tipo2 == "float") ||
				(tipo1 == "float" && tipo2 == "int") ||
				(tipo1 == "float" && tipo2 == "float") then
			("float", op1, (cabeca exprTail), op2, expr)
		else
			exibeMsgErro (tiposDiferentesCmp (cabeca exprTail))
	else
		exibeMsgErro (lexemaInesperado (cabeca exprTail))


-- Obtem a primeira expressão aritmética que encontrar.
getFirstExprAritmetica :: [String] -> [Variavel] -> [Funcao] -> (String,[String],[String])
getFirstExprAritmetica (h:t) variaveis funcoes =
	getFirstExprAritmeticaAux (h:t) variaveis funcoes [] "int"


getFirstExprAritmeticaAux :: [String] -> [Variavel] -> [Funcao] -> 
						  [String] -> String -> (String,[String],[String])
getFirstExprAritmeticaAux [] variaveis funcoes expr tipo = (tipo, expr, [])
getFirstExprAritmeticaAux (h:t) variaveis funcoes expr tipo =
	if elem h [">",">=","<","<=","==","!=","&&","||"] then
		(tipo, expr, (h:t))
	else if (isLiteralFloat h) && (not (isLiteralInt h)) then
		getFirstExprAritmeticaAux t variaveis funcoes (expr ++ [h]) "float"
	else
		let (status, variavel, _, _) = findVariavelByNome variaveis h in
		if status == True then
			if equalsTipo Float (getTipoVariavel variavel) then
				getFirstExprAritmeticaAux t variaveis funcoes (expr ++ [h]) "float"
			else
				getFirstExprAritmeticaAux t variaveis funcoes (expr ++ [h]) tipo
		else
			getFirstExprAritmeticaAux t variaveis funcoes (expr ++ [h]) tipo


getExprParentese :: [String] -> ([String], [String])
getExprParentese lexemas =
	getExprParenteseAux lexemas [] 0


getExprParenteseAux :: [String] -> [String] -> Int -> ([String], [String])
getExprParenteseAux [] expr n = exibeMsgErro (expressaoInvalida)
getExprParenteseAux (h:t) expr n =
	if h == ")" then
		if n == 0 then
			(expr, t)
		else
			getExprParenteseAux t (expr ++ [h]) (n-1)
	else if h == "(" then
		getExprParenteseAux t (expr ++ [h]) (n+1)
	else
		getExprParenteseAux t (expr ++ [h]) n


getExprChaves :: [String] -> ([String], [String])
getExprChaves lexemas =
	getExprChavesAux lexemas [] 0


getExprChavesAux :: [String] -> [String] -> Int -> ([String], [String])
getExprChavesAux [] expr n = exibeMsgErro (expressaoInvalida)
getExprChavesAux (h:t) expr n =
	if h == "}" then
		if n == 0 then
			(expr, t)
		else
			getExprChavesAux t (expr ++ [h]) (n-1)
	else if h == "{" then
		getExprChavesAux t (expr ++ [h]) (n+1)
	else
		getExprChavesAux t (expr ++ [h]) n


isExprBool (h:t) variaveis funcoes =
	if t == [] then
		if isLiteralBool h then
			True
		else
			let (status, variavel, _, _) = findVariavelByNome variaveis h in
			if status == True then
				equalsTipo (getTipoVariavel variavel) Bool
			else
				False
	else
		isExprBoolAux (h:t) variaveis funcoes


isExprBoolAux [] variaveis funcoes = False
isExprBoolAux (h:t) variaveis funcoes =
	if elem h ["==","!","!=",">",">=","<","<=","||","&&"] then
		True
	else
		isExprBoolAux t variaveis funcoes


--let (status, tipo) = isExprAritmetica instrucoes variaveis funcoes in
{-
getFirstExprAritmeticaAux :: [String] -> [Variavel] -> [Funcao] -> 
						  [String] -> String -> (String,[String],[String])
getFirstExprAritmeticaAux [] variaveis funcoes expr tipo = (tipo, expr, [])
getFirstExprAritmeticaAux (h:t) variaveis funcoes expr tipo =
	if elem h [">",">=","<","<=","==","!=","&&","||"] then
		(tipo, expr, (h:t))
	else if (isLiteralFloat h) && (not (isLiteralInt h)) then
		getFirstExprAritmeticaAux t variaveis funcoes (expr ++ [h]) "float"
	else
		getFirstExprAritmeticaAux t variaveis funcoes (expr ++ [h]) tipo
-}
isExprAritmetica expr variaveis funcoes =
	isExprAritmeticaAux expr variaveis funcoes "int"


isExprAritmeticaAux [] variaveis funcoes tipo = (True, tipo)
isExprAritmeticaAux (h:t) variaveis funcoes tipo =
	if isLiteralInt h then
		isExprAritmeticaAux t variaveis funcoes tipo
	else if isLiteralFloat h then
		isExprAritmeticaAux t variaveis funcoes "float"
	else if elem h ["(",")","+","-","*","/"] then
		isExprAritmeticaAux t variaveis funcoes tipo
	else
		let (status, variavel, _, _) = findVariavelByNome variaveis h in
		if status == True then
			if equalsTipo (getTipoVariavel variavel) Int then
				isExprAritmeticaAux t variaveis funcoes tipo
			else if equalsTipo (getTipoVariavel variavel) Float then
				isExprAritmeticaAux t variaveis funcoes "float"
			else
				exibeMsgErro (tipoInvalidoOpAritmetica (tipoToString (getTipoVariavel variavel)))
		else
			(False, "") -- TODO ver variaveis


-- funcao ( funcao (a, b), b )
-- printVariaveis (getArgumentosFromParametros (stringToLexemas "1 , 2") [] [] [("a",(IntV 0),"funcao"),("b", (FloatV 0), "funcao")])
getArgumentosFromParametros [] variaveis funcoes [] = []
getArgumentosFromParametros instrucoes variaveis funcoes argumentos =
	let tmp = instrucoes in
	let (expr, instrucoes) = getFirstArgumento tmp [] in
	let tipoExpr = getTipoExpr expr variaveis funcoes in
	let tipoEsperado = getTipoVariavel (cabeca argumentos) in
	if equalsTipo tipoExpr tipoEsperado then
		let resultExpr = avalExpr tipoExpr expr variaveis funcoes in
		let tmp = cabeca argumentos in
		let arg = ( (getNomeVariavel tmp) , resultExpr, (getEscopoVariavel tmp) ) in
		[arg] ++ ( getArgumentosFromParametros instrucoes variaveis funcoes (cauda argumentos) )
	else
		exibeMsgErro (tipoEsperadoExpr (tipoToString tipoExpr) (tipoToString tipoEsperado))
getArgumentosFromParametros _ variaveis funcoes _ =
	exibeMsgErro qtdArgumentosFuncao


getFirstArgumento [] expr = (expr, [])
getFirstArgumento (h:t) expr =
	if h == "," then
		(expr, t)
	else if h == "(" then
		let (exprPar, instrucoes) = getExprParentese t in -- exprPar = a, b  instrucoes
		getFirstArgumento instrucoes (expr ++ ["("] ++ exprPar ++ [")"])
	else
		getFirstArgumento t (expr ++ [h])