vladx 1.2.4 → 1.2.5

package/modules/logger/index.vx

@@ -0,0 +1,68 @@
+// vladx-logger - Logger per VladX
+//
+// API:
+//   - esporta funzione info(messaggio)
+//   - esporta funzione avviso(messaggio)
+//   - esporta funzione errore(messaggio)
+//   - esporta funzione debug(messaggio)
+//   - esporta funzione creaLogger(nome) -> oggetto con i 4 metodi sopra
+//
+// Ogni messaggio viene stampato con timestamp e livello.
+
+funzione _oraIso() {
+    variabile ms = Sistema.esegui("date -u +\"%Y-%m-%dT%H:%M:%SZ\"");
+    ritorna ms;
+}
+
+funzione _formattaMessaggio(livello, nome, messaggio) {
+    variabile prefissoNome = "";
+
+    se (nome && tipo(nome) === "string" && nome !== "") {
+        prefissoNome = "[" + nome + "] ";
+    }
+
+    ritorna "[" + _oraIso().trim() + "]" + "[" + livello + "] " + prefissoNome + messaggio;
+}
+
+funzione _logGenerico(livello, nome, messaggio) {
+    // Se il messaggio non è stringa, proviamo a convertirlo
+    se (tipo(messaggio) !== "string") {
+        messaggio = stringa(messaggio);
+    }
+    stampa(_formattaMessaggio(livello, nome, messaggio));
+}
+
+esporta funzione info(messaggio) {
+    _logGenerico("INFO", "", messaggio);
+}
+
+esporta funzione avviso(messaggio) {
+    _logGenerico("AVVISO", "", messaggio);
+}
+
+esporta funzione errore(messaggio) {
+    _logGenerico("ERRORE", "", messaggio);
+}
+
+esporta funzione debug(messaggio) {
+    _logGenerico("DEBUG", "", messaggio);
+}
+
+// Logger con nome (es. modulo, servizio, contesto)
+esporta funzione creaLogger(nome) {
+    ritorna {
+        info: (messaggio) => _logGenerico("INFO", nome, messaggio),
+        avviso: (messaggio) => _logGenerico("AVVISO", nome, messaggio),
+        errore: (messaggio) => _logGenerico("ERRORE", nome, messaggio),
+        debug: (messaggio) => _logGenerico("DEBUG", nome, messaggio)
+    };
+}
+
+// Esempio rapido se eseguito direttamente
+se (Sistema.argomenti && Sistema.argomenti.length > 0) {
+    variabile log = creaLogger("esempio-logger");
+    info("Logger globale attivo");
+    log.debug("Messaggio di debug");
+    log.info("Informazione di esempio");
+    log.errore("Errore di esempio");
+}

package/modules/logger/vladx-lock.json

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

package/modules/logger/vladx.json

@@ -0,0 +1,18 @@
+{
+  "name": "vladx-logger",
+  "version": "1.0.0",
+  "description": "Logger semplice per VladX con livelli e prefissi",
+  "main": "index.vx",
+  "scripts": {
+    "start": "vladx index.vx",
+    "test": "vladx test.vx"
+  },
+  "keywords": [
+    "logger",
+    "logging",
+    "vladx"
+  ],
+  "author": "VladX Team",
+  "license": "MIT",
+  "dependencies": {}
+}

package/modules/stringhe/index.vx

