@designliquido/delegua - npm Package Compare versions

Comparing version 0.26.1 to 0.26.2

bin/package.json

 {
     "name": "@designliquido/delegua",
-    "version": "0.26.0",
+    "version": "0.26.1",
     "description": "Linguagem de programação simples e moderna usando português estruturado, com suporte a múltiplos dialetos",
@@ -5,0 +5,0 @@ "main": "index.js",

fontes/analisador-semantico/analisador-semantico.d.ts

@@ -34,2 +34,3 @@ import { Atribuir, Chamada, ExpressaoRegular, FimPara, FormatacaoEscrita, Literal, Super, TipoDe } from '../construtos';
     visitarExpressaoTipoDe(expressao: TipoDe): Promise<any>;
+    private verificarTipoDe;
     visitarExpressaoFalhar(expressao: any): Promise<any>;
@@ -56,2 +57,11 @@ visitarExpressaoLiteral(expressao: Literal): Promise<any>;
     visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<void>;
+    private verificarCondicao;
+    private verificarVariavelBinaria;
+    private verificarVariavel;
+    private verificarBinario;
+    private verificarOperadorBinario;
+    private verificarLadoBinario;
+    private verificarLogico;
+    private verificarChamada;
+    private verificarLadoLogico;
     visitarDeclaracaoImportar(declaracao: Importar): Promise<void>;
@@ -58,0 +68,0 @@ visitarDeclaracaoEscreva(declaracao: Escreva): Promise<void>;

fontes/analisador-semantico/analisador-semantico.js

@@ -69,2 +69,15 @@ "use strict";
     visitarExpressaoTipoDe(expressao) {
+        return this.verificarTipoDe(expressao.valor);
+    }
+    verificarTipoDe(valor) {
+        if (valor instanceof construtos_1.Binario) {
+            this.verificarTipoDe(valor.direita);
+            this.verificarTipoDe(valor.esquerda);
+        }
+        if (valor instanceof construtos_1.Agrupamento) {
+            return this.verificarTipoDe(valor.expressao);
+        }
+        if (valor instanceof construtos_1.Variavel) {
+            return this.verificarVariavel(valor);
+        }
         return Promise.resolve();
@@ -225,14 +238,90 @@ }
     visitarDeclaracaoEnquanto(declaracao) {
-        if (declaracao.condicao instanceof construtos_1.Variavel) {
-            const variavel = declaracao.condicao;
-            const valor = this.variaveis[variavel.simbolo.lexema];
-            if (!valor) {
-                this.erro(declaracao.condicao.simbolo, `Variável ${declaracao.condicao.simbolo.lexema} ainda não foi declarada até este ponto.`);
+        return this.verificarCondicao(declaracao.condicao);
+    }
+    verificarCondicao(condicao) {
+        if (condicao instanceof construtos_1.Agrupamento) {
+            return this.verificarCondicao(condicao.expressao);
+        }
+        if (condicao instanceof construtos_1.Variavel) {
+            return this.verificarVariavelBinaria(condicao);
+        }
+        if (condicao instanceof construtos_1.Binario) {
+            return this.verificarBinario(condicao);
+        }
+        if (condicao instanceof construtos_1.Logico) {
+            return this.verificarLogico(condicao);
+        }
+        if (condicao instanceof construtos_1.Chamada) {
+            return this.verificarChamada(condicao);
+        }
+        return Promise.resolve();
+    }
+    verificarVariavelBinaria(variavel) {
+        this.verificarVariavel(variavel);
+        const variavelHipotetica = this.variaveis[variavel.simbolo.lexema];
+        if (variavelHipotetica && !(variavelHipotetica.valor instanceof construtos_1.Binario) && (typeof variavelHipotetica.valor !== 'boolean')) {
+            this.erro(variavel.simbolo, `Esperado tipo 'lógico' na condição do 'enquanto'.`);
+        }
+        return Promise.resolve();
+    }
+    verificarVariavel(variavel) {
+        const variavelHipotetica = this.variaveis[variavel.simbolo.lexema];
+        if (!variavelHipotetica) {
+            this.erro(variavel.simbolo, `Variável ${variavel.simbolo.lexema} ainda não foi declarada até este ponto.`);
+        }
+        return Promise.resolve();
+    }
+    verificarBinario(binario) {
+        this.verificarLadoBinario(binario.direita);
+        this.verificarLadoBinario(binario.esquerda);
+        this.verificarOperadorBinario(binario);
+        return Promise.resolve();
+    }
+    verificarOperadorBinario(binario) {
+        var _a, _b, _c;
+        const operadoresMatematicos = ['ADICAO', 'SUBTRACAO', 'MULTIPLICACAO', 'DIVISAO', 'MODULO'];
+        if (operadoresMatematicos.includes(binario.operador.tipo)) {
+            if (binario.direita instanceof construtos_1.Variavel && binario.esquerda instanceof construtos_1.Variavel) {
+                const tipoDireita = typeof ((_a = this.variaveis[binario.direita.simbolo.lexema]) === null || _a === void 0 ? void 0 : _a.valor);
+                const tipoEsquerda = typeof ((_b = this.variaveis[binario.esquerda.simbolo.lexema]) === null || _b === void 0 ? void 0 : _b.valor);
+                if (tipoDireita !== tipoEsquerda) {
+                    this.erro(binario.operador, `Operação inválida, tipos diferentes.`);
+                }
             }
-            else if (typeof (valor.valor) !== 'boolean') {
-                this.erro(declaracao.condicao.simbolo, `Esperado tipo 'lógico' na condição do 'enquanto'.`);
+        }
+        if (binario.operador.tipo === 'DIVISAO') {
+            if (((_c = this.variaveis[binario.direita.simbolo.lexema]) === null || _c === void 0 ? void 0 : _c.valor) === 0) {
+                this.erro(binario.operador, `Divisão por zero.`);
             }
         }
+    }
+    verificarLadoBinario(lado) {
+        if (lado instanceof construtos_1.Variavel && !this.variaveis[lado.simbolo.lexema]) {
+            this.erro(lado.simbolo, `Variável ${lado.simbolo.lexema} ainda não foi declarada até este ponto.`);
+            return;
+        }
+        if (lado instanceof construtos_1.Binario) {
+            this.verificarBinario(lado);
+            return;
+        }
+        return;
+    }
+    verificarLogico(logio) {
+        this.verificarLadoLogico(logio.direita);
+        this.verificarLadoLogico(logio.esquerda);
         return Promise.resolve();
     }
+    verificarChamada(chamada) {
+        let funcaoChamada = chamada.entidadeChamada;
+        if (!this.funcoes[funcaoChamada.simbolo.lexema]) {
+            this.erro(funcaoChamada.simbolo, `Chamada da função '${funcaoChamada.simbolo.lexema}' não existe.`);
+            return Promise.resolve();
+        }
+    }
+    verificarLadoLogico(lado) {
+        if (lado instanceof construtos_1.Variavel) {
+            let variavel = lado;
+            this.verificarVariavelBinaria(variavel);
+        }
+    }
     visitarDeclaracaoImportar(declaracao) {
@@ -289,3 +378,3 @@ return Promise.resolve();
             tipo: declaracao.tipo,
-            valor: declaracao.inicializador.valor || declaracao.inicializador
+            valor: declaracao.inicializador !== null ? declaracao.inicializador.valor !== undefined ? declaracao.inicializador.valor : declaracao.inicializador : undefined
         };
@@ -292,0 +381,0 @@ return Promise.resolve();

fontes/interpretador/interpretador-base.js

@@ -79,3 +79,4 @@ "use strict";
             tipoDe instanceof construtos_1.Unario ||
-            tipoDe instanceof construtos_1.Variavel) {
+            tipoDe instanceof construtos_1.Variavel ||
+            tipoDe instanceof construtos_1.Agrupamento) {
             tipoDe = await this.avaliar(tipoDe);
@@ -82,0 +83,0 @@ return tipoDe.tipo || (0, inferenciador_1.inferirTipoVariavel)(tipoDe);

package.json

 {
     "name": "@designliquido/delegua",
-    "version": "0.26.1",
+    "version": "0.26.2",
     "description": "Linguagem de programação simples e moderna usando português estruturado, com suporte a múltiplos dialetos",
@@ -5,0 +5,0 @@ "main": "index.js",

No alert changes

Improved metrics

Total package byte prevSize

3061755

increased by0.25%

Lines of code

45321

increased by0.22%

No dependency changes