vladx 1.2.1 → 1.2.4

package/DOCUMENTAZIONE.md

@@ -0,0 +1,375 @@
+# 🇮🇹 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
+```
+
+## 🏛️ Classi
+
+VladX supporta la programmazione orientata agli oggetti con classi.
+
+### Dichiarazione Classe
+```javascript
+classe Persona {
+    funzione costruttore(nome, eta) {
+        questo.nome = nome;
+        questo.eta = eta;
+    }
+
+    funzione saluta() {
+        stampa("Ciao, sono " + questo.nome);
+    }
+}
+```
+
+### Creazione Istanze
+Usa la parola chiave `nuovo` per creare un'istanza di una classe:
+```javascript
+variabile p = nuovo Persona("Mario", 25);
+p.saluta(); // "Ciao, sono Mario"
+```
+
+### Ereditarietà
+Le classi possono estendere altre classi usando `da`:
+```javascript
+classe Studente da Persona {
+    funzione costruttore(nome, eta, scuola) {
+        questo.nome = nome;
+        questo.eta = eta;
+        questo.scuola = scuola;
+    }
+
+    funzione studia() {
+        stampa(questo.nome + " studia alla " + questo.scuola);
+    }
+}
+```
+
+### Parola Chiave `questo`
+Usa `questo` per riferirti all'istanza corrente della classe:
+```javascript
+classe Contatore {
+    funzione costruttore() {
+        questo.valore = 0;
+    }
+
+    funzione incrementa() {
+        questo.valore++;
+    }
+}
+```
+
+---
+
+## 🧩 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,143 @@
+# 🇮🇹 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;
+```
+
+### Classi
+```javascript
+classe Persona {
+    funzione costruttore(nome, eta) {
+        questo.nome = nome;
+        questo.eta = eta;
+    }
+
+    funzione saluta() {
+        stampa("Ciao, sono " + questo.nome);
+    }
+}
+
+variabile p = nuovo Persona("Mario", 25);
+p.saluta();
+```
+
+### 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_classi.vx

@@ -0,0 +1,42 @@
+// Test delle classi in VladX
+
+classe Persona {
+    funzione costruttore(nome, eta) {
+        questo.nome = nome;
+        questo.eta = eta;
+    }
+
+    funzione saluta() {
+        stampa("Ciao, sono " + questo.nome + " e ho " + questo.eta + " anni");
+    }
+
+    funzione compieAnni() {
+        questo.eta++;
+        stampa(questo.nome + " ora ha " + questo.eta + " anni");
+    }
+}
+
+variabile p1 = nuovo Persona("Mario", 25);
+p1.saluta();
+p1.compieAnni();
+
+variabile p2 = nuovo Persona("Luigi", 30);
+p2.saluta();
+
+// Test con classe derivata (ereditarietà)
+classe Studente da Persona {
+    funzione costruttore(nome, eta, scuola) {
+        // Chiamata al costruttore padre (se supportato)
+        questo.nome = nome;
+        questo.eta = eta;
+        questo.scuola = scuola;
+    }
+
+    funzione studia() {
+        stampa(questo.nome + " studia alla " + questo.scuola);
+    }
+}
+
+variabile s1 = nuovo Studente("Anna", 20, "Università");
+s1.saluta();
+s1.studia();

package/examples/test_classi_semplice.vx

@@ -0,0 +1,15 @@
+// Test semplice delle classi
+
+classe Test {
+    funzione costruttore(nome) {
+        questo.nome = nome;
+    }
+
+    funzione saluta() {
+        stampa("Ciao " + questo.nome);
+    }
+}
+
+variabile t = nuovo Test("Mario");
+stampa("Istanza creata");
+t.saluta();

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.4",
   "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

@@ -116,8 +116,77 @@ class ArrowFunc {
     }
 }
 
