vladx 1.2.1 → 1.2.3

package/DOCUMENTAZIONE.md

@@ -0,0 +1,320 @@
+# 🇮🇹 Documentazione Ufficiale VladX
+
+Benvenuti nella documentazione ufficiale di **VladX**, un linguaggio di programmazione moderno con **sintassi italiana**. VladX è progettato per essere leggibile, intuitivo e completo, ideale per chi vuole programmare in modo naturale senza rinunciare alla potenza di un linguaggio moderno.
+
+---
+
+## 📑 Indice
+
+1. [Installazione](#-installazione)
+2. [Guida Rapida CLI](#-guida-rapida-cli)
+3. [Sintassi di Base](#-sintassi-di-base)
+4. [Tipi di Dati](#-tipi-di-dati)
+5. [Operatori](#-operatori)
+6. [Controllo del Flusso](#-controllo-del-flusso)
+7. [Funzioni](#-funzioni)
+8. [Moduli](#-moduli)
+9. [Libreria Standard (StdLib)](#-libreria-standard-stdlib)
+10. [Funzioni Globali](#-funzioni-globali)
+11. [Metodi di Array e Oggetti](#-metodi-di-array-e-oggetti)
+12. [VladPM (Package Manager)](#-vladpm-package-manager)
+13. [Esempi Completi](#-esempi-completi)
+
+---
+
+## 🚀 Installazione
+
+Puoi installare VladX sul tuo sistema in due modi:
+
+### Tramite NPM (Consigliato)
+Se hai Node.js installato, puoi installare VladX globalmente con un semplice comando:
+```bash
+npm install -g vladx
+```
+
+### Tramite Script Bash
+Puoi utilizzare lo script di installazione incluso nel repository:
+```bash
+chmod +x install.sh
+./install.sh
+```
+
+---
+
+## 🛠 Guida Rapida CLI
+
+Il comando principale è `vladx`.
+
+- **REPL Interattivo**: Digita semplicemente `vladx` per entrare nella console interattiva.
+- **Esecuzione Script**: `vladx mio_programma.vx`
+- **Analisi AST**: `vladx ast mio_programma.vx` (mostra la struttura interna del codice).
+- **Lexing**: `vladx lex mio_programma.vx` (mostra i token analizzati).
+
+---
+
+## 📝 Sintassi di Base
+
+### Commenti
+```javascript
+// Questo è un commento su riga singola
+/* Questo è un commento
+   multilinea */
+```
+
+### Variabili e Costanti
+In VladX, le variabili vengono dichiarate con la parola chiave `variabile` e le costanti con `costante`.
+
+```javascript
+variabile nome = "Vlad";
+nome = "VladX"; // Ok, è una variabile
+
+costante VERSIONE = 1.2;
+// VERSIONE = 1.3; // Errore! Non puoi riassegnare una costante
+```
+
+---
+
+## 💎 Tipi di Dati
+
+VladX supporta i seguenti tipi di dati fondamentali:
+
+| Tipo | Esempio |
+| :--- | :--- |
+| **Numero** | `10`, `3.14`, `-5` |
+| **Stringa** | `"Ciao Mondo"`, `'Esempio'` |
+| **Booleano** | `vero`, `falso` |
+| **Nullo** | `nullo` |
+| **Array** | `[1, 2, 3, "test"]` |
+| **Oggetto** | `{ nome: "Vlad", eta: 20 }` |
+
+---
+
+## ⚡ Operatori
+
+### Aritmetici
+Supporto completo per le operazioni matematiche:
+- `+` (Addizione / Concatenazione stringhe)
+- `-` (Sottrazione)
+- `*` (Moltiplicazione)
+- `/` (Divisione)
+- `%` (Resto della divisione)
+- `++` / `--` (Incremento e decremento)
+
+### Confronto
+- `==` / `===` (Uguaglianza)
+- `!=` / `!==` (Diversità)
+- `<` / `>` (Minore / Maggiore)
+- `<=` / `>=` (Minore o uguale / Maggiore o uguale)
+
+### Logici
+- `e` (AND logico)
+- `o` (OR logico)
+- `non` (NOT logico)
+
+---
+
+## 🔄 Controllo del Flusso
+
+### Condizionali (se / altrimenti)
+```javascript
+variabile voto = 8;
+
+se (voto >= 6) {
+    stampa("Promosso!");
+} altrimenti {
+    stampa("Bocciato!");
+}
+```
+
+### Ciclo Mentre (mentre)
+```javascript
+variabile contatore = 0;
+mentre (contatore < 5) {
+    stampa("Conteggio: " + contatore);
+    contatore++;
+}
+```
+
+### Ciclo Per (per)
+```javascript
+per (variabile i = 0; i < 3; i++) {
+    stampa("Giro numero " + i);
+}
+```
+
+### Gestione Errori (prova / cattura / finalmente)
+VladX include un sistema robusto per gestire le eccezioni:
+```javascript
+prova {
+    lancia "Qualcosa è andato storto!";
+} cattura (errore) {
+    stampa("Errore catturato: " + errore);
+} finalmente {
+    stampa("Esecuzione terminata.");
+}
+```
+
+---
+
+## 📦 Funzioni
+
+### Dichiarazione Funzione
+```javascript
+funzione saluta(nome) {
+    ritorna "Ciao, " + nome + "!";
+}
+
+stampa(saluta("Amico"));
+```
+
+### Arrow Functions
+Sintassi compatta per funzioni rapide:
+```javascript
+costante quadrato = (n) => n * n;
+stampa(quadrato(4)); // 16
+```
+
+---
+
+## 🧩 Moduli
+
+VladX permette di organizzare il codice in più file.
+
+**file: `matematica.vx`**
+```javascript
+esporta costante PI = 3.14;
+esporta funzione doppia(n) { ritorna n * 2; }
+```
+
+**file: `app.vx`**
+```javascript
+importa { PI, doppia } da "./matematica.vx";
+
+stampa("Il doppio di PI è: " + doppia(PI));
+```
+
+---
+
+## 📚 Libreria Standard (StdLib)
+
+La libreria standard offre strumenti potenti pronti all'uso.
+
+### 📁 Archivio (File System)
+Gestisci i file in modo semplice.
+- `Archivio.leggi(percorso)`: Legge il contenuto di un file.
+- `Archivio.scrivi(percorso, dati)`: Scrive dati in un file.
+- `Archivio.esiste(percorso)`: Verifica se un file esiste.
+- `Archivio.elimina(percorso)`: Rimuove un file.
+
+### 💻 Sistema (OS)
+Interagisci con il sistema operativo.
+- `Sistema.esegui(comando)`: Esegue un comando shell e restituisce l'output.
+- `Sistema.argomenti`: Array degli argomenti passati da riga di comando.
+- `Sistema.piattaforma`: Stringa che indica l'OS (es. "linux", "darwin").
+- `Sistema.cartellaCorrente()`: Percorso della directory attuale.
+- `Sistema.esci(codice)`: Termina il programma.
+
+### 🌐 Rete (HTTP)
+Includi capacità di rete nei tuoi script.
+- `Rete.chiama(url)`: Esegue una richiesta HTTP GET (utilizza curl internamente).
+- `Rete.server(porta, gestore)`: Avvia un server web sulla porta specificata.
+
+```javascript
+funzione mioGestore(richiesta) {
+    ritorna {
+        stato: 200,
+        corpo: "Ciao dal server VladX!",
+        intestazioni: { "Content-Type": "text/plain" }
+    };
+}
+
+Rete.server(8080, mioGestore);
+```
+
+---
+
+## 🌍 Funzioni Globali
+
+Funzioni sempre disponibili senza importazioni:
+- `stampa(valore)`: Mostra un valore nella console.
+- `aspetta(ms)`: Sospende l'esecuzione per il numero specificato di millisecondi.
+- `lunghezza(valore)`: Restituisce la lunghezza di una stringa o array.
+- `tipo(valore)`: Restituisce il tipo del valore (es. "number", "string").
+- `numero(valore)`: Converte in numero.
+- `stringa(valore)`: Converte in stringa.
+- `array(valore)`: Verifica se il valore è un array.
+
+---
+
+## 📊 Metodi di Array e Oggetti
+
+### Array
+Gli array supportano metodi dinamici:
+```javascript
+variabile lista = [1, 2];
+lista.aggiungi(3); // lista è [1, 2, 3]
+variabile rimosso = lista.rimuovi(); // rimosso = 3, lista è [1, 2]
+stampa(lista.lunghezza); // 2
+```
+
+### Oggetti
+Accesso alle proprietà tramite punto o parentesi quadre:
+```javascript
+variabile auto = { marca: "Fiat", modello: "500" };
+stampa(auto.marca); // "Fiat"
+auto.anno = 2022;
+```
+
+---
+
+## 📦 VladPM (Package Manager)
+
+VladPM è lo strumento per gestire le dipendenze e i progetti VladX.
+
+- `vladpm init`: Crea un nuovo file `vladx.json` nel progetto.
+- `vladpm install <pacchetto>`: Installa un pacchetto dal registry.
+- `vladpm publish`: Pubblica il progetto nel registry VladX.
+- `vladpm start`: Esegue lo script `start` definito in `vladx.json`.
+- `vladpm run <nome>`: Esegue uno script personalizzato.
+
+---
+
+## 🌟 Esempi Completi
+
+#### Fibonacci
+```javascript
+funzione fibonacci(n) {
+    se (n <= 1) {
+        ritorna n;
+    }
+    ritorna fibonacci(n - 1) + fibonacci(n - 2);
+}
+
+per (variabile i = 0; i < 10; i++) {
+    stampa(fibonacci(i));
+}
+```
+
+#### Client HTTP API
+```javascript
+variabile risposta = Rete.chiama("https://api.github.com/users/octocat");
+stampa("Nome utente: " + risposta.name);
+stampa("Bio: " + risposta.bio);
+```
+
+#### Generatore di File
+```javascript
+costante NOME_FILE = "test.txt";
+
+se (non Archivio.esiste(NOME_FILE)) {
+    Archivio.scrivi(NOME_FILE, "Contenuto generato automaticamente da VladX");
+    stampa("File creato con successo!");
+} altrimenti {
+    stampa("Il file esiste già. Contenuto:");
+    stampa(Archivio.leggi(NOME_FILE));
+}
+```
+
+---
+
+Creato con ❤️ dal team di **VladX**.

package/README.md

@@ -0,0 +1,126 @@
+# 🇮🇹 VladX
+
+**VladX** è un linguaggio di programmazione moderno con **sintassi italiana**, progettato per essere potente, leggibile e completo. Include un interprete robusto, una libreria standard (StdLib) estesa e un package manager dedicato (**VladPM**).
+
+---
+
+## 🚀 Installazione
+
+Puoi installare VladX in due modi:
+
+### Metodo 1: NPM (Consigliato)
+Se hai Node.js installato:
+```bash
+npm install -g vladx
+```
+
+### Metodo 2: Script di installazione
+```bash
+chmod +x install.sh
+./install.sh
+```
+
+---
+
+## 🛠️ Utilizzo CLI
+
+- `vladx` - Avvia il REPL interattivo.
+- `vladx programma.vx` - Esegue un file VladX.
+- `vladx ast programma.vx` - Mostra l'Abstract Syntax Tree.
+- `vladx lex programma.vx` - Mostra i token analizzati.
+
+---
+
+## 📝 Sintassi in breve
+
+### Variabili e Costanti
+```javascript
+variabile nome = "Vlad";
+costante PI = 3.14;
+```
+
+### Controllo del Flusso
+```javascript
+se (x > 10) {
+    stampa("Maggiore di 10");
+} altrimenti {
+    stampa("Minore o uguale a 10");
+}
+
+per (variabile i = 0; i < 5; i++) {
+    stampa(i);
+}
+
+mentre (condizione) { ... }
+```
+
+### Funzioni e Arrow Functions
+```javascript
+funzione saluta(nome) {
+    ritorna "Ciao, " + nome;
+}
+
+costante somma = (a, b) => a + b;
+```
+
+### Gestione Errori (Try/Catch)
+```javascript
+prova {
+    lancia "Ops!";
+} cattura (err) {
+    stampa("Errore: " + err);
+} finalmente {
+    stampa("Fine.");
+}
+```
+
+---
+
+## 📦 Sistema Moduli
+
+Dividi il tuo codice in più file:
+
+```javascript
+// math.vx
+esporta costante PI = 3.14;
+esporta funzione doppia(n) { ritorna n * 2; }
+
+// app.vx
+importa { PI, doppia } da "./math.vx";
+stampa(doppia(PI));
+```
+
+---
+
+## 📚 Libreria Standard (StdLib)
+
+VladX include moduli nativi potenti:
+
+- **`Archivio`**: `leggi`, `scrivi`, `esiste`, `elimina`.
+- **`Sistema`**: `esegui` (shell), `argomenti`, `piattaforma`, `esci`.
+- **`Rete`**: `chiama` (HTTP GET), `server` (Crea server web).
+
+---
+
+## 📦 VladPM (Package Manager)
+
+VladPM è il gestore di pacchetti ufficiale per VladX.
+
+- `vladpm init` - Inizializza un nuovo progetto (`vladx.json`).
+- `vladpm install <nome>` - Installa un pacchetto dal registry.
+- `vladpm publish` - Pubblica il tuo pacchetto.
+- `vladpm start` / `vladpm run <script>` - Esegue gli script definiti nel progetto.
+
+---
+
+## 🌟 Esempi
+
+Trovi molti esempi nella cartella `examples/`:
+- `test_eccezioni.vx` - Test try/catch.
+- `test_stdlib_fs.vx` - Test File System.
+- `test_stdlib_rete.vx` - Test HTTP e Server.
+- `moduli/` - Esempio di sistema a moduli.
+
+---
+
+Creato con ❤️ per la comunità italiana.

package/examples/test_eccezioni.vx

@@ -0,0 +1,33 @@
+/**
+ * Test Eccezioni VladX
+ */
+
+stampa("--- Inizio Test Eccezioni ---");
+
+prova {
+    stampa("1. Provo a fare qualcosa...");
+    lancia "Ops! Qualcosa è andato storto.";
+    stampa("Questo non dovrebbe apparire.");
+} cattura (errore) {
+    stampa("2. Catturato errore: " + errore);
+} finalmente {
+    stampa("3. Questo viene eseguito sempre (finalmente).");
+}
+
+stampa("");
+
+prova {
+    stampa("4. Provo divisione per zero (errore runtime)...");
+    variabile x = 10 / 0; // In JS è Infinity, non lancia errore. Proviamo qualcosa che lancia errore.
+    stampa("Risultato: " + x);
+    
+    // Forza errore runtime reale (chiamata a non funzione)
+    variabile nonFunzione = 10;
+    nonFunzione();
+} cattura (err) {
+    stampa("5. Catturato errore runtime: " + err);
+} finalmente {
+    stampa("6. Fine secondo blocco prova.");
+}
+
+stampa("--- Fine Test Eccezioni ---");

package/examples/test_stdlib_fs.vx

@@ -0,0 +1,43 @@
+/**
+ * Test Archivio e Sistema
+ */
+
+stampa("--- Test Sistema ---");
+stampa("Piattaforma: " + Sistema.piattaforma);
+stampa("Cartella Corrente: " + Sistema.cartellaCorrente());
+
+stampa("\n--- Test Archivio ---");
+costante fileTest = "test_stdlib.txt";
+costante contenuto = "Questo è un test della StdLib di VladX!";
+
+stampa("Scrittura file...");
+Archivio.scrivi(fileTest, contenuto);
+
+se (Archivio.esiste(fileTest)) {
+    stampa("File creato con successo.");
+    costante letto = Archivio.leggi(fileTest);
+    stampa("Contenuto letto: " + letto);
+    
+    se (letto == contenuto) {
+        stampa("VERIFICA: I contenuti corrispondono.");
+    } altrimenti {
+        stampa("ERRORE: I contenuti NON corrispondono!");
+    }
+    
+    stampa("Eliminazione file...");
+    Archivio.elimina(fileTest);
+    
+    se (!Archivio.esiste(fileTest)) {
+        stampa("File eliminato con successo.");
+    }
+} altrimenti {
+    stampa("ERRORE: Il file non è stato creato!");
+}
+
+stampa("\n--- Esecuzione comando shell ---");
+prova {
+    costante output = Sistema.esegui("ls -l bin/vladx");
+    stampa("Output ls: " + output);
+} cattura (err) {
+    stampa("Errore esecuzione: " + err);
+}

package/examples/test_stdlib_rete.vx

@@ -0,0 +1,46 @@
+/**
+ * Test Rete VladX
+ */
+
+stampa("--- Test Rete.chiama ---");
+prova {
+    // Chiamata a JSONPlaceholder per test
+    stampa("Eseguo chiamata a JSONPlaceholder...");
+    costante post = Rete.chiama("https://jsonplaceholder.typicode.com/posts/1");
+    
+    stampa("Risposta ricevuta!");
+    stampa("Titolo: " + post.title);
+    stampa("ID: " + post.id);
+} cattura (err) {
+    stampa("Errore chiamata: " + err);
+}
+
+stampa("\n--- Test Rete.server ---");
+// Creiamo un server che risponde con JSON
+funzione mioGestore(req) {
+    stampa("Richiesta ricevuta: " + req.metodo + " " + req.url);
+    
+    ritorna {
+        stato: 200,
+        intestazioni: { "Content-Type": "application/json" },
+        corpo: {
+            messaggio: "Ciao dal Server VladX!",
+            percorso: req.url,
+            metodo: req.metodo
+        }
+    };
+}
+
+// Avviamo il server sulla porta 8080
+// Nota: In questo ambiente il server rimarrà attivo finché non terminiamo lo script.
+// Per il test automatico, lo avviamo e poi usiamo Sistema.esegui per testarlo se possibile,
+// ma Sistema.esegui è sincrono, quindi dovremmo usare un altro approccio se volessimo testarlo automatizzato qui.
+// Per ora lo avviamo semplicemente per conferma visiva.
+
+stampa("Avvio server su porta 8080...");
+Rete.server(8080, mioGestore);
+
+// Mock test: visto che non possiamo fare chiamate asincrone facilmente nel test suite qui,
+// il test si ferma qui o continua se il server non blocca (http.listen non blocca in Node).
+stampa("Server avviato. Test completato.");
+Sistema.esci(0);

package/install.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+# VladX & VladPM Global Installer
+# 🇮🇹 Script di installazione completa per VladX
+
+set -e
+
+echo "🚀 Inizio installazione VladX..."
+
+# 1. Installazione NVM if not present
+if [ -z "$NVM_DIR" ]; then
+    echo "📦 Installazione NVM (Node Version Manager)..."
+    curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
+    
+    # Load nvm for current session
+    export NVM_DIR="$HOME/.nvm"
+    [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
+    [ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"
+else
+    echo "✅ NVM già installato."
+fi
+
+# 2. Installazione Node.js (Ultima versione)
+echo "🌐 Installazione dell'ultima versione di Node.js..."
+nvm install node
+nvm use node
+
+# 3. Installazione VladX
+echo "🛠️ Installazione globale di VladX e VladPM dal registry NPM..."
+
+npm install -g vladx
+
+echo ""
+echo "✅ Installazione completata con successo!"
+echo "Node.js: $(node -v)"
+echo "NPM: $(npm -v)"
+echo ""
+echo "Puoi ora usare i comandi:"
+echo "  vladx"
+echo "  vladpm"
+echo ""
+echo "🇮🇹 Buona programmazione con VladX!"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vladx",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "VladX - Linguaggio di programmazione con sintassi italiana",
   "main": "src/index.js",
   "type": "commonjs",

package/programs/1/index.vx

@@ -1,3 +1,4 @@
 stampa("Ciao dal programma 1!");
 costante saluti = { matteo: "Ciao!", vlad: "Ehilà!" };
 stampa("Matteo dice: " + saluti.matteo);
+stampa("Vlad dice: " + saluti.vlad);

package/src/interpreter/interpreter.js

@@ -118,6 +118,9 @@ class ArrowFunc {
 
 const fs = require('fs');
 const path = require('path');
+const http = require('http');
+const https = require('https');
+const { execSync } = require('child_process');
 const { Lexer } = require('../lexer/lexer.js');
 const { Parser } = require('../parser/parser.js');
 
@@ -155,6 +158,113 @@ class Interpreter {
         this.globals.define('array', {
             call: (_, args) => Array.isArray(args[0])
         });
+
+        this.globals.define('aspetta', {
+            call: (_, args) => {
+                const ms = args[0];
+                if (typeof ms === 'number') {
+                    const start = Date.now();
+                    while (Date.now() - start < ms);
+                }
+                return null;
+            }
+        });
+
+        this._registerStdLib();
+    }
+
+    _registerStdLib() {
+        // --- ARCHIVIO (File System) ---
+        const Archivio = {
+            leggi: {
+                call: (_, args) => fs.readFileSync(path.resolve(this.currentPath, '..', args[0]), 'utf8')
+            },
+            scrivi: {
+                call: (_, args) => {
+                    fs.writeFileSync(path.resolve(this.currentPath, '..', args[0]), args[1]);
+                    return true;
+                }
+            },
+            esiste: {
+                call: (_, args) => fs.existsSync(path.resolve(this.currentPath, '..', args[0]))
+            },
+            elimina: {
+                call: (_, args) => {
+                    fs.unlinkSync(path.resolve(this.currentPath, '..', args[0]));
+                    return true;
+                }
+            }
+        };
+        this.globals.define('Archivio', Archivio);
+
+        // --- SISTEMA (Process/OS) ---
+        const Sistema = {
+            esegui: {
+                call: (_, args) => execSync(args[0], { encoding: 'utf8' })
+            },
+            argomenti: process.argv.slice(2),
+            esci: {
+                call: (_, args) => process.exit(args[0] || 0)
+            },
+            piattaforma: process.platform,
+            cartellaCorrente: {
+                call: () => process.cwd()
+            }
+        };
+        this.globals.define('Sistema', Sistema);
+
+        // --- RETE (HTTP) ---
+        const Rete = {
+            chiama: {
+                call: (_, args) => {
+                    const url = args[0];
+                    try {
+                        const output = execSync(`curl -sL "${url}"`, { encoding: 'utf8' });
+                        try {
+                            return JSON.parse(output);
+                        } catch (e) {
+                            return output;
+                        }
+                    } catch (err) {
+                        throw new Error(`Errore chiamata HTTP: ${err.message}`);
+                    }
+                }
+            },
+            server: {
+                call: (_, args) => {
+                    const porta = args[0] || 3000;
+                    const gestore = args[1]; // Una funzione VladX
+
+                    const server = http.createServer(async (req, res) => {
+                        if (gestore && gestore.call) {
+                            // Creiamo un oggetto richiesta per VladX
+                            const richiesta = {
+                                metodo: req.method,
+                                url: req.url,
+                                intestazioni: req.headers
+                            };
+
+                            try {
+                                const risposta = await gestore.call(this, [richiesta]);
+                                res.writeHead(risposta.stato || 200, risposta.intestazioni || { 'Content-Type': 'text/plain' });
+                                res.end(typeof risposta.corpo === 'object' ? JSON.stringify(risposta.corpo) : String(risposta.corpo));
+                            } catch (e) {
+                                res.writeHead(500);
+                                res.end("Errore Server VladX: " + e.message);
+                            }
+                        } else {
+                            res.writeHead(200);
+                            res.end("Server VladX attivo sulla porta " + porta);
+                        }
+                    });
+
+                    server.listen(porta);
+                    console.log(`Server VladX in ascolto sulla porta ${porta}`);
+                    return true;
+                }
+            }
+        };
+        this.globals.define('Rete', Rete);
     }
 
     interpret(program) {
@@ -192,6 +302,10 @@ class Interpreter {
                 throw new BreakSignal();
             case 'ContinueStatement':
                 throw new ContinueSignal();
+            case 'TryStatement':
+                return this.executeTryStatement(node);
+            case 'ThrowStatement':
+                return this.executeThrowStatement(node);
             case 'ExportNamedDeclaration':
                 return this.executeExportNamedDeclaration(node);
             case 'ImportDeclaration':
@@ -273,6 +387,43 @@ class Interpreter {
         }
     }
 
+    executeTryStatement(node) {
+        try {
+            this.execute(node.block);
+        } catch (error) {
+            // Se è un ReturnValue o Break/Continue Signal, non catturarlo qui
+            if (error instanceof ReturnValue || error instanceof BreakSignal || error instanceof ContinueSignal) {
+                throw error;
+            }
+
+            if (node.handler) {
+                const catchEnv = new Environment(this.environment);
+                // Il valore errore può essere quello lanciato da LANCIA o un errore JS
+                const errorValue = error instanceof Error ? error.message : error;
+                catchEnv.define(node.handler.param, errorValue);
+
+                const previousEnv = this.environment;
+                this.environment = catchEnv;
+                try {
+                    this.execute(node.handler.body);
+                } finally {
+                    this.environment = previousEnv;
+                }
+            } else if (!node.finalizer) {
+                throw error;
+            }
+        } finally {
+            if (node.finalizer) {
+                this.execute(node.finalizer);
+            }
+        }
+    }
+
+    executeThrowStatement(node) {
+        const value = this.evaluate(node.argument);
+        throw value;
+    }
+
     executeExportNamedDeclaration(node) {
         this.execute(node.declaration);
         const name = node.declaration.name;

package/src/parser/ast.js

@@ -104,6 +104,30 @@ class PrintStatement extends ASTNode {
     }
 }
 
+class TryStatement extends ASTNode {
+    constructor(block, handler, finalizer = null) {
+        super('TryStatement');
+        this.block = block;
+        this.handler = handler;
+        this.finalizer = finalizer;
+    }
+}
+
+class CatchClause extends ASTNode {
+    constructor(param, body) {
+        super('CatchClause');
+        this.param = param;
+        this.body = body;
+    }
+}
+
+class ThrowStatement extends ASTNode {
+    constructor(argument) {
+        super('ThrowStatement');
+        this.argument = argument;
+    }
+}
+
 // === Espressioni ===
 class Identifier extends ASTNode {
     constructor(name) {
@@ -269,6 +293,9 @@ module.exports = {
     ContinueStatement,
     ExpressionStatement,
     PrintStatement,
+    TryStatement,
+    CatchClause,
+    ThrowStatement,
     ExportNamedDeclaration,
     ImportDeclaration,
     ImportSpecifier,

package/src/parser/parser.js

@@ -146,6 +146,8 @@ class Parser {
         if (this.match(TokenType.INTERROMPI)) return this.breakStatement();
         if (this.match(TokenType.CONTINUA)) return this.continueStatement();
         if (this.match(TokenType.STAMPA)) return this.printStatement();
+        if (this.match(TokenType.PROVA)) return this.tryStatement();
+        if (this.match(TokenType.LANCIA)) return this.throwStatement();
         if (this.match(TokenType.GRAFFA_APERTA)) return this.blockStatement();
         return this.expressionStatement();
     }
@@ -242,6 +244,39 @@ class Parser {
         return new AST.PrintStatement(argument);
     }
 
+    tryStatement() {
+        this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo "prova"');
+        const block = this.blockStatement();
+
+        let handler = null;
+        if (this.match(TokenType.CATTURA)) {
+            this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo "cattura"');
+            const param = this.consume(TokenType.IDENTIFICATORE, 'Nome variabile errore atteso').value;
+            this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo nome variabile');
+            this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo clausola "cattura"');
+            const body = this.blockStatement();
+            handler = new AST.CatchClause(param, body);
+        }
+
+        let finalizer = null;
+        if (this.match(TokenType.FINALMENTE)) {
+            this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo "finalmente"');
+            finalizer = this.blockStatement();
+        }
+
+        if (!handler && !finalizer) {
+            throw new ParserError('Atteso "cattura" o "finalmente" dopo blocco "prova"', this.peek());
+        }
+
+        return new AST.TryStatement(block, handler, finalizer);
+    }
+
+    throwStatement() {
+        const argument = this.expression();
+        this.match(TokenType.PUNTO_VIRGOLA);
+        return new AST.ThrowStatement(argument);
+    }
+
     expressionStatement() {
         const expr = this.expression();
         this.match(TokenType.PUNTO_VIRGOLA);
@@ -478,7 +513,12 @@ class Parser {
         const properties = [];
         if (!this.check(TokenType.GRAFFA_CHIUSA)) {
             do {
-                const key = this.consume(TokenType.IDENTIFICATORE, 'Nome proprietà atteso').value;
+                let key;
+                if (this.match(TokenType.IDENTIFICATORE, TokenType.STRINGA)) {
+                    key = this.previous().value;
+                } else {
+                    throw new ParserError('Nome proprietà o stringa atteso', this.peek());
+                }
                 this.consume(TokenType.DUE_PUNTI, 'Atteso ":" dopo nome proprietà');
                 const value = this.expression();
                 properties.push(new AST.Property(key, value));