@@ -0,0 +1,248 @@
+// vladx-stringhe - Utility per stringhe in VladX
+//
+// API principale (tutte esportate):
+//   - trim(testo)
+//   - minuscolo(testo)
+//   - maiuscolo(testo)
+//   - iniziaCon(testo, prefisso)
+//   - finisceCon(testo, suffisso)
+//   - contiene(testo, parte)
+//   - sostituisciTutto(testo, cerca, sostituisci)
+//   - slug(testo)
+//   - ripeti(testo, volte)
+//   - unisci(separatore, elementiArray)
+
+funzione _assicuratiStringa(valore) {
+    se (tipo(valore) === "string") {
+        ritorna valore;
+    }
+    ritorna stringa(valore);
+}
+
+esporta funzione trim(testo) {
+    testo = _assicuratiStringa(testo);
+
+    // rimuove spazi iniziali
+    mentre (lunghezza(testo) > 0 && (
+        testo[0] === " " ||
+        testo[0] === "\n" ||
+        testo[0] === "\t" ||
+        testo[0] === "\r"
+    )) {
+        testo = testo.substring(1);
+    }
+
+    // rimuove spazi finali
+    mentre (lunghezza(testo) > 0) {
+        variabile ultimo = testo[lunghezza(testo) - 1];
+        se (ultimo === " " || ultimo === "\n" || ultimo === "\t" || ultimo === "\r") {
+            testo = testo.substring(0, lunghezza(testo) - 1);
+        } altrimenti {
+            interrompi;
+        }
+    }
+
+    ritorna testo;
+}
+
+esporta funzione minuscolo(testo) {
+    testo = _assicuratiStringa(testo);
+    ritorna testo.toLowerCase();
+}
+
+esporta funzione maiuscolo(testo) {
+    testo = _assicuratiStringa(testo);
+    ritorna testo.toUpperCase();
+}
+
+esporta funzione iniziaCon(testo, prefisso) {
+    testo = _assicuratiStringa(testo);
+    prefisso = _assicuratiStringa(prefisso);
+
+    se (lunghezza(prefisso) > lunghezza(testo)) {
+        ritorna falso;
+    }
+
+    variabile i = 0;
+    mentre (i < lunghezza(prefisso)) {
+        se (testo[i] !== prefisso[i]) {
+            ritorna falso;
+        }
+        i++;
+    }
+
+    ritorna vero;
+}
+
+esporta funzione finisceCon(testo, suffisso) {
+    testo = _assicuratiStringa(testo);
+    suffisso = _assicuratiStringa(suffisso);
+
+    se (lunghezza(suffisso) > lunghezza(testo)) {
+        ritorna falso;
+    }
+
+    variabile offset = lunghezza(testo) - lunghezza(suffisso);
+    variabile i = 0;
+    mentre (i < lunghezza(suffisso)) {
+        se (testo[offset + i] !== suffisso[i]) {
+            ritorna falso;
+        }
+        i++;
+    }
+
+    ritorna vero;
+}
+
+esporta funzione contiene(testo, parte) {
+    testo = _assicuratiStringa(testo);
+    parte = _assicuratiStringa(parte);
+
+    se (lunghezza(parte) === 0) {
+        ritorna vero;
+    }
+
+    variabile i = 0;
+    mentre (i <= lunghezza(testo) - lunghezza(parte)) {
+        variabile j = 0;
+        variabile match = vero;
+
+        mentre (j < lunghezza(parte)) {
+            se (testo[i + j] !== parte[j]) {
+                match = falso;
+                interrompi;
+            }
+            j++;
+        }
+
+        se (match) {
+            ritorna vero;
+        }
+
+        i++;
+    }
+
+    ritorna falso;
+}
+
+esporta funzione sostituisciTutto(testo, cerca, sostituisci) {
+    testo = _assicuratiStringa(testo);
+    cerca = _assicuratiStringa(cerca);
+    sostituisci = _assicuratiStringa(sostituisci);
+
+    se (lunghezza(cerca) === 0) {
+        ritorna testo;
+    }
+
+    variabile risultato = "";
+    variabile i = 0;
+
+    mentre (i < lunghezza(testo)) {
+        variabile j = 0;
+        variabile match = vero;
+
+        mentre (j < lunghezza(cerca) && i + j < lunghezza(testo)) {
+            se (testo[i + j] !== cerca[j]) {
+                match = falso;
+                interrompi;
+            }
+            j++;
+        }
+
+        se (match && j === lunghezza(cerca)) {
+            risultato = risultato + sostituisci;
+            i = i + lunghezza(cerca);
+        } altrimenti {
+            risultato = risultato + testo[i];
+            i = i + 1;
+        }
+    }
+
+    ritorna risultato;
+}
+
+esporta funzione slug(testo) {
+    testo = _assicuratiStringa(testo);
+
+    // minuscolo
+    testo = testo.toLowerCase();
+
+    // sostituisci spazi con -
+    testo = sostituisciTutto(testo, " ", "-");
+
+    // rimuovi caratteri non alfanumerici (mantieni -)
+    variabile risultato = "";
+    variabile i = 0;
+    mentre (i < lunghezza(testo)) {
+        variabile c = testo[i];
+
+        se (
+            (c >= "a" && c <= "z") ||
+            (c >= "0" && c <= "9") ||
+            c === "-"
+        ) {
+            risultato = risultato + c;
+        }
+
+        i++;
+    }
+
+    // rimuovi eventuali -- doppi
+    mentre (contiene(risultato, "--")) {
+        risultato = sostituisciTutto(risultato, "--", "-");
+    }
+
+    // togli - iniziali e finali
+    risultato = trim(risultato);
+    mentre (lunghezza(risultato) > 0 && risultato[0] === "-") {
+        risultato = risultato.substring(1);
+    }
+    mentre (lunghezza(risultato) > 0 && risultato[lunghezza(risultato) - 1] === "-") {
+        risultato = risultato.substring(0, lunghezza(risultato) - 1);
+    }
+
+    ritorna risultato;
+}
+
+esporta funzione ripeti(testo, volte) {
+    testo = _assicuratiStringa(testo);
+    se (tipo(volte) !== "number" || volte <= 0) {
+        ritorna "";
+    }
+
+    variabile risultato = "";
+    variabile i = 0;
+    mentre (i < volte) {
+        risultato = risultato + testo;
+        i++;
+    }
+
+    ritorna risultato;
+}
+
+esporta funzione unisci(separatore, elementi) {
+    separatore = _assicuratiStringa(separatore);
+
+    se (!array(elementi)) {
+        ritorna "";
+    }
+
+    se (lunghezza(elementi) === 0) {
+        ritorna "";
+    }
+
+    variabile risultato = _assicuratiStringa(elementi[0]);
+    variabile i = 1;
+
+    mentre (i < lunghezza(elementi)) {
+        risultato = risultato + separatore + _assicuratiStringa(elementi[i]);
+        i++;
+    }
+
+    ritorna risultato;
+}
+
+// Esempio rapido se eseguito direttamente
+se (Sistema.argomenti && Sistema.argomenti.length > 0) {
+    stampa(slug("Ciao Mondo da VladX Stringhe!"));
+}

