vladx 1.0.1 → 1.1.1

package/examples/moduli/main.vx

@@ -0,0 +1,19 @@
+/**
+ * main.vx - Applicazione che usa i moduli
+ */
+
+importa { somma, sottrai, PI } da "./math.vx";
+
+stampa("Test Moduli VladX");
+stampa("-----------------");
+
+variabile r1 = somma(10, 5);
+stampa("10 + 5 = " + r1);
+
+variabile r2 = sottrai(20, 8);
+stampa("20 - 8 = " + r2);
+
+stampa("Valore di PI: " + PI);
+
+
+stampa("Fine del test.");

package/examples/moduli/math.vx

@@ -0,0 +1,13 @@
+/**
+ * math.vx - Modulo di esempio
+ */
+
+esporta funzione somma(a, b) {
+    ritorna a + b;
+}
+
+esporta funzione sottrai(a, b) {
+    ritorna a - b;
+}
+
+esporta costante PI = 3.14159;

package/package.json

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

package/src/cli/cli.js

@@ -69,6 +69,7 @@ function runFile(filePath) {
         const ast = parser.parse();
 
         const interpreter = new Interpreter();
+        interpreter.currentPath = absolutePath;
         interpreter.interpret(ast);
     } catch (error) {
         console.error(colorize(`✗ Errore: ${error.message}`, 'red'));

package/src/interpreter/interpreter.js

@@ -116,11 +116,19 @@ class ArrowFunc {
     }
 }
 
