Subindo arquivos

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,13 +1,46 @@
 ---
-title: Pseudocodelab
-emoji: 🦀
-colorFrom: green
-colorTo: gray
+title: PseudocodeLab
+emoji: 🖥️🇧🇷🦀
+colorFrom: blue
+colorTo: pink
 sdk: gradio
-sdk_version: 4.42.0
+sdk_version: 4.12.0
 app_file: app.py
 pinned: false
 license: ecl-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Language
+Portuguese (Brazilian)
+
+## Informação
+
+Este interpretador é uma ferramenta criada para auxiliar na interpretação de pseudocódigo, transformando as instruções fornecidas em execução ou validaçãodo código. Foi desenvolvido com o objetivo de auxiliar estudantes e profissionais que estão aprendendo/ensinando lógica de programação.
+
+## Funcionamento
+
+1. Digite ou cole o pseudocódigo na área de texto.
+2. Pressione o botão de Submit.
+3. O resultado da interpretação será exibido ao lado.
+
+## Manual
+
+O manual completo pode ser acessado e baixado clicando no [Manual do PseudocodeLab](https://huggingface.co/spaces/rmayormartins/pseudocodelab/blob/main/Manual_PseudocodeLab.pdf).
+
+
+## A fazer
+
+- Verificação de erros
+- Tradução para espanhol e inglês
+- Adicionar outras funções
+
+## Informação adicional
+
+- Desenvolvido por Ramon Mayor Martins, Ph.D. (2024)
+- E-mail: rmayormartins at: gmail.com
+- Pessoal: [https://rmayormartins.github.io/](https://rmayormartins.github.io/)
+- GitHub: [https://github.com/rmayormartins](https://github.com/rmayormartins)
+
+## Agradecimento especial
+
+Instituto Federal de Santa Catarina, Câmpus São José, Área de Telecomunicações [https://ifsc.edu.br/](https://ifsc.edu.br/)

app.py

@@ -0,0 +1,237 @@
+import gradio as gr
+import io
+import contextlib
+import re
+import traceback
+import math
+
+# Funções auxiliares
+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
+
+# Função para interpretar o pseudocódigo
+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)
+
+# Interface Gradio
+description_html = """
+<p>PseudocodeLab - Interpretador de Pseudocódigo</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="Manual_PseudocodeLab.pdf" download>Clique aqui para baixar o Manual do PseudocodeLab</a></p>
+"""
+
+# Criação da interface Gradio
+iface = gr.Interface(
+    fn=interpretar,
+    inputs=gr.Textbox(lines=20, label="Código Portugol"),
+    outputs="text",
+    title="PseudocodeLab - Interpretador de Pseudocódigo",
+    description=description_html
+)
+
+# Lançamento da interface
+if __name__ == "__main__":
+    iface.launch(debug=True)

requirements.txt

@@ -0,0 +1,3 @@
+gradio==4.12.0
+
+