@designliquido/delegua
Version:
Linguagem de programação simples e moderna usando português estruturado.
514 lines • 27.2 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.aleatorio = aleatorio;
exports.aleatorioEntre = aleatorioEntre;
exports.algum = algum;
exports.encontrar = encontrar;
exports.encontrarIndice = encontrarIndice;
exports.encontrarUltimo = encontrarUltimo;
exports.encontrarUltimoIndice = encontrarUltimoIndice;
exports.filtrarPor = filtrarPor;
exports.incluido = incluido;
exports.inteiro = inteiro;
exports.mapear = mapear;
exports.numero = numero;
exports.ordenar = ordenar;
exports.paraCada = paraCada;
exports.primeiroEmCondicao = primeiroEmCondicao;
exports.real = real;
exports.reduzir = reduzir;
exports.tamanho = tamanho;
exports.texto = texto;
exports.todosEmCondicao = todosEmCondicao;
exports.tupla = tupla;
const excecoes_1 = require("../excecoes");
const objeto_delegua_classe_1 = require("../interpretador/estruturas/objeto-delegua-classe");
const funcao_padrao_1 = require("../interpretador/estruturas/funcao-padrao");
const descritor_tipo_classe_1 = require("../interpretador/estruturas/descritor-tipo-classe");
const estruturas_1 = require("../interpretador/estruturas");
const construtos_1 = require("../construtos");
/**
* Retorna um número aleatório entre 0 e 1.
* @returns {Promise<number>} Número real.
*/
async function aleatorio(interpretador) {
return Promise.resolve(Math.random());
}
/**
* Retorna um número aleatório de acordo com o parâmetro passado.
* Mínimo(inclusivo) - Máximo(exclusivo).
* @param {number} minimo O número mínimo.
* @param {number} maximo O número máximo.
* @returns {Promise<number>} Um número real entre os valores máximo e mínimo especificados.
*/
async function aleatorioEntre(interpretador, minimo, maximo) {
if (arguments.length <= 0) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'A função recebe ao menos um parâmetro.'));
}
const valorMinimo = minimo.hasOwnProperty('valor') ? minimo.valor : minimo;
if (arguments.length === 2) {
if (typeof valorMinimo !== 'number') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'O parâmetro deve ser um número.'));
}
return Math.floor(Math.random() * (0 - valorMinimo)) + valorMinimo;
}
if (arguments.length > 3) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'A quantidade de parâmetros máxima para esta função é 2.'));
}
const valorMaximo = maximo.hasOwnProperty('valor') ? maximo.valor : maximo;
if (typeof valorMinimo !== 'number' || typeof valorMaximo !== 'number') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Os dois parâmetros devem ser do tipo número.'));
}
return Promise.resolve(Math.floor(Math.random() * (valorMaximo - valorMinimo)) + valorMinimo);
}
/**
* Verifica se algum dos elementos satisfaz à condição para por parâmetro.
* @param {InterpretadorInterface} interpretador A instância do interpretador.
* @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
* @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
* @returns {Promise<boolean>} Verdadeiro se há algum elemento no vetor com a condição. Falso caso contrário.
*/
async function algum(interpretador, vetor, funcaoPesquisa) {
const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
if (!Array.isArray(valorVetor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
}
if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
}
for (let indice = 0; indice < valorVetor.length; ++indice) {
if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
return true;
}
}
return false;
}
/**
* Encontra o primeiro elemento de um vetor cuja função de pesquisa retorne
* verdadeiro na avaliação de cada elemento.
* @param {InterpretadorInterface} interpretador A instância do interpretador.
* @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
* @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
* @returns {Promise<any>} Um elemento, caso o elemento seja encontraro, ou nulo em caso contrário.
*/
async function encontrar(interpretador, vetor, funcaoPesquisa) {
const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
if (!Array.isArray(valorVetor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
}
if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
}
for (let indice = 0; indice < valorVetor.length; ++indice) {
if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
return valorVetor[indice];
}
}
return null;
}
/**
* Encontra o índice do primeiro elemento de um vetor cuja função de pesquisa retorne
* verdadeiro na avaliação de cada elemento.
* @param {InterpretadorInterface} interpretador A instância do interpretador.
* @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
* @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
* @returns {Promise<number>} O número correspondente ao índice se o elemento for encontrado, ou nulo em caso contrário.
*/
async function encontrarIndice(interpretador, vetor, funcaoPesquisa) {
const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
if (!Array.isArray(valorVetor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
}
if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
}
for (let indice = 0; indice < valorVetor.length; ++indice) {
if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
return indice;
}
}
return -1;
}
/**
* Encontrar o último elemento de um vetor cuja função de pesquisa retorne
* verdadeiro na avaliação de cada elemento.
* @param {InterpretadorInterface} interpretador A instância do interpretador.
* @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
* @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
* @returns {Promise<any>} O número correspondente ao índice se o elemento for encontrado, ou nulo em caso contrário.
*/
async function encontrarUltimo(interpretador, vetor, funcaoPesquisa) {
const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
if (!Array.isArray(valorVetor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
}
if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
}
for (let indice = valorVetor.length - 1; indice >= 0; --indice) {
if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
return valorVetor[indice];
}
}
return null;
}
/**
*
* @param {InterpretadorInterface} interpretador A instância do interpretador.
* @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
* @param {VariavelInterface | any} funcaoPesquisa A função que ensina o método de pesquisa.
* @returns {Promise<number>} O número correspondente ao índice se o elemento for encontrado, ou nulo em caso contrário.
*/
async function encontrarUltimoIndice(interpretador, vetor, funcaoPesquisa) {
const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
const valorFuncaoPesquisa = funcaoPesquisa.hasOwnProperty('valor') ? funcaoPesquisa.valor : funcaoPesquisa;
if (!Array.isArray(valorVetor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
}
if (valorFuncaoPesquisa.constructor.name !== 'DeleguaFuncao') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
}
for (let indice = valorVetor.length - 1; indice >= 0; --indice) {
if (await valorFuncaoPesquisa.chamar(interpretador, [valorVetor[indice]])) {
return indice;
}
}
return null;
}
/**
*
* @param interpretador
* @param vetor
* @param funcaoFiltragem
* @returns
*/
async function filtrarPor(interpretador, vetor, funcaoFiltragem) {
if (vetor === null || vetor === undefined)
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função filtrarPor() não pode ser nulo.'));
const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor') ? funcaoFiltragem.valor : funcaoFiltragem;
if (!Array.isArray(valorVetor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função filtrarPor() deve ser um vetor.'));
}
if (valorFuncaoFiltragem.constructor.name !== 'DeleguaFuncao') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O segundo parâmetro da função filtrarPor() deve ser uma função.'));
}
const resultados = [];
for (let indice = 0; indice < valorVetor.length; ++indice) {
const deveRetornarValor = await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
if (deveRetornarValor === false)
continue;
resultados.push(valorVetor[indice]);
}
return resultados;
}
/**
*
* @param {InterpretadorInterface} interpretador A instância do interpretador.
* @param {VariavelInterface | any} vetor Uma variável de Delégua ou um vetor nativo de JavaScript.
* @param valor
* @returns
*/
async function incluido(interpretador, vetor, valor) {
const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
const valorValor = valor.hasOwnProperty('valor') ? valor.valor : valor;
if (!Array.isArray(valorVetor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
}
for (let indice = 0; indice < valorVetor.length; ++indice) {
if (valorVetor[indice] == valorValor) {
return true;
}
}
return false;
}
function validacaoComumNumeros(valorParaConverter) {
if (isNaN(valorParaConverter)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Valor não parece ser um número. Somente números ou textos com números podem ser convertidos para inteiro.'));
}
if (!/^(-)?\d+(\.\d+)?$/.test(valorParaConverter)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Valor não parece estar estruturado como um número (texto vazio, falso ou não definido). Somente números ou textos com números podem ser convertidos para inteiro.'));
}
return null;
}
/**
* Converte um valor em um número inteiro.
* @param {InterpretadorInterface} interpretador A instância do interpretador.
* @param {VariavelInterface | any} valorParaConverter O valor a ser convertido.
* @returns {Promise<any>} Uma Promise com o resultado da conversão.
*/
async function inteiro(interpretador, valorParaConverter) {
if (valorParaConverter === null || valorParaConverter === undefined)
return Promise.resolve(0);
const valor = valorParaConverter.hasOwnProperty('valor') ? valorParaConverter.valor : valorParaConverter;
const resultadoValidacao = validacaoComumNumeros(valor);
return resultadoValidacao || Promise.resolve(parseInt(valor));
}
/**
*
* @param interpretador
* @param vetor
* @param funcaoMapeamento
* @returns
*/
async function mapear(interpretador, vetor, funcaoMapeamento) {
if (vetor === null || vetor === undefined)
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função mapear() não pode ser nulo.'));
const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
const valorFuncaoMapeamento = funcaoMapeamento.hasOwnProperty('valor') ? funcaoMapeamento.valor : funcaoMapeamento;
// TODO: As lógicas de validação abaixo deixam de fazer sentido com a validação de argumentos feita
// na avaliação sintática. Estudar remoção.
if (!Array.isArray(valorVetor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função mapear() deve ser um vetor.'));
}
if (valorFuncaoMapeamento.constructor.name !== 'DeleguaFuncao') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O segundo parâmetro da função mapear() deve ser uma função.'));
}
const resultados = [];
for (let indice = 0; indice < valorVetor.length; ++indice) {
resultados.push(await valorFuncaoMapeamento.chamar(interpretador, [valorVetor[indice]]));
}
return resultados;
}
/**
* Converte um valor em um número, com parte decimal ou não.
* @param {InterpretadorInterface} interpretador A instância do interpretador.
* @param {VariavelInterface | any} valorParaConverter O valor a ser convertido.
* @returns {Promise<any>} Uma Promise com o resultado da conversão.
*/
async function numero(interpretador, valorParaConverter) {
if (valorParaConverter === null || valorParaConverter === undefined)
return Promise.resolve(0);
const valor = valorParaConverter.hasOwnProperty('valor') ? valorParaConverter.valor : valorParaConverter;
const resultadoValidacao = validacaoComumNumeros(valor);
return resultadoValidacao || Promise.resolve(Number(valor));
}
/**
*
* @param vetor
* @returns
*/
async function ordenar(interpretador, vetor) {
if (vetor === null || vetor === undefined)
throw new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função ordenar() não pode ser nulo.');
const objeto = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
if (!Array.isArray(objeto)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Valor inválido. Objeto inserido não é um vetor.'));
}
let trocado;
const tamanho = objeto.length;
do {
trocado = false;
for (let i = 0; i < tamanho - 1; i++) {
if (objeto[i] > objeto[i + 1]) {
[objeto[i], objeto[i + 1]] = [objeto[i + 1], objeto[i]];
trocado = true;
}
}
} while (trocado);
return Promise.resolve(objeto);
}
/**
*
* @param interpretador
* @param vetor
* @param funcaoFiltragem
* @returns
*/
async function paraCada(interpretador, vetor, funcaoFiltragem) {
if (vetor === null || vetor === undefined)
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função paraCada() não pode ser nulo.'));
const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor') ? funcaoFiltragem.valor : funcaoFiltragem;
// TODO: As lógicas de validação abaixo deixam de fazer sentido com a validação de argumentos feita
// na avaliação sintática. Estudar remoção.
if (!Array.isArray(valorVetor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função paraCada() deve ser um vetor.'));
}
if (valorFuncaoFiltragem.constructor.name !== 'DeleguaFuncao') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O segundo parâmetro da função paraCada() deve ser uma função.'));
}
for (let indice = 0; indice < valorVetor.length; ++indice) {
await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
}
}
/**
*
* @param interpretador
* @param vetor
* @param funcaoFiltragem
* @returns
*/
async function primeiroEmCondicao(interpretador, vetor, funcaoFiltragem) {
if (vetor === null || vetor === undefined)
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função primeiroEmCondicao() não pode ser nulo.'));
const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
const valorFuncaoFiltragem = funcaoFiltragem.hasOwnProperty('valor') ? funcaoFiltragem.valor : funcaoFiltragem;
if (!Array.isArray(valorVetor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função primeiroEmCondicao() deve ser um vetor.'));
}
if (valorFuncaoFiltragem.constructor.name !== 'DeleguaFuncao') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O segundo parâmetro da função primeiroEmCondicao() deve ser uma função.'));
}
for (let indice = 0; indice < valorVetor.length; ++indice) {
const valorResolvido = await valorFuncaoFiltragem.chamar(interpretador, [valorVetor[indice]]);
if (valorResolvido !== null) {
return valorResolvido;
}
}
return undefined;
}
/**
*
* @param interpretador
* @param numero
* @returns
*/
async function real(interpretador, numero) {
if (numero === null || numero === undefined)
return Promise.resolve(parseFloat('0'));
const valor = numero.hasOwnProperty('valor') ? numero.valor : numero;
if (!/^(-)?\d+(\.\d+)?$/.test(valor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Valor não parece estar estruturado como um número (texto/valor vazio, falso ou não definido). Somente números ou textos com números podem ser convertidos para real.'));
}
return Promise.resolve(parseFloat(valor));
}
/**
*
* @param interpretador
* @param vetor
* @param funcaoReducao
* @param valorInicial
* @returns
*/
async function reduzir(interpretador, vetor, funcaoReducao, valorInicial = null) {
const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
const valorFuncaoReducao = funcaoReducao.hasOwnProperty('valor') ? funcaoReducao.valor : funcaoReducao;
const valorPadrao = valorInicial.hasOwnProperty('valor') ? valorInicial.valor : valorInicial;
if (!Array.isArray(valorVetor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função deve ser um vetor.'));
}
if (valorFuncaoReducao.constructor.name !== 'DeleguaFuncao') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O segundo parâmetro da função deve ser uma função.'));
}
let resultado = valorPadrao;
let inicio = 0;
if (!resultado) {
resultado = vetor[0];
inicio = 1;
}
for (let index = inicio; index < vetor.length; ++index) {
resultado = await valorFuncaoReducao.chamar(interpretador, [resultado, vetor[index]]);
}
return resultado;
}
/**
*
* @param objeto
* @returns
*/
async function tamanho(interpretador, objeto) {
const valorObjeto = objeto.hasOwnProperty('valor') ? objeto.valor : objeto;
if (typeof valorObjeto === 'number') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Função global tamanho() não funciona com números.'));
}
if (valorObjeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Função global tamanho não funciona com objetos complexos.'));
}
if (valorObjeto instanceof estruturas_1.DeleguaFuncao) {
return Promise.resolve(valorObjeto.declaracao.parametros.length);
}
if (valorObjeto instanceof funcao_padrao_1.FuncaoPadrao) {
return Promise.resolve(valorObjeto.valorAridade);
}
if (valorObjeto instanceof descritor_tipo_classe_1.DescritorTipoClasse) {
const metodos = valorObjeto.metodos;
let tamanho = 0;
if (metodos.inicializacao && metodos.inicializacao.eInicializador) {
tamanho = metodos.inicializacao.declaracao.parametros.length;
}
return Promise.resolve(tamanho);
}
return Promise.resolve(valorObjeto.length);
}
/**
* Transforma o valor ou variável em texto.
* @param {InterpretadorInterface} interpretador A instância do interpretador.
* @param {VariavelInterface | any} valorParaConverter O valor ou variável.
* @returns {Promise<string>} O valor resolvido em texto.
*/
async function texto(interpretador, valorParaConverter) {
return Promise.resolve(`${valorParaConverter.hasOwnProperty('valor') ? valorParaConverter.valor : valorParaConverter}`);
}
/**
* Retorna verdadeiro se todos os elementos do primeiro parâmetro retornam verdadeiro ao
* serem aplicados como argumentos da função passada como segundo parâmetro.
* @param {InterpretadorInterface} interpretador A instância do interpretador.
* @param {VariavelInterface | any} vetor O primeiro parâmetro, um vetor.
* @param {VariavelInterface | any} funcaoCondicional A função que será executada com cada
* valor do vetor passado como primeiro parâmetro.
* @returns {Promise<boolean>} Verdadeiro, se todos os valores do vetor fazem a função passada
* por parâmetro devolver verdadeiro, ou falso em caso contrário.
*/
async function todosEmCondicao(interpretador, vetor, funcaoCondicional) {
if (vetor === null || vetor === undefined)
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função todosEmCondicao() não pode ser nulo.'));
const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
const valorFuncaoCondicional = funcaoCondicional.hasOwnProperty('valor')
? funcaoCondicional.valor
: funcaoCondicional;
if (!Array.isArray(valorVetor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O primeiro parâmetro da função todosEmCondicao() deve ser um vetor.'));
}
if (valorFuncaoCondicional.constructor.name !== 'DeleguaFuncao') {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Parâmetro inválido. O segundo parâmetro da função todosEmCondicao() deve ser uma função.'));
}
for (let indice = 0; indice < valorVetor.length; ++indice) {
if (!(await valorFuncaoCondicional.chamar(interpretador, [valorVetor[indice]])))
return false;
}
return true;
}
/**
* Transforma um vetor de elementos em uma tupla de N elementos, sendo N a
* largura do vetor.
* @param {InterpretadorInterface} interpretador A instância do interpretador.
* @param {VariavelInterface | any[]} vetor O vetor.
* @returns A tupla resolvida.
*/
async function tupla(interpretador, vetor) {
const valorVetor = !Array.isArray(vetor) && vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
// TODO: As lógicas de validação abaixo deixam de fazer sentido com a validação de argumentos feita
// na avaliação sintática. Estudar remoção.
if (!Array.isArray(valorVetor)) {
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Argumento de função nativa `tupla` não parece ser um vetor.'));
}
switch (valorVetor.length) {
case 2:
return Promise.resolve(new construtos_1.Dupla(valorVetor[0], valorVetor[1]));
case 3:
return Promise.resolve(new construtos_1.Trio(valorVetor[0], valorVetor[1], valorVetor[2]));
case 4:
return Promise.resolve(new construtos_1.Quarteto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3]));
case 5:
return Promise.resolve(new construtos_1.Quinteto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4]));
case 6:
return Promise.resolve(new construtos_1.Sexteto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5]));
case 7:
return Promise.resolve(new construtos_1.Septeto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6]));
case 8:
return Promise.resolve(new construtos_1.Octeto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6], valorVetor[7]));
case 9:
return Promise.resolve(new construtos_1.Noneto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6], valorVetor[7], valorVetor[8]));
case 10:
return Promise.resolve(new construtos_1.Deceto(valorVetor[0], valorVetor[1], valorVetor[2], valorVetor[3], valorVetor[4], valorVetor[5], valorVetor[6], valorVetor[7], valorVetor[8], valorVetor[9]));
case 1:
default:
return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(this.simbolo, 'Para ser transformado em uma tupla, vetor precisa ter de 2 a 10 elementos.'));
}
}
//# sourceMappingURL=biblioteca-global.js.map