vladx 1.0.1

package/src/lexer/lexer.js

@@ -0,0 +1,284 @@
+/**
+ * VladX Lexer
+ * Tokenizzatore per il linguaggio VladX
+ */
+
+const { TokenType, KEYWORDS } = require('./tokens.js');
+
+class Token {
+    constructor(type, value, line, column) {
+        this.type = type;
+        this.value = value;
+        this.line = line;
+        this.column = column;
+    }
+
+    toString() {
+        return `Token(${this.type}, "${this.value}", riga:${this.line}, col:${this.column})`;
+    }
+}
+
+class Lexer {
+    constructor(source) {
+        this.source = source;
+        this.tokens = [];
+        this.current = 0;
+        this.line = 1;
+        this.column = 1;
+    }
+
+    peek() {
+        if (this.isAtEnd()) return '\0';
+        return this.source[this.current];
+    }
+
+    peekNext() {
+        if (this.current + 1 >= this.source.length) return '\0';
+        return this.source[this.current + 1];
+    }
+
+    advance() {
+        const char = this.source[this.current];
+        this.current++;
+        if (char === '\n') {
+            this.line++;
+            this.column = 1;
+        } else {
+            this.column++;
+        }
+        return char;
+    }
+
+    isAtEnd() {
+        return this.current >= this.source.length;
+    }
+
+    match(expected) {
+        if (this.isAtEnd()) return false;
+        if (this.source[this.current] !== expected) return false;
+        this.advance();
+        return true;
+    }
+
+    addToken(type, value) {
+        this.tokens.push(new Token(type, value, this.line, this.column));
+    }
+
+    skipWhitespaceAndComments() {
+        while (!this.isAtEnd()) {
+            const char = this.peek();
+
+            if (char === ' ' || char === '\t' || char === '\r' || char === '\n') {
+                this.advance();
+                continue;
+            }
+
+            if (char === '/' && this.peekNext() === '/') {
+                while (this.peek() !== '\n' && !this.isAtEnd()) {
+                    this.advance();
+                }
+                continue;
+            }
+
+            if (char === '/' && this.peekNext() === '*') {
+                this.advance();
+                this.advance();
+                while (!this.isAtEnd()) {
+                    if (this.peek() === '*' && this.peekNext() === '/') {
+                        this.advance();
+                        this.advance();
+                        break;
+                    }
+                    this.advance();
+                }
+                continue;
+            }
+
+            break;
+        }
+    }
+
+    readNumber() {
+        const startColumn = this.column;
+        let value = '';
+
+        while (this.isDigit(this.peek())) {
+            value += this.advance();
+        }
+
+        if (this.peek() === '.' && this.isDigit(this.peekNext())) {
+            value += this.advance();
+            while (this.isDigit(this.peek())) {
+                value += this.advance();
+            }
+        }
+
+        this.tokens.push(new Token(TokenType.NUMERO, parseFloat(value), this.line, startColumn));
+    }
+
+    readString(quote) {
+        const startColumn = this.column;
+        const startLine = this.line;
+        this.advance();
+        let value = '';
+
+        while (!this.isAtEnd() && this.peek() !== quote) {
+            if (this.peek() === '\\' && !this.isAtEnd()) {
+                this.advance();
+                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;
+                    default: value += escaped;
+                }
+                this.advance();
+            } else {
+                value += this.advance();
+            }
+        }
+
+        if (this.isAtEnd()) {
+            throw new Error(`Stringa non terminata alla riga ${startLine}`);
+        }
+
+        this.advance();
+        this.tokens.push(new Token(TokenType.STRINGA, value, startLine, startColumn));
+    }
+
+    readIdentifier() {
+        const startColumn = this.column;
+        let value = '';
+
+        while (this.isAlphaNumeric(this.peek())) {
+            value += this.advance();
+        }
+
+        const type = KEYWORDS[value.toLowerCase()] || TokenType.IDENTIFICATORE;
+        this.tokens.push(new Token(type, value, this.line, startColumn));
+    }
+
+    isDigit(char) {
+        return char >= '0' && char <= '9';
+    }
+
+    isAlpha(char) {
+        return (char >= 'a' && char <= 'z') ||
+            (char >= 'A' && char <= 'Z') ||
+            char === '_' ||
+            'àèéìòùÀÈÉÌÒÙ'.includes(char);
+    }
+
+    isAlphaNumeric(char) {
+        return this.isAlpha(char) || this.isDigit(char);
+    }
+
+    scanToken() {
+        const char = this.advance();
+
+        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.addToken(TokenType.QUADRA_APERTA, '['); break;
+            case ']': this.addToken(TokenType.QUADRA_CHIUSA, ']'); break;
+            case ',': this.addToken(TokenType.VIRGOLA, ','); break;
+            case ';': this.addToken(TokenType.PUNTO_VIRGOLA, ';'); break;
+            case '.': this.addToken(TokenType.PUNTO, '.'); break;
+            case ':': this.addToken(TokenType.DUE_PUNTI, ':'); break;
+            case '?': this.addToken(TokenType.PUNTO_INTERROGATIVO, '?'); break;
+
+            case '+':
+                if (this.match('+')) this.addToken(TokenType.INCREMENTA, '++');
+                else if (this.match('=')) this.addToken(TokenType.PIU_ASSEGNA, '+=');
+                else this.addToken(TokenType.PIU, '+');
+                break;
+
+            case '-':
+                if (this.match('-')) this.addToken(TokenType.DECREMENTA, '--');
+                else if (this.match('=')) this.addToken(TokenType.MENO_ASSEGNA, '-=');
+                else this.addToken(TokenType.MENO, '-');
+                break;
+
+            case '*': this.addToken(TokenType.MOLTIPLICA, '*'); break;
+            case '/': this.addToken(TokenType.DIVIDI, '/'); break;
+            case '%': this.addToken(TokenType.MODULO, '%'); break;
+
+            case '=':
+                if (this.match('=')) {
+                    if (this.match('=')) this.addToken(TokenType.UGUALE_STRETTO, '===');
+                    else this.addToken(TokenType.UGUALE, '==');
+                } else if (this.match('>')) {
+                    this.addToken(TokenType.FRECCIA, '=>');
+                } else {
+                    this.addToken(TokenType.ASSEGNA, '=');
+                }
+                break;
+
+            case '!':
+                if (this.match('=')) {
+                    if (this.match('=')) this.addToken(TokenType.DIVERSO_STRETTO, '!==');
+                    else this.addToken(TokenType.DIVERSO, '!=');
+                } else {
+                    this.addToken(TokenType.NON, '!');
+                }
+                break;
+
+            case '<':
+                if (this.match('=')) this.addToken(TokenType.MINORE_UGUALE, '<=');
+                else this.addToken(TokenType.MINORE, '<');
+                break;
+
+            case '>':
+                if (this.match('=')) this.addToken(TokenType.MAGGIORE_UGUALE, '>=');
+                else this.addToken(TokenType.MAGGIORE, '>');
+                break;
+
+            case '&':
+                if (this.match('&')) this.addToken(TokenType.AND, '&&');
+                break;
+
+            case '|':
+                if (this.match('|')) this.addToken(TokenType.OR, '||');
+                break;
+
+            case '"':
+            case "'":
+                this.current--;
+                this.column--;
+                this.readString(char);
+                break;
+
+            default:
+                if (this.isDigit(char)) {
+                    this.current--;
+                    this.column--;
+                    this.readNumber();
+                } else if (this.isAlpha(char)) {
+                    this.current--;
+                    this.column--;
+                    this.readIdentifier();
+                } else {
+                    this.addToken(TokenType.SCONOSCIUTO, char);
+                }
+        }
+    }
+
+    tokenize() {
+        while (!this.isAtEnd()) {
+            this.skipWhitespaceAndComments();
+            if (!this.isAtEnd()) {
+                this.scanToken();
+            }
+        }
+
+        this.tokens.push(new Token(TokenType.FINE, '', this.line, this.column));
+        return this.tokens;
+    }
+}
+
+module.exports = { Lexer, Token };

