app.py

import gradio as gr
import io
import contextlib
import re
import traceback
import math

#
def preprocessar_codigos(portugol_code):
    replacements = {
        r"\bSENAO\b": "ELSE",
        r"\bFIMSE\b": "ENDIF",
        r"\bENTAO\b": "THEN",
        r"\bRAIZ\(": "math.sqrt(",
        r"(\w+)\^(\w+)": r"math.pow(\1, \2)",
        r"\bE\b": "and",
        r"\bOU\b": "or",
        r"\bNAO\b": "not",
        r"\bESCOLHA\b": "SWITCH",
        r"\bCASO\b": "CASE",
        r"\bCASO CONTRARIO\b": "DEFAULT",
        r"\bFIM-ESCOLHA\b": "ENDSWITCH",
        r"\bPARA\b": "FOR",
        r"\bATÉ\b": "TO",
        r"\bATE\b": "TO",
        r"\bFIM-PARA\b": "ENDFOR",
        r"\bESCREVER\b": "ESCREVA",
        r"\bENQUANTO\b": "WHILE",
        r"\bFIM-ENQUANTO\b": "ENDWHILE"
    }
    for pattern, replacement in replacements.items():
        portugol_code = re.sub(pattern, replacement, portugol_code, flags=re.IGNORECASE)
    return portugol_code

def processar_escreva(linha):
    padrao = r'ESCREVA\s*(.*)'
    match = re.match(padrao, linha, re.IGNORECASE)
    if match:
        conteudo = match.group(1).strip()
        conteudo_parts = conteudo.split('//', 1)
        conteudo = conteudo_parts[0].strip()
        comentario = f"  # {conteudo_parts[1].strip()}" if len(conteudo_parts) > 1 else ""
        if conteudo.startswith('"') and conteudo.endswith('"'):
            return f"print({conteudo}){comentario}"
        else:
            return f"print({conteudo}){comentario}"
    return linha

def verificar_tipo(var_name, valor, tipos_variaveis, linha):
    if var_name in tipos_variaveis:
        tipo_declarado = tipos_variaveis[var_name]
        if tipo_declarado == "INTEIRO" and "/" in valor:
            return f"# Atenção: Possível atribuição de valor real à variável inteira '{var_name}' na linha: {linha}"
    return None