+class VladXClass {
+    constructor(name, superclass, constructor, methods) {
+        this.name = name;
+        this.superclass = superclass;
+        this.constructor = constructor;
+        this.methods = methods;
+    }
+
+    findMethod(name) {
+        if (this.methods.has(name)) {
+            return this.methods.get(name);
+        }
+        if (this.superclass) {
+            return this.superclass.findMethod(name);
+        }
+        return null;
+    }
+}
+
+class VladXInstance {
+    constructor(klass) {
+        this.klass = klass;
+        this.fields = new Map();
+    }
+
+    get(name) {
+        if (this.fields.has(name)) {
+            return this.fields.get(name);
+        }
+        const method = this.klass.findMethod(name);
+        if (method) {
+            return new BoundMethod(method, this);
+        }
+        throw new Error(`Proprietà "${name}" non definita nella classe "${this.klass.name}"`);
+    }
+
+    set(name, value) {
+        this.fields.set(name, value);
+    }
+}
+
+class BoundMethod {
+    constructor(method, instance) {
+        this.method = method;
+        this.instance = instance;
+    }
+
+    call(interpreter, args) {
+        const env = new Environment(this.method.closure);
+        env.define('questo', this.instance);
+        for (let i = 0; i < this.method.declaration.params.length; i++) {
+            env.define(this.method.declaration.params[i], args[i] !== undefined ? args[i] : null);
+        }
+
+        try {
+            interpreter.executeBlock(this.method.declaration.body.body, env);
+        } catch (e) {
+            if (e instanceof ReturnValue) {
+                return e.value;
+            }
+            throw e;
+        }
+        return null;
+    }
+}
+
 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 +224,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) {
@@ -178,6 +354,8 @@ class Interpreter {
                 return this.executeVariableDeclaration(node);
             case 'FunctionDeclaration':
                 return this.executeFunctionDeclaration(node);
+            case 'ClassDeclaration':
+                return this.executeClassDeclaration(node);
             case 'BlockStatement':
                 return this.executeBlock(node.body, new Environment(this.environment));
             case 'IfStatement':
@@ -192,6 +370,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':
@@ -215,6 +397,28 @@ class Interpreter {
         this.environment.define(node.name, func);
     }
 
+    executeClassDeclaration(node) {
+        let superclass = null;
+        if (node.superclass) {
+            const superclassValue = this.environment.get(node.superclass);
+            if (!(superclassValue instanceof VladXClass)) {
+                throw new Error(`"${node.superclass}" non è una classe`);
+            }
+            superclass = superclassValue;
+        }
+
+        const methods = new Map();
+        if (node.constructor) {
+            methods.set('costruttore', new VladXFunction(node.constructor, this.environment));
+        }
+        for (const method of node.methods) {
+            methods.set(method.name, new VladXFunction(method, this.environment));
+        }
+
+        const klass = new VladXClass(node.name, superclass, node.constructor, methods);
+        this.environment.define(node.name, klass);
+    }
+
     executeBlock(statements, env) {
         const previousEnv = this.environment;
         this.environment = env;
@@ -273,6 +477,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;
@@ -351,6 +592,8 @@ class Interpreter {
                 return null;
             case 'Identifier':
                 return this.environment.get(node.name);
+            case 'ThisExpression':
+                return this.environment.get('questo');
             case 'ArrayLiteral':
                 return node.elements.map(el => this.evaluate(el));
             case 'ObjectLiteral':
@@ -371,6 +614,8 @@ class Interpreter {
                 return this.evaluateUpdateExpression(node);
             case 'CallExpression':
                 return this.evaluateCallExpression(node);
+            case 'NewExpression':
+                return this.evaluateNewExpression(node);
             case 'MemberExpression':
                 return this.evaluateMemberExpression(node);
             case 'ArrowFunction':
@@ -441,7 +686,13 @@ class Interpreter {
             const prop = node.left.computed
                 ? this.evaluate(node.left.property)
                 : node.left.property.name;
-            obj[prop] = value;
+            
+            // Handle class instances
+            if (obj instanceof VladXInstance) {
+                obj.set(prop, value);
+            } else {
+                obj[prop] = value;
+            }
         }
 
         return value;
@@ -469,6 +720,25 @@ class Interpreter {
         throw new Error(`"${node.callee.name || 'valore'}" non è una funzione`);
     }
 
+    evaluateNewExpression(node) {
+        const klass = this.evaluate(node.callee);
+        
+        if (!(klass instanceof VladXClass)) {
+            throw new Error(`"${node.callee.name || 'valore'}" non è una classe`);
+        }
+
+        const instance = new VladXInstance(klass);
+        const constructor = klass.findMethod('costruttore');
+        
+        if (constructor) {
+            const boundConstructor = new BoundMethod(constructor, instance);
+            const args = node.arguments.map(arg => this.evaluate(arg));
+            boundConstructor.call(this, args);
+        }
+
+        return instance;
+    }
+
     evaluateMemberExpression(node) {
         const obj = this.evaluate(node.object);
         if (obj === null || obj === undefined) {
@@ -492,6 +762,11 @@ class Interpreter {
             }
         }
 
+        // Handle class instances
+        if (obj instanceof VladXInstance) {
+            return obj.get(prop);
+        }
+
         return obj[prop];
     }
 
@@ -523,4 +798,4 @@ class Interpreter {
     }
 }
 
-module.exports = { Interpreter, Environment };
+module.exports = { Interpreter, Environment, VladXClass, VladXInstance };

package/src/parser/ast.js

@@ -36,6 +36,30 @@ class FunctionDeclaration extends ASTNode {
     }
 }
 
+class ClassDeclaration extends ASTNode {
+    constructor(name, superclass, constructor, methods) {
+        super('ClassDeclaration');
+        this.name = name;
+        this.superclass = superclass;
+        this.constructor = constructor;
+        this.methods = methods;
+    }
+}
+
+class ThisExpression extends ASTNode {
+    constructor() {
+        super('ThisExpression');
+    }
+}
+
+class NewExpression extends ASTNode {
+    constructor(callee, args) {
+        super('NewExpression');
+        this.callee = callee;
+        this.arguments = args;
+    }
+}
+
 // === Statements ===
 class BlockStatement extends ASTNode {
     constructor(body) {
@@ -104,6 +128,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) {
@@ -260,6 +308,7 @@ module.exports = {
     Program,
     VariableDeclaration,
     FunctionDeclaration,
+    ClassDeclaration,
     BlockStatement,
     IfStatement,
     WhileStatement,
@@ -269,6 +318,9 @@ module.exports = {
     ContinueStatement,
     ExpressionStatement,
     PrintStatement,
+    TryStatement,
+    CatchClause,
+    ThrowStatement,
     ExportNamedDeclaration,
     ImportDeclaration,
     ImportSpecifier,
@@ -287,5 +339,7 @@ module.exports = {
     MemberExpression,
     ArrowFunction,
     UpdateExpression,
-    LogicalExpression
+    LogicalExpression,
+    ThisExpression,
+    NewExpression
 };

package/src/parser/parser.js

@@ -74,6 +74,7 @@ class Parser {
             if (this.match(TokenType.VARIABILE)) return this.variableDeclaration(false);
             if (this.match(TokenType.COSTANTE)) return this.variableDeclaration(true);
             if (this.match(TokenType.FUNZIONE)) return this.functionDeclaration();
+            if (this.match(TokenType.CLASSE)) return this.classDeclaration();
             return this.statement();
         } catch (error) {
             this.synchronize();
@@ -112,6 +113,10 @@ class Parser {
             const decl = this.functionDeclaration();
             return new AST.ExportNamedDeclaration(decl);
         }
+        if (this.match(TokenType.CLASSE)) {
+            const decl = this.classDeclaration();
+            return new AST.ExportNamedDeclaration(decl);
+        }
         if (this.match(TokenType.VARIABILE)) {
             const decl = this.variableDeclaration(false);
             return new AST.ExportNamedDeclaration(decl);
@@ -120,7 +125,7 @@ class Parser {
             const decl = this.variableDeclaration(true);
             return new AST.ExportNamedDeclaration(decl);
         }
-        throw new ParserError('Atteso funzione o variabile dopo "esporta"', this.peek());
+        throw new ParserError('Atteso funzione, classe o variabile dopo "esporta"', this.peek());
     }
 
     functionDeclaration() {
@@ -138,6 +143,54 @@ class Parser {
         return new AST.FunctionDeclaration(name, params, body);
     }
 
+    classDeclaration() {
+        // Il token CLASSE è già stato consumato se chiamato da exportDeclaration
+        // Ma se chiamato direttamente, dobbiamo consumarlo
+        if (!this.previous() || this.previous().type !== TokenType.CLASSE) {
+            if (this.check(TokenType.CLASSE)) {
+                this.advance();
+            }
+        }
+        const name = this.consume(TokenType.IDENTIFICATORE, 'Nome classe atteso').value;
+        
+        let superclass = null;
+        if (this.match(TokenType.DA)) {
+            superclass = this.consume(TokenType.IDENTIFICATORE, 'Nome classe padre atteso').value;
+        }
+
+        this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo nome classe');
+
+        let constructor = null;
+        const methods = [];
+
+        while (!this.check(TokenType.GRAFFA_CHIUSA) && !this.isAtEnd()) {
+            if (this.match(TokenType.FUNZIONE)) {
+                const funcName = this.consume(TokenType.IDENTIFICATORE, 'Nome metodo atteso').value;
+                this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo nome metodo');
+                const params = [];
+                if (!this.check(TokenType.PARENTESI_CHIUSA)) {
+                    do {
+                        params.push(this.consume(TokenType.IDENTIFICATORE, 'Nome parametro atteso').value);
+                    } while (this.match(TokenType.VIRGOLA));
+                }
+                this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo parametri');
+                this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" prima del corpo metodo');
+                const body = this.blockStatement();
+
+                if (funcName === 'costruttore') {
+                    constructor = new AST.FunctionDeclaration('costruttore', params, body);
+                } else {
+                    methods.push(new AST.FunctionDeclaration(funcName, params, body));
+                }
+            } else {
+                throw new ParserError('Atteso metodo nella classe', this.peek());
+            }
+        }
+
+        this.consume(TokenType.GRAFFA_CHIUSA, 'Atteso "}" alla fine della classe');
+        return new AST.ClassDeclaration(name, superclass, constructor, methods);
+    }
+
     statement() {
         if (this.match(TokenType.SE)) return this.ifStatement();
         if (this.match(TokenType.MENTRE)) return this.whileStatement();
@@ -146,6 +199,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 +297,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);
@@ -379,6 +467,19 @@ class Parser {
         return expr;
     }
 
+    newExpression() {
+        const callee = this.consume(TokenType.IDENTIFICATORE, 'Nome classe atteso dopo "nuovo"').value;
+        this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo nome classe');
+        const args = [];
+        if (!this.check(TokenType.PARENTESI_CHIUSA)) {
+            do {
+                args.push(this.expression());
+            } while (this.match(TokenType.VIRGOLA));
+        }
+        this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo argomenti');
+        return new AST.NewExpression(new AST.Identifier(callee), args);
+    }
+
     finishCall(callee) {
         const args = [];
         if (!this.check(TokenType.PARENTESI_CHIUSA)) {
@@ -403,12 +504,16 @@ class Parser {
             return new AST.StringLiteral(this.previous().value);
         }
 
+        if (this.match(TokenType.NUOVO)) {
+            return this.newExpression();
+        }
+
         if (this.match(TokenType.IDENTIFICATORE)) {
             return new AST.Identifier(this.previous().value);
         }
 
         if (this.match(TokenType.QUESTO)) {
-            return new AST.Identifier('questo');
+            return new AST.ThisExpression();
         }
 
         if (this.match(TokenType.QUADRA_APERTA)) {
@@ -478,7 +583,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));