@designliquido/delegua 0.0.1

package/.vscode/launch.json

@@ -0,0 +1,29 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "REPL",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "console": "integratedTerminal",
+            "program": "${workspaceFolder}\\index.js"
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Testes",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "args": ["${workspaceFolder}\\tests\\tests.egua"],
+            "console": "integratedTerminal",
+            "program": "${workspaceFolder}\\index.js"
+        }
+    ]
+}

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "liveServer.settings.port": 5501
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Linguagem Egua
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,59 @@
+<br>
+<p align="center">
+  <img src="./web/assets/egua.png" alt="egua" width="auto" height="80px">
+
+  <h3 align="center">Linguagem Delégua</h3>
+
+  <p align="center">
+    Linguagem de programação, derivada da linguagem Égua
+    <br />
+    <a href="https://egua.tech/docs/egua" target="_blank"><strong>Documentação da Linguagem Égua »</strong></a>
+    <br />
+    <br />
+    <a href="https://egua.tech/egua/" target="_blank">IDEgua (Ambiente de Desenvolvimento Integrado da Linguagem Égua)</a>
+    ·
+  </p>
+</p>
+
+## Introdução
+
+Delégua é uma variação da linguagem Égua, usada para fins educacionais e comerciais pela Design Líquido.
+
+Por ora, Delégua tem retrocompatibilidade com a linguagem Égua. Em outras palavras, todo programa escrito em Égua funciona em Delégua, mas Delégua tem capacidades a mais, conforme mencionado em documentação.
+
+## Características
+
+- **Simples e Completa.** Podendo ser usadas por pessoas com ou sem experiência em programação.
+- **Totalmente em Português.** Desenvolvida totalmente em português para quebrar a barreira do inglês.
+- **Grátis.** Sem planos, sem limitações e sem propaganda.
+- **Código aberto (open-source).** Todo código fonte disponível para estudar, modificar e contribuir.
+- **Constantes Atualizações.** Junto à nossa comunidade, para trazermos melhorias e inovações.
+- **Linguagem Científica.** Apoiamos e encorajamos o desenvolvimento e aprimoramento da ciência e da educação.
+
+### Usando como LAIR (Leia-Avalie-Imprima-Repita) em console
+
+[Você deve ter o Node.js instalado em seu ambiente](https://dicasdejavascript.com.br/instalacao-do-nodejs-e-npm-no-windows-passo-a-passo). 
+
+Com o Node.js instalado, execute o seguinte comando em um prompt de comando (Terminal, PowerShell ou `cmd` no Windows, Terminal ou `bash` em Mac e Linux):
+
+```
+npm install -g @designliquido/delegua
+```
+
+Feito isso, execute o seguinte comando:
+
+```
+delegua
+```
+
+Você terá um interpretador Egua que avalia expressões linha a linha. 
+
+Para finalizar a execução do interpretador LAIR Delégua, use o atalho <key>Ctrl</key> + <key>C</key> (todos os sistemas operacionais).
+
+## Documentação
+
+- Para acessar nossa documentação, visite o [site de documentação](https://egua.tech/docs).
+
+## Contruibuições
+
+* Para contribuições, por favor, leia o nosso [Guia de Contribuição](.github/CONTRIBUTING.md) antes de submeter uma Pull Request.

package/babel.config.js

@@ -0,0 +1 @@
+module.exports = {presets: ['@babel/preset-env']}

package/bin/delegua

@@ -0,0 +1,3 @@
+#! /usr/bin/env node
+
+require('../index.js');

package/index.html

@@ -0,0 +1,43 @@
+<html lang="pt-br">
+
+<head>
+  <!-- Global site tag (gtag.js) - Google Analytics -->
+  <script async src="https://www.googletagmanager.com/gtag/js?id=UA-147268561-3"></script>
+  <script>
+    window.dataLayer = window.dataLayer || [];
+    function gtag() { dataLayer.push(arguments); }
+    gtag('js', new Date());
+
+    gtag('config', 'UA-147268561-3');
+  </script>
+
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
+  <meta charset="UTF-8">
+
+  <title>IDEgua - Linguagem egua</title>
+  <link rel="stylesheet" href="./web/style.css" />
+  <link rel="stylesheet" href="./web/theme.css">
+  <link href="https://fonts.googleapis.com/css?family=Roboto+Mono&display=swap" rel="stylesheet" />
+  <link rel="shortcut icon" href="./web/assets/logo2.svg">
+</head>
+
+<body>
+  <div id="container">
+    <div id="left"><select id="demoSelector"></select></div>
+    <div id="middle"><img src="web/assets/egua.png" alt="egua" width="100px" height="auto"></div>
+    <div id="right"><button id="runBtn">Executar</button></div>
+  </div>
+
+  <div id="editor"></div>
+  <div id="output" aria-live="polite"></div>
+
+  <script src="web/dist.js"></script>
+
+  <!-- framework do editor do código -->
+  <script src="./web/codeflask.min.js"></script>
+
+  <script src="web/demos.js"></script>
+  <script src="web/index.js"></script>
+</body>
+
+</html>

package/index.js

@@ -0,0 +1,14 @@
+const Egua = require("./src/egua.js").Egua;
+
+const main = function() {
+    let args = process.argv;
+
+    const egua = new Egua();
+    if (args.length === 2) {
+        egua.runPrompt();
+    } else {
+        egua.runfile(args[2]);
+    }
+};
+
+main();

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@designliquido/delegua",
+  "version": "0.0.1",
+  "description": "Linguagem de programação simples e moderna usando português",
+  "main": "index.js",
+  "scripts": {
+    "npm-publish": "npm publish --access public",
+    "testes": "./bin/delegua testes/testes.egua",
+    "testes-unitarios": "jest",
+    "production": "npm run npm-publish"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DesignLiquido/delegua.git"
+  },
+  "bin": {
+    "delegua": "./bin/delegua"
+  },
+  "keywords": [
+    "egua",
+    "delegua"
+  ],
+  "author": "Leonel Sanches da Silva",
+  "contributors": [
+    "Leonel Sanches da Silva <leonel@designliquido.com.br> (https://www.linkedin.com/in/leonelsanchesdasilva/)"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/DesignLiquido/delegua/issues"
+  },
+  "homepage": "https://github.com/DesignLiquido/delegua#readme",
+  "devDependencies": {
+    "@babel/preset-env": "^7.12.1",
+    "jest": "^26.6.1"
+  },
+  "dependencies": {}
+}

package/src/egua.js

@@ -0,0 +1,102 @@
+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");
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+
+module.exports.Egua = class Egua {
+    constructor(nomeArquivo) {
+        this.nomeArquivo = nomeArquivo;
+
+        this.teveErro = false;
+        this.teveErroEmTempoDeExecucao = false;
+    }
+
+    runPrompt() {
+        const interpreter = new Interpreter(this, process.cwd(), undefined);
+        console.log("Console da Linguagem Delégua v1.1.15");
+        const leiaLinha = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: "\negua> "
+        });
+
+        leiaLinha.prompt();
+
+        leiaLinha.on("line", linha => {
+            this.teveErro = false;
+            this.teveErroEmTempoDeExecucao = false;
+
+            this.run(linha, interpreter);
+            leiaLinha.prompt();
+        });
+    }
+
+    runfile(nomeArquivo) {
+        this.nomeArquivo = path.basename(nomeArquivo);
+        const interpretador = new Interpreter(this, process.cwd());
+
+        const dadosDoArquivo = fs.readFileSync(nomeArquivo).toString();
+        this.run(dadosDoArquivo, interpretador);
+
+        if (this.teveErro) process.exit(65);
+        if (this.teveErroEmTempoDeExecucao) process.exit(70);
+    }
+
+    run(code, interpretador) {
+        const lexer = new Lexer(code, this);
+        const simbolos = lexer.scan();
+
+        if (this.teveErro === true) return;
+
+        const analisar = new Parser(simbolos, this);
+        const declaracoes = analisar.analisar();
+
+        if (this.teveErro === true) return;
+
+        const resolver = new Resolver(interpretador, this);
+        resolver.resolver(declaracoes);
+
+        if (this.teveErro === true) return;
+
+        interpretador.interpretar(declaracoes);
+    }
+
+    reportar(linha, onde, mensagem) {
+        if (this.nomeArquivo)
+            console.error(
+                `[Arquivo: ${this.nomeArquivo}] [Linha: ${linha}] Erro${onde}: ${mensagem}`
+            );
+        else console.error(`[Linha: ${linha}] Erro${onde}: ${mensagem}`);
+        this.teveErro = true;
+    }
+
+    error(simbolo, mensagemDeErro) {
+        if (simbolo.type === tokenTypes.EOF) {
+            this.reportar(simbolo.line, " no final", mensagemDeErro);
+        } else {
+            this.reportar(simbolo.line, ` no '${simbolo.lexeme}'`, mensagemDeErro);
+        }
+    }
+
+    lexerError(linha, caractere, mensagem) {
+        this.reportar(linha, ` no '${caractere}'`, mensagem);
+    }
+
+    runtimeError(erro) {
+        const linha = erro.token.line;
+        if (erro.token && linha) {
+            if (this.nomeArquivo)
+                console.error(
+                    `Erro: [Arquivo: ${this.nomeArquivo}] [Linha: ${erro.token.line}] ${erro.message}`
+                );
+            else console.error(`Erro: [Linha: ${erro.token.line}] ${erro.message}`);
+        } else {
+            console.error(`Erro: ${erro.message}`);
+        }
+        this.teveErroEmTempoDeExecucao = true;
+    }
+};