package/modules/stringhe/vladx-lock.json

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

package/modules/stringhe/vladx.json

@@ -0,0 +1,19 @@
+{
+  "name": "vladx-stringhe",
+  "version": "1.0.0",
+  "description": "Utility per la manipolazione di stringhe in VladX",
+  "main": "index.vx",
+  "scripts": {
+    "start": "vladx index.vx",
+    "test": "vladx test.vx"
+  },
+  "keywords": [
+    "string",
+    "stringhe",
+    "vladx",
+    "utility"
+  ],
+  "author": "VladX Team",
+  "license": "MIT",
+  "dependencies": {}
+}

package/package.json

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

package/src/interpreter/interpreter.js

@@ -620,11 +620,25 @@ class Interpreter {
                 return this.evaluateMemberExpression(node);
             case 'ArrowFunction':
                 return new ArrowFunc(node.params, node.body, this.environment);
+            case 'TemplateLiteral':
+                return this.evaluateTemplateLiteral(node);
             default:
                 throw new Error(`Tipo espressione sconosciuto: ${node.type}`);
         }
     }
 
+    evaluateTemplateLiteral(node) {
+        let result = node.quasis[0];
+
+        for (let i = 0; i < node.expressions.length; i++) {
+            const value = this.evaluate(node.expressions[i]);
+            result += this.stringify(value);
+            result += node.quasis[i + 1];
+        }
+
+        return result;
+    }
+
     evaluateBinaryExpression(node) {
         const left = this.evaluate(node.left);
         const right = this.evaluate(node.right);
@@ -686,7 +700,7 @@ class Interpreter {
             const prop = node.left.computed
                 ? this.evaluate(node.left.property)
                 : node.left.property.name;
-            
+
             // Handle class instances
             if (obj instanceof VladXInstance) {
                 obj.set(prop, value);
@@ -722,14 +736,14 @@ class Interpreter {
 
     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));

package/src/lexer/lexer.js

@@ -25,6 +25,8 @@ class Lexer {
         this.current = 0;
         this.line = 1;
         this.column = 1;
+        this.braceDepth = 0;
+        this.templateStack = [];
     }
 
     peek() {
@@ -149,6 +151,70 @@ class Lexer {
         this.tokens.push(new Token(TokenType.STRINGA, value, startLine, startColumn));
     }
 
+    readTemplateString(isRestart) {
+        // If not restarting (fresh backtick), consume the backtick
+        if (!isRestart) {
+            this.advance();
+        }
+
+        let value = '';
+        const startLine = this.line;
+        const startColumn = this.column;
+
+        while (!this.isAtEnd()) {
+            // Check for end of template string
+            if (this.peek() === '`') {
+                this.advance(); // consume backtick
+                if (isRestart) {
+                    this.tokens.push(new Token(TokenType.TEMPLATE_FINE, value, startLine, startColumn));
+                } else {
+                    this.tokens.push(new Token(TokenType.TEMPLATE_COMPLETO, value, startLine, startColumn));
+                }
+                return;
+            }
+
+            // Check for start of interpolation
+            if (this.peek() === '$' && this.peekNext() === '{') {
+                this.advance(); // consume $
+                this.advance(); // consume {
+
+                if (isRestart) {
+                    this.tokens.push(new Token(TokenType.TEMPLATE_CENTRO, value, startLine, startColumn));
+                } else {
+                    this.tokens.push(new Token(TokenType.TEMPLATE_INIZIO, value, startLine, startColumn));
+                }
+
+                // Track brace depth for this interpolation
+                this.templateStack.push(this.braceDepth);
+                return;
+            }
+
+            // Handle escapes
+            if (this.peek() === '\\') {
+                this.advance();
+                if (this.isAtEnd()) break;
+
+                const escaped = this.peek();
+                switch (escaped) {
+                    case 'n': value += '\n'; break;
+                    case 't': value += '\t'; break;
+                    case 'r': value += '\r'; break;
+                    case '\\': value += '\\'; break;
+                    case '"': value += '"'; break;
+                    case "'": value += "'"; break;
+                    case '`': value += '`'; break;
+                    case '$': value += '$'; break;
+                    default: value += escaped;
+                }
+                this.advance();
+            } else {
+                value += this.advance();
+            }
+        }
+
+        throw new Error(`Template string non terminata alla riga ${startLine}`);
+    }
+
     readIdentifier() {
         const startColumn = this.column;
         let value = '';
@@ -182,8 +248,22 @@ class Lexer {
         switch (char) {
             case '(': this.addToken(TokenType.PARENTESI_APERTA, '('); break;
             case ')': this.addToken(TokenType.PARENTESI_CHIUSA, ')'); break;
-            case '{': this.addToken(TokenType.GRAFFA_APERTA, '{'); break;
-            case '}': this.addToken(TokenType.GRAFFA_CHIUSA, '}'); break;
+
+            case '{':
+                this.braceDepth++;
+                this.addToken(TokenType.GRAFFA_APERTA, '{');
+                break;
+
+            case '}':
+                if (this.templateStack.length > 0 && this.braceDepth === this.templateStack[this.templateStack.length - 1]) {
+                    this.templateStack.pop();
+                    this.readTemplateString(true);
+                } else {
+                    this.braceDepth--;
+                    this.addToken(TokenType.GRAFFA_CHIUSA, '}');
+                }
+                break;
+
             case '[': this.addToken(TokenType.QUADRA_APERTA, '['); break;
             case ']': this.addToken(TokenType.QUADRA_CHIUSA, ']'); break;
             case ',': this.addToken(TokenType.VIRGOLA, ','); break;
@@ -253,6 +333,12 @@ class Lexer {
                 this.readString(char);
                 break;
 
+            case '`':
+                this.current--;
+                this.column--;
+                this.readTemplateString(false);
+                break;
+
             default:
                 if (this.isDigit(char)) {
                     this.current--;

package/src/lexer/tokens.js

@@ -78,7 +78,13 @@ const TokenType = {
 
     // Special
     FINE: 'FINE',
-    SCONOSCIUTO: 'SCONOSCIUTO'
+    SCONOSCIUTO: 'SCONOSCIUTO',
+
+    // Template Strings
+    TEMPLATE_COMPLETO: 'TEMPLATE_COMPLETO', // `stringa`
+    TEMPLATE_INIZIO: 'TEMPLATE_INIZIO',     // `str${
+    TEMPLATE_CENTRO: 'TEMPLATE_CENTRO',     // }str${
+    TEMPLATE_FINE: 'TEMPLATE_FINE'          // }str`
 };
 
 const KEYWORDS = {

package/src/parser/ast.js

@@ -174,6 +174,14 @@ class StringLiteral extends ASTNode {
     }
 }
 
+class TemplateLiteral extends ASTNode {
+    constructor(quasis, expressions) {
+        super('TemplateLiteral');
+        this.quasis = quasis;
+        this.expressions = expressions;
+    }
+}
+
 class BooleanLiteral extends ASTNode {
     constructor(value) {
         super('BooleanLiteral');
@@ -341,5 +349,6 @@ module.exports = {
     UpdateExpression,
     LogicalExpression,
     ThisExpression,
-    NewExpression
+    NewExpression,
+    TemplateLiteral
 };

package/src/parser/parser.js

@@ -152,7 +152,7 @@ class Parser {
             }
         }
         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;
@@ -504,6 +504,30 @@ class Parser {
             return new AST.StringLiteral(this.previous().value);
         }
 
+        if (this.match(TokenType.TEMPLATE_COMPLETO)) {
+            return new AST.TemplateLiteral([this.previous().value], []);
+        }
+
+        if (this.match(TokenType.TEMPLATE_INIZIO)) {
+            const quasis = [this.previous().value];
+            const expressions = [];
+
+            while (true) {
+                expressions.push(this.expression());
+
+                if (this.match(TokenType.TEMPLATE_CENTRO)) {
+                    quasis.push(this.previous().value);
+                } else if (this.match(TokenType.TEMPLATE_FINE)) {
+                    quasis.push(this.previous().value);
+                    break;
+                } else {
+                    throw new ParserError('Atteso parte centrale o finale della template string', this.peek());
+                }
+            }
+
+            return new AST.TemplateLiteral(quasis, expressions);
+        }
+
         if (this.match(TokenType.NUOVO)) {
             return this.newExpression();
         }