def traduzir_para_python(portugol_code):
    portugol_code = preprocessar_codigos(portugol_code)
    lines = portugol_code.splitlines()
    codigo_python = ["import math"]
    indentacao = 0
    contexto_bloco = []
    tipos_variaveis = {}
    avisos = []
    in_variaveis = False
    in_algoritmo = False
    algoritmo_iniciado = False

    for i, line in enumerate(lines, 1):
        original_line = line
        line = line.strip()

        line_parts = line.split('//', 1)
        line = line_parts[0].strip()
        comentario = f"  # {line_parts[1].strip()}" if len(line_parts) > 1 else ""

        if not line and comentario:
            codigo_python.append(f"{'    ' * indentacao}{comentario.strip()}")
            continue

        if line.upper().startswith("ALGORITMO"):
            in_algoritmo = True
            algoritmo_iniciado = True
            continue
        if line.upper() in ["VARIAVEIS", "VARIAVEL"]:
            in_variaveis = True
            algoritmo_iniciado = True
            continue
        if line.upper() == "INICIO":
            in_variaveis = False
            in_algoritmo = False
            algoritmo_iniciado = True
            continue
        if line.upper() == "FIM":
            break

        if not algoritmo_iniciado and line:
            in_variaveis = False
            in_algoritmo = False
            algoritmo_iniciado = True

        if in_variaveis or (not algoritmo_iniciado and (":" in line or "=" in line)):
            if ":" in line:
                parts = line.split(":", 1)
                var_name = parts[0].strip()
                var_type_and_value = parts[1].strip()

                if "=" in var_type_and_value:
                    var_type, var_value = var_type_and_value.split("=", 1)
                    var_type = var_type.strip().upper()
                    var_value = var_value.strip()
                else:
                    var_type = var_type_and_value.upper()
                    var_value = None

                tipos_variaveis[var_name] = var_type

                if var_value:
                    codigo_python.append(f"{var_name} = {var_value}")
                else:
                    if var_type == "INTEIRO":
                        codigo_python.append(f"{var_name} = 0")
                    elif var_type == "REAL":
                        codigo_python.append(f"{var_name} = 0.0")
                    elif var_type == "LOGICO":
                        codigo_python.append(f"{var_name} = False")
                    elif var_type == "STRING":
                        codigo_python.append(f"{var_name} = ''")
                    elif var_type == "CARACTERE":
                        codigo_python.append(f"{var_name} = ''")
            elif "=" in line:
                var_name, valor = line.split("=", 1)
                var_name = var_name.strip()
                valor = valor.strip()
                codigo_python.append(f"{var_name} = {valor}")
            continue

        if not in_algoritmo:
            if line.upper().startswith("LEIA"):
                var_name = line.split("(")[1].split(")")[0].strip()
                if var_name in tipos_variaveis:
                    tipo = tipos_variaveis[var_name]
                    if tipo == "INTEIRO":
                        codigo_python.append(f"{var_name} = int(input('Digite um valor para {var_name}: '))")
                    elif tipo == "REAL":
                        codigo_python.append(f"{var_name} = float(input('Digite um valor para {var_name}: '))")
                    elif tipo == "STRING":
                        codigo_python.append(f"{var_name} = input('Digite um valor para {var_name}: ')")
                    elif tipo == "CARACTERE":
                        codigo_python.append(f"_temp_{var_name} = input('Digite um valor para {var_name}: ')")
                        codigo_python.append(f"if len(_temp_{var_name}) != 1:")
                        codigo_python.append(f"    print('Atenção: Esperava-se um único caractere para {var_name}. Usando apenas o primeiro caractere.')")
                        codigo_python.append(f"{var_name} = _temp_{var_name}[0] if _temp_{var_name} else ''")
                    else:
                        codigo_python.append(f"{var_name} = input('Digite um valor para {var_name}: ')")
                else:
                    codigo_python.append(f"{var_name} = input('Digite um valor para {var_name}: ')")

            elif line.upper().startswith("SE"):
                condicao = line[2:].split("THEN")[0].strip()
                codigo_python.append(f"{'    ' * indentacao}if {condicao}:")
                contexto_bloco.append("if")
                indentacao += 1

            elif line.upper() == "ELSE":
                if contexto_bloco and contexto_bloco[-1] == "if":
                    indentacao -= 1
                    codigo_python.append(f"{'    ' * indentacao}else:")
                    indentacao += 1
                else:
                    codigo_python.append(f"# Aviso: 'ELSE' sem 'SE' correspondente: {line}")

            elif line.upper() == "ENDIF":
                if contexto_bloco and contexto_bloco[-1] in ["if", "else"]:
                    indentacao -= 1
                    contexto_bloco.pop()
                else:
                    codigo_python.append(f"# Aviso: 'ENDIF' sem 'SE' correspondente: {line}")

            elif line.upper().startswith("ESCREVA"):
                codigo_python.append(f"{'    ' * indentacao}{processar_escreva(line)}")

            elif "=" in line:
                var_name, valor = line.split("=", 1)
                var_name = var_name.strip()
                valor = valor.strip()
                aviso = verificar_tipo(var_name, valor, tipos_variaveis, i)
                if aviso:
                    avisos.append(aviso)
                codigo_python.append(f"{'    ' * indentacao}{line}{comentario}")

            else:
                codigo_python.append(f"{'    ' * indentacao}{line}{comentario}")

    return "\n".join(codigo_python), avisos

#
def interpretador(portugol_code):
    codigo_python = "# Código Python não gerado devido a um erro"
    try:
        codigo_python, avisos = traduzir_para_python(portugol_code)
        codigo_python = re.sub(r"\bAND\b", "and", codigo_python)

        output = io.StringIO()
        with contextlib.redirect_stdout(output):
            exec(codigo_python, globals())

        resultado = ""
        if avisos:
            resultado += "Avisos:\n" + "\n".join(avisos) + "\n\n"
        resultado += f"Saída:\n{output.getvalue().strip()}"
        return resultado
    except Exception as e:
        error_traceback = traceback.format_exc()
        return f"Erro durante a execução:\n{error_traceback}\n\nCódigo Python Gerado:\n{codigo_python}"

def interpretar(portugol_code):
    return interpretador(portugol_code)

#
description_html = """
<p>PseudocodeLab:</p>
<p>Ramon Mayor Martins: <a href="https://rmayormartins.github.io/" target="_blank">Website</a> | <a href="https://huggingface.co/rmayormartins" target="_blank">Spaces</a></p>
<p><a href="https://huggingface.co/spaces/rmayormartins/pseudocodelab/blob/main/Manual_PseudocodeLab.pdf" target="_blank">Clique aqui para visualizar o Manual do PseudocodeLab</a></p>
"""

#
iface = gr.Interface(
    fn=interpretar,
    inputs=gr.Textbox(lines=20, label="Pseudocodigo"),
    outputs="text",
    title="Interpretador de Pseudocódigo",
    description=description_html
)

#
if __name__ == "__main__":
    iface.launch(debug=True)