package/src/environment.js

@@ -0,0 +1,53 @@
+const RuntimeError = require("./errors.js").RuntimeError;
+
+module.exports = class Environment {
+    constructor(enclosing) {
+        this.enclosing = enclosing || null;
+        this.values = {};
+    }
+
+    defineVar(varName, value) {
+        this.values[varName] = value;
+    }
+
+    assignVarAt(distance, name, value) {
+        this.ancestor(distance).values[name.lexeme] = value;
+    }
+
+    assignVar(name, value) {
+        if (this.values[name.lexeme] !== undefined) {
+            this.values[name.lexeme] = value;
+            return;
+        }
+
+        if (this.enclosing != null) {
+            this.enclosing.assignVar(name, value);
+            return;
+        }
+
+        throw new RuntimeError(name, "Variável não definida '" + name.lexeme + "'.");
+    }
+
+    ancestor(distance) {
+        let environment = this;
+        for (let i = 0; i < distance; i++) {
+            environment = environment.enclosing;
+        }
+
+        return environment;
+    }
+
+    getVarAt(distance, name) {
+        return this.ancestor(distance).values[name];
+    }
+
+    getVar(token) {
+        if (this.values[token.lexeme] !== undefined) {
+            return this.values[token.lexeme];
+        }
+
+        if (this.enclosing !== null) return this.enclosing.getVar(token);
+
+        throw new RuntimeError(token, "Variável não definida '" + token.lexeme + "'.");
+    }
+};

