vladx 1.0.0

package/src/runtime/environment.js

@@ -0,0 +1,140 @@
+/**
+ * VladX Environment — Окружение выполнения
+ * Управляет областями видимости переменных
+ */
+
+export class Environment {
+    constructor(parent = null, name = '<anonymous>') {
+        this.parent = parent;
+        this.name = name;
+        this.variables = new Map();
+        this.constants = new Set();
+    }
+
+    /**
+     * Определение переменной
+     */
+    define(name, value, isConst = false) {
+        // Check if it's already defined as a constant in the current environment only
+        // Local variables should be able to shadow parent constants/functions
+        if (this.constants.has(name)) {
+            throw new Error(`Константа ${name} уже объявлена`);
+        }
+
+        if (this.variables.has(name) && !isConst) {
+            // Предупреждение о переопределении
+        }
+
+        this.variables.set(name, value);
+
+        if (isConst) {
+            this.constants.add(name);
+        }
+    }
+
+    /**
+     * Получение значения переменной
+     */
+    get(name) {
+        if (this.variables.has(name)) {
+            return this.variables.get(name);
+        }
+        
+        if (this.parent) {
+            return this.parent.get(name);
+        }
+        
+        throw new Error(`Переменная "${name}" не найдена в окружении ${this.name}`);
+
+    }
+
+    /**
+     * Присваивание значения переменной
+     */
+    assign(name, value) {
+        if (this.variables.has(name)) {
+            if (this.constants.has(name)) {
+                throw new Error(`Нельзя изменить константу ${name}`);
+            }
+            this.variables.set(name, value);
+            return true;
+        }
+        
+        if (this.parent) {
+            return this.parent.assign(name, value);
+        }
+        
+        throw new Error(`Переменная ${name} не найдена`);
+    }
+
+    /**
+     * Проверка существования переменной
+     */
+    has(name) {
+        return this.variables.has(name) || (this.parent && this.parent.has(name));
+    }
+
+    /**
+     * Создание дочернего окружения
+     */
+    child(name = '<child>') {
+        return new Environment(this, name);
+    }
+
+    /**
+     * Клонирование окружения
+     */
+    clone() {
+        const cloned = new Environment(this.parent, this.name);
+        
+        for (const [key, value] of this.variables) {
+            cloned.variables.set(key, value);
+        }
+        
+        for (const constant of this.constants) {
+            cloned.constants.add(constant);
+        }
+        
+        return cloned;
+    }
+
+    /**
+     * Получение всех переменных
+     */
+    getAll() {
+        const result = {};
+        
+        if (this.parent) {
+            Object.assign(result, this.parent.getAll());
+        }
+        
+        for (const [key, value] of this.variables) {
+            result[key] = value;
+        }
+        
+        return result;
+    }
+
+    /**
+     * Удаление переменной
+     */
+    delete(name) {
+        if (this.variables.has(name)) {
+            this.variables.delete(name);
+            this.constants.delete(name);
+            return true;
+        }
+        
+        return false;
+    }
+
+    /**
+     * Очистка окружения
+     */
+    clear() {
+        this.variables.clear();
+        this.constants.clear();
+    }
+}
+
+export default Environment;

package/src/runtime/event-emitter.js

