@designliquido/delegua 0.0.1

package/src/structures/function.js

@@ -0,0 +1,62 @@
+const Callable = require("./callable.js");
+const Environment = require("../environment.js");
+const ReturnExpection = require("../errors.js").ReturnException;
+
+module.exports = class EguaFunction extends Callable {
+    constructor(name, declaration, closure, isInitializer = false) {
+        super();
+        this.name = name;
+        this.declaration = declaration;
+        this.closure = closure;
+        this.isInitializer = isInitializer;
+    }
+
+    arity() {
+        return this.declaration.params.length;
+    }
+
+    toString() {
+        if (this.name === null) return "<função>";
+        return `<função ${this.name}>`;
+    }
+
+    call(interpreter, args) {
+        let environment = new Environment(this.closure);
+        let params = this.declaration.params;
+        for (let i = 0; i < params.length; i++) {
+            let param = params[i];
+
+            let name = param["name"].lexeme;
+            let value = args[i];
+            if (args[i] === null) {
+                value = param["default"] ? param["default"].value : null;
+            }
+            environment.defineVar(name, value);
+        }
+
+        try {
+            interpreter.executeBlock(this.declaration.body, environment);
+        } catch (error) {
+            if (error instanceof ReturnExpection) {
+                if (this.isInitializer) return this.closure.getVarAt(0, "isto");
+                return error.value;
+            } else {
+                throw error;
+            }
+        }
+
+        if (this.isInitializer) return this.closure.getVarAt(0, "isto");
+        return null;
+    }
+
+    bind(instance) {
+        let environment = new Environment(this.closure);
+        environment.defineVar("isto", instance);
+        return new EguaFunction(
+            this.name,
+            this.declaration,
+            environment,
+            this.isInitializer
+        );
+    }
+};

package/src/structures/instance.js

@@ -0,0 +1,27 @@
+const RuntimeError = require("../errors.js").RuntimeError;
+
+module.exports = class EguaInstance {
+    constructor(creatorClass) {
+        this.creatorClass = creatorClass;
+        this.fields = {};
+    }
+
+    get(name) {
+        if (this.fields.hasOwnProperty(name.lexeme)) {
+            return this.fields[name.lexeme];
+        }
+
+        let method = this.creatorClass.findMethod(name.lexeme);
+        if (method) return method.bind(this);
+
+        throw new RuntimeError(name, "Método indefinido não recuperado.");
+    }
+
+    set(name, value) {
+        this.fields[name.lexeme] = value;
+    }
+
+    toString() {
+        return "<Objeto " + this.creatorClass.name + ">";
+    }
+};

package/src/structures/module.js

@@ -0,0 +1,9 @@
+module.exports = class EguaModule {
+    constructor(name) {
+        if (name !== undefined) this.name = name;
+    }
+
+    toString() {
+        return this.name ? `<module ${this.name}>` : "<module>";
+    }
+};

package/src/structures/standardFn.js

@@ -0,0 +1,18 @@
+const Callable = require("./callable.js");
+
+module.exports = class StandardFn extends Callable {
+    constructor(arityValue, func) {
+        super();
+        this.arityValue = arityValue;
+        this.func = func;
+    }
+
+    call(interpreter, args, token) {
+        this.token = token;
+        return this.func.apply(this, args);
+    }
+
+    toString() {
+        return "<função>";
+    }
+};

package/src/tokenTypes.js