package/src/errors.js

@@ -0,0 +1,17 @@
+module.exports.RuntimeError = class RuntimeError extends Error {
+  constructor(token, message) {
+    super(message);
+    this.token = token;
+  }
+};
+
+module.exports.ContinueException = class ContinueException extends Error { };
+
+module.exports.BreakException = class BreakException extends Error { };
+
+module.exports.ReturnException = class ReturnException extends Error {
+  constructor(value) {
+    super(value);
+    this.value = value;
+  }
+};

package/src/expr.js

@@ -0,0 +1,228 @@
+class Expr {
+    aceitar(visitor) {}
+}
+
+class Assign extends Expr {
+    constructor(name, value) {
+        super();
+        this.name = name;
+        this.value = value;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitAssignExpr(this);
+    }
+}
+
+class Binary extends Expr {
+    constructor(left, operator, right) {
+        super();
+        this.left = left;
+        this.operator = operator;
+        this.right = right;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitBinaryExpr(this);
+    }
+}
+
+class Funcao extends Expr {
+    constructor(params, body) {
+        super();
+        this.params = params;
+        this.body = body;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitFunctionExpr(this);
+    }
+}
+
+class Call extends Expr {
+    constructor(callee, paren, args) {
+        super();
+        this.callee = callee;
+        this.paren = paren;
+        this.args = args;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitCallExpr(this);
+    }
+}
+
+class Get extends Expr {
+    constructor(object, name) {
+        super();
+        this.object = object;
+        this.name = name;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitGetExpr(this);
+    }
+}
+
+class Grouping extends Expr {
+    constructor(expression) {
+        super();
+        this.expression = expression;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitGroupingExpr(this);
+    }
+}
+
+class Literal extends Expr {
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitLiteralExpr(this);
+    }
+}
+
+class Array extends Expr {
+    constructor(values) {
+        super();
+        this.values = values;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitArrayExpr(this);
+    }
+}
+
+class Dictionary extends Expr {
+    constructor(keys, values) {
+        super();
+        this.keys = keys;
+        this.values = values;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitDictionaryExpr(this);
+    }
+}
+
+class Subscript extends Expr {
+    constructor(callee, index, closeBracket) {
+        super();
+        this.callee = callee;
+        this.index = index;
+        this.closeBracket = closeBracket;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitSubscriptExpr(this);
+    }
+}
+
+class Assignsubscript extends Expr {
+    constructor(obj, index, value) {
+        super();
+        this.obj = obj;
+        this.index = index;
+        this.value = value;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitAssignsubscriptExpr(this);
+    }
+}
+
+class Logical extends Expr {
+    constructor(left, operator, right) {
+        super();
+        this.left = left;
+        this.operator = operator;
+        this.right = right;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitLogicalExpr(this);
+    }
+}
+
+class Set extends Expr {
+    constructor(object, name, value) {
+        super();
+        this.object = object;
+        this.name = name;
+        this.value = value;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitSetExpr(this);
+    }
+}
+
+class Super extends Expr {
+    constructor(keyword, method) {
+        super();
+        this.keyword = keyword;
+        this.method = method;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitSuperExpr(this);
+    }
+}
+
+class Isto extends Expr {
+    constructor(keyword) {
+        super();
+        this.keyword = keyword;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitThisExpr(this);
+    }
+}
+
+class Unary extends Expr {
+    constructor(operator, right) {
+        super();
+        this.operator = operator;
+        this.right = right;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitUnaryExpr(this);
+    }
+}
+
+class Variable extends Expr {
+    constructor(name) {
+        super();
+        this.name = name;
+    }
+
+    aceitar(visitor) {
+        return visitor.visitVariableExpr(this);
+    }
+}
+
+module.exports = {
+    Assign,
+    Binary,
+    Funcao,
+    Call,
+    Get,
+    Grouping,
+    Literal,
+    Array,
+    Dictionary,
+    Subscript,
+    Assignsubscript,
+    Logical,
+    Set,
+    Super,
+    Isto,
+    Unary,
+    Variable
+};