package/src/lexer/tokens.js

@@ -0,0 +1,116 @@
+/**
+ * VladX - Token Types
+ * Definizione dei tipi di token e keyword italiane
+ */
+
+const TokenType = {
+    // Literals
+    NUMERO: 'NUMERO',
+    STRINGA: 'STRINGA',
+    IDENTIFICATORE: 'IDENTIFICATORE',
+
+    // Keywords
+    VARIABILE: 'VARIABILE',
+    COSTANTE: 'COSTANTE',
+    FUNZIONE: 'FUNZIONE',
+    SE: 'SE',
+    ALTRIMENTI: 'ALTRIMENTI',
+    MENTRE: 'MENTRE',
+    PER: 'PER',
+    RITORNA: 'RITORNA',
+    VERO: 'VERO',
+    FALSO: 'FALSO',
+    NULLO: 'NULLO',
+    E: 'E',
+    O: 'O',
+    NON: 'NON',
+    STAMPA: 'STAMPA',
+    CLASSE: 'CLASSE',
+    NUOVO: 'NUOVO',
+    QUESTO: 'QUESTO',
+    IMPORTA: 'IMPORTA',
+    ESPORTA: 'ESPORTA',
+    DA: 'DA',
+    PROVA: 'PROVA',
+    CATTURA: 'CATTURA',
+    FINALMENTE: 'FINALMENTE',
+    LANCIA: 'LANCIA',
+    ASINCRONO: 'ASINCRONO',
+    ATTENDI: 'ATTENDI',
+    INTERROMPI: 'INTERROMPI',
+    CONTINUA: 'CONTINUA',
+
+    // Operators
+    PIU: 'PIU',
+    MENO: 'MENO',
+    MOLTIPLICA: 'MOLTIPLICA',
+    DIVIDI: 'DIVIDI',
+    MODULO: 'MODULO',
+    ASSEGNA: 'ASSEGNA',
+    UGUALE: 'UGUALE',
+    UGUALE_STRETTO: 'UGUALE_STRETTO',
+    DIVERSO: 'DIVERSO',
+    DIVERSO_STRETTO: 'DIVERSO_STRETTO',
+    MINORE: 'MINORE',
+    MAGGIORE: 'MAGGIORE',
+    MINORE_UGUALE: 'MINORE_UGUALE',
+    MAGGIORE_UGUALE: 'MAGGIORE_UGUALE',
+    PIU_ASSEGNA: 'PIU_ASSEGNA',
+    MENO_ASSEGNA: 'MENO_ASSEGNA',
+    INCREMENTA: 'INCREMENTA',
+    DECREMENTA: 'DECREMENTA',
+    FRECCIA: 'FRECCIA',
+    AND: 'AND',
+    OR: 'OR',
+
+    // Delimiters
+    PARENTESI_APERTA: 'PARENTESI_APERTA',
+    PARENTESI_CHIUSA: 'PARENTESI_CHIUSA',
+    GRAFFA_APERTA: 'GRAFFA_APERTA',
+    GRAFFA_CHIUSA: 'GRAFFA_CHIUSA',
+    QUADRA_APERTA: 'QUADRA_APERTA',
+    QUADRA_CHIUSA: 'QUADRA_CHIUSA',
+    VIRGOLA: 'VIRGOLA',
+    PUNTO_VIRGOLA: 'PUNTO_VIRGOLA',
+    PUNTO: 'PUNTO',
+    DUE_PUNTI: 'DUE_PUNTI',
+    PUNTO_INTERROGATIVO: 'PUNTO_INTERROGATIVO',
+
+    // Special
+    FINE: 'FINE',
+    SCONOSCIUTO: 'SCONOSCIUTO'
+};
+
+const KEYWORDS = {
+    'variabile': TokenType.VARIABILE,
+    'costante': TokenType.COSTANTE,
+    'funzione': TokenType.FUNZIONE,
+    'se': TokenType.SE,
+    'altrimenti': TokenType.ALTRIMENTI,
+    'mentre': TokenType.MENTRE,
+    'per': TokenType.PER,
+    'ritorna': TokenType.RITORNA,
+    'vero': TokenType.VERO,
+    'falso': TokenType.FALSO,
+    'nullo': TokenType.NULLO,
+    'e': TokenType.E,
+    'o': TokenType.O,
+    'non': TokenType.NON,
+    'stampa': TokenType.STAMPA,
+    'classe': TokenType.CLASSE,
+    'nuovo': TokenType.NUOVO,
+    'questo': TokenType.QUESTO,
+    'importa': TokenType.IMPORTA,
+    'esporta': TokenType.ESPORTA,
+    'da': TokenType.DA,
+    'prova': TokenType.PROVA,
+    'cattura': TokenType.CATTURA,
+    'finalmente': TokenType.FINALMENTE,
+    'lancia': TokenType.LANCIA,
+    'asincrono': TokenType.ASINCRONO,
+    'attendi': TokenType.ATTENDI,
+    'interrompi': TokenType.INTERROMPI,
+    'continua': TokenType.CONTINUA
+};
+
+module.exports = { TokenType, KEYWORDS };

