vladx 1.0.1 → 1.2.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.2.1",
   "description": "VladX - Linguaggio di programmazione con sintassi italiana",
   "main": "src/index.js",
   "type": "commonjs",

package/programs/1/index.vx

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

package/programs/1/vladx-lock.json

@@ -0,0 +1,5 @@
+{
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {}
+}

package/programs/1/vladx.json

@@ -0,0 +1,14 @@
+{
+  "name": "1",
+  "version": "1.2.0",
+  "description": "",
+  "main": "index.vx",
+  "scripts": {
+    "start": "vladx index.vx",
+    "test": "vladx test.vx"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {}
+}

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');

package/src/pm/cli.js

@@ -11,6 +11,7 @@ const uninstall = require('./commands/uninstall.js');
 const search = require('./commands/search.js');
 const list = require('./commands/list.js');
 const config = require('./commands/config.js');
+const runCmd = require('./commands/run.js');
 
 const VERSION = '1.0.0';
 
@@ -40,6 +41,10 @@ ${colorize('Uso:', 'cyan')}
   vladpm uninstall <pkg>     Rimuove un pacchetto
   vladpm search <query>      Cerca pacchetti
   vladpm list                Lista pacchetti installati
+  vladpm run <script>        Esegue uno script definito in vladx.json
+  vladpm start               Scorciatoia per "vladpm run start"
+  vladpm test                Scorciatoia per "vladpm run test"
+  vladpm dev                 Scorciatoia per "vladpm run dev"
   vladpm --help, -h          Mostra questo aiuto
   vladpm --version, -v       Mostra la versione
 
@@ -116,6 +121,22 @@ async function run(args) {
                 await config.execute(args.slice(1));
                 break;
 
+            case 'run':
+                await runCmd.execute(args.slice(1));
+                break;
+
+            case 'start':
+                await runCmd.execute(['start', ...args.slice(1)]);
+                break;
+
+            case 'test':
+                await runCmd.execute(['test', ...args.slice(1)]);
+                break;
+
+            case 'dev':
+                await runCmd.execute(['dev', ...args.slice(1)]);
+                break;
+
             default:
                 console.error(colorize(`✗ Comando sconosciuto: ${command}`, 'red'));
                 console.log('Usa "vladpm --help" per vedere i comandi disponibili.');

package/src/pm/commands/run.js

@@ -0,0 +1,77 @@
+/**
+ * VladPM - run command
+ * Esegue script definiti in vladx.json
+ */
+
+const { execSync } = require('child_process');
+const { getVladxJson } = require('../utils/config.js');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m'
+};
+
+function colorize(text, color) {
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+
+async function execute(args) {
+    if (args.length === 0) {
+        console.error(colorize('✗ Errore: Specificare il nome dello script da eseguire.', 'red'));
+        console.log('Uso: vladpm run <script>');
+        showScripts();
+        process.exit(1);
+    }
+
+    const scriptName = args[0];
+    const vladxJson = getVladxJson();
+
+    if (!vladxJson) {
+        console.error(colorize('✗ Errore: vladx.json non trovato.', 'red'));
+        process.exit(1);
+    }
+
+    const scripts = vladxJson.scripts || {};
+    const command = scripts[scriptName];
+
+    if (!command) {
+        console.error(colorize(`✗ Errore: Script "${scriptName}" non trovato in vladx.json.`, 'red'));
+        showScripts(scripts);
+        process.exit(1);
+    }
+
+    console.log(`\n> ${vladxJson.name}@${vladxJson.version} ${scriptName}`);
+    console.log(`> ${command}\n`);
+
+    try {
+        // Aggiungiamo il path della bin di vladx locale all'ambiente se necessario
+        // Ma per ora assumiamo che vladx sia nel path o eseguito tramite node
+
+        execSync(command, {
+            stdio: 'inherit',
+            env: { ...process.env, PATH: `${process.env.PATH}:${process.cwd()}/node_modules/.bin` }
+        });
+    } catch (error) {
+        process.exit(error.status || 1);
+    }
+}
+
+function showScripts(scripts) {
+    if (!scripts) {
+        const vladxJson = getVladxJson();
+        scripts = vladxJson ? vladxJson.scripts : null;
+    }
+
+    if (scripts && Object.keys(scripts).length > 0) {
+        console.log('\nScript disponibili:');
+        for (const name of Object.keys(scripts)) {
+            console.log(`  - ${colorize(name, 'cyan')}: ${scripts[name]}`);
+        }
+    }
+}
+
+module.exports = { execute };