+const fs = require('fs');
+const path = require('path');
+const { Lexer } = require('../lexer/lexer.js');
+const { Parser } = require('../parser/parser.js');
+
 class Interpreter {
     constructor() {
         this.globals = new Environment();
         this.environment = this.globals;
         this.output = [];
+        this.modules = new Map(); // path -> exports
+        this.currentPath = process.cwd();
+        this.exportedSymbols = new Map(); // symbols exported by the current module
 
         // Built-in functions
         this.globals.define('lunghezza', {
@@ -184,6 +192,10 @@ class Interpreter {
                 throw new BreakSignal();
             case 'ContinueStatement':
                 throw new ContinueSignal();
+            case 'ExportNamedDeclaration':
+                return this.executeExportNamedDeclaration(node);
+            case 'ImportDeclaration':
+                return this.executeImportDeclaration(node);
             case 'PrintStatement':
                 return this.executePrintStatement(node);
             case 'ExpressionStatement':
@@ -261,6 +273,65 @@ class Interpreter {
         }
     }
 
+    executeExportNamedDeclaration(node) {
+        this.execute(node.declaration);
+        const name = node.declaration.name;
+        const value = this.environment.get(name);
+        this.exportedSymbols.set(name, value);
+    }
+
+    executeImportDeclaration(node) {
+        const sourcePath = node.source;
+        let fullPath;
+
+        if (sourcePath.startsWith('./') || sourcePath.startsWith('../')) {
+            fullPath = path.resolve(path.dirname(this.currentPath), sourcePath);
+        } else {
+            // Check vladx_modules
+            fullPath = path.resolve(process.cwd(), 'vladx_modules', sourcePath);
+            if (!fullPath.endsWith('.vx')) fullPath += '.vx';
+            if (!fs.existsSync(fullPath)) {
+                // Try index.vx inside the module folder
+                const folderPath = path.resolve(process.cwd(), 'vladx_modules', sourcePath);
+                fullPath = path.join(folderPath, 'index.vx');
+            }
+        }
+
+        if (!fs.existsSync(fullPath)) {
+            throw new Error(`Modulo non trovato: ${sourcePath}`);
+        }
+
+        let moduleExports;
+        if (this.modules.has(fullPath)) {
+            moduleExports = this.modules.get(fullPath);
+        } else {
+            // Load and execute module
+            const content = fs.readFileSync(fullPath, 'utf8');
+            const lexer = new Lexer(content);
+            const tokens = lexer.tokenize();
+            const parser = new Parser(tokens);
+            const program = parser.parse();
+
+            const subInterpreter = new Interpreter();
+            // Sharing the same modules cache
+            subInterpreter.modules = this.modules;
+            subInterpreter.currentPath = fullPath;
+
+            subInterpreter.interpret(program);
+            moduleExports = subInterpreter.exportedSymbols;
+            this.modules.set(fullPath, moduleExports);
+        }
+
+        // Import specified symbols
+        for (const specifier of node.specifiers) {
+            if (moduleExports.has(specifier)) {
+                this.environment.define(specifier, moduleExports.get(specifier));
+            } else {
+                throw new Error(`Il modulo "${sourcePath}" non esporta "${specifier}"`);
+            }
+        }
+    }
+
     executePrintStatement(node) {
         const value = this.evaluate(node.argument);
         const output = this.stringify(value);

package/src/parser/ast.js

@@ -232,6 +232,29 @@ class LogicalExpression extends ASTNode {
     }
 }
 
+class ExportNamedDeclaration {
+    constructor(declaration) {
+        this.type = 'ExportNamedDeclaration';
+        this.declaration = declaration;
+    }
+}
+
+class ImportDeclaration {
+    constructor(specifiers, source) {
+        this.type = 'ImportDeclaration';
+        this.specifiers = specifiers; // Array di nomi
+        this.source = source; // StringLiteral path
+    }
+}
+
+class ImportSpecifier {
+    constructor(imported, local) {
+        this.type = 'ImportSpecifier';
+        this.imported = imported;
+        this.local = local;
+    }
+}
+
 module.exports = {
     ASTNode,
     Program,
@@ -246,6 +269,9 @@ module.exports = {
     ContinueStatement,
     ExpressionStatement,
     PrintStatement,
+    ExportNamedDeclaration,
+    ImportDeclaration,
+    ImportSpecifier,
     Identifier,
     NumericLiteral,
     StringLiteral,

package/src/parser/parser.js

@@ -69,6 +69,8 @@ class Parser {
 
     declaration() {
         try {
+            if (this.match(TokenType.IMPORTA)) return this.importDeclaration();
+            if (this.match(TokenType.ESPORTA)) return this.exportDeclaration();
             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();
@@ -89,6 +91,38 @@ class Parser {
         return new AST.VariableDeclaration(name, value, isConstant);
     }
 
+    importDeclaration() {
+        this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo "importa"');
+        const specifiers = [];
+        if (!this.check(TokenType.GRAFFA_CHIUSA)) {
+            do {
+                const name = this.consume(TokenType.IDENTIFICATORE, 'Nome import atteso').value;
+                specifiers.push(name);
+            } while (this.match(TokenType.VIRGOLA));
+        }
+        this.consume(TokenType.GRAFFA_CHIUSA, 'Atteso "}" dopo i nomi importati');
+        this.consume(TokenType.DA, 'Attesa parola chiave "da" dopo gli import');
+        const source = this.consume(TokenType.STRINGA, 'Percorso modulo atteso come stringa').value;
+        this.match(TokenType.PUNTO_VIRGOLA);
+        return new AST.ImportDeclaration(specifiers, source);
+    }
+
+    exportDeclaration() {
+        if (this.match(TokenType.FUNZIONE)) {
+            const decl = this.functionDeclaration();
+            return new AST.ExportNamedDeclaration(decl);
+        }
+        if (this.match(TokenType.VARIABILE)) {
+            const decl = this.variableDeclaration(false);
+            return new AST.ExportNamedDeclaration(decl);
+        }
+        if (this.match(TokenType.COSTANTE)) {
+            const decl = this.variableDeclaration(true);
+            return new AST.ExportNamedDeclaration(decl);
+        }
+        throw new ParserError('Atteso funzione o variabile dopo "esporta"', this.peek());
+    }
+
     functionDeclaration() {
         const name = this.consume(TokenType.IDENTIFICATORE, 'Nome funzione atteso').value;
         this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo nome funzione');