package/src/parser/ast.js

@@ -0,0 +1,265 @@
+/**
+ * VladX AST Node Types
+ * Definizioni dei nodi dell'Abstract Syntax Tree
+ */
+
+class ASTNode {
+    constructor(type) {
+        this.type = type;
+    }
+}
+
+// === Programma ===
+class Program extends ASTNode {
+    constructor(body) {
+        super('Program');
+        this.body = body;
+    }
+}
+
+// === Dichiarazioni ===
+class VariableDeclaration extends ASTNode {
+    constructor(name, value, isConstant = false) {
+        super('VariableDeclaration');
+        this.name = name;
+        this.value = value;
+        this.isConstant = isConstant;
+    }
+}
+
+class FunctionDeclaration extends ASTNode {
+    constructor(name, params, body) {
+        super('FunctionDeclaration');
+        this.name = name;
+        this.params = params;
+        this.body = body;
+    }
+}
+
+// === Statements ===
+class BlockStatement extends ASTNode {
+    constructor(body) {
+        super('BlockStatement');
+        this.body = body;
+    }
+}
+
+class IfStatement extends ASTNode {
+    constructor(condition, consequent, alternate = null) {
+        super('IfStatement');
+        this.condition = condition;
+        this.consequent = consequent;
+        this.alternate = alternate;
+    }
+}
+
+class WhileStatement extends ASTNode {
+    constructor(condition, body) {
+        super('WhileStatement');
+        this.condition = condition;
+        this.body = body;
+    }
+}
+
+class ForStatement extends ASTNode {
+    constructor(init, condition, update, body) {
+        super('ForStatement');
+        this.init = init;
+        this.condition = condition;
+        this.update = update;
+        this.body = body;
+    }
+}
+
+class ReturnStatement extends ASTNode {
+    constructor(argument) {
+        super('ReturnStatement');
+        this.argument = argument;
+    }
+}
+
+class BreakStatement extends ASTNode {
+    constructor() {
+        super('BreakStatement');
+    }
+}
+
+class ContinueStatement extends ASTNode {
+    constructor() {
+        super('ContinueStatement');
+    }
+}
+
+class ExpressionStatement extends ASTNode {
+    constructor(expression) {
+        super('ExpressionStatement');
+        this.expression = expression;
+    }
+}
+
+class PrintStatement extends ASTNode {
+    constructor(argument) {
+        super('PrintStatement');
+        this.argument = argument;
+    }
+}
+
+// === Espressioni ===
+class Identifier extends ASTNode {
+    constructor(name) {
+        super('Identifier');
+        this.name = name;
+    }
+}
+
+class NumericLiteral extends ASTNode {
+    constructor(value) {
+        super('NumericLiteral');
+        this.value = value;
+    }
+}
+
+class StringLiteral extends ASTNode {
+    constructor(value) {
+        super('StringLiteral');
+        this.value = value;
+    }
+}
+
+class BooleanLiteral extends ASTNode {
+    constructor(value) {
+        super('BooleanLiteral');
+        this.value = value;
+    }
+}
+
+class NullLiteral extends ASTNode {
+    constructor() {
+        super('NullLiteral');
+        this.value = null;
+    }
+}
+
+class ArrayLiteral extends ASTNode {
+    constructor(elements) {
+        super('ArrayLiteral');
+        this.elements = elements;
+    }
+}
+
+class ObjectLiteral extends ASTNode {
+    constructor(properties) {
+        super('ObjectLiteral');
+        this.properties = properties;
+    }
+}
+
+class Property extends ASTNode {
+    constructor(key, value) {
+        super('Property');
+        this.key = key;
+        this.value = value;
+    }
+}
+
+class BinaryExpression extends ASTNode {
+    constructor(operator, left, right) {
+        super('BinaryExpression');
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+}
+
+class UnaryExpression extends ASTNode {
+    constructor(operator, argument, prefix = true) {
+        super('UnaryExpression');
+        this.operator = operator;
+        this.argument = argument;
+        this.prefix = prefix;
+    }
+}
+
+class AssignmentExpression extends ASTNode {
+    constructor(operator, left, right) {
+        super('AssignmentExpression');
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+}
+
+class CallExpression extends ASTNode {
+    constructor(callee, args) {
+        super('CallExpression');
+        this.callee = callee;
+        this.arguments = args;
+    }
+}
+
+class MemberExpression extends ASTNode {
+    constructor(object, property, computed = false) {
+        super('MemberExpression');
+        this.object = object;
+        this.property = property;
+        this.computed = computed;
+    }
+}
+
+class ArrowFunction extends ASTNode {
+    constructor(params, body) {
+        super('ArrowFunction');
+        this.params = params;
+        this.body = body;
+    }
+}
+
+class UpdateExpression extends ASTNode {
+    constructor(operator, argument, prefix = false) {
+        super('UpdateExpression');
+        this.operator = operator;
+        this.argument = argument;
+        this.prefix = prefix;
+    }
+}
+
+class LogicalExpression extends ASTNode {
+    constructor(operator, left, right) {
+        super('LogicalExpression');
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+}
+
+module.exports = {
+    ASTNode,
+    Program,
+    VariableDeclaration,
+    FunctionDeclaration,
+    BlockStatement,
+    IfStatement,
+    WhileStatement,
+    ForStatement,
+    ReturnStatement,
+    BreakStatement,
+    ContinueStatement,
+    ExpressionStatement,
+    PrintStatement,
+    Identifier,
+    NumericLiteral,
+    StringLiteral,
+    BooleanLiteral,
+    NullLiteral,
+    ArrayLiteral,
+    ObjectLiteral,
+    Property,
+    BinaryExpression,
+    UnaryExpression,
+    AssignmentExpression,
+    CallExpression,
+    MemberExpression,
+    ArrowFunction,
+    UpdateExpression,
+    LogicalExpression
+};