diff --git a/.vscode/launch.json b/.vscode/launch.json index ba32e0aa..1f20cde2 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -5,791 +5,25 @@ "version": "0.2.0", "configurations": [ { - "name": "Potigol > Testes Interpretador", - "type": "node", - "request": "launch", - "runtimeArgs": [ - "--inspect-brk", - "${workspaceRoot}/node_modules/jest/bin/jest.js", - "potigol/interpretador.test.ts", - "--runInBand" - ], - "console": "integratedTerminal", - "internalConsoleOptions": "neverOpen" - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Bhaskara", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/dialetos/egua-classico/bhaskara.egua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "name": "Delegua > Testes Interpretador", - "type": "node", - "request": "launch", - "runtimeArgs": [ - "--inspect-brk", - "${workspaceRoot}/node_modules/jest/bin/jest.js", - "interpretador.test.ts", - "--runInBand" - ], - "console": "integratedTerminal", - "internalConsoleOptions": "neverOpen" - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Bloco Enquanto", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/estruturas-de-repeticao/enquanto.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Bloco Enquanto (com Continua)", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/estruturas-de-repeticao/enquanto-continua.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Bloco Fazer ... Enquanto", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/estruturas-de-repeticao/fazer-enquanto.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Bloco Fazer ... Enquanto (com Continua)", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/estruturas-de-repeticao/fazer-enquanto-continua.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Bloco Para", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/estruturas-de-repeticao/para.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Bloco Para (com Continua)", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/estruturas-de-repeticao/para-continua.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Bloco Se", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/condicionais/se.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Classes > Classe vazia", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/classes/classe-vazia.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Classes > Construtor", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/classes/construtor-classe.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Classes > Herança", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - // "--depurador", - "./exemplos/classes/heranca.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Escolha", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/condicionais/escolha.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Estruturas de Dados > Inteiros", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - // "--depurador", - "./exemplos/estruturas-de-dados/inteiros.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Estruturas de Repetição > Fazer ... Enquanto", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/estruturas-de-repeticao/fazer-enquanto.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Fibonacci", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/fibonacci.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Fila estática", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/fila-estatica.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > FizzBuzz", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/fizzbuzz.egua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Funções Anônimas", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - // "--depurador", - "./exemplos/funcoes/funcoes-anonimas.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Importação", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - // "--depurador", - "./exemplos/importacao/inicial.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Importação > Animais", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - // "--depurador", - "./exemplos/importacao/animais.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Inteiros", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - // "--depurador", - "./exemplos/estruturas-de-dados/inteiros.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Leia", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/leia.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Média", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/media.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Parâmetro -c", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--codigo", - "escreva(2+1)" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Perceptron", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/perceptron.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Primitivas > Texto > Minúsculo", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/primitivas/texto/minusculo.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Primitivas > Lista > Inclui", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/primitivas/lista/inclui.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Teste de Classe", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "./exemplos/classes/teste-classe.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Delégua > Todos os Testes de Égua", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "-p", - "./exemplos/testes.egua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "name": "Testes unitários", - "type": "node", - "request": "launch", - "runtimeArgs": [ - "--inspect-brk", - "${workspaceRoot}/node_modules/jest/bin/jest.js", - "--runInBand" - ], - "skipFiles": [ - "/**", - "node_modules/**" - ], - "console": "integratedTerminal", - "internalConsoleOptions": "neverOpen" - }, - { - "name": "Testes unitários - Delégua", - "type": "node", - "request": "launch", - "runtimeArgs": [ - "--inspect-brk", - "${workspaceRoot}/node_modules/jest/bin/jest.js", - "interpretador", - "--runInBand" - ], - "skipFiles": [ - "/**", - "node_modules/**" - ], - "console": "integratedTerminal", - "internalConsoleOptions": "neverOpen" - }, - { - "name": "Testes unitários - Mapler", - "type": "node", - "request": "launch", - "runtimeArgs": [ - "--inspect-brk", - "${workspaceRoot}/node_modules/jest/bin/jest.js", - "mapler", - "--runInBand" - ], - "skipFiles": [ - "/**", - "node_modules/**" - ], - "console": "integratedTerminal", - "internalConsoleOptions": "neverOpen" - }, - { - "name": "Testes unitários - Pituguês", - "type": "node", - "request": "launch", - "runtimeArgs": [ - "--inspect-brk", - "${workspaceRoot}/node_modules/jest/bin/jest.js", - "pitugues/interpretador", - "--runInBand" - ], - "skipFiles": [ - "/**", - "node_modules/**" - ], - "console": "integratedTerminal", - "internalConsoleOptions": "neverOpen" - }, - { - "name": "Testes unitários - Potigol", - "type": "node", - "request": "launch", - "runtimeArgs": [ - "--inspect-brk", - "${workspaceRoot}/node_modules/jest/bin/jest.js", - "potigol/avaliador-sintatico.test.ts", - "--runInBand" - ], - "skipFiles": [ - "/**", - "node_modules/**" - ], - "console": "integratedTerminal", - "internalConsoleOptions": "neverOpen" - }, - { - "name": "Testes unitários - Portugol IPT", - "type": "node", - "request": "launch", - "runtimeArgs": [ - "--inspect-brk", - "${workspaceRoot}/node_modules/jest/bin/jest.js", - "portugol-ipt/interpretador", - "--runInBand" - ], - "skipFiles": [ - "/**", - "node_modules/**" - ], - "console": "integratedTerminal", - "internalConsoleOptions": "neverOpen" - }, - { - "name": "Testes unitários - Tradutor Delégua para Javascript", - "type": "node", - "request": "launch", - "runtimeArgs": [ - "--inspect-brk", - "${workspaceRoot}/node_modules/jest/bin/jest.js", - "tradutor-javascript.test.ts", - "--runInBand" - ], - "skipFiles": [ - "/**", - "node_modules/**" - ], - "console": "integratedTerminal", - "internalConsoleOptions": "neverOpen" - }, - { - "name": "Testes unitários - Tradutor Javascript para Delégua", + "name": "Delegua > Testes Interpretador", "type": "node", "request": "launch", "runtimeArgs": [ "--inspect-brk", "${workspaceRoot}/node_modules/jest/bin/jest.js", - "tradutor-reverso-javascript.test.ts", + "interpretador.test.ts", "--runInBand" ], - "skipFiles": [ - "/**", - "node_modules/**" - ], "console": "integratedTerminal", "internalConsoleOptions": "neverOpen" }, { - "name": "Testes unitários - Tradutor Portugol IPT para Delégua", + "name": "Testes unitários", "type": "node", "request": "launch", "runtimeArgs": [ "--inspect-brk", "${workspaceRoot}/node_modules/jest/bin/jest.js", - "tradutor-portugol-ipt.test.ts", "--runInBand" ], "skipFiles": [ @@ -800,13 +34,13 @@ "internalConsoleOptions": "neverOpen" }, { - "name": "Testes unitários - Tradutor Visualg para Delégua", + "name": "Testes unitários - Delégua", "type": "node", "request": "launch", "runtimeArgs": [ "--inspect-brk", "${workspaceRoot}/node_modules/jest/bin/jest.js", - "tradutor-visualg.test.ts", + "interpretador", "--runInBand" ], "skipFiles": [ @@ -817,13 +51,13 @@ "internalConsoleOptions": "neverOpen" }, { - "name": "Testes unitários - Tradutor Delégua para Python", + "name": "Testes unitários - Mapler", "type": "node", "request": "launch", "runtimeArgs": [ "--inspect-brk", "${workspaceRoot}/node_modules/jest/bin/jest.js", - "tradutor-python.test.ts", + "mapler", "--runInBand" ], "skipFiles": [ @@ -834,13 +68,13 @@ "internalConsoleOptions": "neverOpen" }, { - "name": "Testes unitários - Tradutor Python para Delégua", + "name": "Testes unitários - Pituguês", "type": "node", "request": "launch", "runtimeArgs": [ "--inspect-brk", "${workspaceRoot}/node_modules/jest/bin/jest.js", - "tradutor-reverso-python.test.ts", + "pitugues/interpretador", "--runInBand" ], "skipFiles": [ @@ -851,553 +85,123 @@ "internalConsoleOptions": "neverOpen" }, { + "name": "Testes unitários - Portugol IPT", "type": "node", "request": "launch", - "name": "Todos os Testes de Delégua", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - // "--depurador", - "./exemplos/index.delegua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Égua Clássico > Bhaskara", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "egua", - "./exemplos/dialetos/egua-classico/bhaskara.egua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Egua Clássico > Bloco Para (com Continua)", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "egua", - "./exemplos/dialetos/egua-classico/estruturas-de-repeticao/para-continua.egua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Égua Clássico > Fibonacci", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "egua", - "./exemplos/dialetos/egua-classico/fibonacci.egua" - ], - "runtimeExecutable": "node", "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Égua Clássico > Classes > Construtor", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "egua", - "./exemplos/classes/construtor-classe.egua" + "--inspect-brk", + "${workspaceRoot}/node_modules/jest/bin/jest.js", + "portugol-ipt/interpretador", + "--runInBand" ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Égua Clássico > Merge Sort", "skipFiles": [ "/**", "node_modules/**" ], - "cwd": "${workspaceRoot}", "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "egua", - "./exemplos/dialetos/egua-classico/merge-sort.egua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] + "internalConsoleOptions": "neverOpen" }, { + "name": "Testes unitários - Tradutor Delégua para Javascript", "type": "node", "request": "launch", - "name": "Égua Clássico > Fila Estática", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "egua", - "./exemplos/dialetos/egua-classico/fila-estatica.egua" - ], - "runtimeExecutable": "node", "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Égua Clássico > Funções > Retorna sem valor", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "egua", - "./exemplos/dialetos/egua-classico/funcoes/retorna-sem-valor.egua" + "--inspect-brk", + "${workspaceRoot}/node_modules/jest/bin/jest.js", + "tradutor-javascript.test.ts", + "--runInBand" ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Égua Clássico > Biblioteca Matemática > Gerar pontos da abscissa", "skipFiles": [ "/**", "node_modules/**" ], - "cwd": "${workspaceRoot}", "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "egua", - "./exemplos/dialetos/egua-classico/bibliotecas/matematica/gerar-pontos-abscissa.egua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] + "internalConsoleOptions": "neverOpen" }, { + "name": "Testes unitários - Tradutor Javascript para Delégua", "type": "node", "request": "launch", - "name": "Égua Clássico > Perceptron", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "egua", - "./exemplos/dialetos/egua-classico/perceptron.egua" - ], - "runtimeExecutable": "node", "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Égua Clássico > REPL", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "egua" + "--inspect-brk", + "${workspaceRoot}/node_modules/jest/bin/jest.js", + "tradutor-reverso-javascript.test.ts", + "--runInBand" ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Égua Clássico > Todos os Testes de Égua", "skipFiles": [ "/**", "node_modules/**" ], - "cwd": "${workspaceRoot}", "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "egua", - "./exemplos/testes.egua" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] + "internalConsoleOptions": "neverOpen" }, { + "name": "Testes unitários - Tradutor Portugol IPT para Delégua", "type": "node", "request": "launch", - "name": "Égua Clássico > Teste de Classe", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "egua", - "./exemplos/dialetos/egua-classico/teste-classe.egua" - ], - "runtimeExecutable": "node", "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Pituguês > Bhaskara", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "pitugues", - "./exemplos/dialetos/pitugues/bhaskara.pitugues" + "--inspect-brk", + "${workspaceRoot}/node_modules/jest/bin/jest.js", + "tradutor-portugol-ipt.test.ts", + "--runInBand" ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Pituguês > Bloco Enquanto", "skipFiles": [ "/**", "node_modules/**" ], - "cwd": "${workspaceRoot}", "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "pitugues", - "./exemplos/dialetos/pitugues/estruturas-de-repeticao/enquanto.pitugues" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] + "internalConsoleOptions": "neverOpen" }, { + "name": "Testes unitários - Tradutor Visualg para Delégua", "type": "node", "request": "launch", - "name": "Pituguês > Bloco Escolha", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "pitugues", - "./exemplos/dialetos/pitugues/condicionais/escolha.pitugues" - ], - "runtimeExecutable": "node", "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Pituguês > Bloco Fazer ... Enquanto", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "pitugues", - "./exemplos/dialetos/pitugues/estruturas-de-repeticao/fazer-enquanto.pitugues" + "--inspect-brk", + "${workspaceRoot}/node_modules/jest/bin/jest.js", + "tradutor-visualg.test.ts", + "--runInBand" ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Pituguês > Bloco Para", "skipFiles": [ "/**", "node_modules/**" ], - "cwd": "${workspaceRoot}", "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "pitugues", - "./exemplos/dialetos/pitugues/estruturas-de-repeticao/para.pitugues" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] + "internalConsoleOptions": "neverOpen" }, { + "name": "Testes unitários - Tradutor Delégua para Python", "type": "node", "request": "launch", - "name": "Pituguês > Bloco Se", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "pitugues", - "./exemplos/dialetos/pitugues/condicionais/se.pitugues" - ], - "runtimeExecutable": "node", "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Pituguês > Classes", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "pitugues", - "./exemplos/dialetos/pitugues/classes/teste-classe.pitugues" + "--inspect-brk", + "${workspaceRoot}/node_modules/jest/bin/jest.js", + "tradutor-python.test.ts", + "--runInBand" ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Pituguês > Classes > Construtor", "skipFiles": [ "/**", "node_modules/**" ], - "cwd": "${workspaceRoot}", "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "pitugues", - "./exemplos/dialetos/pitugues/classes/construtor-classe.pitugues" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] + "internalConsoleOptions": "neverOpen" }, { + "name": "Testes unitários - Tradutor Python para Delégua", "type": "node", "request": "launch", - "name": "Pituguês > FizzBuzz", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "pitugues", - "./exemplos/dialetos/pitugues/fizzbuzz.pitugues" - ], - "runtimeExecutable": "node", "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Pituguês > Média", - "skipFiles": [ - "/**", - "node_modules/**" - ], - "cwd": "${workspaceRoot}", - "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "pitugues", - "./exemplos/dialetos/pitugues/media.pitugues" + "--inspect-brk", + "${workspaceRoot}/node_modules/jest/bin/jest.js", + "tradutor-reverso-python.test.ts", + "--runInBand" ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] - }, - { - "type": "node", - "request": "launch", - "name": "Pituguês > REPL", "skipFiles": [ "/**", "node_modules/**" ], - "cwd": "${workspaceRoot}", "console": "integratedTerminal", - "args": [ - "${workspaceFolder}${pathSeparator}execucao.ts", - "--dialeto", - "pitugues" - ], - "runtimeExecutable": "node", - "runtimeArgs": [ - "--nolazy", - "-r", - "ts-node/register/transpile-only" - ] + "internalConsoleOptions": "neverOpen" }, { "name": "Tradutor > Delégua para AssemblyScript", diff --git a/fontes/avaliador-sintatico/README.md b/fontes/avaliador-sintatico/README.md index c0b42b80..ea7f8651 100644 --- a/fontes/avaliador-sintatico/README.md +++ b/fontes/avaliador-sintatico/README.md @@ -14,6 +14,6 @@ Há dois grupos de estruturas de alto nível: Construtos e Declarações. ## Micro Avaliador Sintático -Há algumas situações em que a avaliação sintática de uma linguagem precisa ser feita num âmbito reduzido, como por exemplo em interpolações de texto (como no analisador sintático de Delégua), ou em verificação preguiçosa de parâmetros de funções (ver analisador sintático de Potigol para um exemplo). Por exemplo, não faz sentido em uma interpolação de texto termos uma declaração de classe, de tipo ou de função, mas faz sentido avaliarmos expressões. +Há algumas situações em que a avaliação sintática de uma linguagem precisa ser feita num âmbito reduzido, como por exemplo em interpolações de texto (como no analisador sintático de Delégua), ou em verificação preguiçosa de parâmetros de funções (ver [avaliador sintático de Potigol](https://github.com/DesignLiquido/potigol/tree/principal/fontes/avaliador-sintatico) para um exemplo). Por exemplo, não faz sentido em uma interpolação de texto termos uma declaração de classe, de tipo ou de função, mas faz sentido avaliarmos expressões. Micro avaliadores sintáticos cumprem essa função. Tendo a implementação da sintaxe da linguagem reduzida para alguns casos, não apenas o processamento é mais rápido como é também mais seguro, tendo a limitação de escopo como uma vantagem para detecção de erros. \ No newline at end of file diff --git a/fontes/avaliador-sintatico/dialetos/index.ts b/fontes/avaliador-sintatico/dialetos/index.ts index bfc60385..9814bda5 100644 --- a/fontes/avaliador-sintatico/dialetos/index.ts +++ b/fontes/avaliador-sintatico/dialetos/index.ts @@ -2,5 +2,3 @@ export * from './avaliador-sintatico-egua-classico'; export * from './avaliador-sintatico-pitugues'; export * from './avaliador-sintatico-mapler'; export * from './avaliador-sintatico-portugol-ipt'; - -export * from './potigol'; diff --git a/fontes/avaliador-sintatico/dialetos/potigol/README.md b/fontes/avaliador-sintatico/dialetos/potigol/README.md deleted file mode 100644 index c62d53f0..00000000 --- a/fontes/avaliador-sintatico/dialetos/potigol/README.md +++ /dev/null @@ -1,28 +0,0 @@ -# Avaliador Sintático para dialeto Potigol - -Aqui temos toda a implementação da avaliação sintática para Potigol separada em dois elementos: - -- `AvaliadorSintaticoPotigol`: O avaliador sintático em si; -- `MicroAvaliadorSintaticoPotigol`: O micro avaliador sintático, usado para inferência de parâmetros e pequenas operações de expressões. - -## Características de Potigol - -### Tipos e Objetos - -Cada tipo em Potigol implementa um construtor implícito: cada propriedade anotada com tipo e sem valor é entendida como parte do construtor. Por exemplo; - -``` -tipo Quadrado - lado: Inteiro - area() = lado * lado - perimetro() = 4 * lado -fim -``` - -`lado: Inteiro` irá gerar um construtor com um parâmetro inteiro: - -``` -q1 = Quadrado(10) -``` - -A ordem das propriedades é importante para a definição do construtor. \ No newline at end of file diff --git a/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts b/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts deleted file mode 100644 index 74551cac..00000000 --- a/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts +++ /dev/null @@ -1,1119 +0,0 @@ -import { - AcessoIndiceVariavel, - AcessoMetodoOuPropriedade, - Agrupamento, - Atribuir, - Binario, - Chamada, - Constante, - ConstanteOuVariavel, - Construto, - DefinirValor, - FimPara, - FuncaoConstruto, - Isto, - Literal, - QualTipo, - Unario, - Variavel, - Vetor, -} from '../../../construtos'; -import { - Escreva, - Declaracao, - Se, - Enquanto, - Para, - Escolha, - Fazer, - EscrevaMesmaLinha, - Const, - Var, - Bloco, - Expressao, - FuncaoDeclaracao, - Classe, - PropriedadeClasse, - Leia, - LeiaMultiplo, - ConstMultiplo, -} from '../../../declaracoes'; -import { RetornoLexador, RetornoAvaliadorSintatico } from '../../../interfaces/retornos'; -import { AvaliadorSintaticoBase } from '../../avaliador-sintatico-base'; - -import { ParametroInterface, SimboloInterface } from '../../../interfaces'; -import { TipoDadosElementar } from '../../../tipo-dados-elementar'; -import { Simbolo } from '../../../lexador'; -import { ErroAvaliadorSintatico } from '../../erro-avaliador-sintatico'; -import { RetornoDeclaracao } from '../../retornos'; - -import tiposDeSimbolos from '../../../tipos-de-simbolos/potigol'; -import { SeletorTuplas, Tupla } from '../../../construtos/tuplas'; -import { MicroAvaliadorSintaticoPotigol } from './micro-avaliador-sintatico-potigol'; - -/** - * TODO: Pensar numa forma de avaliar múltiplas constantes sem - * transformar o retorno de `primario()` em um vetor. - */ -export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase { - microAvaliadorSintatico: MicroAvaliadorSintaticoPotigol; - - tiposPotigolParaDelegua = { - Caractere: 'texto', - Inteiro: 'inteiro', - Logico: 'logico', - Lógico: 'lógico', - Real: 'numero', - Texto: 'texto', - undefined: undefined, - }; - - declaracoesAnteriores: { [identificador: string]: any[] }; - - /** - * Testa se o primeiro parâmetro na lista de símbolos - * pertence a uma declaração ou não. - * @param simbolos Os símbolos que fazem parte da lista de argumentos - * de uma chamada ou declaração de função. - * @returns `true` se parâmetros são de declaração. `false` caso contrário. - */ - protected testePrimeiroParametro(simbolos: SimboloInterface[]) { - let atual = 0; - - // Primeiro teste: literal ou identificador - if ( - [tiposDeSimbolos.INTEIRO, tiposDeSimbolos.LOGICO, tiposDeSimbolos.REAL, tiposDeSimbolos.TEXTO].includes( - simbolos[atual].tipo - ) - ) { - return false; - } - - // Segundo teste: vírgula imediatamente após identificador, - // ou simplesmente fim da lista de símbolos. - atual++; - if (atual === simbolos.length || simbolos[atual].tipo === tiposDeSimbolos.VIRGULA) { - return false; - } - - // Outros casos: dois-pontos após identificador, etc. - return true; - } - - /** - * Retorna uma declaração de função iniciada por igual, - * ou seja, com apenas uma instrução. - * @param simboloPrimario O símbolo que identifica a função (nome). - * @param parenteseEsquerdo O parêntese esquerdo, usado para fins de pragma. - * @param parametros A lista de parâmetros da função. - * @param tipoRetorno O tipo de retorno da função. - * @returns Um construto do tipo `FuncaoDeclaracao`. - */ - protected declaracaoFuncaoPotigolIniciadaPorIgual( - simboloPrimario: SimboloInterface, - parenteseEsquerdo: SimboloInterface, - parametros: ParametroInterface[], - tipoRetorno?: SimboloInterface - ): FuncaoDeclaracao { - const corpo = new FuncaoConstruto(simboloPrimario.hashArquivo, simboloPrimario.linha, parametros, [ - new Expressao(this.expressao()), - ]); - return new FuncaoDeclaracao(simboloPrimario, corpo, tipoRetorno); - } - - /** - * Retorna uma declaração de função terminada por fim, - * ou seja, com mais de uma instrução. - * @param simboloPrimario O símbolo que identifica a função (nome). - * @param parenteseEsquerdo O parêntese esquerdo, usado para fins de pragma. - * @param parametros A lista de parâmetros da função. - * @param tipoRetorno O tipo de retorno da função. - * @returns Um construto do tipo `FuncaoDeclaracao`. - */ - protected declaracaoFuncaoPotigolTerminadaPorFim( - simboloPrimario: SimboloInterface, - parenteseEsquerdo: SimboloInterface, - parametros: ParametroInterface[], - tipoRetorno?: SimboloInterface - ): FuncaoDeclaracao { - const corpo = this.corpoDaFuncao(simboloPrimario.lexema, parenteseEsquerdo, parametros); - return new FuncaoDeclaracao(simboloPrimario, corpo, tipoRetorno); - } - - corpoDaFuncao(nomeFuncao: string, simboloPragma?: SimboloInterface, parametros?: any[]): FuncaoConstruto { - // this.consumir(tiposDeSimbolos.IGUAL, `Esperado '=' antes do escopo da função ${nomeFuncao}.`); - - const corpo = this.blocoEscopo(); - - return new FuncaoConstruto(this.hashArquivo, Number(simboloPragma.linha), parametros, corpo); - } - - protected declaracaoDeFuncaoOuMetodo(construtoPrimario: ConstanteOuVariavel): FuncaoDeclaracao { - // O parêntese esquerdo é considerado o símbolo inicial para - // fins de pragma. - const parenteseEsquerdo = this.avancarEDevolverAnterior(); - - const simbolosEntreParenteses: SimboloInterface[] = []; - while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) { - simbolosEntreParenteses.push(this.avancarEDevolverAnterior()); - } - - const resolucaoParametros = this.logicaComumParametrosPotigol(simbolosEntreParenteses); - const parenteseDireito = this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após parâmetros."); - - // Pode haver uma dica do tipo de retorno ou não. - // Se houver, é uma declaração de função (verificado mais abaixo). - let tipoRetorno: SimboloInterface = undefined; - if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DOIS_PONTOS)) { - this.verificacaoTipo( - this.simbolos[this.atual], - 'Esperado tipo válido após dois-pontos como retorno de função.' - ); - tipoRetorno = this.simbolos[this.atual]; - } - - // Se houver símbolo de igual, seja após fechamento de parênteses, - // seja após a dica de retorno, é uma declaração de função. - if (this.simbolos[this.atual].tipo === tiposDeSimbolos.IGUAL) { - this.avancarEDevolverAnterior(); - this.declaracoesAnteriores[construtoPrimario.simbolo.lexema] = []; - return this.declaracaoFuncaoPotigolIniciadaPorIgual( - construtoPrimario.simbolo, - parenteseEsquerdo, - resolucaoParametros.parametros, - tipoRetorno - ); - } - - return this.declaracaoFuncaoPotigolTerminadaPorFim( - construtoPrimario.simbolo, - parenteseEsquerdo, - resolucaoParametros.parametros, - tipoRetorno - ); - } - - finalizarChamada(entidadeChamada: Construto): Construto { - // Parêntese esquerdo - // this.avancarEDevolverAnterior(); - - const simbolosEntreParenteses: SimboloInterface[] = []; - while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) { - simbolosEntreParenteses.push(this.avancarEDevolverAnterior()); - } - - const parenteseDireito = this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após parâmetros."); - - const argumentos = this.microAvaliadorSintatico.analisar( - { simbolos: simbolosEntreParenteses } as any, - entidadeChamada.linha - ); - - return new Chamada( - this.hashArquivo, - entidadeChamada, - parenteseDireito, - argumentos.declaracoes.filter((d) => d) - ); - } - - /** - * Verificação comum de tipos. - * Avança o símbolo se não houver erros. - * @param simbolo O símbolo sendo analisado. - * @param mensagemErro A mensagem de erro caso o símbolo atual não seja de tipo. - */ - protected verificacaoTipo(simbolo: SimboloInterface, mensagemErro: string) { - if ( - ![tiposDeSimbolos.INTEIRO, tiposDeSimbolos.LOGICO, tiposDeSimbolos.REAL, tiposDeSimbolos.TEXTO].includes( - simbolo.tipo - ) - ) { - throw this.erro(simbolo, mensagemErro); - } - } - - protected logicaComumParametrosPotigol(simbolos: SimboloInterface[]): { - parametros: ParametroInterface[]; - tipagemDefinida: boolean; - } { - const parametros: ParametroInterface[] = []; - let indice = 0; - let tipagemDefinida = false; - - while (indice < simbolos.length) { - if (parametros.length >= 255) { - this.erro(simbolos[indice], 'Não pode haver mais de 255 parâmetros'); - } - - const parametro: Partial = {}; - - // TODO: verificar se Potigol trabalha com número variável de parâmetros. - /* if (this.simbolos[this.atual].tipo === tiposDeSimbolos.MULTIPLICACAO) { - this.consumir(tiposDeSimbolos.MULTIPLICACAO, null); - parametro.abrangencia = 'multiplo'; - } else { - parametro.abrangencia = 'padrao'; - } */ - - parametro.abrangencia = 'padrao'; - if (simbolos[indice].tipo !== tiposDeSimbolos.IDENTIFICADOR) { - throw this.erro(simbolos[indice], 'Esperado nome do parâmetro.'); - } - - parametro.nome = simbolos[indice]; - indice++; - - if (simbolos[indice].tipo === tiposDeSimbolos.DOIS_PONTOS) { - // throw this.erro(simbolos[indice], 'Esperado dois-pontos após nome de argumento para função.'); - - indice++; - this.verificacaoTipo( - simbolos[indice], - 'Esperado tipo do argumento após dois-pontos, em definição de função.' - ); - - const tipoParametro = simbolos[indice]; - const resolucaoTipo = this.tiposPotigolParaDelegua[tipoParametro.lexema]; - parametro.tipoDado = { - nome: simbolos[indice - 2].lexema, - tipo: resolucaoTipo, - }; - tipagemDefinida = true; - } - - // TODO: Verificar se Potigol trabalha com valores padrão em argumentos. - /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) { - parametro.valorPadrao = this.primario(); - } */ - - parametros.push(parametro as ParametroInterface); - - // if (parametro.abrangencia === 'multiplo') break; - indice++; - if (indice < simbolos.length && simbolos[indice].tipo !== tiposDeSimbolos.VIRGULA) { - throw this.erro(simbolos[indice], 'Esperado vírgula entre parâmetros de função.'); - } - - indice++; - } - - return { - parametros, - tipagemDefinida, - }; - } - - primario(): Construto { - const simboloAtual = this.simbolos[this.atual]; - - switch (simboloAtual.tipo) { - case tiposDeSimbolos.PARENTESE_ESQUERDO: - this.avancarEDevolverAnterior(); - const expressao = this.expressao(); - switch (this.simbolos[this.atual].tipo) { - case tiposDeSimbolos.VIRGULA: - // Tupla - const argumentos = [expressao]; - while (this.simbolos[this.atual].tipo === tiposDeSimbolos.VIRGULA) { - this.avancarEDevolverAnterior(); - argumentos.push(this.expressao()); - } - - this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão."); - return new SeletorTuplas(...argumentos) as Tupla; - default: - this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão."); - return new Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao); - } - case tiposDeSimbolos.COLCHETE_ESQUERDO: - this.avancarEDevolverAnterior(); - let valores = []; - - if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) { - return new Vetor(this.hashArquivo, Number(simboloAtual.linha), []); - } - - while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) { - const valor = this.atribuir(); - valores.push(valor); - if (this.simbolos[this.atual].tipo !== tiposDeSimbolos.COLCHETE_DIREITO) { - this.consumir(tiposDeSimbolos.VIRGULA, 'Esperado vírgula antes da próxima expressão.'); - } - } - - return new Vetor(this.hashArquivo, Number(simboloAtual.linha), valores); - case tiposDeSimbolos.CARACTERE: - case tiposDeSimbolos.INTEIRO: - case tiposDeSimbolos.LOGICO: - case tiposDeSimbolos.REAL: - case tiposDeSimbolos.TEXTO: - const simboloLiteral: SimboloInterface = this.avancarEDevolverAnterior(); - return new Literal(this.hashArquivo, Number(simboloLiteral.linha), simboloLiteral.literal); - case tiposDeSimbolos.FALSO: - case tiposDeSimbolos.VERDADEIRO: - const simboloVerdadeiroFalso: SimboloInterface = this.avancarEDevolverAnterior(); - return new Literal( - this.hashArquivo, - Number(simboloVerdadeiroFalso.linha), - simboloVerdadeiroFalso.tipo === tiposDeSimbolos.VERDADEIRO - ); - case tiposDeSimbolos.LEIA_INTEIRO: - case tiposDeSimbolos.LEIA_REAL: - case tiposDeSimbolos.LEIA_TEXTO: - const simboloLeia: SimboloInterface = this.avancarEDevolverAnterior(); - return new Leia(simboloLeia, []); - case tiposDeSimbolos.LEIA_INTEIROS: - case tiposDeSimbolos.LEIA_REAIS: - case tiposDeSimbolos.LEIA_TEXTOS: - const simboloLeiaDefinido: SimboloInterface = this.avancarEDevolverAnterior(); - this.consumir( - tiposDeSimbolos.PARENTESE_ESQUERDO, - `Esperado parêntese esquerdo após ${simboloLeiaDefinido.lexema}.` - ); - - const argumento = this.expressao(); - - this.consumir( - tiposDeSimbolos.PARENTESE_DIREITO, - `Esperado parêntese direito após número de parâmetros em chamada de ${simboloLeiaDefinido.lexema}.` - ); - - const leiaDefinido = new LeiaMultiplo(simboloLeiaDefinido, argumento); - - return leiaDefinido; - default: - const simboloIdentificador: SimboloInterface = this.avancarEDevolverAnterior(); - return new ConstanteOuVariavel(this.hashArquivo, simboloIdentificador); - } - } - - /** - * Em Potigol, só é possível determinar a diferença entre uma chamada e uma - * declaração de função depois dos argumentos. - * - * Chamadas não aceitam dicas de tipos de parâmetros. - * @returns Um construto do tipo `AcessoMetodo`, `AcessoIndiceVariavel` ou `Constante`, - * dependendo dos símbolos encontrados. - */ - chamar(): Construto { - let expressao = this.primario(); - - while (true) { - if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO)) { - if (expressao instanceof ConstanteOuVariavel) { - expressao = new Constante(expressao.hashArquivo, expressao.simbolo); - } - expressao = this.finalizarChamada(expressao); - } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO)) { - if (this.verificarTipoSimboloAtual(tiposDeSimbolos.QUAL_TIPO)) { - const identificador = this.simbolos[this.atual - 2]; - const simbolo = this.simbolos[this.atual]; - const valor = expressao ? expressao : identificador.lexema; - this.avancarEDevolverAnterior(); - return new QualTipo(this.hashArquivo, simbolo, valor); - } else { - const nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, "Esperado nome do método após '.'."); - const variavelMetodo = new Variavel(expressao.hashArquivo, (expressao as any).simbolo); - expressao = new AcessoMetodoOuPropriedade(this.hashArquivo, variavelMetodo, nome); - } - } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) { - const indice = this.expressao(); - const simboloFechamento = this.consumir( - tiposDeSimbolos.COLCHETE_DIREITO, - "Esperado ']' após escrita do indice." - ); - const variavelVetor = new Variavel(expressao.hashArquivo, (expressao as any).simbolo); - expressao = new AcessoIndiceVariavel(this.hashArquivo, variavelVetor, indice, simboloFechamento); - } else { - if (expressao instanceof ConstanteOuVariavel) { - expressao = new Constante(expressao.hashArquivo, (expressao as any).simbolo); - } - - break; - } - } - - return expressao; - } - - comparacaoIgualdade(): Construto { - let expressao = this.comparar(); - - while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DIFERENTE, tiposDeSimbolos.IGUAL_IGUAL)) { - const operador = this.simbolos[this.atual - 1]; - const direito = this.comparar(); - expressao = new Binario(this.hashArquivo, expressao, operador, direito); - } - - return expressao; - } - - declaracaoEscreva(): Escreva { - const simboloAtual = this.avancarEDevolverAnterior(); - - const argumentos: Construto[] = []; - - this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO); - - do { - argumentos.push(this.ou()); - } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA)); - - this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_DIREITO); - - return new Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos); - } - - declaracaoImprima(): EscrevaMesmaLinha { - const simboloAtual = this.avancarEDevolverAnterior(); - - const argumentos: Construto[] = []; - - do { - argumentos.push(this.expressao()); - } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA)); - - return new EscrevaMesmaLinha(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos); - } - - /** - * Blocos de escopo em Potigol existem quando: - * - * - Em uma declaração de função ou método, após fecha parênteses, o próximo - * símbolo obrigatório não é `=` e há pelo menos um `fim` até o final do código; - * - Em uma declaração `se`; - * - Em uma declaração `enquanto`; - * - Em uma declaração `para`. - * @returns Um vetor de `Declaracao`. - */ - blocoEscopo(): Array { - let declaracoes: Array = []; - - while (!this.estaNoFinal() && !this.verificarTipoSimboloAtual(tiposDeSimbolos.FIM)) { - const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco(); - if (Array.isArray(retornoDeclaracao)) { - declaracoes = declaracoes.concat(retornoDeclaracao); - } else { - declaracoes.push(retornoDeclaracao as Declaracao); - } - } - - return declaracoes; - } - - declaracaoSe(): Se { - const simboloSe: SimboloInterface = this.avancarEDevolverAnterior(); - - const condicao = this.expressao(); - - this.consumir(tiposDeSimbolos.ENTAO, "Esperado palavra reservada 'entao' após condição em declaração 'se'."); - - const declaracoes = []; - do { - declaracoes.push(this.resolverDeclaracaoForaDeBloco()); - } while (![tiposDeSimbolos.SENAO, tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo)); - - let caminhoSenao = null; - if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAO)) { - const simboloSenao = this.simbolos[this.atual - 1]; - const declaracoesSenao = []; - - do { - declaracoesSenao.push(this.resolverDeclaracaoForaDeBloco()); - } while (![tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo)); - - caminhoSenao = new Bloco( - this.hashArquivo, - Number(simboloSenao.linha), - declaracoesSenao.filter((d) => d) - ); - } - - this.consumir(tiposDeSimbolos.FIM, "Esperado palavra-chave 'fim' para fechamento de declaração 'se'."); - - return new Se( - condicao, - new Bloco( - this.hashArquivo, - Number(simboloSe.linha), - declaracoes.filter((d) => d) - ), - [], - caminhoSenao - ); - } - - declaracaoEnquanto(): Enquanto { - const simboloAtual = this.avancarEDevolverAnterior(); - - const condicao = this.expressao(); - - this.consumir( - tiposDeSimbolos.FACA, - "Esperado paravra reservada 'faca' após condição de continuidade em declaracão 'enquanto'." - ); - - const declaracoes = []; - do { - declaracoes.push(this.resolverDeclaracaoForaDeBloco()); - } while (![tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo)); - - this.consumir(tiposDeSimbolos.FIM, "Esperado palavra-chave 'fim' para fechamento de declaração 'enquanto'."); - - return new Enquanto( - condicao, - new Bloco( - simboloAtual.hashArquivo, - Number(simboloAtual.linha), - declaracoes.filter((d) => d) - ) - ); - } - - declaracaoPara(): Para { - const simboloPara: SimboloInterface = this.avancarEDevolverAnterior(); - - const variavelIteracao = this.consumir( - tiposDeSimbolos.IDENTIFICADOR, - "Esperado identificador de variável após 'para'." - ); - - this.consumir(tiposDeSimbolos.DE, "Esperado palavra reservada 'de' após variável de controle de 'para'."); - - const literalOuVariavelInicio = this.adicaoOuSubtracao(); - - this.consumir( - tiposDeSimbolos.ATE, - "Esperado palavra reservada 'ate' após valor inicial do laço de repetição 'para'." - ); - - const literalOuVariavelFim = this.adicaoOuSubtracao(); - - let operadorCondicao = new Simbolo( - tiposDeSimbolos.MENOR_IGUAL, - '', - '', - Number(simboloPara.linha), - this.hashArquivo - ); - let operadorCondicaoIncremento = new Simbolo( - tiposDeSimbolos.MENOR, - '', - '', - Number(simboloPara.linha), - this.hashArquivo - ); - - // Isso existe porque o laço `para` do Potigol pode ter o passo positivo ou negativo - // dependendo dos operandos de início e fim, que só são possíveis de determinar - // em tempo de execução. - // Quando um dos operandos é uma variável, tanto a condição do laço quanto o - // passo são considerados indefinidos aqui. - let passo: Construto; - let resolverIncrementoEmExecucao = false; - if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PASSO)) { - passo = this.unario(); - } else { - if (literalOuVariavelInicio instanceof Literal && literalOuVariavelFim instanceof Literal) { - if (literalOuVariavelInicio.valor > literalOuVariavelFim.valor) { - passo = new Unario( - this.hashArquivo, - new Simbolo( - tiposDeSimbolos.SUBTRACAO, - '-', - undefined, - simboloPara.linha, - simboloPara.hashArquivo - ), - new Literal(this.hashArquivo, Number(simboloPara.linha), 1), - 'ANTES' - ); - operadorCondicao = new Simbolo( - tiposDeSimbolos.MAIOR_IGUAL, - '', - '', - Number(simboloPara.linha), - this.hashArquivo - ); - operadorCondicaoIncremento = new Simbolo( - tiposDeSimbolos.MAIOR, - '', - '', - Number(simboloPara.linha), - this.hashArquivo - ); - } else { - passo = new Literal(this.hashArquivo, Number(simboloPara.linha), 1); - } - } else { - // Passo e operador de condição precisam ser resolvidos em tempo de execução. - passo = undefined; - operadorCondicao = undefined; - operadorCondicaoIncremento = undefined; - resolverIncrementoEmExecucao = true; - } - } - - this.consumir( - tiposDeSimbolos.FACA, - "Esperado palavra reservada 'faca' após valor final do laço de repetição 'para'." - ); - - const declaracoesBlocoPara = []; - let simboloAtualBlocoPara: SimboloInterface = this.simbolos[this.atual]; - while (simboloAtualBlocoPara.tipo !== tiposDeSimbolos.FIM) { - declaracoesBlocoPara.push(this.resolverDeclaracaoForaDeBloco()); - simboloAtualBlocoPara = this.simbolos[this.atual]; - } - - this.consumir(tiposDeSimbolos.FIM, ''); - - const corpo = new Bloco( - this.hashArquivo, - Number(simboloPara.linha) + 1, - declaracoesBlocoPara.filter((d) => d) - ); - - const para = new Para( - this.hashArquivo, - Number(simboloPara.linha), - new Atribuir(this.hashArquivo, variavelIteracao, literalOuVariavelInicio), - new Binario( - this.hashArquivo, - new Variavel(this.hashArquivo, variavelIteracao), - operadorCondicao, - literalOuVariavelFim - ), - new FimPara( - this.hashArquivo, - Number(simboloPara.linha), - new Binario( - this.hashArquivo, - new Variavel(this.hashArquivo, variavelIteracao), - operadorCondicaoIncremento, - literalOuVariavelFim - ), - new Expressao( - new Atribuir( - this.hashArquivo, - variavelIteracao, - new Binario( - this.hashArquivo, - new Variavel(this.hashArquivo, variavelIteracao), - new Simbolo(tiposDeSimbolos.ADICAO, '', null, Number(simboloPara.linha), this.hashArquivo), - passo - ) - ) - ) - ), - corpo - ); - para.blocoPosExecucao = corpo; - para.resolverIncrementoEmExecucao = resolverIncrementoEmExecucao; - return para; - } - - declaracaoEscolha(): Escolha { - this.avancarEDevolverAnterior(); - - const condicao = this.expressao(); - - const caminhos = []; - let caminhoPadrao = null; - - while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FIM)) { - this.consumir(tiposDeSimbolos.CASO, "Esperado palavra reservada 'caso' após condição de 'escolha'."); - if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.TRACO_BAIXO)) { - // Caso padrão - if (caminhoPadrao !== null) { - const excecao = new ErroAvaliadorSintatico( - this.simbolos[this.atual], - "Você só pode ter um caminho padrão em cada declaração de 'escolha'." - ); - this.erros.push(excecao); - throw excecao; - } - - this.consumir(tiposDeSimbolos.SETA, "Esperado '=>' após palavra reservada 'caso'."); - const declaracoesPadrao = [this.resolverDeclaracaoForaDeBloco()]; - - // TODO: Verificar se Potigol admite bloco de escopo para `escolha`. - /* const declaracoesPadrao = []; - do { - declaracoesPadrao.push(this.declaracao()); - } while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CASO, tiposDeSimbolos.FIM)); */ - - caminhoPadrao = { - declaracoes: declaracoesPadrao, - }; - - continue; - } - - const caminhoCondicoes = [this.expressao()]; - this.consumir(tiposDeSimbolos.SETA, "Esperado '=>' após palavra reservada 'caso'."); - const declaracoes = [this.resolverDeclaracaoForaDeBloco()]; - - // TODO: Verificar se Potigol admite bloco de escopo para `escolha`. - /* const declaracoes = []; - do { - declaracoes.push(this.declaracao()); - } while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CASO, tiposDeSimbolos.FIM)); */ - - caminhos.push({ - condicoes: caminhoCondicoes, - declaracoes, - }); - } - - return new Escolha(condicao, caminhos, caminhoPadrao); - } - - protected declaracaoDeConstantes(): ConstMultiplo | Const[] { - const identificadores: SimboloInterface[] = []; - let tipo: any = null; - - do { - identificadores.push(this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da constante.')); - } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA)); - - /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DOIS_PONTOS)) { - const tipoConstante = this.verificarDefinicaoTipoAtual(); - if (!tipoConstante) { - throw this.erro(this.simboloAtual(), 'Tipo definido na constante não é válido.'); - } - tipo = tipoConstante; - this.avancarEDevolverAnterior(); - } */ - - this.consumir(tiposDeSimbolos.IGUAL, "Esperado '=' após identificador em instrução 'constante'."); - - const inicializadores = []; - do { - let inicializador = this.expressao(); - if (inicializador instanceof Leia && identificadores.length > 1) { - inicializador = new LeiaMultiplo( - inicializador.simbolo, - new Literal(this.hashArquivo, Number(inicializador.simbolo.linha), identificadores.length) - ); - } - - inicializadores.push(inicializador); - } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA)); - - if (identificadores.length !== inicializadores.length) { - // Pode ser que a inicialização seja feita por uma das - // funções `leia`, que podem ler vários valores. Neste caso, não deve dar erro. - if (!(inicializadores.length === 1 && inicializadores[0] instanceof LeiaMultiplo)) { - throw this.erro( - this.simbolos[this.atual], - 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.' - ); - } - - const inicializadorLeia = inicializadores[0]; - - let tipoConversao: TipoDadosElementar; - switch (inicializadorLeia.simbolo.tipo) { - case tiposDeSimbolos.LEIA_INTEIROS: - tipoConversao = 'inteiro[]'; - break; - case tiposDeSimbolos.LEIA_INTEIRO: - tipoConversao = 'inteiro'; - break; - case tiposDeSimbolos.LEIA_REAL: - case tiposDeSimbolos.LEIA_REAIS: - tipoConversao = 'real'; - break; - default: - tipoConversao = 'texto'; - break; - } - - return new ConstMultiplo(identificadores, inicializadores[0], tipoConversao); - } - - let retorno: Const[] = []; - for (let [indice, identificador] of identificadores.entries()) { - // const inicializador = inicializadores[indice]; - // this.verificarTipoAtribuido(tipo, inicializador); - - retorno.push(new Const(identificador, inicializadores[indice], tipo)); - } - - // this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA); - - return retorno; - } - - protected declaracaoDeVariaveis(): Var[] { - const simboloVar = this.avancarEDevolverAnterior(); - const identificadores: SimboloInterface[] = []; - do { - identificadores.push(this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome de variável.')); - } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA)); - - this.consumir(tiposDeSimbolos.REATRIBUIR, "Esperado ':=' após identificador em instrução 'var'."); - - const inicializadores = []; - do { - inicializadores.push(this.expressao()); - } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA)); - - if (identificadores.length !== inicializadores.length) { - throw this.erro( - simboloVar, - 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.' - ); - } - - const retorno = []; - for (let [indice, identificador] of identificadores.entries()) { - retorno.push(new Var(identificador, inicializadores[indice])); - } - - return retorno; - } - - protected logicaAtribuicaoComDicaDeTipo(expressao: Constante) { - // A dica de tipo é opcional. - // Só que, se a avaliação entra na dica, só - // podemos ter uma constante apenas. - this.avancarEDevolverAnterior(); - if ( - ![ - tiposDeSimbolos.CARACTERE, - tiposDeSimbolos.INTEIRO, - tiposDeSimbolos.LOGICO, - tiposDeSimbolos.REAL, - tiposDeSimbolos.TEXTO, - ].includes(this.simbolos[this.atual].tipo) - ) { - throw this.erro(this.simbolos[this.atual], 'Esperado tipo após dois-pontos e nome de identificador.'); - } - - return this.avancarEDevolverAnterior(); - } - - declaracaoFazer(): Fazer { - throw new Error('Método não implementado.'); - } - - /** - * Uma declaração de tipo nada mais é do que um declaração de classe. - * Em Potigol, classe e tipo são praticamente a mesma coisa. - * - * @returns Um construto do tipo `Classe`. - */ - protected declaracaoTipo(): Classe { - const simboloTipo = this.avancarEDevolverAnterior(); - const construto: ConstanteOuVariavel = this.primario() as ConstanteOuVariavel; - - // TODO: Verificar se Potigol trabalha com herança. - /* let superClasse = null; - if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.HERDA)) { - this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da Superclasse.'); - superClasse = new Variavel(this.hashArquivo, this.simbolos[this.atual - 1]); - } */ - - const metodos: FuncaoDeclaracao[] = []; - const propriedades: PropriedadeClasse[] = []; - while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.FIM) && !this.estaNoFinal()) { - const identificador: SimboloInterface = this.consumir( - tiposDeSimbolos.IDENTIFICADOR, - 'Esperado nome de propriedade ou método.' - ); - - if (this.simbolos[this.atual].tipo === tiposDeSimbolos.PARENTESE_ESQUERDO) { - // Método - const construtoMetodo = new Constante(identificador.hashArquivo, identificador); - metodos.push(this.declaracaoDeFuncaoOuMetodo(construtoMetodo)); - } else { - // Propriedade - this.consumir( - tiposDeSimbolos.DOIS_PONTOS, - 'Esperado dois-pontos após nome de propriedade em declaração de tipo.' - ); - - this.verificacaoTipo( - this.simbolos[this.atual], - 'Esperado tipo do argumento após dois-pontos, em definição de função.' - ); - - const tipoPropriedade = this.avancarEDevolverAnterior(); - propriedades.push( - new PropriedadeClasse(identificador, this.tiposPotigolParaDelegua[tipoPropriedade.lexema]) - ); - } - } - - this.consumir(tiposDeSimbolos.FIM, "Esperado 'fim' após o escopo do tipo."); - - // Depois de verificadas todas as propriedades anotadas com tipo, - // Precisamos gerar um construtor com todas elas na ordem em que - // foram lidas. - const instrucoesConstrutor = []; - for (let propriedade of propriedades) { - instrucoesConstrutor.push( - new Expressao( - new DefinirValor( - propriedade.hashArquivo, - propriedade.linha, - new Isto( - propriedade.hashArquivo, - propriedade.linha, - new Simbolo( - tiposDeSimbolos.ISTO, - 'isto', - undefined, - simboloTipo.linha, - simboloTipo.hashArquivo - ) - ), - propriedade.nome, - new Variavel(propriedade.hashArquivo, propriedade.nome) - ) - ) - ); - } - - const construtorConstruto = new FuncaoConstruto( - simboloTipo.hashArquivo, - simboloTipo.linha, - propriedades.map( - (p) => - ({ - abrangencia: 'padrao', - nome: p.nome, - } as ParametroInterface) - ), - instrucoesConstrutor - ); - - const construtor = new FuncaoDeclaracao( - new Simbolo( - tiposDeSimbolos.CONSTRUTOR, - 'construtor', - undefined, - simboloTipo.hashArquivo, - simboloTipo.linha - ), - construtorConstruto, - undefined - ); - - metodos.unshift(construtor); - return new Classe(construto.simbolo, undefined, metodos, propriedades); - } - - atribuir(): any | any[] { - const expressao = this.ou(); - - if (!this.estaNoFinal() && expressao instanceof Constante) { - let tipoVariavelOuConstante; - // Atribuição constante. - if (this.simbolos[this.atual].tipo === tiposDeSimbolos.DOIS_PONTOS) { - tipoVariavelOuConstante = this.logicaAtribuicaoComDicaDeTipo(expressao); - } - - switch (this.simbolos[this.atual].tipo) { - case tiposDeSimbolos.VIRGULA: - this.atual--; - return this.declaracaoDeConstantes(); - case tiposDeSimbolos.IGUAL: - this.avancarEDevolverAnterior(); - const valorAtribuicao = this.ou(); - return new Const( - (expressao as Constante).simbolo, - valorAtribuicao, - tipoVariavelOuConstante - ? (this.tiposPotigolParaDelegua[tipoVariavelOuConstante.lexema] as TipoDadosElementar) - : undefined - ); - } - } - - return expressao; - } - - /** - * Em Potigol, uma definição de função normalmente começa com um - * identificador - que não é uma palavra reservada - seguido de parênteses. - * Este ponto de entrada verifica o símbolo atual e o próximo. - * - * Diferentemente dos demais dialetos, verificamos logo de cara se - * temos uma definição ou chamada de função, isto porque definições - * nunca aparecem do lado direito de uma atribuição, a não ser que - * estejam entre parênteses (_currying_). - * - * Se o próximo símbolo for parênteses, ou é uma definiçao de função, - * ou uma chamada de função. - */ - expressaoOuDefinicaoFuncao() { - if (!this.estaNoFinal() && this.simbolos[this.atual].tipo === tiposDeSimbolos.IDENTIFICADOR) { - if (this.atual + 1 < this.simbolos.length) { - switch (this.simbolos[this.atual + 1].tipo) { - case tiposDeSimbolos.PARENTESE_ESQUERDO: - const construtoPrimario = this.primario(); - return this.declaracaoDeFuncaoOuMetodo(construtoPrimario as ConstanteOuVariavel); - } - } - } - - return this.atribuir(); - } - - resolverDeclaracaoForaDeBloco(): Declaracao | Declaracao[] | Construto | Construto[] | any { - const simboloAtual = this.simbolos[this.atual]; - switch (simboloAtual.tipo) { - case tiposDeSimbolos.ENQUANTO: - return this.declaracaoEnquanto(); - case tiposDeSimbolos.ESCOLHA: - return this.declaracaoEscolha(); - case tiposDeSimbolos.ESCREVA: - return this.declaracaoEscreva(); - case tiposDeSimbolos.IMPRIMA: - return this.declaracaoImprima(); - case tiposDeSimbolos.PARA: - return this.declaracaoPara(); - case tiposDeSimbolos.SE: - return this.declaracaoSe(); - case tiposDeSimbolos.TIPO: - return this.declaracaoTipo(); - case tiposDeSimbolos.VARIAVEL: - return this.declaracaoDeVariaveis(); - default: - return this.expressaoOuDefinicaoFuncao(); - } - } - - analisar( - retornoLexador: RetornoLexador, - hashArquivo: number - ): RetornoAvaliadorSintatico { - this.microAvaliadorSintatico = new MicroAvaliadorSintaticoPotigol(hashArquivo); - this.erros = []; - this.atual = 0; - this.blocos = 0; - this.declaracoesAnteriores = {}; - - this.hashArquivo = hashArquivo || 0; - this.simbolos = retornoLexador?.simbolos || []; - - let declaracoes: Declaracao[] = []; - while (!this.estaNoFinal()) { - const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco(); - if (Array.isArray(retornoDeclaracao)) { - declaracoes = declaracoes.concat(retornoDeclaracao); - } else { - declaracoes.push(retornoDeclaracao as Declaracao); - } - } - - return { - declaracoes: declaracoes, - erros: this.erros, - } as RetornoAvaliadorSintatico; - } -} diff --git a/fontes/avaliador-sintatico/dialetos/potigol/index.ts b/fontes/avaliador-sintatico/dialetos/potigol/index.ts deleted file mode 100644 index 033af9f6..00000000 --- a/fontes/avaliador-sintatico/dialetos/potigol/index.ts +++ /dev/null @@ -1 +0,0 @@ -export * from './avaliador-sintatico-potigol'; diff --git a/fontes/avaliador-sintatico/dialetos/potigol/micro-avaliador-sintatico-potigol.ts b/fontes/avaliador-sintatico/dialetos/potigol/micro-avaliador-sintatico-potigol.ts deleted file mode 100644 index 3a867a52..00000000 --- a/fontes/avaliador-sintatico/dialetos/potigol/micro-avaliador-sintatico-potigol.ts +++ /dev/null @@ -1,85 +0,0 @@ -import { Agrupamento, ConstanteOuVariavel, Construto, Literal, Logico } from '../../../construtos'; -import { Declaracao } from '../../../declaracoes'; -import { RetornoLexador, RetornoAvaliadorSintatico } from '../../../interfaces/retornos'; -import { MicroAvaliadorSintaticoBase } from '../../micro-avaliador-sintatico-base'; -import { SeletorTuplas, Tupla } from '../../../construtos/tuplas'; -import { SimboloInterface } from '../../../interfaces'; - -import tiposDeSimbolos from '../../../tipos-de-simbolos/potigol'; - -export class MicroAvaliadorSintaticoPotigol extends MicroAvaliadorSintaticoBase { - hashArquivo: number; - - constructor(hashArquivo: number) { - super(); - this.hashArquivo = hashArquivo; - } - - primario(): Construto { - const simboloAtual = this.simbolos[this.atual]; - - switch (simboloAtual.tipo) { - case tiposDeSimbolos.PARENTESE_ESQUERDO: - this.avancarEDevolverAnterior(); - const expressao = this.ou(); - switch (this.simbolos[this.atual].tipo) { - case tiposDeSimbolos.VIRGULA: - // Tupla - const argumentos = [expressao]; - while (this.simbolos[this.atual].tipo === tiposDeSimbolos.VIRGULA) { - this.avancarEDevolverAnterior(); - argumentos.push(this.ou()); - } - - this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão."); - return new SeletorTuplas(...argumentos) as Tupla; - default: - this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão."); - return new Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao); - } - - case tiposDeSimbolos.CARACTERE: - case tiposDeSimbolos.INTEIRO: - case tiposDeSimbolos.LOGICO: - case tiposDeSimbolos.REAL: - case tiposDeSimbolos.TEXTO: - const simboloLiteral: SimboloInterface = this.avancarEDevolverAnterior(); - return new Literal(this.hashArquivo, Number(simboloLiteral.linha), simboloLiteral.literal); - case tiposDeSimbolos.FALSO: - case tiposDeSimbolos.VERDADEIRO: - const simboloVerdadeiroFalso: SimboloInterface = this.avancarEDevolverAnterior(); - return new Literal( - this.hashArquivo, - Number(simboloVerdadeiroFalso.linha), - simboloVerdadeiroFalso.tipo === tiposDeSimbolos.VERDADEIRO - ); - case tiposDeSimbolos.VIRGULA: - return undefined; - default: - const simboloIdentificador: SimboloInterface = this.avancarEDevolverAnterior(); - return new ConstanteOuVariavel(this.hashArquivo, simboloIdentificador); - } - } - - chamar(): Construto { - return this.primario(); - } - - analisar(retornoLexador: RetornoLexador, linha: number): RetornoAvaliadorSintatico { - this.erros = []; - this.atual = 0; - this.linha = linha; - - this.simbolos = retornoLexador?.simbolos || []; - - const declaracoes: Declaracao[] = []; - while (this.atual < this.simbolos.length) { - declaracoes.push(this.declaracao() as Declaracao); - } - - return { - declaracoes: declaracoes, - erros: this.erros, - } as RetornoAvaliadorSintatico; - } -} diff --git a/fontes/bibliotecas/dialetos/potigol/biblioteca-global.ts b/fontes/bibliotecas/dialetos/potigol/biblioteca-global.ts deleted file mode 100644 index 22e38dc5..00000000 --- a/fontes/bibliotecas/dialetos/potigol/biblioteca-global.ts +++ /dev/null @@ -1,92 +0,0 @@ -import { FuncaoPadrao } from '../../../estruturas'; -import { PilhaEscoposExecucaoInterface } from '../../../interfaces/pilha-escopos-execucao-interface'; -import { InterpretadorBase } from '../../../interpretador'; - -export function registrarBibliotecaGlobalPotigol( - interpretador: InterpretadorBase, - pilhaEscoposExecucao: PilhaEscoposExecucaoInterface -) { - pilhaEscoposExecucao.definirVariavel( - 'abs', - new FuncaoPadrao(1, function (valor: number) { - return Math.abs(valor); - }) - ); - - pilhaEscoposExecucao.definirVariavel( - 'aleatório', - new FuncaoPadrao(0, function () { - return Math.random(); - }) - ); - - pilhaEscoposExecucao.definirVariavel( - 'arccos', - new FuncaoPadrao(1, function (valor: number) { - return Math.acos(valor); - }) - ); - - pilhaEscoposExecucao.definirVariavel( - 'arcsen', - new FuncaoPadrao(1, function (valor: number) { - return Math.asin(valor); - }) - ); - - pilhaEscoposExecucao.definirVariavel( - 'arctg', - new FuncaoPadrao(1, function (valor: number) { - return Math.atan(valor); - }) - ); - - pilhaEscoposExecucao.definirVariavel( - 'cos', - new FuncaoPadrao(1, function (valor: number) { - return Math.cos(valor); - }) - ); - - pilhaEscoposExecucao.definirVariavel( - 'log', - new FuncaoPadrao(1, function (valor: number) { - return Math.log(valor); - }) - ); - - pilhaEscoposExecucao.definirVariavel( - 'log10', - new FuncaoPadrao(1, function (valor: number) { - return Math.log10(valor); - }) - ); - - pilhaEscoposExecucao.definirVariavel( - 'pi', - new FuncaoPadrao(0, function () { - return Math.PI; - }) - ); - - pilhaEscoposExecucao.definirVariavel( - 'raiz', - new FuncaoPadrao(1, function (valor: number) { - return Math.sqrt(valor); - }) - ); - - pilhaEscoposExecucao.definirVariavel( - 'sen', - new FuncaoPadrao(1, function (valor: number) { - return Math.sin(valor); - }) - ); - - pilhaEscoposExecucao.definirVariavel( - 'tg', - new FuncaoPadrao(1, function (valor: number) { - return Math.tan(valor); - }) - ); -} diff --git a/fontes/bibliotecas/dialetos/potigol/primitivas-numero.ts b/fontes/bibliotecas/dialetos/potigol/primitivas-numero.ts deleted file mode 100644 index 400eb692..00000000 --- a/fontes/bibliotecas/dialetos/potigol/primitivas-numero.ts +++ /dev/null @@ -1,16 +0,0 @@ -import { VisitanteComumInterface } from '../../../interfaces'; - -export default { - arredonde: (interpretador: VisitanteComumInterface, numero: number): Promise => - Promise.resolve(Math.ceil(numero)), - caractere: (interpretador: VisitanteComumInterface, numero: number): Promise => - Promise.resolve(String.fromCharCode(numero)), - inteiro: (interpretador: VisitanteComumInterface, numero: number): Promise => - Promise.resolve(Math.floor(numero)), - qual_tipo: (interpretador: VisitanteComumInterface, numero: number): Promise => - Promise.resolve(Math.floor(numero) === numero ? 'Inteiro' : 'Real'), - piso: (interpretador: VisitanteComumInterface, numero: number): Promise => Promise.resolve(Math.floor(numero)), - real: (interpretador: VisitanteComumInterface, numero: number): Promise => Promise.resolve(numero), - teto: (interpretador: VisitanteComumInterface, numero: number): Promise => Promise.resolve(Math.ceil(numero)), - texto: (interpretador: VisitanteComumInterface, numero: number): Promise => Promise.resolve(String(numero)), -}; diff --git a/fontes/bibliotecas/dialetos/potigol/primitivas-texto.ts b/fontes/bibliotecas/dialetos/potigol/primitivas-texto.ts deleted file mode 100644 index e4f86e17..00000000 --- a/fontes/bibliotecas/dialetos/potigol/primitivas-texto.ts +++ /dev/null @@ -1,53 +0,0 @@ -import { VisitanteComumInterface } from '../../../interfaces'; - -export default { - cabeça: (interpretador: VisitanteComumInterface, texto: string): Promise => Promise.resolve(texto[0]), - cauda: (interpretador: VisitanteComumInterface, texto: string): Promise => Promise.resolve(texto.substring(1)), - contém: (interpretador: VisitanteComumInterface, texto: string, caractere: string): Promise => - Promise.resolve(texto.includes(caractere)), - descarte: (interpretador: VisitanteComumInterface, texto: string, posicao: number): Promise => - Promise.resolve(texto.substring(posicao)), - descarte_enquanto: (interpretador: VisitanteComumInterface, texto: string): Promise => Promise.resolve(''), - divida: (interpretador: VisitanteComumInterface, texto: string, separador: string = ' '): Promise => - Promise.resolve(texto.split(separador)), - injete: (interpretador: VisitanteComumInterface, texto: string): Promise => Promise.resolve(''), - insira: ( - interpretador: VisitanteComumInterface, - texto: string, - posicao: number, - elemento: string - ): Promise => { - let vetor = texto.split(''); - vetor.splice(posicao - 1, 0, elemento); - return Promise.resolve(vetor.join('')); - }, - inteiro: (interpretador: VisitanteComumInterface, texto: string): Promise => - Promise.resolve(Math.floor(Number(texto))), - inverta: (interpretador: VisitanteComumInterface, texto: string): Promise => - Promise.resolve(texto.split('').reduce((texto, caracter) => (texto = caracter + texto), '')), - junte: (interpretador: VisitanteComumInterface, texto: string, separador: string): Promise => - Promise.resolve(texto.split('').join(separador)), - lista: (interpretador: VisitanteComumInterface, texto: string): Promise => Promise.resolve(texto.split('')), - maiúsculo: (interpretador: VisitanteComumInterface, texto: string): Promise => - Promise.resolve(texto.toUpperCase()), - minúsculo: (interpretador: VisitanteComumInterface, texto: string): Promise => - Promise.resolve(texto.toLowerCase()), - ordene: (interpretador: VisitanteComumInterface, texto: string): Promise => - Promise.resolve(texto.split('').sort().join('')), - qual_tipo: (interpretador: VisitanteComumInterface, texto: string): Promise => Promise.resolve('Texto'), - pegue: (interpretador: VisitanteComumInterface, texto: string, caracteres: number): Promise => - Promise.resolve(texto.substring(0, caracteres)), - pegue_enquanto: (interpretador: VisitanteComumInterface, texto: string): Promise => Promise.resolve(''), - posição: (interpretador: VisitanteComumInterface, texto: string, caractere: string): Promise => - Promise.resolve(texto.indexOf(caractere) + 1), - real: (interpretador: VisitanteComumInterface, texto: string): Promise => Promise.resolve(Number(texto)), - remova: (interpretador: VisitanteComumInterface, texto: string, posicao: number): Promise => { - let vetor = texto.split(''); - vetor.splice(posicao - 1, 1); - return Promise.resolve(vetor.join('')); - }, - selecione: (interpretador: VisitanteComumInterface, texto: string): Promise => Promise.resolve(''), - tamanho: (interpretador: VisitanteComumInterface, texto: string): Promise => Promise.resolve(texto.length), - último: (interpretador: VisitanteComumInterface, texto: string): Promise => - Promise.resolve(texto.length > 0 ? texto[texto.length - 1] : ''), -}; diff --git a/fontes/bibliotecas/dialetos/potigol/primitivas-vetor.ts b/fontes/bibliotecas/dialetos/potigol/primitivas-vetor.ts deleted file mode 100644 index 86f654cd..00000000 --- a/fontes/bibliotecas/dialetos/potigol/primitivas-vetor.ts +++ /dev/null @@ -1,60 +0,0 @@ -import { VisitanteComumInterface } from '../../../interfaces'; - -export default { - cabeça: (interpretador: VisitanteComumInterface, vetor: Array): Promise => Promise.resolve(vetor[0]), - cauda: (interpretador: VisitanteComumInterface, vetor: Array): Promise => { - let copia = [...vetor]; - copia.splice(0, 1); - return Promise.resolve(copia); - }, - contém: (interpretador: VisitanteComumInterface, vetor: Array, elemento: any): Promise => - Promise.resolve(vetor.includes(elemento)), - descarte: (interpretador: VisitanteComumInterface, vetor: Array, elementos: number): Promise => { - let copia = [...vetor]; - copia.splice(0, elementos); - return Promise.resolve(copia); - }, - descarte_enquanto: (interpretador: VisitanteComumInterface, vetor: Array): Promise => Promise.resolve(), - divida_quando: (interpretador: VisitanteComumInterface, vetor: Array): Promise => Promise.resolve(), - imutável: (interpretador: VisitanteComumInterface, vetor: Array): Promise => Promise.resolve(), - injete: (interpretador: VisitanteComumInterface, vetor: Array): Promise => Promise.resolve(), - insira: ( - interpretador: VisitanteComumInterface, - vetor: Array, - posicao: number, - elemento: string - ): Promise => { - let copia = [...vetor]; - copia.splice(posicao - 1, 0, elemento); - return Promise.resolve(copia); - }, - inverta: (interpretador: VisitanteComumInterface, vetor: Array): Promise => { - let copia = []; - for (let elemento of vetor) { - copia.unshift(elemento); - } - return Promise.resolve(copia); - }, - junte: (interpretador: VisitanteComumInterface, vetor: Array, separador: string): Promise => - Promise.resolve(vetor.join(separador)), - mapeie: (interpretador: VisitanteComumInterface, vetor: Array): Promise => Promise.resolve(), - ordene: (interpretador: VisitanteComumInterface, vetor: Array): Promise => - Promise.resolve(vetor.sort((a, b) => a - b)), - pegue: (interpretador: VisitanteComumInterface, vetor: Array, elementos: number): Promise => - Promise.resolve(vetor.slice(0, elementos)), - pegue_enquanto: (interpretador: VisitanteComumInterface, vetor: Array): Promise => Promise.resolve(), - posição: (interpretador: VisitanteComumInterface, vetor: Array, elemento: any): Promise => - Promise.resolve(vetor.indexOf(elemento) + 1), - qual_tipo: (interpretador: VisitanteComumInterface, vetor: Array): Promise => Promise.resolve('Lista'), - remova: (interpretador: VisitanteComumInterface, vetor: Array, posicao: number): Promise => { - let copia = [...vetor]; - copia.splice(posicao - 1, 1); - return Promise.resolve(copia); - }, - selecione: (interpretador: VisitanteComumInterface, vetor: Array): Promise => Promise.resolve(), - tamanho: (interpretador: VisitanteComumInterface, vetor: Array): Promise => Promise.resolve(vetor.length), - último: (interpretador: VisitanteComumInterface, vetor: Array): Promise => - Promise.resolve(vetor.length > 0 ? vetor[vetor.length - 1] : undefined), - vazia: (interpretador: VisitanteComumInterface, vetor: Array): Promise => - Promise.resolve(vetor.length === 0), -}; diff --git a/fontes/construtos/qual-tipo.ts b/fontes/construtos/qual-tipo.ts index 781e0795..74269d72 100644 --- a/fontes/construtos/qual-tipo.ts +++ b/fontes/construtos/qual-tipo.ts @@ -2,6 +2,7 @@ import { SimboloInterface } from '../interfaces'; import { InterpretadorInterfacePotigol } from '../interfaces/interpretador-interface-potigol'; import { Construto } from './construto'; +// TODO: Depreciado. Priorizar `TipoDe`. export class QualTipo implements Construto { linha: number; hashArquivo: number; diff --git a/fontes/interfaces/interpretador-interface-potigol.ts b/fontes/interfaces/interpretador-interface-potigol.ts index 91290ade..9b8117d8 100644 --- a/fontes/interfaces/interpretador-interface-potigol.ts +++ b/fontes/interfaces/interpretador-interface-potigol.ts @@ -2,6 +2,7 @@ import { QualTipo } from '../construtos'; import { VisitanteComumInterface } from './visitante-comum-interface'; +// TODO: Depreciado. Remover após remover `QualTipo`. export interface InterpretadorInterfacePotigol extends VisitanteComumInterface { visitarExpressaoQualTipo(expressao: QualTipo): Promise; } diff --git a/fontes/interpretador/dialetos/index.ts b/fontes/interpretador/dialetos/index.ts index 2311908b..f030e4fa 100644 --- a/fontes/interpretador/dialetos/index.ts +++ b/fontes/interpretador/dialetos/index.ts @@ -1,4 +1,3 @@ export * from './egua-classico'; export * from './mapler'; export * from './portugol-ipt'; -export * from './potigol'; diff --git a/fontes/interpretador/dialetos/potigol/comum.ts b/fontes/interpretador/dialetos/potigol/comum.ts deleted file mode 100644 index 58a13e27..00000000 --- a/fontes/interpretador/dialetos/potigol/comum.ts +++ /dev/null @@ -1,142 +0,0 @@ -import { AcessoMetodoOuPropriedade } from '../../../construtos'; -import { DeleguaModulo, MetodoPrimitiva, ObjetoDeleguaClasse } from '../../../estruturas'; -import { VariavelInterface } from '../../../interfaces'; -import { inferirTipoVariavel } from './inferenciador'; - -import primitivasNumero from '../../../bibliotecas/dialetos/potigol/primitivas-numero'; -import primitivasTexto from '../../../bibliotecas/dialetos/potigol/primitivas-texto'; -import primitivasVetor from '../../../bibliotecas/dialetos/potigol/primitivas-vetor'; -import { ErroEmTempoDeExecucao } from '../../../excecoes'; -import { InterpretadorBase } from '../../interpretador-base'; - -/** - * Executa um acesso a método, normalmente de um objeto de classe. - * @param expressao A expressão de acesso. - * @returns O resultado da execução. - */ -export async function visitarExpressaoAcessoMetodo( - interpretador: InterpretadorBase, - expressao: AcessoMetodoOuPropriedade -): Promise { - const variavelObjeto: VariavelInterface = await interpretador.avaliar(expressao.objeto); - const objeto = variavelObjeto.hasOwnProperty('valor') ? variavelObjeto.valor : variavelObjeto; - - if (objeto instanceof ObjetoDeleguaClasse) { - return objeto.obter(expressao.simbolo) || null; - } - - // TODO: Possivelmente depreciar esta forma. - // Não parece funcionar em momento algum. - if (objeto.constructor === Object) { - return objeto[expressao.simbolo.lexema] || null; - } - - // Função tradicional do JavaScript. - // Normalmente executa quando uma biblioteca é importada. - if (typeof objeto[expressao.simbolo.lexema] === 'function') { - return objeto[expressao.simbolo.lexema]; - } - - // Objeto tradicional do JavaScript. - // Normalmente executa quando uma biblioteca é importada. - if (typeof objeto[expressao.simbolo.lexema] === 'object') { - return objeto[expressao.simbolo.lexema]; - } - - if (objeto instanceof DeleguaModulo) { - return objeto.componentes[expressao.simbolo.lexema] || null; - } - - let tipoObjeto: any = variavelObjeto.tipo; - if (tipoObjeto === null || tipoObjeto === undefined) { - tipoObjeto = inferirTipoVariavel(variavelObjeto as any); - } - - switch (tipoObjeto) { - case 'numero': - case 'número': - const metodoDePrimitivaNumero: Function = primitivasNumero[expressao.simbolo.lexema]; - if (metodoDePrimitivaNumero) { - return new MetodoPrimitiva(objeto, metodoDePrimitivaNumero); - } - break; - case 'texto': - const metodoDePrimitivaTexto: Function = primitivasTexto[expressao.simbolo.lexema]; - if (metodoDePrimitivaTexto) { - return new MetodoPrimitiva(objeto, metodoDePrimitivaTexto); - } - break; - case 'vetor': - const metodoDePrimitivaVetor: Function = primitivasVetor[expressao.simbolo.lexema]; - if (metodoDePrimitivaVetor) { - return new MetodoPrimitiva(objeto, metodoDePrimitivaVetor); - } - break; - } - - return Promise.reject( - new ErroEmTempoDeExecucao( - expressao.simbolo, - `Método para objeto ou primitiva não encontrado: ${expressao.simbolo.lexema}.`, - expressao.linha - ) - ); -} - -/** - * Resolve todas as interpolações em um texto. - * @param {texto} textoOriginal O texto original com as variáveis interpoladas. - * @returns Uma lista de variáveis interpoladas. - */ -export async function resolverInterpolacoes( - interpretador: InterpretadorBase, - textoOriginal: string, - linha: number -): Promise { - const variaveis = textoOriginal.match(interpretador.regexInterpolacao); - - let resultadosAvaliacaoSintatica = variaveis.map((s) => { - const expressao: string = s.replace(/[\{\}]*/gm, ''); - - let microLexador = interpretador.microLexador.mapear(expressao); - const resultadoMicroAvaliadorSintatico = interpretador.microAvaliadorSintatico.analisar(microLexador, linha); - - return { - nomeVariavel: expressao, - resultadoMicroAvaliadorSintatico, - }; - }); - - // TODO: Verificar erros do `resultadosAvaliacaoSintatica`. - - const resolucoesPromises = await Promise.all( - resultadosAvaliacaoSintatica - .flatMap((r) => r.resultadoMicroAvaliadorSintatico.declaracoes) - .map((d) => interpretador.avaliar(d)) - ); - - return resolucoesPromises.map((item, indice) => ({ - variavel: resultadosAvaliacaoSintatica[indice].nomeVariavel, - valor: item, - })); -} - -/** - * Retira a interpolação de um texto. - * @param {texto} texto O texto - * @param {any[]} variaveis A lista de variaveis interpoladas - * @returns O texto com o valor das variaveis. - */ -export function retirarInterpolacao(texto: string, variaveis: any[]): string { - let textoFinal = texto; - - variaveis.forEach((elemento) => { - if (elemento?.valor?.tipo === 'lógico') { - textoFinal = textoFinal.replace('{' + elemento.variavel + '}', this.paraTexto(elemento?.valor?.valor)); - } else { - textoFinal = textoFinal.replace('{' + elemento.variavel + '}', elemento?.valor?.valor || elemento?.valor); - } - }); - - return textoFinal; -} diff --git a/fontes/interpretador/dialetos/potigol/index.ts b/fontes/interpretador/dialetos/potigol/index.ts deleted file mode 100644 index edd1ee29..00000000 --- a/fontes/interpretador/dialetos/potigol/index.ts +++ /dev/null @@ -1,2 +0,0 @@ -export * from './interpretador-potigol'; -export * from './interpretador-potigol-com-depuracao'; diff --git a/fontes/interpretador/dialetos/potigol/inferenciador.ts b/fontes/interpretador/dialetos/potigol/inferenciador.ts deleted file mode 100644 index b53e00d6..00000000 --- a/fontes/interpretador/dialetos/potigol/inferenciador.ts +++ /dev/null @@ -1,25 +0,0 @@ -export function inferirTipoVariavel(variavel: string | number | Array | boolean | null | undefined) { - const tipo = typeof variavel; - switch (tipo) { - case 'string': - return 'Texto'; - case 'number': - if (variavel.toString().indexOf('.') > -1) return 'Real'; - return 'Inteiro'; - case 'bigint': - return 'Longo'; - case 'boolean': - return 'Lógico'; - case 'undefined': - return 'Nulo'; - case 'object': - if (Array.isArray(variavel)) return 'Lista'; - if (variavel === null) return 'nulo'; - if (variavel.constructor.name === 'DeleguaModulo') return 'módulo'; - return 'Dicionário'; - case 'function': - return 'Função'; - case 'symbol': - return 'Símbolo'; - } -} diff --git a/fontes/interpretador/dialetos/potigol/interpretador-potigol-com-depuracao.ts b/fontes/interpretador/dialetos/potigol/interpretador-potigol-com-depuracao.ts deleted file mode 100644 index 6134d327..00000000 --- a/fontes/interpretador/dialetos/potigol/interpretador-potigol-com-depuracao.ts +++ /dev/null @@ -1,27 +0,0 @@ -import { registrarBibliotecaGlobalPotigol } from '../../../bibliotecas/dialetos/potigol/biblioteca-global'; -import { AcessoMetodoOuPropriedade } from '../../../construtos'; -import { InterpretadorComDepuracao } from '../../interpretador-com-depuracao'; - -import * as comum from './comum'; - -export class InterpretadorPotigolComDepuracao extends InterpretadorComDepuracao { - constructor(diretorioBase: string, funcaoDeRetorno: Function = null, funcaoDeRetornoMesmaLinha: Function = null) { - super(diretorioBase, funcaoDeRetorno, funcaoDeRetornoMesmaLinha); - this.expandirPropriedadesDeObjetosEmEspacoVariaveis = true; - this.regexInterpolacao = /{(.*?)}/g; - - registrarBibliotecaGlobalPotigol(this, this.pilhaEscoposExecucao); - } - - protected async resolverInterpolacoes(textoOriginal: string, linha: number): Promise { - return comum.resolverInterpolacoes(this, textoOriginal, linha); - } - - protected retirarInterpolacao(texto: string, variaveis: any[]): string { - return comum.retirarInterpolacao(texto, variaveis); - } - - async visitarExpressaoAcessoMetodo(expressao: AcessoMetodoOuPropriedade): Promise { - return comum.visitarExpressaoAcessoMetodo(this, expressao); - } -} diff --git a/fontes/interpretador/dialetos/potigol/interpretador-potigol.ts b/fontes/interpretador/dialetos/potigol/interpretador-potigol.ts deleted file mode 100644 index 667827e4..00000000 --- a/fontes/interpretador/dialetos/potigol/interpretador-potigol.ts +++ /dev/null @@ -1,109 +0,0 @@ -import { InterpretadorBase } from '../../interpretador-base'; - -import { registrarBibliotecaGlobalPotigol } from '../../../bibliotecas/dialetos/potigol/biblioteca-global'; -import { - AcessoMetodoOuPropriedade, - Binario, - ConstanteOuVariavel, - Construto, - Literal, - QualTipo, - Unario, - Variavel, -} from '../../../construtos'; - -import * as comum from './comum'; -import { ObjetoPadrao } from '../../../estruturas'; -import { inferirTipoVariavel } from './inferenciador'; -import { InterpretadorInterfacePotigol } from '../../../interfaces/interpretador-interface-potigol'; - -/** - * Uma implementação do interpretador de Potigol. - */ -export class InterpretadorPotigol extends InterpretadorBase implements InterpretadorInterfacePotigol { - constructor( - diretorioBase: string, - performance = false, - funcaoDeRetorno: Function = null, - funcaoDeRetornoMesmaLinha: Function = null - ) { - super(diretorioBase, performance, funcaoDeRetorno, funcaoDeRetornoMesmaLinha); - this.expandirPropriedadesDeObjetosEmEspacoVariaveis = true; - this.regexInterpolacao = /{(.*?)}/g; - - registrarBibliotecaGlobalPotigol(this, this.pilhaEscoposExecucao); - } - - paraTexto(objeto: any) { - if (objeto === null || objeto === undefined) return 'nulo'; - if (typeof objeto === 'boolean') { - return objeto ? 'verdadeiro' : 'falso'; - } - - if (objeto instanceof Date) { - const formato = Intl.DateTimeFormat('pt', { - dateStyle: 'full', - timeStyle: 'full', - }); - return formato.format(objeto); - } - - if (Array.isArray(objeto)) return `[${objeto.join(', ')}]`; - if (objeto.valor instanceof ObjetoPadrao) return objeto.valor.paraTexto(); - if (typeof objeto === 'object') return JSON.stringify(objeto); - - return objeto.toString(); - } - - protected async resolverInterpolacoes(textoOriginal: string, linha: number): Promise { - return comum.resolverInterpolacoes(this, textoOriginal, linha); - } - - protected retirarInterpolacao(texto: string, variaveis: any[]): string { - return comum.retirarInterpolacao(texto, variaveis); - } - - async visitarExpressaoAcessoMetodo(expressao: AcessoMetodoOuPropriedade): Promise { - return comum.visitarExpressaoAcessoMetodo(this, expressao); - } - - async visitarExpressaoQualTipo(expressao: QualTipo): Promise { - let qualTipo = expressao.valor; - - if (expressao?.valor instanceof ConstanteOuVariavel) { - const nome = expressao?.valor.simbolo.lexema; - qualTipo = this.pilhaEscoposExecucao.topoDaPilha().ambiente.valores[nome].valor; - } - - if ( - qualTipo instanceof Binario || - qualTipo instanceof Literal || - qualTipo instanceof QualTipo || - qualTipo instanceof Unario || - qualTipo instanceof Variavel - ) { - qualTipo = await this.avaliar(qualTipo); - return qualTipo.tipo || inferirTipoVariavel(qualTipo); - } - - return inferirTipoVariavel(qualTipo?.valores || qualTipo); - } - - protected async avaliarArgumentosEscreva(argumentos: Construto[]): Promise { - let formatoTexto: string = ''; - - for (const argumento of argumentos) { - const resultadoAvaliacao = await this.avaliar(argumento); - let valor = resultadoAvaliacao?.hasOwnProperty('valor') ? resultadoAvaliacao.valor : resultadoAvaliacao; - formatoTexto += `${this.paraTexto(valor)},`; - } - - formatoTexto = formatoTexto.slice(0, -1); - - if (argumentos.length > 1) { - formatoTexto = `(${formatoTexto})`; - } - - return formatoTexto; - } -} diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts index 000e57f3..07f68df3 100644 --- a/fontes/interpretador/interpretador-base.ts +++ b/fontes/interpretador/interpretador-base.ts @@ -250,6 +250,7 @@ export class InterpretadorBase implements InterpretadorInterface { return inferirTipoVariavel(tipoDe?.valores || tipoDe); } + // TODO: Depreciado. Priorizar `visitarExpressaoTipoDe`. async visitarExpressaoQualTipo(expressao: QualTipo): Promise { throw new Error('Método não implementado.'); } diff --git a/testes/potigol/avaliador-sintatico.test.ts b/testes/potigol/avaliador-sintatico.test.ts deleted file mode 100644 index 632b7190..00000000 --- a/testes/potigol/avaliador-sintatico.test.ts +++ /dev/null @@ -1,433 +0,0 @@ -import { LexadorPotigol } from "../../fontes/lexador/dialetos"; -import { AvaliadorSintaticoPotigol } from "../../fontes/avaliador-sintatico/dialetos"; -import { ErroAvaliadorSintatico } from "../../fontes/avaliador-sintatico/erro-avaliador-sintatico"; - -describe('Avaliador sintático', () => { - describe('analisar()', () => { - let lexador = new LexadorPotigol(); - let avaliadorSintatico = new AvaliadorSintaticoPotigol(); - - describe('Cenários de sucesso', () => { - describe('Entrada e saída', () => { - it('Sucesso - Escreva Olá Mundo', () => { - const retornoLexador = lexador.mapear(['escreva "Olá mundo"'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Imprima Olá Mundo', () => { - const retornoLexador = lexador.mapear(['imprima "Olá mundo"'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - }); - - describe('Operações matemáticas', () => { - it('Sucesso - 2 + 2', () => { - const retornoLexador = lexador.mapear(['escreva 2 + 2'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Operações encadeadas', () => { - const retornoLexador = lexador.mapear(['escreva (2 * 8) - (5 / 4 ^ 7)'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2); - }); - - it('Sucesso - Mod e Div', () => { - const retornoLexador = lexador.mapear(['escreva (100 mod 6 div 2)'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - }); - - describe('Operações lógicas', () => { - it('Sucesso - Ou', () => { - const retornoLexador = lexador.mapear(['verdadeiro ou falso'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - E', () => { - const retornoLexador = lexador.mapear(['verdadeiro e falso'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Não (sem acento)', () => { - const retornoLexador = lexador.mapear(['nao verdadeiro'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Não (com acento)', () => { - const retornoLexador = lexador.mapear(['não verdadeiro'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Comparação de igualdade', () => { - const retornoLexador = lexador.mapear(['escreva 2 == 2'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Comparação de desigualdade', () => { - const retornoLexador = lexador.mapear(['escreva 2 <> 2'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Comparação de menor', () => { - const retornoLexador = lexador.mapear(['escreva 2 < 2'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Comparação de menor ou igual', () => { - const retornoLexador = lexador.mapear(['escreva 2 <= 2'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Comparação de maior', () => { - const retornoLexador = lexador.mapear(['escreva 2 > 2'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Comparação de maior ou igual', () => { - const retornoLexador = lexador.mapear(['escreva 2 >= 2'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - }); - - describe('Atribuição de variáveis', () => { - it('Sucesso - Declaração de inteiro constante, inferência', () => { - const retornoLexador = lexador.mapear(['a = 10'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Declaração de inteiro variável, inferência', () => { - const retornoLexador = lexador.mapear(['var a := 10'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Declaração de múltiplas variáveis inteiras, inferência', () => { - const retornoLexador = lexador.mapear(['var a, b, c := 10, 20, 30'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3); - }); - - it('Sucesso - Declaração de caractere constante, dica de tipo', () => { - const retornoLexador = lexador.mapear(["c: Caractere = 'z'"], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Declaração de inteiro constante, dica de tipo', () => { - const retornoLexador = lexador.mapear(['a: Inteiro = 10'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Declaração de lógico (com acento) constante, dica de tipo', () => { - const retornoLexador = lexador.mapear(['b: Lógico = verdadeiro'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Declaração de lógico (sem acento) constante, dica de tipo', () => { - const retornoLexador = lexador.mapear(['b: Logico = verdadeiro'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Declaração de real constante, dica de tipo', () => { - const retornoLexador = lexador.mapear(['r: Real = 3.14'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Declaração de texto constante, dica de tipo', () => { - const retornoLexador = lexador.mapear(['s: Texto = "Programação"'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Declaração de múltiplas constantes, lado direito usando `leia_inteiro`', () => { - const retornoLexador = lexador.mapear(['a, b, c = leia_inteiro'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.erros).toHaveLength(0); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sucesso - Declaração de múltiplas constantes, lado direito usando `leia_inteiros`', () => { - const retornoLexador = lexador.mapear(['a, b, c = leia_inteiros(3)'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.erros).toHaveLength(0); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - }); - - describe('Estruturas de decisão', () => { - it('Escolha', () => { - const retornoLexador = lexador.mapear([ - 'escolha x', - ' caso 1 => escreva "Um"', - ' caso 2 => escreva "Dois"', - ' caso 3 => escreva "Três"', - ' caso _ => escreva "Outro valor"', - 'fim' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Se', () => { - const retornoLexador = lexador.mapear([ - 'se verdadeiro então', - ' escreva "verdadeiro"', - 'senão', - ' escreva "falso"', - 'fim' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - }); - - describe('Estruturas de repetição', () => { - it('Enquanto', () => { - const retornoLexador = lexador.mapear([ - 'var i := 0', - 'enquanto i <= 10 faça', - ' escreva i', - ' i := i + 1', - 'fim' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2); - }); - - it('Para', () => { - const retornoLexador = lexador.mapear([ - 'var soma := 0', - 'para i de 1 até 10 faça', - ' soma := soma + i', - 'fim', - 'escreva "A soma é {soma}."' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3); - }); - }); - - describe('Declarações de funções', () => { - it('Função de uma linha, argumentos com tipo definido, sem dica de retorno', () => { - const retornoLexador = lexador.mapear([ - 'soma(x: Inteiro, y: Inteiro) = x + y' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Função de uma linha, argumentos com tipo definido, com dica de retorno', () => { - const retornoLexador = lexador.mapear([ - 'soma(x: Inteiro, y: Inteiro): Inteiro = x + y' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - }); - - describe('Declarações de tuplas', () => { - it('Dupla', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Trio', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Quarteto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Quinteto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4, 5)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Sexteto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4, 5, 6)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Septeto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4, 5, 6, 7)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Octeto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4, 5, 6, 7, 8)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Noneto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4, 5, 6, 7, 8, 9)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - it('Deceto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - }); - - describe('Tipos', () => { - it('Trivial', () => { - const retornoLexador = lexador.mapear([ - 'tipo Quadrado', - ' lado: Inteiro', - ' area() = lado * lado', - ' perimetro() = 4 * lado', - 'fim' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - }); - }); - - describe('Cenários de Falha', () => { - it('Falha - Declaração de múltiplas variáveis inteiras, lado direito diferente de esquerdo', () => { - const retornoLexador = lexador.mapear(['var a, b, c := 10, 20'], -1); - expect(() => avaliadorSintatico.analisar(retornoLexador, -1)).toThrow(ErroAvaliadorSintatico); - expect(() => avaliadorSintatico.analisar(retornoLexador, -1)).toThrow( - expect.objectContaining({ - message: "Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.", - }) - ); - }); - }); - }); -}); diff --git a/testes/potigol/formatador-potigol.test.ts b/testes/potigol/formatador-potigol.test.ts deleted file mode 100644 index 826cfe9b..00000000 --- a/testes/potigol/formatador-potigol.test.ts +++ /dev/null @@ -1,432 +0,0 @@ -import * as sistemaOperacional from 'os'; - -import { AvaliadorSintaticoPotigol } from "../../fontes/avaliador-sintatico/dialetos"; -import { LexadorPotigol } from "../../fontes/lexador/dialetos"; -import { FormatadorPotigol } from "../../fontes/formatadores"; - -describe('Formatador > Potigol', () => { - describe('analisar()', () => { - const formatadorPotigol = new FormatadorPotigol(sistemaOperacional.EOL); - let avaliadorSintatico = new AvaliadorSintaticoPotigol(); - let lexador = new LexadorPotigol(); - - describe('Cenários de sucesso', () => { - describe('Entrada e saída', () => { - it('Sucesso - Escreva Olá Mundo', () => { - const retornoLexador = lexador.mapear(['escreva "Olá mundo"'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Sucesso - Imprima Olá Mundo', () => { - const retornoLexador = lexador.mapear(['imprima "Olá mundo"'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(1) - }); - }); - - describe('Operações matemáticas', () => { - it('Sucesso - Operações encadeadas', () => { - const retornoLexador = lexador.mapear(['escreva (2 * 8) - (5 / 4 ^ 7)'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2); - expect(linhasResultado).toHaveLength(3) - }); - - it('Sucesso - Mod e Div', () => { - const retornoLexador = lexador.mapear(['escreva (100 mod 6 div 2)'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(linhasResultado).toHaveLength(2) - }); - }); - - describe('Operações lógicas', () => { - it('Sucesso - Ou', () => { - const retornoLexador = lexador.mapear(['verdadeiro ou falso'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(1) - }); - - it('Sucesso - Não (sem acento)', () => { - const retornoLexador = lexador.mapear(['nao verdadeiro'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Sucesso - Comparação de igualdade', () => { - const retornoLexador = lexador.mapear(['escreva 2 == 2'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Sucesso - Comparação de desigualdade', () => { - const retornoLexador = lexador.mapear(['escreva 2 <> 2'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Sucesso - Comparação de menor', () => { - const retornoLexador = lexador.mapear(['escreva 2 < 2'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Sucesso - Comparação de menor ou igual', () => { - const retornoLexador = lexador.mapear(['escreva 2 <= 2'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Sucesso - Comparação de maior', () => { - const retornoLexador = lexador.mapear(['escreva 2 > 2'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Sucesso - Comparação de maior ou igual', () => { - const retornoLexador = lexador.mapear(['escreva 2 >= 2'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - }); - - describe('Atribuição de variáveis', () => { - it('Sucesso - Declaração de inteiro constante, inferência', () => { - const retornoLexador = lexador.mapear(['a = 10'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(linhasResultado).toHaveLength(1) - }); - - it('Sucesso - Declaração de caractere constante, dica de tipo', () => { - const retornoLexador = lexador.mapear(["c: Real = 3.5"], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(1) - }); - - it('Sucesso - Declaração de inteiro variável, inferência', () => { - const retornoLexador = lexador.mapear(['var a := 10'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(linhasResultado).toHaveLength(2) - }); - - it('Sucesso - Declaração de múltiplas variáveis inteiras, inferência', () => { - const retornoLexador = lexador.mapear(['var a, b, c := 10, 20, 30'], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(4) - }); - }); - - describe('Estruturas de decisão', () => { - it('Escolha', () => { - const retornoLexador = lexador.mapear([ - 'escolha x', - ' caso 1 => escreva "Um"', - ' caso 2 => escreva "Dois"', - ' caso 3 => escreva "Três"', - ' caso _ => escreva "Outro valor"', - 'fim' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(10) - }); - - it('Se', () => { - const retornoLexador = lexador.mapear([ - 'se verdadeiro então', - ' escreva "verdadeiro"', - 'senão', - ' escreva "falso"', - 'fim' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(8) - }); - }); - - describe('Estruturas de repetição', () => { - it('Enquanto', () => { - const retornoLexador = lexador.mapear([ - 'var i := 0', - 'enquanto i <= 10 faça', - ' escreva i', - ' i := i + 1', - 'fim' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(5) - }); - - it('Para', () => { - const retornoLexador = lexador.mapear([ - 'var soma := 0', - 'para i de 1 até 10 faça', - ' soma := soma + i', - 'fim', - 'escreva "A soma é {soma}."' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3); - expect(linhasResultado).toHaveLength(5) - }); - }); - - it('Função de uma linha, argumentos com tipo definido, sem dica de retorno', () => { - const retornoLexador = lexador.mapear([ - 'soma(x: Inteiro, y: Inteiro) = x + y' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(1) - }); - it('Função de uma linha, argumentos com tipo definido, com dica de retorno', () => { - const retornoLexador = lexador.mapear([ - 'soma(x: Inteiro, y: Inteiro): Inteiro = x + y' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - }); - - describe('Declarações de tuplas', () => { - it('Dupla', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Trio', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Quarteto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Quinteto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4, 5)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Sexteto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4, 5, 6)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Septeto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4, 5, 6, 7)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Octeto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4, 5, 6, 7, 8)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Noneto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4, 5, 6, 7, 8, 9)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - - it('Deceto', () => { - const retornoLexador = lexador.mapear([ - 'var t := (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const resultado = formatadorPotigol.formatar(retornoAvaliadorSintatico.declaracoes); - const linhasResultado = resultado.split(sistemaOperacional.EOL) - - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(linhasResultado).toHaveLength(2) - }); - }); - }); - }); -}); diff --git a/testes/potigol/interpretador.test.ts b/testes/potigol/interpretador.test.ts deleted file mode 100644 index 54bceeac..00000000 --- a/testes/potigol/interpretador.test.ts +++ /dev/null @@ -1,405 +0,0 @@ -import { AvaliadorSintaticoPotigol } from "../../fontes/avaliador-sintatico/dialetos"; -import { InterpretadorPotigol } from "../../fontes/interpretador/dialetos"; -import { LexadorPotigol } from "../../fontes/lexador/dialetos"; - -describe('Interpretador', () => { - describe('interpretar()', () => { - let lexador: LexadorPotigol; - let avaliadorSintatico: AvaliadorSintaticoPotigol; - let interpretador: InterpretadorPotigol; - - beforeEach(() => { - lexador = new LexadorPotigol(); - avaliadorSintatico = new AvaliadorSintaticoPotigol(); - interpretador = new InterpretadorPotigol(process.cwd()); - }); - - it('Trivial', async () => { - const retornoLexador = lexador.mapear([ - 'escreva "Olá mundo"' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual("Olá mundo") - } - - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - - expect(retornoInterpretador.erros).toHaveLength(0); - }); - - describe('Tipos e objetos', () => { - it('Trivial', async () => { - const saidasMensagens = [ - "100", - "40" - ] - const retornoLexador = lexador.mapear([ - 'tipo Quadrado', - ' area() = lado * lado', - ' lado: Inteiro', - ' perimetro() = 4 * lado', - 'fim', - 'q1 = Quadrado(10)', - 'escreva q1.area()', - 'escreva q1.perimetro()' - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - // TODO: Repensar isso aqui. Quando dá erro, o erro não - // faz sentido algum. - /* interpretador.funcaoDeRetorno = (saida: any) => { - expect(saidasMensagens.includes(saida)).toBeTruthy() - } */ - - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - - expect(retornoInterpretador.erros).toHaveLength(0); - }); - }); - - describe('qual_tipo', () => { - it('Dado um inteiro, escreva qual_tipo deve retornar Inteiro', async () => { - const retornoLexador = lexador.mapear([ - 'a = 3', - 'escreva(a.qual_tipo)' - ], -1); - - // Substitua a função de saída - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual("Inteiro"); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - expect(retornoInterpretador.erros).toHaveLength(0); - }); - - it('Dado um inteiro, escreva qual_tipo deve retornar Inteiro 2', async () => { - const retornoLexador = lexador.mapear([ - 'escreva(3.qual_tipo)' - ], -1); - - // Substitua a função de saída - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual("Inteiro"); - } - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - expect(retornoInterpretador.erros).toHaveLength(0); - }); - - it('Dado um real, escreva qual_tipo deve retornar Real', async () => { - const retornoLexador = lexador.mapear([ - 'a = 3.1', - 'escreva(a.qual_tipo)' - ], -1); - - // Substitua a função de saída - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual("Real"); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - expect(retornoInterpretador.erros).toHaveLength(0); - }); - - it('Dado uma variável, escreva qual_tipo deve atribuir Inteiro', async () => { - const retornoLexador = lexador.mapear([ - 'a = 3.qual_tipo', - 'escreva(a)' - ], -1); - - // Substitua a função de saída - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual("Inteiro"); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - expect(retornoInterpretador.erros).toHaveLength(0); - }); - - it('Dado um vetor, escreva qual_tipo deve imprirmir Lista', async () => { - const retornoLexador = lexador.mapear([ - 'a = [3, 4]', - 'escreva (a.qual_tipo)' - ], -1); - - // Substitua a função de saída - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual("Lista"); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - expect(retornoInterpretador.erros).toHaveLength(0); - }); - }); - - describe('Declaração de lista', () => { - it('Dado um vetor, escreva deve imprirmir o vetor', async () => { - const retornoLexador = lexador.mapear([ - 'a = [3, 4]', - 'escreva (a)' - ], -1); - - // Substitua a função de saída - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual('[3, 4]'); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - expect(retornoInterpretador.erros).toHaveLength(0); - }); - }) - - describe('Leia', () => { - it('Dado um leia_inteiro, escreva deve imprimir o valor lido', async () => { - const retornoLexador = lexador.mapear([ - 'escreva(leia_inteiro)' - ], -1); - - const resposta = 1; - interpretador.interfaceEntradaSaida = { - question: (mensagem: string, callback: Function) => { - callback(resposta); - } - }; - - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual('1'); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - - expect(retornoInterpretador.erros).toHaveLength(0); - }); - - it('Dado um leia_real, escreva deve imprimir o valor lido', async () => { - const retornoLexador = lexador.mapear([ - 'escreva(leia_real)' - ], -1); - - const resposta = 1.2; - interpretador.interfaceEntradaSaida = { - question: (mensagem: string, callback: Function) => { - callback(resposta); - } - }; - - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual('1.2'); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - - expect(retornoInterpretador.erros).toHaveLength(0); - }); - - it('Dado um leia_texto, escreva deve imprimir o valor lido', async () => { - const retornoLexador = lexador.mapear([ - 'escreva(leia_texto)' - ], -1); - - const resposta = "texto"; - interpretador.interfaceEntradaSaida = { - question: (mensagem: string, callback: Function) => { - callback(resposta); - } - }; - - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual('texto'); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - - expect(retornoInterpretador.erros).toHaveLength(0); - }); - - it('Dado um leia_inteiro, escreva deve imprimir os valores inicializados', async () => { - const retornoLexador = lexador.mapear([ - 'a, b, c = leia_inteiro', - 'escreva(a, b, c)' - ], -1); - - const resposta = [1, 2, 3]; - interpretador.interfaceEntradaSaida = { - question: (mensagem: string, callback: Function) => { - callback(resposta.shift()); - } - }; - - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual('(1,2,3)'); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - - expect(retornoInterpretador.erros).toHaveLength(0); - }); - - it('Dado um leia_inteiro, escreva deve imprimir o valor inicializado', async () => { - const retornoLexador = lexador.mapear([ - 'a = leia_inteiro', - 'escreva(a)' - ], -1); - - const resposta = [1]; - interpretador.interfaceEntradaSaida = { - question: (mensagem: string, callback: Function) => { - callback(resposta.shift()); - } - }; - - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual('1'); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - - expect(retornoInterpretador.erros).toHaveLength(0); - }); - }); - - describe('Leia vetores', () => { - it('Dado um leia_inteiros separador por virgula, escreva deve imprimir o valor lido', async () => { - const retornoLexador = lexador.mapear([ - 'escreva(leia_inteiros(","))' - ], -1); - - const resposta = '1,2,3'; - interpretador.interfaceEntradaSaida = { - question: (mensagem: string, callback: Function) => { - callback(resposta); - } - }; - - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual('[1, 2, 3]'); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - expect(retornoInterpretador.erros).toHaveLength(0); - }); - - it('Dado um leia_inteiros, escreva deve imprimir o valor lido', async () => { - const retornoLexador = lexador.mapear([ - 'programa', - 'escreva(leia_inteiros(3))', - 'fim', - ], -1); - - const respostas = [1, 2, 3]; - interpretador.interfaceEntradaSaida = { - question: (mensagem: string, callback: Function) => { - callback(respostas.shift()); - } - }; - - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual('[1, 2, 3]'); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - expect(retornoInterpretador.erros).toHaveLength(2); - }); - - it('Dado um leia_reais separador por virgula, escreva deve imprimir o valor lido', async () => { - const retornoLexador = lexador.mapear([ - 'escreva(leia_reais(","))' - ], -1); - - const resposta = '1,2,3'; - interpretador.interfaceEntradaSaida = { - question: (mensagem: string, callback: Function) => { - callback(resposta); - } - }; - - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual('[1, 2, 3]'); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - expect(retornoInterpretador.erros).toHaveLength(0); - }); - - it('Dado um leia_reais, escreva deve imprimir o valor lido', async () => { - const retornoLexador = lexador.mapear([ - 'escreva(leia_reais(3))' - ], -1); - - const respostas = [1, 2, 3]; - interpretador.interfaceEntradaSaida = { - question: (mensagem: string, callback: Function) => { - callback(respostas.shift()); - } - }; - - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual('[1, 2, 3]'); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - expect(retornoInterpretador.erros).toHaveLength(0); - }); - - it('Dado um leia_textos separador por virgula, escreva deve imprimir o valor lido', async () => { - const retornoLexador = lexador.mapear([ - 'escreva(leia_textos(","))' - ], -1); - - const resposta = 'a,b,c'; - interpretador.interfaceEntradaSaida = { - question: (mensagem: string, callback: Function) => { - callback(resposta); - } - }; - - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual('[a, b, c]'); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - expect(retornoInterpretador.erros).toHaveLength(0); - }); - - it('Dado um leia_textos, escreva deve imprimir o valor lido', async () => { - const retornoLexador = lexador.mapear([ - 'escreva(leia_textos(3))' - ], -1); - - const respostas = ['a', 'b', 'c']; - interpretador.interfaceEntradaSaida = { - question: (mensagem: string, callback: Function) => { - callback(respostas.shift()); - } - }; - - interpretador.funcaoDeRetorno = (saida: any) => { - expect(saida).toEqual('[a, b, c]'); - }; - - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); - expect(retornoInterpretador.erros).toHaveLength(0); - }); - }); - }); -}); diff --git a/testes/potigol/lexador.test.ts b/testes/potigol/lexador.test.ts deleted file mode 100644 index 94082536..00000000 --- a/testes/potigol/lexador.test.ts +++ /dev/null @@ -1,29 +0,0 @@ -import { LexadorPotigol } from "../../fontes/lexador/dialetos"; - -describe('Lexador (Potigol)', () => { - describe('mapear()', () => { - let lexador: LexadorPotigol; - - beforeEach(() => { - lexador = new LexadorPotigol(); - }); - - describe('Cenário de sucesso', () => { - it('Arquivo vazio.', () => { - const resultado = lexador.mapear([''], -1); - - expect(resultado).toBeTruthy(); - expect(resultado.simbolos).toHaveLength(0); - }); - - it('Olá mundo', () => { - const resultado = lexador.mapear([ - 'escreva "Olá Mundo"' - ], -1); - - expect(resultado).toBeTruthy(); - expect(resultado.simbolos).toHaveLength(2); - }); - }); - }); -}); diff --git a/testes/potigol/primitivas/primitivas-numero.test.ts b/testes/potigol/primitivas/primitivas-numero.test.ts deleted file mode 100644 index 072f1755..00000000 --- a/testes/potigol/primitivas/primitivas-numero.test.ts +++ /dev/null @@ -1,74 +0,0 @@ -import primitivasNumero from "../../../fontes/bibliotecas/dialetos/potigol/primitivas-numero"; -import { InterpretadorPotigol } from "../../../fontes/interpretador/dialetos/potigol/interpretador-potigol"; - -describe('Primitivas de número - Potigol', () => { - let interpretador: InterpretadorPotigol; - - beforeEach(() => { - interpretador = new InterpretadorPotigol( - process.cwd(), - false - ) - }); - - describe('arredonde()', () => { - it('Trivial', async () => { - const resultado = await primitivasNumero.arredonde(interpretador, 123.45); - expect(resultado).toStrictEqual(124); - }); - }); - - describe('caractere()', () => { - it('Trivial', async () => { - const resultado = await primitivasNumero.caractere(interpretador, 97); - expect(resultado).toStrictEqual('a'); - }); - }); - - describe('inteiro()', () => { - it('Trivial', async () => { - const resultado = await primitivasNumero.inteiro(interpretador, 123.45); - expect(resultado).toStrictEqual(123); - }); - }); - - describe('qual_tipo()', () => { - it('Inteiro', async () => { - const resultado = await primitivasNumero.qual_tipo(interpretador, 123); - expect(resultado).toStrictEqual('Inteiro'); - }); - - it('Real', async () => { - const resultado = await primitivasNumero.qual_tipo(interpretador, 123.45); - expect(resultado).toStrictEqual('Real'); - }); - }); - - describe('piso()', () => { - it('Trivial', async () => { - const resultado = await primitivasNumero.piso(interpretador, 123.45); - expect(resultado).toStrictEqual(123); - }); - }); - - describe('real()', () => { - it('Trivial', async () => { - const resultado = await primitivasNumero.real(interpretador, 123.45); - expect(resultado).toStrictEqual(123.45); - }); - }); - - describe('teto()', () => { - it('Trivial', async () => { - const resultado = await primitivasNumero.teto(interpretador, 123.45); - expect(resultado).toStrictEqual(124); - }); - }); - - describe('texto()', () => { - it('Trivial', async () => { - const resultado = await primitivasNumero.texto(interpretador, 123.45); - expect(resultado).toStrictEqual('123.45'); - }); - }); -}); diff --git a/testes/potigol/primitivas/primitivas-texto.test.ts b/testes/potigol/primitivas/primitivas-texto.test.ts deleted file mode 100644 index ce705941..00000000 --- a/testes/potigol/primitivas/primitivas-texto.test.ts +++ /dev/null @@ -1,173 +0,0 @@ -import primitivasTexto from '../../../fontes/bibliotecas/dialetos/potigol/primitivas-texto'; -import { InterpretadorPotigol } from '../../../fontes/interpretador/dialetos/potigol/interpretador-potigol'; - -describe('Primitivas de texto - Potigol', () => { - let interpretador: InterpretadorPotigol; - - beforeEach(() => { - interpretador = new InterpretadorPotigol( - process.cwd(), - false - ) - }); - - describe('cabeça()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.cabeça(interpretador, 'abc'); - expect(resultado).toStrictEqual('a'); - }); - }); - - describe('cauda()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.cauda(interpretador, 'abc'); - expect(resultado).toStrictEqual('bc'); - }); - }); - - describe('contém()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.contém(interpretador, 'abc', 'b'); - expect(resultado).toBe(true); - }); - - it('Elemento inexistente', async () => { - const resultado = await primitivasTexto.contém(interpretador, 'abc', 'f'); - expect(resultado).toBe(false); - }); - }); - - describe('descarte()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.descarte(interpretador, 'abcde', 2); - expect(resultado).toStrictEqual('cde'); - }); - }); - - describe('divida()', () => { - it('Sem separador como argumento', async () => { - const resultado = await primitivasTexto.divida(interpretador, 'Um texto'); - expect(resultado).toStrictEqual(['Um', 'texto']); - }); - - it('Com separador como argumento', async () => { - const resultado = await primitivasTexto.divida(interpretador, 'Um-texto', '-'); - expect(resultado).toStrictEqual(['Um', 'texto']); - }); - }); - - describe('insira()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.insira(interpretador, 'abc', 3, 'd'); - expect(resultado).toStrictEqual('abdc'); - }); - }); - - describe('inteiro()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.inteiro(interpretador, '123'); - expect(resultado).toStrictEqual(123); - }); - - it('Texto decimal', async () => { - const resultado = await primitivasTexto.inteiro(interpretador, '123.45'); - expect(resultado).toStrictEqual(123); - }); - }); - - describe('inverta()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.inverta(interpretador, 'abcde'); - expect(resultado).toStrictEqual('edcba'); - }); - }); - - describe('junte()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.junte(interpretador, 'abc', '-'); - expect(resultado).toStrictEqual('a-b-c'); - }); - }); - - describe('lista()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.lista(interpretador, 'abc'); - expect(resultado).toStrictEqual(['a', 'b', 'c']); - }); - }); - - describe('maiúsculo()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.maiúsculo(interpretador, 'Abc'); - expect(resultado).toStrictEqual('ABC'); - }); - }); - - describe('minúsculo()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.minúsculo(interpretador, 'Abc'); - expect(resultado).toStrictEqual('abc'); - }); - }); - - describe('ordene()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.ordene(interpretador, 'bca'); - expect(resultado).toStrictEqual('abc'); - }); - }); - - describe('pegue()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.pegue(interpretador, 'abcde', 3); - expect(resultado).toStrictEqual('abc'); - }); - }); - - describe('posição()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.posição(interpretador, 'abcde', 'b'); - expect(resultado).toStrictEqual(2); - }); - }); - - describe('qual_tipo()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.qual_tipo(interpretador, 'bca'); - expect(resultado).toStrictEqual('Texto'); - }); - }); - - describe('real()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.real(interpretador, '123.45'); - expect(resultado).toStrictEqual(123.45); - }); - }); - - describe('remova()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.remova(interpretador, 'abc', 2); - expect(resultado).toStrictEqual('ac'); - }); - }); - - describe('tamanho()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.tamanho(interpretador, 'abc'); - expect(resultado).toStrictEqual(3); - }); - }); - - describe('último()', () => { - it('Trivial', async () => { - const resultado = await primitivasTexto.último(interpretador, 'abc'); - expect(resultado).toStrictEqual('c'); - }); - - it('Texto vazio', async () => { - const resultado = await primitivasTexto.último(interpretador, ''); - expect(resultado).toStrictEqual(''); - }); - }); -}); \ No newline at end of file diff --git a/testes/potigol/primitivas/primitivas-vetor.test.ts b/testes/potigol/primitivas/primitivas-vetor.test.ts deleted file mode 100644 index 80ce44db..00000000 --- a/testes/potigol/primitivas/primitivas-vetor.test.ts +++ /dev/null @@ -1,114 +0,0 @@ -import primitivasVetor from '../../../fontes/bibliotecas/dialetos/potigol/primitivas-vetor'; -import { InterpretadorPotigol } from '../../../fontes/interpretador/dialetos/potigol/interpretador-potigol'; - -describe('Primitivas de vetor - Potigol', () => { - let interpretador: InterpretadorPotigol; - - beforeEach(() => { - interpretador = new InterpretadorPotigol( - process.cwd(), - false - ) - }); - - describe('cabeça()', () => { - it('Trivial', async () => { - const resultado = await primitivasVetor.cabeça(interpretador, [1, 2, 3]); - expect(resultado).toStrictEqual(1); - }); - }); - - describe('cauda()', () => { - it('Trivial', async () => { - const resultado = await primitivasVetor.cauda(interpretador, [1, 2, 3]); - expect(resultado).toStrictEqual([2, 3]); - }); - }); - - describe('contém()', () => { - it('Trivial', async () => { - const resultado = await primitivasVetor.contém(interpretador, [1, 2, 3], 2); - expect(resultado).toBe(true); - }); - - it('Elemento inexistente', async () => { - const resultado = await primitivasVetor.contém(interpretador, [1, 2, 3], 4); - expect(resultado).toBe(false); - }); - }); - - describe('descarte()', () => { - it('Trivial', async () => { - const resultado = await primitivasVetor.descarte(interpretador, [2, 4, 6, 8, 10], 2); - expect(resultado).toStrictEqual([6, 8, 10]); - }); - }); - - describe('inverta()', () => { - it('Trivial', async () => { - const resultado = await primitivasVetor.inverta(interpretador, [2, 4, 6, 8, 10]); - expect(resultado).toStrictEqual([10, 8, 6, 4, 2]); - }); - }); - - describe('junte()', () => { - it('Trivial', async () => { - const resultado = await primitivasVetor.junte(interpretador, [2, 4, 6, 8, 10], '-'); - expect(resultado).toStrictEqual('2-4-6-8-10'); - }); - }); - - describe('ordene()', () => { - it('Trivial', async () => { - const resultado = await primitivasVetor.ordene(interpretador, [4, 8, 10, 2, 6]); - expect(resultado).toStrictEqual([2, 4, 6, 8, 10]); - }); - }); - - describe('pegue()', () => { - it('Trivial', async () => { - const resultado = await primitivasVetor.pegue(interpretador, [2, 4, 6, 8, 10], 3); - expect(resultado).toStrictEqual([2, 4, 6]); - }); - }); - - describe('posição()', () => { - it('Trivial', async () => { - const resultado = await primitivasVetor.posição(interpretador, [2, 4, 6, 8, 10], 8); - expect(resultado).toStrictEqual(4); - }); - }); - - describe('remova()', () => { - it('Trivial', async () => { - const resultado = await primitivasVetor.remova(interpretador, [2, 4, 6, 8, 10], 3); - expect(resultado).toStrictEqual([2, 4, 8, 10]); - }); - }); - - describe('tamanho()', () => { - it('Trivial', async () => { - const resultado = await primitivasVetor.tamanho(interpretador, [2, 4, 6, 8, 10]); - expect(resultado).toStrictEqual(5); - }); - }); - - describe('último()', () => { - it('Trivial', async () => { - const resultado = await primitivasVetor.último(interpretador, [2, 4, 6, 8, 10]); - expect(resultado).toStrictEqual(10); - }); - }); - - describe('vazia()', () => { - it('Lista com elementos', async () => { - const resultado = await primitivasVetor.vazia(interpretador, [2, 4, 6, 8, 10]); - expect(resultado).toBe(false); - }); - - it('Lista vazia', async () => { - const resultado = await primitivasVetor.vazia(interpretador, []); - expect(resultado).toBe(true); - }); - }); -});