@@ -0,0 +1,67 @@
+module.exports = {
+    BANG: "BANG",
+    BANG_EQUAL: "BANG_EQUAL",
+    BIT_AND: "BIT_AND",
+    BIT_OR: "BIT_OR",
+    BIT_XOR: "BIT_XOR",
+    BIT_NOT: "BIT_NOT",
+    CASO: "CASO",
+    CLASSE: "CLASSE",
+    COLON: "COLON",
+    COMMA: "COMMA",
+    CONTINUA: "CONTINUA",
+    DOT: "DOT",
+    E: "E",
+    EM: "EM",
+    ENQUANTO: "ENQUANTO",
+    EOF: "EOF",
+    EQUAL: "EQUAL",
+    EQUAL_EQUAL: "EQUAL_EQUAL",
+    ESCOLHA: "ESCOLHA",
+    ESCREVA: "ESCREVA",
+    FALSO: "FALSO",
+    FAZER: "FAZER",
+    FINALMENTE: "FINALMENTE",
+    FUNCAO: "FUNCAO",
+    GREATER: "GREATER",
+    GREATER_EQUAL: "GREATER_EQUAL",
+    GREATER_GREATER: "GREATER_GREATER",
+    HERDA: "HERDA",
+    IDENTIFIER: "IDENTIFIER",
+    IMPORTAR: "IMPORTAR",
+    ISTO: "ISTO",
+    LEFT_BRACE: "LEFT_BRACE",
+    LEFT_PAREN: "LEFT_PAREN",
+    LEFT_SQUARE_BRACKET: "LEFT_SQUARE_BRACKET",
+    LESS: "LESS",
+    LESS_EQUAL: "LESS_EQUAL",
+    LESSER_LESSER: "LESSER_LESSER",
+    MAIS_IGUAL: "MAIS_IGUAL",
+    MENOR_IGUAL: "MENOR_IGUAL",
+    MINUS: "MINUS",
+    MODULUS: "MODULUS",
+    NULO: "NULO",
+    NUMBER: "NUMBER",
+    OU: "OU",
+    PADRAO: "PADRAO",
+    PARA: "PARA",
+    PAUSA: "PAUSA",
+    PEGUE: "PEGUE",
+    PLUS: "PLUS",
+    RETORNA: "RETORNA",
+    RIGHT_PAREN: "RIGHT_PAREN",
+    RIGHT_BRACE: "RIGHT_BRACE",
+    RIGHT_SQUARE_BRACKET: "RIGHT_SQUARE_BRACKET",
+    SEMICOLON: "SEMICOLON",
+    SLASH: "SLASH",
+    STAR: "STAR",
+    STAR_STAR: "STAR_STAR",
+    STRING: "STRING",
+    SE: "SE",
+    SENAO: "SENAO",
+    SENAOSE: "SENAOSE",
+    SUPER: "SUPER",
+    TENTE: "TENTE",    
+    VAR: "VAR",
+    VERDADEIRO: "VERDADEIRO"
+};

package/src/web.js

@@ -0,0 +1,70 @@
+const Lexer = require("./lexer.js");
+const Parser = require("./parser.js");
+const Resolver = require("./resolver.js");
+const Interpreter = require("./interpreter.js");
+const tokenTypes = require("./tokenTypes.js");
+
+module.exports.Egua = class Egua {
+  constructor(filename) {
+    this.filename = filename;
+
+    this.hadError = false;
+    this.hadRuntimeError = false;
+  }
+
+  runBlock(code) {
+    const interpreter = new Interpreter(this, process.cwd());
+
+    const lexer = new Lexer(code, this);
+    const tokens = lexer.scan();
+
+    if (this.hadError === true) return;
+
+    const parser = new Parser(tokens, this);
+    const statements = parser.parse();
+
+    if (this.hadError === true) return;
+
+    const resolver = new Resolver(interpreter, this);
+    resolver.resolve(statements);
+
+    if (this.hadError === true) return;
+
+    interpreter.interpret(statements);
+  }
+
+  report(line, where, message) {
+    if (this.filename)
+      console.error(
+        `[Arquivo: ${this.filename}] [Linha: ${line}] Erro${where}: ${message}`
+      );
+    else console.error(`[Linha: ${line}] Erro${where}: ${message}`);
+    this.hadError = true;
+  }
+
+  error(token, errorMessage) {
+    if (token.type === tokenTypes.EOF) {
+      this.report(token.line, " no fim", errorMessage);
+    } else {
+      this.report(token.line, ` no '${token.lexeme}'`, errorMessage);
+    }
+  }
+
+  lexerError(line, char, msg) {
+    this.report(line, ` no '${char}'`, msg);
+  }
+
+  runtimeError(error) {
+    let line = error.token.line;
+    if (error.token && line) {
+      if (this.filename)
+        console.error(
+          `Erro: [Arquivo: ${this.filename}] [Linha: ${error.token.line}] ${error.message}`
+        );
+      else console.error(`Erro: [Linha: ${error.token.line}] ${error.message}`);
+    } else {
+      console.error(error);
+    }
+    this.hadRuntimeError = true;
+  }
+};