lucidaflow 1.0.8__tar.gz → 1.2.2__tar.gz

lucidaflow-1.2.2/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: lucidaflow
+Version: 1.2.2
+Summary: Uma linguagem de script moderna, extensível e com tipagem gradual, implementada em Python.
+Author-email: Marco Lago <marconeed2@gmail.com>
+Project-URL: Homepage, https://github.com/marconeed/Lucida-Flow
+Project-URL: Issues, https://github.com/marconeed/Lucida-Flow/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Interpreters
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pysine
+Requires-Dist: requests
+Dynamic: license-file
+
+[Volume 1: O Manual de Referência](https://www.amazon.com.br/dp/B0FJ1HYJN8)
+
+[Volume 2: Construindo Aplicações Gráficas](https://www.amazon.com.br/dp/B0FLJ8PNYJ)
+
+[Lucida-Flow Support - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=SoteroApps.lucidaflow-support)
+
+[Lucida-Flow - pypi org](https://pypi.org/project/lucidaflow)
+
+[Lucida-Flow - GitHub](https://github.com/marconeed/Lucida-Flow)
+
+[Sponsor](https://github.com/sponsors/marconeed)
+
+______________________________________________________________________________________________
+
+## Usando o Terminal:
+
+OBS:
+
+Faça download do repositorio Lucida-Flow em uma pasta usando o terminal Windows ou o terminal do VScode:
+
+```
+git clone https://github.com/marconeed/Lucida-Flow
+cd Lucida-Flow
+```
+
+OBS:
+
+Baixe as dependencias usando o terminal Windows ou o terminal do VScode:
+
+```pip install requests```   
+
+OBS:
+
+Para criar programas com interface grafica precisamos criar 2 arquivos o:
+
+O arquivo .py contendo os codigos para desenhar a interface grafica
+
+O arquivo .lf contendo os codigos da logica  do programa
+
+Os 2 arquivos precisam estar na raiz da linguagem de programação, onde fica todo o codigo da linguagem, ou você pode colocar em outros locais, mais tera que referenciar nos 2 arquivos as pastas onde estão as importações de que os 2 arquivos precisam para funcionar
+
+a linguagem contem codigos das guis usadas no livro, estão na raiz do projeto em uma pasta chamada gui, basta colocar as que for usar na raiz junto ao arquivo .lf. Se quiser deixar onde esta precisa mudar o caminho das importações dos 2 arquivos.
+
+OBS:
+
+Para executar basta colocar esse comando usando o terminal Windows ou o terminal do VScode na pasta onde esta os arquivos e lembrar de refenciar o arquivo .lf na nome-do-arquivo-gui_host.py:
+
+```python main.py nome_arquivo.lf```
+
+```python nome-do-arquivo-gui_host.py```
+
+
+## Usando o VS code:
+
+OBS:
+
+Faça download da estensão da linguagem para VS code
+
+```https://marketplace.visualstudio.com/items?itemName=SoteroApps.lucidaflow-support```
+
+OBS:
+
+Baixe as dependencias usando o terminal Windows ou o terminal do VScode:
+
+```pip install requests```   
+
+OBS:
+
+A extensão funciona para auxiliar na contrução do codigo com sugestões e constução da sytanxe sublinhando as palavras, fica melhor programar no VS code
+
+O VS code suporta executar o codigo direto nele nome_arquivo.lf, mais para porgramas de interface grafica tera que usar o terminal do VS code para dar o comando para executar. o comando é o mesmo ```python nome-do-arquivo-gui_host.py```
+
+
+## Usando o pypi org:
+
+OBS:
+
+Faça download da linguagem na pypi org
+
+```https://pypi.org/project/lucidaflow```
+
+```pip install lucidaflow```
+
+OBS:
+
+Usando a linguagem dessa forma você elimina a necessidade dos arquivos da linguagem estar na mesma pasta para funcionar, basta cria uma pasta vazia com o .lf e executar, ou nome-do-arquivo-gui_host.py + .lf e executar se for com interface grafica. Para executar o comando é ```python -m lucidaflow nome_arquivo.lf``` ou ```python nome-do-arquivo-gui_host.py```
+
+Usar dessa forma combinado com o VS code e a extensão funciona para auxiliar na contrução do codigo com sugestões e constução da sytanxe sublinhando as palavras, fica melhor programar no VS code
+
+Para executar no terminal Windows basta abrir o terminal windows na pasta onde esta o .lf e digitar ```python -m lucidaflow nome-do-arquivo.lf```, ou abrir o terminal windows na pasta onde esta o gui.py e digitar ```python nome-do-arquivo-gui_host.py`` se for com interface grafica
+
+Para executar no VS code basta apertar play para arquivos .lf. Para arquivo .lf e gui.py precisa ser usado o terminal do VS code ```python nome-do-arquivo-gui_host.py```
+
+
+## Ativar o REPL (em qualquer pasta do computador):
+
+transformar a sua linguagem numa ferramenta de linha de comando profissional
+
+```python -m lucidaflow.cli```
+
+__________________________________________________________________________________________________________________________________________
+
+## Apoie o Projeto
+
+A Lucida-Flow é um projeto independente e de código aberto. Se você gosta da linguagem e quer ver o seu desenvolvimento continuar, considere [tornar-se um patrocinador no GitHub Sponsors](https://github.com/sponsors/marconeed)! O seu apoio é fundamental para a manutenção e evolução do projeto.

lucidaflow-1.2.2/README.md

@@ -0,0 +1,105 @@
+[Volume 1: O Manual de Referência](https://www.amazon.com.br/dp/B0FJ1HYJN8)
+
+[Volume 2: Construindo Aplicações Gráficas](https://www.amazon.com.br/dp/B0FLJ8PNYJ)
+
+[Lucida-Flow Support - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=SoteroApps.lucidaflow-support)
+
+[Lucida-Flow - pypi org](https://pypi.org/project/lucidaflow)
+
+[Lucida-Flow - GitHub](https://github.com/marconeed/Lucida-Flow)
+
+[Sponsor](https://github.com/sponsors/marconeed)
+
+______________________________________________________________________________________________
+
+## Usando o Terminal:
+
+OBS:
+
+Faça download do repositorio Lucida-Flow em uma pasta usando o terminal Windows ou o terminal do VScode:
+
+```
+git clone https://github.com/marconeed/Lucida-Flow
+cd Lucida-Flow
+```
+
+OBS:
+
+Baixe as dependencias usando o terminal Windows ou o terminal do VScode:
+
+```pip install requests```   
+
+OBS:
+
+Para criar programas com interface grafica precisamos criar 2 arquivos o:
+
+O arquivo .py contendo os codigos para desenhar a interface grafica
+
+O arquivo .lf contendo os codigos da logica  do programa
+
+Os 2 arquivos precisam estar na raiz da linguagem de programação, onde fica todo o codigo da linguagem, ou você pode colocar em outros locais, mais tera que referenciar nos 2 arquivos as pastas onde estão as importações de que os 2 arquivos precisam para funcionar
+
+a linguagem contem codigos das guis usadas no livro, estão na raiz do projeto em uma pasta chamada gui, basta colocar as que for usar na raiz junto ao arquivo .lf. Se quiser deixar onde esta precisa mudar o caminho das importações dos 2 arquivos.
+
+OBS:
+
+Para executar basta colocar esse comando usando o terminal Windows ou o terminal do VScode na pasta onde esta os arquivos e lembrar de refenciar o arquivo .lf na nome-do-arquivo-gui_host.py:
+
+```python main.py nome_arquivo.lf```
+
+```python nome-do-arquivo-gui_host.py```
+
+
+## Usando o VS code:
+
+OBS:
+
+Faça download da estensão da linguagem para VS code
+
+```https://marketplace.visualstudio.com/items?itemName=SoteroApps.lucidaflow-support```
+
+OBS:
+
+Baixe as dependencias usando o terminal Windows ou o terminal do VScode:
+
+```pip install requests```   
+
+OBS:
+
+A extensão funciona para auxiliar na contrução do codigo com sugestões e constução da sytanxe sublinhando as palavras, fica melhor programar no VS code
+
+O VS code suporta executar o codigo direto nele nome_arquivo.lf, mais para porgramas de interface grafica tera que usar o terminal do VS code para dar o comando para executar. o comando é o mesmo ```python nome-do-arquivo-gui_host.py```
+
+
+## Usando o pypi org:
+
+OBS:
+
+Faça download da linguagem na pypi org
+
+```https://pypi.org/project/lucidaflow```
+
+```pip install lucidaflow```
+
+OBS:
+
+Usando a linguagem dessa forma você elimina a necessidade dos arquivos da linguagem estar na mesma pasta para funcionar, basta cria uma pasta vazia com o .lf e executar, ou nome-do-arquivo-gui_host.py + .lf e executar se for com interface grafica. Para executar o comando é ```python -m lucidaflow nome_arquivo.lf``` ou ```python nome-do-arquivo-gui_host.py```
+
+Usar dessa forma combinado com o VS code e a extensão funciona para auxiliar na contrução do codigo com sugestões e constução da sytanxe sublinhando as palavras, fica melhor programar no VS code
+
+Para executar no terminal Windows basta abrir o terminal windows na pasta onde esta o .lf e digitar ```python -m lucidaflow nome-do-arquivo.lf```, ou abrir o terminal windows na pasta onde esta o gui.py e digitar ```python nome-do-arquivo-gui_host.py`` se for com interface grafica
+
+Para executar no VS code basta apertar play para arquivos .lf. Para arquivo .lf e gui.py precisa ser usado o terminal do VS code ```python nome-do-arquivo-gui_host.py```
+
+
+## Ativar o REPL (em qualquer pasta do computador):
+
+transformar a sua linguagem numa ferramenta de linha de comando profissional
+
+```python -m lucidaflow.cli```
+
+__________________________________________________________________________________________________________________________________________
+
+## Apoie o Projeto
+
+A Lucida-Flow é um projeto independente e de código aberto. Se você gosta da linguagem e quer ver o seu desenvolvimento continuar, considere [tornar-se um patrocinador no GitHub Sponsors](https://github.com/sponsors/marconeed)! O seu apoio é fundamental para a manutenção e evolução do projeto.

{lucidaflow-1.0.8 → lucidaflow-1.2.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lucidaflow"
-version = "1.0.8" # Aumentei a versão para a nova publicação
+version = "1.2.2" # Aumentei a versão para a nova publicação
 authors = [
   { name="Marco Lago", email="marconeed2@gmail.com" },
 ]

lucidaflow-1.2.2/src/lucidaflow/__main__.py

@@ -0,0 +1,14 @@
+# src/lucidaflow/__main__.py
+import sys
+from lucidaflow.cli import run_file, start_repl
+
+def main():
+    # Se um nome de arquivo foi passado, executa o arquivo
+    if len(sys.argv) > 1:
+        run_file(sys.argv[1])
+    # Se não, entra no modo REPL
+    else:
+        start_repl()
+
+if __name__ == "__main__":
+    main()

lucidaflow-1.2.2/src/lucidaflow/cli.py

@@ -0,0 +1,100 @@
+# main.py (Versão Final)
+
+import sys
+from lucidaflow.lucida_lexer import Lexer
+from lucidaflow.lucida_parser import Parser
+from lucidaflow.lucida_analyzer import SemanticAnalyzer
+from lucidaflow.lucida_interpreter import Interpreter
+from lucidaflow.lucida_errors import LucidaError
+from lucidaflow.lucida_ast import ProgramNode # Import necessário para o "truque" do REPL
+from lucidaflow.lib.parser_patch import apply_patch
+apply_patch()
+
+# --- Função para executar um trecho de código ---
+def run_code(source_code, analyzer, interpreter):
+    """Função auxiliar que executa as 4 fases da linguagem."""
+    # Fases 1 e 2: Lexer e Parser são sempre novos
+    lexer = Lexer(source_code)
+    parser = Parser(lexer)
+    ast = parser.parse()
+
+    # Fases 3 e 4: Analyzer e Interpreter são reutilizados para manter o estado
+    analyzer.visit(ast)
+    result = interpreter.visit(ast)
+    return result
+
+# --- Função para o modo REPL ---
+def start_repl():
+    print("Lucida-Flow REPL v1.0")
+    print("Digite 'exit' ou 'sair' para terminar.")
+    
+    # Criamos as instâncias FORA do loop para manter o estado (variáveis, etc.)
+    analyzer = SemanticAnalyzer()
+    interpreter = Interpreter()
+
+    # Truque para inicializar as tabelas de símbolos do analisador
+    # antes de receber o primeiro input.
+    analyzer.visit(ProgramNode([]))
+    
+    while True:
+        try:
+            # 1. READ (Ler)
+            line = input("lf> ")
+            if line.strip().lower() in ('exit', 'sair'):
+                break
+            
+            if not line.strip():
+                continue
+
+            # 2. EVAL & PRINT (Avaliar e Imprimir)
+            result = run_code(line, analyzer, interpreter)
+            
+            # Imprime o resultado da expressão, se houver um
+            if result is not None:
+                print(result)
+
+        # Captura erros sem quebrar o REPL
+        except LucidaError as e:
+            print(e)
+        except Exception as e:
+            # Para erros inesperados do Python, mostra o traceback para nos ajudar
+            import traceback
+            print("--- ERRO DE SISTEMA NO REPL ---")
+            traceback.print_exc()
+
+# --- Função para executar um ficheiro ---
+def run_file(filename):
+    print(f"--- Lendo código do arquivo: {filename} ---")
+    try:
+        with open(filename, 'r', encoding='utf-8') as f:
+            source_code = f.read()
+        
+        # Para execução de ficheiro, criamos instâncias novas a cada vez
+        analyzer = SemanticAnalyzer()
+        interpreter = Interpreter()
+        run_code(source_code, analyzer, interpreter)
+
+        print("\n--- Execução Concluída ---")
+
+    except FileNotFoundError:
+        print(f"\nERRO: O arquivo '{filename}' não foi encontrado.")
+    except LucidaError as e:
+        print(f"\n--- OCORREU UM ERRO NA LUCIDA-FLOW ---")
+        print(e)
+    except Exception as e:
+        print(f"\n--- OCORREU UM ERRO INESPERADO NO SISTEMA ---")
+        import traceback
+        traceback.print_exc()
+
+
+# --- Ponto de Entrada Principal ---
+def main():
+    # Se um nome de arquivo foi passado, executa o arquivo
+    if len(sys.argv) > 1:
+        run_file(sys.argv[1])
+    # Se não, entra no modo REPL
+    else:
+        start_repl()
+
+if __name__ == "__main__":
+    main()

{lucidaflow-1.0.8 → lucidaflow-1.2.2}/src/lucidaflow/lib/dado.py

@@ -1,35 +1,35 @@
-# lib/dado.py
-import random
-from lucidaflow.lucida_symbols import VarSymbol, BuiltInFunctionSymbol, ScopedSymbolTable, BuiltInTypeSymbol
-
-# --- Lógica de Runtime ---
-def lf_d6(args):
-    return random.randint(1, 6)
-
-def lf_rolar_entre(args):
-    if len(args) != 2: raise TypeError("rolar_entre() espera 2 argumentos (min, max)")
-    min_val, max_val = int(args[0]), int(args[1])
-    return random.randint(min_val, max_val)
-
-NATIVE_DADO_MODULE = {
-    'd6': lf_d6,
-    'rolar_entre': lf_rolar_entre,
-}
-
-# --- Descrição Semântica ---
-def register_semantics():
-    int_type = BuiltInTypeSymbol('int')
-    module_scope = ScopedSymbolTable(scope_name='dado', scope_level=2)
-    module_scope.define(BuiltInFunctionSymbol(name='d6', params=[], return_type=int_type))
-    
-    # --- A DEFINIÇÃO QUE PROVAVELMENTE FALTA ---
-    module_scope.define(
-        BuiltInFunctionSymbol(
-            name='rolar_entre',
-            params=[VarSymbol('min', int_type), VarSymbol('max', int_type)],
-            return_type=int_type
-        )
-    )
-    # -----------------------------------------
-    
+# lib/dado.py
+import random
+from lucidaflow.lucida_symbols import VarSymbol, BuiltInFunctionSymbol, ScopedSymbolTable, BuiltInTypeSymbol
+
+# --- Lógica de Runtime ---
+def lf_d6(args):
+    return random.randint(1, 6)
+
+def lf_rolar_entre(args):
+    if len(args) != 2: raise TypeError("rolar_entre() espera 2 argumentos (min, max)")
+    min_val, max_val = int(args[0]), int(args[1])
+    return random.randint(min_val, max_val)
+
+NATIVE_DADO_MODULE = {
+    'd6': lf_d6,
+    'rolar_entre': lf_rolar_entre,
+}
+
+# --- Descrição Semântica ---
+def register_semantics():
+    int_type = BuiltInTypeSymbol('int')
+    module_scope = ScopedSymbolTable(scope_name='dado', scope_level=2)
+    module_scope.define(BuiltInFunctionSymbol(name='d6', params=[], return_type=int_type))
+    
+    # --- A DEFINIÇÃO QUE PROVAVELMENTE FALTA ---
+    module_scope.define(
+        BuiltInFunctionSymbol(
+            name='rolar_entre',
+            params=[VarSymbol('min', int_type), VarSymbol('max', int_type)],
+            return_type=int_type
+        )
+    )
+    # -----------------------------------------
+    
     return module_scope

{lucidaflow-1.0.8 → lucidaflow-1.2.2}/src/lucidaflow/lib/json.py

@@ -1,46 +1,46 @@
-# lib/json.py
-import json
-from lucidaflow.lucida_symbols import VarSymbol, BuiltInFunctionSymbol, ScopedSymbolTable, BuiltInTypeSymbol
-
-# --- PARTE 1: Lógica de Runtime ---
-
-def lf_json_parse(args):
-    if len(args) != 1: raise TypeError("parse() espera 1 argumento (a string JSON)")
-    try:
-        return json.loads(args[0])
-    except json.JSONDecodeError as e:
-        raise ValueError(f"String JSON inválida: {e}")
-
-def lf_json_stringify(args):
-    obj_to_stringify = args[0]
-    indent = int(args[1]) if len(args) > 1 else None
-    return json.dumps(obj_to_stringify, indent=indent, ensure_ascii=False)
-
-NATIVE_JSON_MODULE = {
-    "parse": lf_json_parse,
-    "stringify": lf_json_stringify,
-}
-
-# --- PARTE 2: Descrição Semântica ---
-
-def register_semantics():
-    string_type = BuiltInTypeSymbol('string')
-    int_type = BuiltInTypeSymbol('int')
-    any_type = BuiltInTypeSymbol('any')
-    
-    module_scope = ScopedSymbolTable(scope_name='json', scope_level=2)
-    module_scope.define(
-        BuiltInFunctionSymbol(
-            name='parse', 
-            params=[VarSymbol('json_string', string_type)], 
-            return_type=any_type
-        )
-    )
-    module_scope.define(
-        BuiltInFunctionSymbol(
-            name='stringify', 
-            params=[VarSymbol('objeto', any_type), VarSymbol('indent', int_type, is_optional=True)],
-            return_type=string_type
-        )
-    )
+# lib/json.py
+import json
+from lucidaflow.lucida_symbols import VarSymbol, BuiltInFunctionSymbol, ScopedSymbolTable, BuiltInTypeSymbol
+
+# --- PARTE 1: Lógica de Runtime ---
+
+def lf_json_parse(args):
+    if len(args) != 1: raise TypeError("parse() espera 1 argumento (a string JSON)")
+    try:
+        return json.loads(args[0])
+    except json.JSONDecodeError as e:
+        raise ValueError(f"String JSON inválida: {e}")
+
+def lf_json_stringify(args):
+    obj_to_stringify = args[0]
+    indent = int(args[1]) if len(args) > 1 else None
+    return json.dumps(obj_to_stringify, indent=indent, ensure_ascii=False)
+
+NATIVE_JSON_MODULE = {
+    "parse": lf_json_parse,
+    "stringify": lf_json_stringify,
+}
+
+# --- PARTE 2: Descrição Semântica ---
+
+def register_semantics():
+    string_type = BuiltInTypeSymbol('string')
+    int_type = BuiltInTypeSymbol('int')
+    any_type = BuiltInTypeSymbol('any')
+    
+    module_scope = ScopedSymbolTable(scope_name='json', scope_level=2)
+    module_scope.define(
+        BuiltInFunctionSymbol(
+            name='parse', 
+            params=[VarSymbol('json_string', string_type)], 
+            return_type=any_type
+        )
+    )
+    module_scope.define(
+        BuiltInFunctionSymbol(
+            name='stringify', 
+            params=[VarSymbol('objeto', any_type), VarSymbol('indent', int_type, is_optional=True)],
+            return_type=string_type
+        )
+    )
     return module_scope

lucidaflow-1.2.2/src/lucidaflow/lib/math.py

@@ -0,0 +1,54 @@
+# lib/math.py
+from lucidaflow.lucida_symbols import VarSymbol, BuiltInFunctionSymbol, ScopedSymbolTable, BuiltInTypeSymbol
+import math
+
+# --- PARTE 1: LÓGICA DE RUNTIME ---
+
+def lf_soma(args):
+    if len(args) != 2: raise TypeError("soma() espera 2 argumentos.")
+    return float(args[0]) + float(args[1])
+
+def lf_sub(args):
+    if len(args) != 2: raise TypeError("sub() espera 2 argumentos.")
+    return float(args[0]) - float(args[1])
+
+def lf_mult(args):
+    if len(args) != 2: raise TypeError("mult() espera 2 argumentos.")
+    return float(args[0]) * float(args[1])
+
+def lf_div(args):
+    if len(args) != 2: raise TypeError("div() espera 2 argumentos.")
+    if float(args[1]) == 0: raise ZeroDivisionError("Divisão por zero.")
+    return float(args[0]) / float(args[1])
+
+def lf_pot(args):
+    if len(args) != 2: raise TypeError("pot() espera 2 argumentos.")
+    return float(args[0]) ** float(args[1])
+
+
+# O dicionário que o Interpreter irá usar
+NATIVE_MATH_MODULE = {
+    "soma": lf_soma,
+    "sub": lf_sub,
+    "mult": lf_mult,
+    "div": lf_div,
+    "pot": lf_pot,
+    "pi": math.pi,
+}
+
+# --- PARTE 2: DESCRIÇÃO SEMÂNTICA ---
+
+def register_semantics():
+    float_type = BuiltInTypeSymbol('float')
+    any_type = BuiltInTypeSymbol('any')
+    
+    module_scope = ScopedSymbolTable(scope_name='math', scope_level=2)
+    
+    module_scope.define(VarSymbol('pi', float_type))
+    module_scope.define(BuiltInFunctionSymbol('soma', params=[VarSymbol('a', any_type), VarSymbol('b', any_type)], return_type=float_type))
+    module_scope.define(BuiltInFunctionSymbol('sub', params=[VarSymbol('a', any_type), VarSymbol('b', any_type)], return_type=float_type))
+    module_scope.define(BuiltInFunctionSymbol('mult', params=[VarSymbol('a', any_type), VarSymbol('b', any_type)], return_type=float_type))
+    module_scope.define(BuiltInFunctionSymbol('div', params=[VarSymbol('a', any_type), VarSymbol('b', any_type)], return_type=float_type))
+    module_scope.define(BuiltInFunctionSymbol('pot', params=[VarSymbol('a', any_type), VarSymbol('b', any_type)], return_type=float_type))
+    
+    return module_scope

lucidaflow-1.2.2/src/lucidaflow/lib/media.py

@@ -0,0 +1,61 @@
+# lib/media.py
+import pygame
+from lucidaflow.lucida_symbols import VarSymbol, BuiltInFunctionSymbol, ScopedSymbolTable, BuiltInTypeSymbol
+
+# Inicializa o mixer do Pygame uma vez
+pygame.mixer.init()
+
+# --- Funções de Runtime ---
+def lf_media_carregar(args):
+    pygame.mixer.music.load(str(args[0]))
+    return None
+
+def lf_media_tocar(args):
+    pygame.mixer.music.play()
+    return None
+
+def lf_media_pausar(args):
+    pygame.mixer.music.pause()
+    return None
+
+def lf_media_continuar(args):
+    pygame.mixer.music.unpause()
+    return None
+
+def lf_media_parar(args):
+    pygame.mixer.music.stop()
+    return None
+
+def lf_media_definir_volume(args):
+    # Volume é de 0.0 a 1.0
+    volume = float(args[0])
+    pygame.mixer.music.set_volume(volume)
+    return None
+
+def lf_media_esta_a_tocar(args):
+    return pygame.mixer.music.get_busy()
+
+NATIVE_MEDIA_MODULE = {
+    "carregar": lf_media_carregar,
+    "tocar": lf_media_tocar,
+    "pausar": lf_media_pausar,
+    "continuar": lf_media_continuar,
+    "parar": lf_media_parar,
+    "definir_volume": lf_media_definir_volume,
+    "esta_a_tocar": lf_media_esta_a_tocar,
+}
+
+# --- Descrição Semântica ---
+def register_semantics():
+    string_type = BuiltInTypeSymbol('string'); float_type = BuiltInTypeSymbol('float')
+    bool_type = BuiltInTypeSymbol('bool'); null_type = BuiltInTypeSymbol('null')
+    
+    scope = ScopedSymbolTable(scope_name='media', scope_level=2)
+    scope.define(BuiltInFunctionSymbol('carregar', params=[VarSymbol('caminho', string_type)], return_type=null_type))
+    scope.define(BuiltInFunctionSymbol('tocar', params=[], return_type=null_type))
+    scope.define(BuiltInFunctionSymbol('pausar', params=[], return_type=null_type))
+    scope.define(BuiltInFunctionSymbol('continuar', params=[], return_type=null_type))
+    scope.define(BuiltInFunctionSymbol('parar', params=[], return_type=null_type))
+    scope.define(BuiltInFunctionSymbol('definir_volume', params=[VarSymbol('volume', float_type)], return_type=null_type))
+    scope.define(BuiltInFunctionSymbol('esta_a_tocar', params=[], return_type=bool_type))
+    return scope

lucidaflow-1.2.2/src/lucidaflow/lib/parser_patch.py

@@ -0,0 +1,24 @@
+# lib/parser_patch.py
+from lucidaflow.lucida_parser import Parser
+
+def apply_patch():
+    """
+    Esta função aplica um "remendo" em tempo de execução na classe Parser
+    para corrigir a assinatura do método de erro.
+    """
+    print("-> Aplicando patch no Parser...")
+
+    # 1. Guardamos a função de erro original
+    original_error_method = Parser.error
+
+    # 2. Definimos uma nova função de erro que aceita o argumento 'token'
+    def novo_metodo_de_erro(self, msg="Sintaxe inválida", token=None):
+        # Esta nova função simplesmente chama a original da forma que ela espera
+        token_to_report = token if token else self.current_token
+        detailed_msg = f'{msg} (token: {token_to_report})'
+        # A chamada à função original precisa de ser feita com o 'self' correto
+        original_error_method(self, detailed_msg)
+
+    # 3. Substituímos a função de erro antiga da classe Parser pela nossa nova versão
+    Parser.error = novo_metodo_de_erro
+    print("-> Patch do Parser aplicado com sucesso!")