@@ -0,0 +1,232 @@
+/**
+ * EventEmitter — Реализация события emitter
+ */
+
+export class EventEmitter {
+    constructor() {
+        this.events = new Map();
+        this.onceEvents = new Map();
+        this.maxListeners = 10;
+    }
+
+    /**
+     * Добавить listener
+     */
+    on(event, listener) {
+        if (!this.events.has(event)) {
+            this.events.set(event, []);
+        }
+
+        const listeners = this.events.get(event);
+
+        // Проверка на maxListeners
+        if (listeners.length >= this.maxListeners) {
+            console.warn(`Possible memory leak detected. ${listeners.length} ${event} listeners added.`);
+        }
+
+        listeners.push(listener);
+        return this;
+    }
+
+    /**
+     * Добавить one-time listener
+     */
+    once(event, listener) {
+        const wrapper = (...args) => {
+            this.off(event, wrapper);
+            listener(...args);
+        };
+
+        this.on(event, wrapper);
+        return this;
+    }
+
+    /**
+     * Удалить listener
+     */
+    off(event, listener) {
+        const listeners = this.events.get(event);
+        if (listeners) {
+            const index = listeners.indexOf(listener);
+            if (index !== -1) {
+                listeners.splice(index, 1);
+            }
+
+            if (listeners.length === 0) {
+                this.events.delete(event);
+            }
+        }
+        return this;
+    }
+
+    /**
+     * Запустить событие
+     */
+    emit(event, ...args) {
+        const listeners = this.events.get(event);
+        if (listeners) {
+            // Копируем массив для безопасной модификации во время итерации
+            const listenersCopy = [...listeners];
+
+            for (const listener of listenersCopy) {
+                try {
+                    listener(...args);
+                } catch (error) {
+                    // Ошибка в listener не должна прерывать других
+                    console.error(`Error in ${event} listener:`, error);
+                }
+            }
+
+            return listeners.length > 0;
+        }
+        return false;
+    }
+
+    /**
+     * Добавить listener (синоним on)
+     */
+    addListener(event, listener) {
+        return this.on(event, listener);
+    }
+
+    /**
+     * Удалить listener (синоним off)
+     */
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+
+    /**
+     * Удалить все listeners для события
+     */
+    removeAllListeners(event) {
+        if (event) {
+            this.events.delete(event);
+        } else {
+            this.events.clear();
+        }
+        return this;
+    }
+
+    /**
+     * Получить listeners для события
+     */
+    listeners(event) {
+        return this.events.get(event) || [];
+    }
+
+    /**
+     * Получить количество listeners для события
+     */
+    listenerCount(event) {
+        return (this.events.get(event) || []).length;
+    }
+
+    /**
+     * Получить все имена событий
+     */
+    eventNames() {
+        return Array.from(this.events.keys());
+    }
+
+    /**
+     * Установить максимальное количество listeners
+     */
+    setMaxListeners(n) {
+        this.maxListeners = n;
+        return this;
+    }
+
+    /**
+     * Получить максимальное количество listeners
+     */
+    getMaxListeners() {
+        return this.maxListeners;
+    }
+
+    /**
+     * Добавить prepend listener (добавляется в начало)
+     */
+    prependListener(event, listener) {
+        if (!this.events.has(event)) {
+            this.events.set(event, []);
+        }
+
+        this.events.get(event).unshift(listener);
+        return this;
+    }
+
+    /**
+     * Добавить prepend once listener
+     */
+    prependOnceListener(event, listener) {
+        const wrapper = (...args) => {
+            this.off(event, wrapper);
+            listener(...args);
+        };
+
+        this.prependListener(event, wrapper);
+        return this;
+    }
+
+    /**
+     * Статический метод для создания emitter
+     */
+    static create() {
+        return new EventEmitter();
+    }
+
+    /**
+     * Асинхронный emit (Promise)
+     */
+    async emitAsync(event, ...args) {
+        const listeners = this.events.get(event);
+        if (!listeners) {
+            return false;
+        }
+
+        const results = [];
+
+        for (const listener of listeners) {
+            try {
+                const result = listener(...args);
+                if (result && typeof result.then === 'function') {
+                    results.push(await result);
+                } else {
+                    results.push(result);
+                }
+            } catch (error) {
+                console.error(`Error in ${event} async listener:`, error);
+                results.push(Promise.reject(error));
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Проверить, есть ли listeners
+     */
+    hasListeners(event) {
+        return this.listenerCount(event) > 0;
+    }
+
+    /**
+     * Получить информацию о памяти
+     */
+    getMemoryUsage() {
+        let totalListeners = 0;
+
+        for (const [event, listeners] of this.events) {
+            totalListeners += listeners.length;
+        }
+
+        return {
+            events: this.events.size,
+            totalListeners,
+            maxListeners: this.maxListeners
+        };
+    }
+}
+
+export default EventEmitter;

package/src/runtime/formatter.js

@@ -0,0 +1,280 @@
+/**
+ * Formatter — Форматирование кода VladX
+ */
+
+import { Lexer } from '../lexer/lexer.js';
+import { Parser } from '../parser/parser.js';
+
+export class Formatter {
+    constructor(options = {}) {
+        this.indentSize = options.indentSize || 4;
+        this.indentChar = options.indentChar || ' ';
+        this.useTabs = options.useTabs || false;
+        this.semicolons = options.semicolons !== false;
+        this.trailingComma = options.trailingComma || false;
+        this.singleQuote = options.singleQuote || false;
+        this.printWidth = options.printWidth || 100;
+        this.insertFinalNewline = options.insertFinalNewline !== false;
+    }
+
+    /**
+     * Отформатировать код
+     */
+    format(source, filename = '<anonymous>') {
+        let formatted = source;
+
+        // Шаг 1: Нормализация пробелов
+        formatted = this.normalizeWhitespace(formatted);
+
+        // Шаг 2: Форматирование блоков
+        formatted = this.formatBlocks(formatted);
+
+        // Шаг 3: Форматирование отступов
+        formatted = this.formatIndentation(formatted);
+
+        // Шаг 4: Форматирование операторов
+        formatted = this.formatOperators(formatted);
+
+        // Шаг 5: Удаление лишних пустых строк
+        formatted = this.formatEmptyLines(formatted);
+
+        // Шаг 6: Добавление перевода строки в конце
+        if (this.insertFinalNewline && !formatted.endsWith('\n')) {
+            formatted += '\n';
+        }
+
+        return formatted;
+    }
+
+    /**
+     * Нормализация пробелов
+     */
+    normalizeWhitespace(source) {
+        // Удалить trailing whitespace
+        let formatted = source.split('\n').map(line => line.trimEnd()).join('\n');
+
+        // Нормализировать табы в пробелы или наоборот
+        if (this.useTabs) {
+            formatted = formatted.replace(/ {4}/g, '\t');
+        } else {
+            formatted = formatted.replace(/\t/g, ' '.repeat(this.indentSize));
+        }
+
+        return formatted;
+    }
+
+    /**
+     * Форматирование блоков
+     */
+    formatBlocks(source) {
+        let formatted = source;
+
+        // Форматирование if/else
+        formatted = formatted.replace(
+            /(?:если|if)\s*\(([^)]*)\)\s*([^{])/g,
+            (match, condition, nextChar) => {
+                const indent = ' '.repeat(this.indentSize);
+                return `если (${condition}) {\n${indent}${nextChar}`;
+            }
+        );
+
+        // Форматирование while
+        formatted = formatted.replace(
+            /(?:пока|while)\s*\(([^)]*)\)\s*([^{])/g,
+            (match, condition, nextChar) => {
+                const indent = ' '.repeat(this.indentSize);
+                return `пока (${condition}) {\n${indent}${nextChar}`;
+            }
+        );
+
+        // Форматирование for
+        formatted = formatted.replace(
+            /(?:для|for)\s*\(([^)]*)\)\s*([^{])/g,
+            (match, condition, nextChar) => {
+                const indent = ' '.repeat(this.indentSize);
+                return `для (${condition}) {\n${indent}${nextChar}`;
+            }
+        );
+
+        return formatted;
+    }
+
+    /**
+     * Форматирование отступов
+     */
+    formatIndentation(source) {
+        const lines = source.split('\n');
+        const formattedLines = [];
+        let indentLevel = 0;
+
+        for (const line of lines) {
+            const trimmed = line.trim();
+
+            if (trimmed.length === 0) {
+                formattedLines.push('');
+                continue;
+            }
+
+            // Уменьшить отступ перед закрывающей скобкой
+            if (trimmed.startsWith('}') || trimmed.startsWith('иначе')) {
+                indentLevel = Math.max(0, indentLevel - 1);
+            }
+
+            // Добавить отступ
+            const indent = this.useTabs
+                ? '\t'.repeat(indentLevel)
+                : ' '.repeat(indentLevel * this.indentSize);
+            formattedLines.push(indent + trimmed);
+
+            // Увеличить отступ после открывающей скобки
+            if (trimmed.endsWith('{')) {
+                indentLevel++;
+            }
+        }
+
+        return formattedLines.join('\n');
+    }
+
+    /**
+     * Форматирование операторов
+     */
+    formatOperators(source) {
+        let formatted = source;
+
+        // Пробелы вокруг операторов
+        const operators = ['+', '-', '*', '/', '%', '=', '==', '!=', '<', '>', '<=', '>=', '&&', '||', '!'];
+
+        for (const op of operators) {
+            formatted = formatted.replace(
+                new RegExp(`([^\\s])\\${op}([^\\s])`, 'g'),
+                `$1 ${op} $2`
+            );
+        }
+
+        // Пробелы после запятых
+        formatted = formatted.replace(/,(\S)/g, ', $1');
+
+        // Пробелы после точек с запятой
+        formatted = formatted.replace(/;(\S)/g, '; $1');
+
+        return formatted;
+    }
+
+    /**
+     * Форматирование пустых строк
+     */
+    formatEmptyLines(source) {
+        const lines = source.split('\n');
+        const formattedLines = [];
+        let emptyCount = 0;
+
+        for (const line of lines) {
+            if (line.trim().length === 0) {
+                emptyCount++;
+                if (emptyCount <= 2) {
+                    formattedLines.push(line);
+                }
+            } else {
+                emptyCount = 0;
+                formattedLines.push(line);
+            }
+        }
+
+        return formattedLines.join('\n');
+    }
+
+    /**
+     * Проверить код
+     */
+    check(source, filename = '<anonymous>') {
+        const issues = [];
+
+        // Проверить длину строк
+        const lines = source.split('\n');
+        lines.forEach((line, index) => {
+            if (line.length > this.printWidth) {
+                issues.push({
+                    message: `Строка слишком длинная: ${line.length} > ${this.printWidth}`,
+                    line: index + 1,
+                    severity: 'warning'
+                });
+            }
+        });
+
+        // Проверить trailing whitespace
+        lines.forEach((line, index) => {
+            if (line !== line.trimEnd()) {
+                issues.push({
+                    message: 'Trailing whitespace в конце строки',
+                    line: index + 1,
+                    severity: 'info'
+                });
+            }
+        });
+
+        // Проверить смешивание табов и пробелов
+        lines.forEach((line, index) => {
+            if (line.includes('\t') && line.includes('  ')) {
+                issues.push({
+                    message: 'Смешивание табов и пробелов',
+                    line: index + 1,
+                    severity: 'error'
+                });
+            }
+        });
+
+        return {
+            issues,
+            hasIssues: issues.length > 0
+        };
+    }
+
+    /**
+     * Форматировать с автофиксом
+     */
+    formatWithFix(source, filename = '<anonymous>') {
+        const checkResult = this.check(source, filename);
+
+        if (!checkResult.hasIssues) {
+            return {
+                source,
+                formatted: false,
+                issues: []
+            };
+        }
+
+        const formatted = this.format(source, filename);
+
+        return {
+            source: formatted,
+            formatted: true,
+            issues: checkResult.issues
+        };
+    }
+
+    /**
+     * Получить конфигурацию
+     */
+    getConfig() {
+        return {
+            indentSize: this.indentSize,
+            indentChar: this.indentChar,
+            useTabs: this.useTabs,
+            semicolons: this.semicolons,
+            trailingComma: this.trailingComma,
+            singleQuote: this.singleQuote,
+            printWidth: this.printWidth,
+            insertFinalNewline: this.insertFinalNewline
+        };
+    }
+
+    /**
+     * Установить конфигурацию
+     */
+    setConfig(config) {
+        Object.assign(this, config);
+        return this;
+    }
+}
+
+export default Formatter;