vladx 1.0.1

package/src/interpreter/interpreter.js

@@ -0,0 +1,455 @@
+/**
+ * VladX Interpreter
+ * Esecutore dell'AST
+ */
+
+class Environment {
+    constructor(parent = null) {
+        this.values = new Map();
+        this.constants = new Set();
+        this.parent = parent;
+    }
+
+    define(name, value, isConstant = false) {
+        if (this.values.has(name)) {
+            throw new Error(`Variabile "${name}" già dichiarata in questo scope`);
+        }
+        this.values.set(name, value);
+        if (isConstant) this.constants.add(name);
+    }
+
+    get(name) {
+        if (this.values.has(name)) {
+            return this.values.get(name);
+        }
+        if (this.parent) {
+            return this.parent.get(name);
+        }
+        throw new Error(`Variabile "${name}" non definita`);
+    }
+
+    set(name, value) {
+        if (this.values.has(name)) {
+            if (this.constants.has(name)) {
+                throw new Error(`Non puoi riassegnare la costante "${name}"`);
+            }
+            this.values.set(name, value);
+            return;
+        }
+        if (this.parent) {
+            this.parent.set(name, value);
+            return;
+        }
+        throw new Error(`Variabile "${name}" non definita`);
+    }
+
+    has(name) {
+        if (this.values.has(name)) return true;
+        if (this.parent) return this.parent.has(name);
+        return false;
+    }
+}
+
+class ReturnValue {
+    constructor(value) {
+        this.value = value;
+    }
+}
+
+class BreakSignal { }
+class ContinueSignal { }
+
+class VladXFunction {
+    constructor(declaration, closure) {
+        this.declaration = declaration;
+        this.closure = closure;
+    }
+
+    call(interpreter, args) {
+        const env = new Environment(this.closure);
+        for (let i = 0; i < this.declaration.params.length; i++) {
+            env.define(this.declaration.params[i], args[i] !== undefined ? args[i] : null);
+        }
+
+        try {
+            interpreter.executeBlock(this.declaration.body.body, env);
+        } catch (e) {
+            if (e instanceof ReturnValue) {
+                return e.value;
+            }
+            throw e;
+        }
+        return null;
+    }
+}
+
+class ArrowFunc {
+    constructor(params, body, closure) {
+        this.params = params;
+        this.body = body;
+        this.closure = closure;
+    }
+
+    call(interpreter, args) {
+        const env = new Environment(this.closure);
+        for (let i = 0; i < this.params.length; i++) {
+            env.define(this.params[i], args[i] !== undefined ? args[i] : null);
+        }
+
+        if (this.body.type === 'BlockStatement') {
+            try {
+                interpreter.executeBlock(this.body.body, env);
+            } catch (e) {
+                if (e instanceof ReturnValue) {
+                    return e.value;
+                }
+                throw e;
+            }
+            return null;
+        } else {
+            const previousEnv = interpreter.environment;
+            interpreter.environment = env;
+            const result = interpreter.evaluate(this.body);
+            interpreter.environment = previousEnv;
+            return result;
+        }
+    }
+}
+
+class Interpreter {
+    constructor() {
+        this.globals = new Environment();
+        this.environment = this.globals;
+        this.output = [];
+
+        // Built-in functions
+        this.globals.define('lunghezza', {
+            call: (_, args) => {
+                if (args[0] && (Array.isArray(args[0]) || typeof args[0] === 'string')) {
+                    return args[0].length;
+                }
+                return 0;
+            }
+        });
+
+        this.globals.define('tipo', {
+            call: (_, args) => typeof args[0]
+        });
+
+        this.globals.define('numero', {
+            call: (_, args) => parseFloat(args[0])
+        });
+
+        this.globals.define('stringa', {
+            call: (_, args) => String(args[0])
+        });
+
+        this.globals.define('array', {
+            call: (_, args) => Array.isArray(args[0])
+        });
+    }
+
+    interpret(program) {
+        this.output = [];
+        try {
+            for (const statement of program.body) {
+                this.execute(statement);
+            }
+        } catch (error) {
+            if (error instanceof ReturnValue) {
+                return error.value;
+            }
+            throw error;
+        }
+        return this.output;
+    }
+
+    execute(node) {
+        switch (node.type) {
+            case 'VariableDeclaration':
+                return this.executeVariableDeclaration(node);
+            case 'FunctionDeclaration':
+                return this.executeFunctionDeclaration(node);
+            case 'BlockStatement':
+                return this.executeBlock(node.body, new Environment(this.environment));
+            case 'IfStatement':
+                return this.executeIfStatement(node);
+            case 'WhileStatement':
+                return this.executeWhileStatement(node);
+            case 'ForStatement':
+                return this.executeForStatement(node);
+            case 'ReturnStatement':
+                throw new ReturnValue(node.argument ? this.evaluate(node.argument) : null);
+            case 'BreakStatement':
+                throw new BreakSignal();
+            case 'ContinueStatement':
+                throw new ContinueSignal();
+            case 'PrintStatement':
+                return this.executePrintStatement(node);
+            case 'ExpressionStatement':
+                return this.evaluate(node.expression);
+            default:
+                throw new Error(`Tipo statement sconosciuto: ${node.type}`);
+        }
+    }
+
+    executeVariableDeclaration(node) {
+        const value = node.value ? this.evaluate(node.value) : null;
+        this.environment.define(node.name, value, node.isConstant);
+    }
+
+    executeFunctionDeclaration(node) {
+        const func = new VladXFunction(node, this.environment);
+        this.environment.define(node.name, func);
+    }
+
+    executeBlock(statements, env) {
+        const previousEnv = this.environment;
+        this.environment = env;
+        try {
+            for (const statement of statements) {
+                this.execute(statement);
+            }
+        } finally {
+            this.environment = previousEnv;
+        }
+    }
+
+    executeIfStatement(node) {
+        if (this.isTruthy(this.evaluate(node.condition))) {
+            this.execute(node.consequent);
+        } else if (node.alternate) {
+            this.execute(node.alternate);
+        }
+    }
+
+    executeWhileStatement(node) {
+        while (this.isTruthy(this.evaluate(node.condition))) {
+            try {
+                this.execute(node.body);
+            } catch (e) {
+                if (e instanceof BreakSignal) break;
+                if (e instanceof ContinueSignal) continue;
+                throw e;
+            }
+        }
+    }
+
+    executeForStatement(node) {
+        const forEnv = new Environment(this.environment);
+        const previousEnv = this.environment;
+        this.environment = forEnv;
+
+        try {
+            if (node.init) this.execute(node.init);
+
+            while (!node.condition || this.isTruthy(this.evaluate(node.condition))) {
+                try {
+                    this.execute(node.body);
+                } catch (e) {
+                    if (e instanceof BreakSignal) break;
+                    if (e instanceof ContinueSignal) {
+                        if (node.update) this.evaluate(node.update);
+                        continue;
+                    }
+                    throw e;
+                }
+                if (node.update) this.evaluate(node.update);
+            }
+        } finally {
+            this.environment = previousEnv;
+        }
+    }
+
+    executePrintStatement(node) {
+        const value = this.evaluate(node.argument);
+        const output = this.stringify(value);
+        console.log(output);
+        this.output.push(output);
+    }
+
+    evaluate(node) {
+        switch (node.type) {
+            case 'NumericLiteral':
+                return node.value;
+            case 'StringLiteral':
+                return node.value;
+            case 'BooleanLiteral':
+                return node.value;
+            case 'NullLiteral':
+                return null;
+            case 'Identifier':
+                return this.environment.get(node.name);
+            case 'ArrayLiteral':
+                return node.elements.map(el => this.evaluate(el));
+            case 'ObjectLiteral':
+                const obj = {};
+                for (const prop of node.properties) {
+                    obj[prop.key] = this.evaluate(prop.value);
+                }
+                return obj;
+            case 'BinaryExpression':
+                return this.evaluateBinaryExpression(node);
+            case 'LogicalExpression':
+                return this.evaluateLogicalExpression(node);
+            case 'UnaryExpression':
+                return this.evaluateUnaryExpression(node);
+            case 'AssignmentExpression':
+                return this.evaluateAssignment(node);
+            case 'UpdateExpression':
+                return this.evaluateUpdateExpression(node);
+            case 'CallExpression':
+                return this.evaluateCallExpression(node);
+            case 'MemberExpression':
+                return this.evaluateMemberExpression(node);
+            case 'ArrowFunction':
+                return new ArrowFunc(node.params, node.body, this.environment);
+            default:
+                throw new Error(`Tipo espressione sconosciuto: ${node.type}`);
+        }
+    }
+
+    evaluateBinaryExpression(node) {
+        const left = this.evaluate(node.left);
+        const right = this.evaluate(node.right);
+
+        switch (node.operator) {
+            case '+':
+                if (typeof left === 'string' || typeof right === 'string') {
+                    return this.stringify(left) + this.stringify(right);
+                }
+                return left + right;
+            case '-': return left - right;
+            case '*': return left * right;
+            case '/': return left / right;
+            case '%': return left % right;
+            case '<': return left < right;
+            case '>': return left > right;
+            case '<=': return left <= right;
+            case '>=': return left >= right;
+            case '==': return left == right;
+            case '===': return left === right;
+            case '!=': return left != right;
+            case '!==': return left !== right;
+            default:
+                throw new Error(`Operatore binario sconosciuto: ${node.operator}`);
+        }
+    }
+
+    evaluateLogicalExpression(node) {
+        const left = this.evaluate(node.left);
+        if (node.operator === '||') {
+            return this.isTruthy(left) ? left : this.evaluate(node.right);
+        } else {
+            return !this.isTruthy(left) ? left : this.evaluate(node.right);
+        }
+    }
+
+    evaluateUnaryExpression(node) {
+        const argument = this.evaluate(node.argument);
+        switch (node.operator) {
+            case '-': return -argument;
+            case '!': return !this.isTruthy(argument);
+            default:
+                throw new Error(`Operatore unario sconosciuto: ${node.operator}`);
+        }
+    }
+
+    evaluateAssignment(node) {
+        let value = this.evaluate(node.right);
+
+        if (node.operator === '+=' || node.operator === '-=') {
+            const current = this.evaluate(node.left);
+            value = node.operator === '+=' ? current + value : current - value;
+        }
+
+        if (node.left.type === 'Identifier') {
+            this.environment.set(node.left.name, value);
+        } else if (node.left.type === 'MemberExpression') {
+            const obj = this.evaluate(node.left.object);
+            const prop = node.left.computed
+                ? this.evaluate(node.left.property)
+                : node.left.property.name;
+            obj[prop] = value;
+        }
+
+        return value;
+    }
+
+    evaluateUpdateExpression(node) {
+        const current = this.evaluate(node.argument);
+        const newValue = node.operator === '++' ? current + 1 : current - 1;
+
+        if (node.argument.type === 'Identifier') {
+            this.environment.set(node.argument.name, newValue);
+        }
+
+        return node.prefix ? newValue : current;
+    }
+
+    evaluateCallExpression(node) {
+        const callee = this.evaluate(node.callee);
+        const args = node.arguments.map(arg => this.evaluate(arg));
+
+        if (callee && typeof callee.call === 'function') {
+            return callee.call(this, args);
+        }
+
+        throw new Error(`"${node.callee.name || 'valore'}" non è una funzione`);
+    }
+
+    evaluateMemberExpression(node) {
+        const obj = this.evaluate(node.object);
+        if (obj === null || obj === undefined) {
+            throw new Error('Impossibile accedere a proprietà di null/undefined');
+        }
+
+        const prop = node.computed
+            ? this.evaluate(node.property)
+            : node.property.name;
+
+        // Handle array methods
+        if (Array.isArray(obj)) {
+            if (prop === 'aggiungi' || prop === 'push') {
+                return { call: (_, args) => { obj.push(...args); return obj.length; } };
+            }
+            if (prop === 'rimuovi' || prop === 'pop') {
+                return { call: () => obj.pop() };
+            }
+            if (prop === 'lunghezza' || prop === 'length') {
+                return obj.length;
+            }
+        }
+
+        return obj[prop];
+    }
+
+    isTruthy(value) {
+        if (value === null || value === undefined) return false;
+        if (typeof value === 'boolean') return value;
+        if (typeof value === 'number') return value !== 0;
+        if (typeof value === 'string') return value.length > 0;
+        return true;
+    }
+
+    stringify(value) {
+        if (value === null) return 'nullo';
+        if (value === undefined) return 'indefinito';
+        if (typeof value === 'boolean') return value ? 'vero' : 'falso';
+        if (Array.isArray(value)) {
+            return '[' + value.map(v => this.stringify(v)).join(', ') + ']';
+        }
+        if (typeof value === 'object') {
+            if (value instanceof VladXFunction || value instanceof ArrowFunc) {
+                return '[Funzione]';
+            }
+            const props = Object.entries(value)
+                .map(([k, v]) => `${k}: ${this.stringify(v)}`)
+                .join(', ');
+            return '{ ' + props + ' }';
+        }
+        return String(value);
+    }
+}
+
+module.exports = { Interpreter, Environment };