From f45ccbe91bf17357e6500fe98b6a9106cf4ec32f Mon Sep 17 00:00:00 2001 From: Aristidescosta Date: Sun, 21 Jan 2024 22:14:12 +0100 Subject: [PATCH 01/12] feat: reconhecendo o aleatorio --- .../visualg/avaliador-sintatico-visualg.ts | 14 ++++++++++++++ fontes/declaracoes/aleatorio.ts | 17 +++++++++++++++++ fontes/declaracoes/index.ts | 1 + .../interfaces/visitante-comum-interface.ts | 2 ++ .../dialetos/palavras-reservadas/visualg.ts | 1 + fontes/tipos-de-simbolos/visualg.ts | 1 + testes/visualg/avaliador-sintatico.test.ts | 19 +++++++++++++++++++ 7 files changed, 55 insertions(+) create mode 100644 fontes/declaracoes/aleatorio.ts diff --git a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts index 525054e0..5b096353 100644 --- a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts +++ b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts @@ -41,6 +41,7 @@ import { Simbolo } from '../../../lexador'; import tiposDeSimbolos from '../../../tipos-de-simbolos/visualg'; import { ParametroVisuAlg } from './parametro-visualg'; import { TiposDadosInterface } from '../../../interfaces/tipos-dados-interface'; +import { Aleatorio } from '../../../declaracoes/aleatorio'; export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { blocoPrincipalIniciado: boolean; @@ -309,6 +310,8 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { primario(): Construto { const simboloAtual = this.simbolos[this.atual]; + console.log(simboloAtual) + if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FALSO)) return new Literal(this.hashArquivo, Number(simboloAtual.linha), false); if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VERDADEIRO)) @@ -321,6 +324,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { if ( this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR, tiposDeSimbolos.METODO_BIBLIOTECA_GLOBAL) ) { + console.log("entro aqui"); return new Variavel(this.hashArquivo, this.simbolos[this.atual - 1]); } @@ -341,6 +345,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { return new Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao); } + console.log("Cheguei até aqui"); throw this.erro(this.simbolos[this.atual], 'Esperado expressão.'); } @@ -1115,9 +1120,18 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { ); } + declaracaoAleatorio(): Aleatorio{ + const simboloAleatorio: SimboloInterface = this.avancarEDevolverAnterior(); + + return new Aleatorio(simboloAleatorio.linha, simboloAleatorio.hashArquivo) + + } + resolverDeclaracaoForaDeBloco(): Declaracao | Declaracao[] | Construto | Construto[] | any { const simboloAtual = this.simbolos[this.atual]; switch (simboloAtual.tipo) { + case tiposDeSimbolos.ALEATORIO: + return this.declaracaoAleatorio(); case tiposDeSimbolos.ENQUANTO: return this.declaracaoEnquanto(); case tiposDeSimbolos.ESCOLHA: diff --git a/fontes/declaracoes/aleatorio.ts b/fontes/declaracoes/aleatorio.ts new file mode 100644 index 00000000..20f74d7d --- /dev/null +++ b/fontes/declaracoes/aleatorio.ts @@ -0,0 +1,17 @@ +import { VisitanteComumInterface } from "../interfaces"; +import { Bloco } from "./bloco"; +import { Declaracao } from "./declaracao"; + +export class Aleatorio extends Declaracao { + /* corpo: Bloco; */ + + constructor(linha: number, hashArquivo: number/* , corpo: Bloco */){ + super(linha, hashArquivo); + + /* this.corpo = corpo */ + } + + async aceitar(visitante: VisitanteComumInterface): Promise { + return await visitante.visitarDeclaracaoAleatorio(this); + } +} \ No newline at end of file diff --git a/fontes/declaracoes/index.ts b/fontes/declaracoes/index.ts index f49ddc92..a401933e 100644 --- a/fontes/declaracoes/index.ts +++ b/fontes/declaracoes/index.ts @@ -24,3 +24,4 @@ export * from './se'; export * from './tente'; export * from './var'; export * from './var-multiplo'; +export * from './aleatorio'; \ No newline at end of file diff --git a/fontes/interfaces/visitante-comum-interface.ts b/fontes/interfaces/visitante-comum-interface.ts index 2a475509..da336147 100644 --- a/fontes/interfaces/visitante-comum-interface.ts +++ b/fontes/interfaces/visitante-comum-interface.ts @@ -1,5 +1,6 @@ import { Atribuir, ExpressaoRegular, FimPara, Literal, Super, TipoDe } from '../construtos'; import { + Aleatorio, Bloco, Classe, Const, @@ -29,6 +30,7 @@ import { ConstMultiplo } from '../declaracoes/const-multiplo'; import { VarMultiplo } from '../declaracoes/var-multiplo'; export interface VisitanteComumInterface { + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise visitarDeclaracaoClasse(declaracao: Classe): any; visitarDeclaracaoConst(declaracao: Const): Promise; visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise; diff --git a/fontes/lexador/dialetos/palavras-reservadas/visualg.ts b/fontes/lexador/dialetos/palavras-reservadas/visualg.ts index df218c64..c745cc50 100644 --- a/fontes/lexador/dialetos/palavras-reservadas/visualg.ts +++ b/fontes/lexador/dialetos/palavras-reservadas/visualg.ts @@ -3,6 +3,7 @@ import tiposDeSimbolos from '../../../tipos-de-simbolos/visualg'; export const palavrasReservadas = { abs: tiposDeSimbolos.METODO_BIBLIOTECA_GLOBAL, algoritmo: tiposDeSimbolos.ALGORITMO, + aleatorio: tiposDeSimbolos.ALEATORIO, arccos: tiposDeSimbolos.METODO_BIBLIOTECA_GLOBAL, arcsen: tiposDeSimbolos.METODO_BIBLIOTECA_GLOBAL, arctan: tiposDeSimbolos.METODO_BIBLIOTECA_GLOBAL, diff --git a/fontes/tipos-de-simbolos/visualg.ts b/fontes/tipos-de-simbolos/visualg.ts index 14bb7f02..13a07362 100644 --- a/fontes/tipos-de-simbolos/visualg.ts +++ b/fontes/tipos-de-simbolos/visualg.ts @@ -1,6 +1,7 @@ export default { ADICAO: 'ADICAO', ALGORITMO: 'ALGORITMO', + ALEATORIO: 'ALEATORIO', ATE: 'ATE', ATÉ: 'ATÉ', CARACTER: 'CARACTER', diff --git a/testes/visualg/avaliador-sintatico.test.ts b/testes/visualg/avaliador-sintatico.test.ts index d9a6a53a..0c17999b 100644 --- a/testes/visualg/avaliador-sintatico.test.ts +++ b/testes/visualg/avaliador-sintatico.test.ts @@ -284,6 +284,25 @@ describe('Avaliador sintático (VisuAlg)', () => { expect(retornoAvaliadorSintatico).toBeTruthy(); expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(22); }); + + it('Sucesso - Aleatorio', () => { + const retornoLexador = lexador.mapear( + [ + 'algoritmo "Exemplo Xou"', + 'var', + 'inicio', + 'aleatorio', + 'fimalgoritmo', + ], + -1 + ); + + const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); + console.log(retornoAvaliadorSintatico); + + /* expect(retornoAvaliadorSintatico).toBeTruthy(); + expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(22); */ + }); }); describe('Cenário de falha', () => { From d3d252472b2f2b778bb5adbca9b8b8db37bb31b0 Mon Sep 17 00:00:00 2001 From: Aristidescosta Date: Mon, 22 Jan 2024 10:52:45 +0100 Subject: [PATCH 02/12] refactor: melhorando o avaliador-sintatico para o aleatorio --- .../analisador-semantico.ts | 6 ++++ .../dialetos/analisador-semantico-visualg.ts | 5 +++ .../visualg/avaliador-sintatico-visualg.ts | 32 +++++++++++++++---- fontes/declaracoes/aleatorio.ts | 6 ++-- .../dialetos/palavras-reservadas/visualg.ts | 2 ++ fontes/tipos-de-simbolos/visualg.ts | 2 ++ testes/visualg/avaliador-sintatico.test.ts | 5 ++- 7 files changed, 47 insertions(+), 11 deletions(-) diff --git a/fontes/analisador-semantico/analisador-semantico.ts b/fontes/analisador-semantico/analisador-semantico.ts index 0bf13bf3..244a402c 100644 --- a/fontes/analisador-semantico/analisador-semantico.ts +++ b/fontes/analisador-semantico/analisador-semantico.ts @@ -1,5 +1,6 @@ import { Agrupamento, Atribuir, Binario, Chamada, Construto, ExpressaoRegular, FimPara, FormatacaoEscrita, FuncaoConstruto, Literal, Logico, Super, TipoDe, Variavel, Vetor } from '../construtos'; import { + Aleatorio, Bloco, Classe, Const, @@ -59,6 +60,11 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface { this.atual = 0; this.diagnosticos = []; } + + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise { + return Promise.resolve(); + } + visitarExpressaoAcessoElementoMatriz(expressao: any) { return Promise.resolve(); } diff --git a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts index b4c6540a..60e9ae43 100644 --- a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts +++ b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts @@ -1,5 +1,6 @@ import { Atribuir, Chamada, ExpressaoRegular, FimPara, FormatacaoEscrita, FuncaoConstruto, Literal, Super, TipoDe, Variavel, Vetor } from "../../construtos"; import { + Aleatorio, Bloco, Classe, Const, @@ -59,6 +60,10 @@ export class AnalisadorSemanticoVisualg implements AnalisadorSemanticoInterface this.diagnosticos = []; } + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise { + return Promise.resolve(); + } + erro(simbolo: SimboloInterface, mensagem: string): void { this.diagnosticos.push({ simbolo: simbolo, diff --git a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts index 5b096353..a6529860 100644 --- a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts +++ b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts @@ -310,8 +310,6 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { primario(): Construto { const simboloAtual = this.simbolos[this.atual]; - console.log(simboloAtual) - if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FALSO)) return new Literal(this.hashArquivo, Number(simboloAtual.linha), false); if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VERDADEIRO)) @@ -324,7 +322,6 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { if ( this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR, tiposDeSimbolos.METODO_BIBLIOTECA_GLOBAL) ) { - console.log("entro aqui"); return new Variavel(this.hashArquivo, this.simbolos[this.atual - 1]); } @@ -345,7 +342,6 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { return new Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao); } - console.log("Cheguei até aqui"); throw this.erro(this.simbolos[this.atual], 'Esperado expressão.'); } @@ -1120,15 +1116,37 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { ); } - declaracaoAleatorio(): Aleatorio{ + declaracaoAleatorio(): Aleatorio { const simboloAleatorio: SimboloInterface = this.avancarEDevolverAnterior(); - - return new Aleatorio(simboloAleatorio.linha, simboloAleatorio.hashArquivo) + + if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NUMERO)) { + this.consumir(tiposDeSimbolos.VIRGULA, "Esperado ',' após declaração do primeiro número."); + + this.consumir(tiposDeSimbolos.NUMERO, "Esperado um número após ','."); + } else if (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ON)) { + this.consumir( + simboloAleatorio.tipo, + "Esperado palavra reservada 'ON'ou 'on' ou combinação de número'(min, max)' após declaração 'aleatorio'" + ) + } + + this.consumir(tiposDeSimbolos.QUEBRA_LINHA, "Esperado quebra de linha após declaração do último número."); + + const decoracoes = []; + + do { + decoracoes.push(this.resolverDeclaracaoForaDeBloco()); + } while ( + !tiposDeSimbolos.OFF + ) + + return new Aleatorio(simboloAleatorio.linha, simboloAleatorio.hashArquivo, new Bloco(simboloAleatorio.hashArquivo, Number(simboloAleatorio.linha), decoracoes.filter((d) => d))) } resolverDeclaracaoForaDeBloco(): Declaracao | Declaracao[] | Construto | Construto[] | any { const simboloAtual = this.simbolos[this.atual]; + switch (simboloAtual.tipo) { case tiposDeSimbolos.ALEATORIO: return this.declaracaoAleatorio(); diff --git a/fontes/declaracoes/aleatorio.ts b/fontes/declaracoes/aleatorio.ts index 20f74d7d..c3889cdf 100644 --- a/fontes/declaracoes/aleatorio.ts +++ b/fontes/declaracoes/aleatorio.ts @@ -3,12 +3,12 @@ import { Bloco } from "./bloco"; import { Declaracao } from "./declaracao"; export class Aleatorio extends Declaracao { - /* corpo: Bloco; */ + corpo: Bloco; - constructor(linha: number, hashArquivo: number/* , corpo: Bloco */){ + constructor(linha: number, hashArquivo: number, corpo: Bloco){ super(linha, hashArquivo); - /* this.corpo = corpo */ + this.corpo = corpo } async aceitar(visitante: VisitanteComumInterface): Promise { diff --git a/fontes/lexador/dialetos/palavras-reservadas/visualg.ts b/fontes/lexador/dialetos/palavras-reservadas/visualg.ts index c745cc50..f2223c7e 100644 --- a/fontes/lexador/dialetos/palavras-reservadas/visualg.ts +++ b/fontes/lexador/dialetos/palavras-reservadas/visualg.ts @@ -48,6 +48,8 @@ export const palavrasReservadas = { logn: tiposDeSimbolos.METODO_BIBLIOTECA_GLOBAL, logico: tiposDeSimbolos.LOGICO, nao: tiposDeSimbolos.NEGACAO, // Exceção + on: tiposDeSimbolos.ON, + off: tiposDeSimbolos.OFF, ou: tiposDeSimbolos.OU, outrocaso: tiposDeSimbolos.OUTRO_CASO, para: tiposDeSimbolos.PARA, diff --git a/fontes/tipos-de-simbolos/visualg.ts b/fontes/tipos-de-simbolos/visualg.ts index 13a07362..4a959719 100644 --- a/fontes/tipos-de-simbolos/visualg.ts +++ b/fontes/tipos-de-simbolos/visualg.ts @@ -52,6 +52,8 @@ export default { MULTIPLICACAO: 'MULTIPLICACAO', NEGACAO: 'NEGACAO', NUMERO: 'NUMERO', + ON: 'ON', + OFF: 'OFF', OU: 'OU', OUTRO_CASO: 'OUTRO_CASO', PARA: 'PARA', diff --git a/testes/visualg/avaliador-sintatico.test.ts b/testes/visualg/avaliador-sintatico.test.ts index 0c17999b..34def0ae 100644 --- a/testes/visualg/avaliador-sintatico.test.ts +++ b/testes/visualg/avaliador-sintatico.test.ts @@ -290,14 +290,17 @@ describe('Avaliador sintático (VisuAlg)', () => { [ 'algoritmo "Exemplo Xou"', 'var', + 'numero: inteiro', 'inicio', - 'aleatorio', + 'aleatorio 1, 5', + 'leia(numero)', 'fimalgoritmo', ], -1 ); const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); + /* const RetornoAnalisadorSemantico = analisa */ console.log(retornoAvaliadorSintatico); /* expect(retornoAvaliadorSintatico).toBeTruthy(); From bb19dc50b33e69444b69f5cdf922b28725c0dadc Mon Sep 17 00:00:00 2001 From: Aristidescosta Date: Mon, 22 Jan 2024 19:14:45 +0100 Subject: [PATCH 03/12] refactor: modificando o interpretador para aceitar valores aleatorios --- .../dialetos/analisador-semantico-visualg.ts | 37 ++++++++++++-- .../visualg/avaliador-sintatico-visualg.ts | 19 ++++++- fontes/declaracoes/aleatorio.ts | 6 ++- .../interpretador-egua-classico.ts | 5 ++ .../egua-classico/resolvedor/resolvedor.ts | 7 ++- .../dialetos/mapler/interpretador-mapler.ts | 9 ++-- .../interpretador-portugol-ipt.ts | 5 +- .../dialetos/visualg/interpretador-visualg.ts | 50 ++++++++++++++----- fontes/interpretador/interpretador-base.ts | 16 ++++-- 9 files changed, 125 insertions(+), 29 deletions(-) diff --git a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts index 60e9ae43..afc0116b 100644 --- a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts +++ b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts @@ -60,10 +60,6 @@ export class AnalisadorSemanticoVisualg implements AnalisadorSemanticoInterface this.diagnosticos = []; } - visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise { - return Promise.resolve(); - } - erro(simbolo: SimboloInterface, mensagem: string): void { this.diagnosticos.push({ simbolo: simbolo, @@ -130,6 +126,39 @@ export class AnalisadorSemanticoVisualg implements AnalisadorSemanticoInterface } } + + private gerarNumeroAleatorio(min: number, max: number) { + return Math.floor(Math.random() * (max - min) + min); + } + + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise { + //Isso acontece quando não é informado os número máximos e mínimos + let menorNumero = 0; + let maiorNumero = 100 + + if (declaracao.argumentos) { + menorNumero = Math.min(declaracao.argumentos.min, declaracao.argumentos.max); + maiorNumero = Math.max(declaracao.argumentos.min, declaracao.argumentos.max); + + } + + for (let declaraca of declaracao.corpo.declaracoes) { + if (declaraca instanceof Leia) { + for (let argumento of declaraca.argumentos) { + let variavel = argumento as Variavel; + let valor = this.gerarNumeroAleatorio(menorNumero, maiorNumero); + + + this.variaveis[variavel.simbolo.lexema].valor = valor; + } + + + } + } + + return Promise.resolve(); + } + visitarDeclaracaoVar(declaracao: Var): Promise { this.variaveis[declaracao.simbolo.lexema] = { imutavel: false, diff --git a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts index a6529860..f2a5827f 100644 --- a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts +++ b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts @@ -343,7 +343,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { return new Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao); } - throw this.erro(this.simbolos[this.atual], 'Esperado expressão.'); + throw this.erro(this.simbolos[this.atual], `Esperado expressão ${simboloAtual.tipo}.`); } comparacaoIgualdade(): Construto { @@ -1119,15 +1119,30 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { declaracaoAleatorio(): Aleatorio { const simboloAleatorio: SimboloInterface = this.avancarEDevolverAnterior(); + let parametros: ParametroInterface[] = [] + let argumentos: { min: number, max: number } | null = { + min: 0, + max: 0 + }; + if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NUMERO)) { + this.consumir(tiposDeSimbolos.VIRGULA, "Esperado ',' após declaração do primeiro número."); + argumentos.min = Number(this.simboloAtual().literal); + this.consumir(tiposDeSimbolos.NUMERO, "Esperado um número após ','."); + + argumentos.max = Number(this.simbolos[this.atual - 1].literal); + console.log(argumentos); + + } else if (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ON)) { this.consumir( simboloAleatorio.tipo, "Esperado palavra reservada 'ON'ou 'on' ou combinação de número'(min, max)' após declaração 'aleatorio'" ) + argumentos = null } this.consumir(tiposDeSimbolos.QUEBRA_LINHA, "Esperado quebra de linha após declaração do último número."); @@ -1140,7 +1155,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { !tiposDeSimbolos.OFF ) - return new Aleatorio(simboloAleatorio.linha, simboloAleatorio.hashArquivo, new Bloco(simboloAleatorio.hashArquivo, Number(simboloAleatorio.linha), decoracoes.filter((d) => d))) + return new Aleatorio(simboloAleatorio.linha, simboloAleatorio.hashArquivo, new Bloco(simboloAleatorio.hashArquivo, Number(simboloAleatorio.linha), decoracoes.filter((d) => d)), argumentos) } diff --git a/fontes/declaracoes/aleatorio.ts b/fontes/declaracoes/aleatorio.ts index c3889cdf..eb11da15 100644 --- a/fontes/declaracoes/aleatorio.ts +++ b/fontes/declaracoes/aleatorio.ts @@ -1,14 +1,16 @@ import { VisitanteComumInterface } from "../interfaces"; -import { Bloco } from "./bloco"; import { Declaracao } from "./declaracao"; +import { Bloco } from "./bloco"; export class Aleatorio extends Declaracao { corpo: Bloco; + argumentos: { min: number, max: number } | null - constructor(linha: number, hashArquivo: number, corpo: Bloco){ + constructor(linha: number, hashArquivo: number, corpo: Bloco, argumentos: { min: number, max: number } | null) { super(linha, hashArquivo); this.corpo = corpo + this.argumentos = argumentos; } async aceitar(visitante: VisitanteComumInterface): Promise { diff --git a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts index 5e5967c7..2e0f1c15 100644 --- a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts +++ b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts @@ -21,6 +21,7 @@ import { Variavel, } from '../../../construtos'; import { + Aleatorio, Classe, Const, ConstMultiplo, @@ -163,6 +164,10 @@ export class InterpretadorEguaClassico implements InterpretadorInterface { return this.avaliar(expressao.expressao); } + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise { + throw new Error('Método não implementado') + } + eVerdadeiro(objeto: any): boolean { if (objeto === null) return false; if (typeof objeto === 'boolean') return Boolean(objeto); diff --git a/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts b/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts index c8216a25..4991ec04 100644 --- a/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts +++ b/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts @@ -1,5 +1,6 @@ import { AcessoMetodoOuPropriedade, Construto, ExpressaoRegular, FimPara, FormatacaoEscrita, QualTipo, Super, TipoDe, Variavel } from '../../../../construtos'; import { + Aleatorio, Bloco, Const, ConstMultiplo, @@ -85,7 +86,7 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise { throw new Error('Método não implementado.'); } - + visitarExpressaoTipoDe(expressao: TipoDe): Promise { throw new Error('Método não implementado.'); } @@ -529,6 +530,10 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado return null; } + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise { + throw new Error('Método não implementado.'); + } + resolver(declaracoes: Construto | Declaracao | Declaracao[]): RetornoResolvedor { if (Array.isArray(declaracoes)) { for (let i = 0; i < declaracoes.length; i++) { diff --git a/fontes/interpretador/dialetos/mapler/interpretador-mapler.ts b/fontes/interpretador/dialetos/mapler/interpretador-mapler.ts index 998855a6..dff5a1ef 100644 --- a/fontes/interpretador/dialetos/mapler/interpretador-mapler.ts +++ b/fontes/interpretador/dialetos/mapler/interpretador-mapler.ts @@ -1,5 +1,5 @@ import { Binario, Construto, ExpressaoRegular, Logico, Variavel } from '../../../construtos'; -import { Const, Escreva, EscrevaMesmaLinha, Fazer, Leia } from '../../../declaracoes'; +import { Aleatorio, Const, Escreva, EscrevaMesmaLinha, Fazer, Leia } from '../../../declaracoes'; import { InterpretadorBase } from '../..'; import { ContinuarQuebra, Quebra } from '../../../quebras'; @@ -21,7 +21,11 @@ export class InterpretadorMapler extends InterpretadorBase { visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise { throw new Error('Método não implementado.'); } - + + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise{ + throw new Error('Método não implementado.'); + } + visitarDeclaracaoConst(declaracao: Const): Promise { throw new Error('Método não implementado.'); } @@ -99,7 +103,6 @@ export class InterpretadorMapler extends InterpretadorBase { this.erros.push(erro); } } - /** * Execução da leitura de valores da entrada configurada no * início da aplicação. diff --git a/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts b/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts index 61e36978..35e1848f 100644 --- a/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts +++ b/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts @@ -1,5 +1,6 @@ import { Atribuir, Construto, ExpressaoRegular, FimPara, FormatacaoEscrita, Literal, QualTipo, Super, TipoDe, Variavel } from '../../../construtos'; import { + Aleatorio, Bloco, Classe, Const, @@ -544,7 +545,9 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface { } return resultado; } - + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise{ + throw new Error('Método não implementado.'); + } /** * Executa o último escopo empilhado no topo na pilha de escopos do interpretador. * Esse método pega exceções, mas apenas as devolve. diff --git a/fontes/interpretador/dialetos/visualg/interpretador-visualg.ts b/fontes/interpretador/dialetos/visualg/interpretador-visualg.ts index e8021e07..52ceb451 100644 --- a/fontes/interpretador/dialetos/visualg/interpretador-visualg.ts +++ b/fontes/interpretador/dialetos/visualg/interpretador-visualg.ts @@ -1,5 +1,5 @@ import { AcessoElementoMatriz, AtribuicaoPorIndicesMatriz, Binario, Construto, FimPara, Logico, Variavel } from '../../../construtos'; -import { Const, Escreva, EscrevaMesmaLinha, Fazer, Leia, Para } from '../../../declaracoes'; +import { Aleatorio, Const, Escreva, EscrevaMesmaLinha, Fazer, Leia, Para } from '../../../declaracoes'; import { InterpretadorBase } from '../..'; import { ContinuarQuebra, Quebra, SustarQuebra } from '../../../quebras'; import { registrarBibliotecaNumericaVisuAlg } from '../../../bibliotecas/dialetos/visualg/numerica'; @@ -40,6 +40,8 @@ export class InterpretadorVisuAlg extends InterpretadorBase { return await comum.visitarExpressaoAtribuicaoPorIndicesMatriz(this, expressao); } + private interromperLeitura: boolean = false; + private async avaliarArgumentosEscrevaVisuAlg(argumentos: Construto[]): Promise { let formatoTexto: string = ''; @@ -137,17 +139,22 @@ export class InterpretadorVisuAlg extends InterpretadorBase { * @returns Promise com o resultado da leitura. */ async visitarExpressaoLeia(expressao: Leia): Promise { - for (let argumento of expressao.argumentos) { - const promessaLeitura: Function = () => - new Promise((resolucao) => - this.interfaceEntradaSaida.question(this.mensagemPrompt, (resposta: any) => { - this.mensagemPrompt = '> '; - resolucao(resposta); - }) - ); - - const valorLido = await promessaLeitura(); - await comum.atribuirVariavel(this, argumento, valorLido); + + // Verifica se a leitura deve ser interrompida antes de prosseguir + + if (!this.interromperLeitura) { + for (let argumento of expressao.argumentos) { + const promessaLeitura: Function = () => + new Promise((resolucao) => + this.interfaceEntradaSaida.question(this.mensagemPrompt, (resposta: any) => { + this.mensagemPrompt = '> '; + resolucao(resposta); + }) + ); + + const valorLido = await promessaLeitura(); + await comum.atribuirVariavel(this, argumento, valorLido); + } } } @@ -197,4 +204,23 @@ export class InterpretadorVisuAlg extends InterpretadorBase { async visitarExpressaoLogica(expressao: Logico): Promise { return comum.visitarExpressaoLogica(this, expressao); } + + async visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise { + + let retornoExecucao: any; + try { + this.interromperLeitura = declaracao.corpo.declaracoes.some(dec => dec instanceof Leia); + retornoExecucao = await this.executar(declaracao.corpo); + + } catch (error) { + this.erros.push({ + erroInterno: error, + linha: declaracao.linha, + hashArquivo: declaracao.hashArquivo, + }); + return Promise.reject(error) + } + + return retornoExecucao; + } } diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts index 2db4648d..0914692b 100644 --- a/fontes/interpretador/interpretador-base.ts +++ b/fontes/interpretador/interpretador-base.ts @@ -9,6 +9,7 @@ import { MicroAvaliadorSintatico } from './../../fontes/avaliador-sintatico/micr import { ErroEmTempoDeExecucao } from '../excecoes'; import { InterpretadorInterface, ParametroInterface, SimboloInterface, VariavelInterface } from '../interfaces'; import { + Aleatorio, Bloco, Classe, Const, @@ -92,14 +93,14 @@ export class InterpretadorBase implements InterpretadorInterface { resultadoInterpretador: Array = []; // Esta variável indica que uma propriedade de um objeto - // não precisa da palavra `isto` para ser acessada, ou seja, + // não precisa da palavra `isto` para ser acessada, ou seja, // `minhaPropriedade` e `isto.minhaPropriedade` são a mesma coisa. // Potigol, por exemplo, é um dialeto que tem essa característica. expandirPropriedadesDeObjetosEmEspacoVariaveis: boolean; // Esta variável indica que propriedades de classes precisam ser // declaradas para serem válidas. - // Delégua e Pituguês são dialetos que requerem a declaração + // Delégua e Pituguês são dialetos que requerem a declaração // de propriedades de classes. requerDeclaracaoPropriedades: boolean; @@ -643,8 +644,8 @@ export class InterpretadorBase implements InterpretadorInterface { argumentos.push(null); } } else { - // TODO: Aparentemente isso aqui nunca funcionou. - // Avaliar de simplesmente apagar este código, e usar o que foi + // TODO: Aparentemente isso aqui nunca funcionou. + // Avaliar de simplesmente apagar este código, e usar o que foi // implementado em `DeleguaFuncao.chamar`. if ( parametros && @@ -1433,6 +1434,11 @@ export class InterpretadorBase implements InterpretadorInterface { return this.procurarVariavel(expressao.palavraChave); } + + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise{ + throw new Error('Método não implementado.'); + } + async visitarExpressaoDicionario(expressao: any): Promise { const dicionario = {}; for (let i = 0; i < expressao.chaves.length; i++) { @@ -1534,7 +1540,9 @@ export class InterpretadorBase implements InterpretadorInterface { * pelo modo LAIR. */ async executar(declaracao: Declaracao, mostrarResultado = false): Promise { + const resultado: any = await declaracao.aceitar(this); + /* console.log("Resultado aceitar: " + resultado, this); */ if (mostrarResultado) { this.funcaoDeRetorno(this.paraTexto(resultado)); } From 2c7ffeef8e483cd992ee2086e842023dbbaf09bd Mon Sep 17 00:00:00 2001 From: Aristidescosta Date: Tue, 23 Jan 2024 13:49:53 +0100 Subject: [PATCH 04/12] refactor: refatorando testes do aleatorio --- .../dialetos/analisador-semantico-birl.ts | 5 +++ .../dialetos/analisador-semantico-mapler.ts | 5 +++ .../visualg/avaliador-sintatico-visualg.ts | 7 ++--- testes/visualg/avaliador-sintatico.test.ts | 31 ++++++++++++++++--- 4 files changed, 38 insertions(+), 10 deletions(-) diff --git a/fontes/analisador-semantico/dialetos/analisador-semantico-birl.ts b/fontes/analisador-semantico/dialetos/analisador-semantico-birl.ts index a342584e..55f184ad 100644 --- a/fontes/analisador-semantico/dialetos/analisador-semantico-birl.ts +++ b/fontes/analisador-semantico/dialetos/analisador-semantico-birl.ts @@ -1,5 +1,6 @@ import { Atribuir, ExpressaoRegular, FimPara, FormatacaoEscrita, Literal, Super, TipoDe, Variavel } from '../../construtos'; import { + Aleatorio, Bloco, Classe, Const, @@ -86,6 +87,10 @@ export class AnalisadorSemanticoBirl implements AnalisadorSemanticoInterface { return Promise.resolve(); } + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise{ + return Promise.resolve(); + } + visitarDeclaracaoDeAtribuicao(expressao: Atribuir) { if (!this.variaveis.hasOwnProperty(expressao.simbolo.lexema)) { this.diagnosticos.push({ diff --git a/fontes/analisador-semantico/dialetos/analisador-semantico-mapler.ts b/fontes/analisador-semantico/dialetos/analisador-semantico-mapler.ts index d4dfd68b..28410205 100644 --- a/fontes/analisador-semantico/dialetos/analisador-semantico-mapler.ts +++ b/fontes/analisador-semantico/dialetos/analisador-semantico-mapler.ts @@ -1,5 +1,6 @@ import { Atribuir, Binario, Chamada, Construto, ExpressaoRegular, FimPara, FormatacaoEscrita, Literal, Super, TipoDe, Vetor } from '../../construtos'; import { + Aleatorio, Bloco, Classe, Const, @@ -69,6 +70,10 @@ export class AnalisadorSemanticoMapler implements AnalisadorSemanticoInterface { return Promise.resolve(); } + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise{ + return Promise.resolve(); + } + erro(simbolo: SimboloInterface, mensagem: string): void { this.diagnosticos.push({ simbolo: simbolo, diff --git a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts index f2a5827f..72dfe957 100644 --- a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts +++ b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts @@ -343,7 +343,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { return new Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao); } - throw this.erro(this.simbolos[this.atual], `Esperado expressão ${simboloAtual.tipo}.`); + throw this.erro(this.simbolos[this.atual], "Esperado expressão."); } comparacaoIgualdade(): Construto { @@ -1118,8 +1118,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { declaracaoAleatorio(): Aleatorio { const simboloAleatorio: SimboloInterface = this.avancarEDevolverAnterior(); - - let parametros: ParametroInterface[] = [] + let argumentos: { min: number, max: number } | null = { min: 0, max: 0 @@ -1134,8 +1133,6 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { this.consumir(tiposDeSimbolos.NUMERO, "Esperado um número após ','."); argumentos.max = Number(this.simbolos[this.atual - 1].literal); - console.log(argumentos); - } else if (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ON)) { this.consumir( diff --git a/testes/visualg/avaliador-sintatico.test.ts b/testes/visualg/avaliador-sintatico.test.ts index 34def0ae..48100db0 100644 --- a/testes/visualg/avaliador-sintatico.test.ts +++ b/testes/visualg/avaliador-sintatico.test.ts @@ -285,7 +285,7 @@ describe('Avaliador sintático (VisuAlg)', () => { expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(22); }); - it('Sucesso - Aleatorio', () => { + it('Sucesso - Aleatorio - Números', () => { const retornoLexador = lexador.mapear( [ 'algoritmo "Exemplo Xou"', @@ -300,11 +300,9 @@ describe('Avaliador sintático (VisuAlg)', () => { ); const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - /* const RetornoAnalisadorSemantico = analisa */ - console.log(retornoAvaliadorSintatico); - /* expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(22); */ + expect(retornoAvaliadorSintatico).toBeTruthy(); + expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2); }); }); @@ -428,6 +426,29 @@ describe('Avaliador sintático (VisuAlg)', () => { expect(() => avaliadorSintatico.analisar(retornoLexador, 1)).toThrowError(); }); + + it('Falha - Aleatorio', () => { + const retornoLexador = lexador.mapear( + [ + 'algoritmo "Exemplo Xou"', + 'var', + 'numero: inteiro', + 'inicio', + 'aleatorio 1, ', + 'leia(numero)', + 'fimalgoritmo', + ], + -1 + ); + + expect(() => avaliadorSintatico.analisar(retornoLexador, -1)).toThrowError(); + expect(() => avaliadorSintatico.analisar(retornoLexador, -1)).toThrow( + expect.objectContaining({ + name: 'Error', + message: "Esperado um número após ','.", + }) + ); + }); }); }); }); From afcc6b9ed0cc0db54731c7ac147e99b3b66d8ef6 Mon Sep 17 00:00:00 2001 From: Aristidescosta Date: Tue, 23 Jan 2024 14:07:36 +0100 Subject: [PATCH 05/12] refactor: adicionado teste do interpretador para aleatorio --- testes/visualg/interpretador.test.ts | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/testes/visualg/interpretador.test.ts b/testes/visualg/interpretador.test.ts index 85e518d6..7787ad97 100644 --- a/testes/visualg/interpretador.test.ts +++ b/testes/visualg/interpretador.test.ts @@ -602,6 +602,23 @@ describe('Interpretador', () => { expect(retornoInterpretador.erros).toHaveLength(0); }); + + it('Sucesso - Aleatorio', async () => { + const retornoLexador = lexador.mapear([ + 'algoritmo "declaração aleatorio on"', + 'var', + 'numero: inteiro', + 'inicio', + 'aleatorio on', + 'leia(numero)', + 'fimalgoritmo' + ], -1); + const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); + + const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes); + + expect(retornoInterpretador.erros).toHaveLength(0); + }); }); }); }); From 61c2e5e750c76a7030b62a0676878d06f43cf472 Mon Sep 17 00:00:00 2001 From: Aristidescosta Date: Tue, 23 Jan 2024 16:56:42 +0100 Subject: [PATCH 06/12] =?UTF-8?q?fix:=20corrigindo=20a=20logica=20para=20i?= =?UTF-8?q?nterromper=20LEIA=20quando=20aleatorio=20est=C3=A1=20ativo?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../dialetos/analisador-semantico-visualg.ts | 10 +++------- .../visualg/avaliador-sintatico-visualg.ts | 17 +++++++++++++---- fontes/declaracoes/leia.ts | 1 + .../dialetos/visualg/interpretador-visualg.ts | 5 +---- 4 files changed, 18 insertions(+), 15 deletions(-) diff --git a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts index afc0116b..c1e97f5a 100644 --- a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts +++ b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts @@ -142,17 +142,13 @@ export class AnalisadorSemanticoVisualg implements AnalisadorSemanticoInterface } - for (let declaraca of declaracao.corpo.declaracoes) { - if (declaraca instanceof Leia) { - for (let argumento of declaraca.argumentos) { + for (let corpoDeclaracao of declaracao.corpo.declaracoes) { + if (corpoDeclaracao instanceof Leia) { + for (let argumento of corpoDeclaracao.argumentos) { let variavel = argumento as Variavel; let valor = this.gerarNumeroAleatorio(menorNumero, maiorNumero); - - this.variaveis[variavel.simbolo.lexema].valor = valor; } - - } } diff --git a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts index 72dfe957..0d79d2b4 100644 --- a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts +++ b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts @@ -1118,7 +1118,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { declaracaoAleatorio(): Aleatorio { const simboloAleatorio: SimboloInterface = this.avancarEDevolverAnterior(); - + let argumentos: { min: number, max: number } | null = { min: 0, max: 0 @@ -1148,9 +1148,18 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { do { decoracoes.push(this.resolverDeclaracaoForaDeBloco()); - } while ( - !tiposDeSimbolos.OFF - ) + } while (![tiposDeSimbolos.ALEATORIO, tiposDeSimbolos.FIM_ALGORITMO].includes(this.simbolos[this.atual].tipo)) + + for(let decoracao of decoracoes){ + if(decoracao instanceof Leia){ + decoracao.eParaInterromper = true; + } + } + + if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ALEATORIO)) { + this.consumir(tiposDeSimbolos.ALEATORIO, "Esperado palavra reservada 'aleatorio' para fechamento de declaração 'aleatorio'."); + this.consumir(tiposDeSimbolos.OFF, "Esperado palavra reservada 'off' ou 'OFF' após declaração 'aleatorio'."); + } return new Aleatorio(simboloAleatorio.linha, simboloAleatorio.hashArquivo, new Bloco(simboloAleatorio.hashArquivo, Number(simboloAleatorio.linha), decoracoes.filter((d) => d)), argumentos) diff --git a/fontes/declaracoes/leia.ts b/fontes/declaracoes/leia.ts index c57401a0..3a5ccf56 100644 --- a/fontes/declaracoes/leia.ts +++ b/fontes/declaracoes/leia.ts @@ -13,6 +13,7 @@ export class Leia extends Declaracao { argumentos: Construto[]; tipo?: string; numeroArgumentosEsperados?: number; + eParaInterromper?: boolean; constructor(simbolo: SimboloInterface, argumentos: Construto[]) { super(simbolo.linha, simbolo.hashArquivo); diff --git a/fontes/interpretador/dialetos/visualg/interpretador-visualg.ts b/fontes/interpretador/dialetos/visualg/interpretador-visualg.ts index 52ceb451..17fa1074 100644 --- a/fontes/interpretador/dialetos/visualg/interpretador-visualg.ts +++ b/fontes/interpretador/dialetos/visualg/interpretador-visualg.ts @@ -40,8 +40,6 @@ export class InterpretadorVisuAlg extends InterpretadorBase { return await comum.visitarExpressaoAtribuicaoPorIndicesMatriz(this, expressao); } - private interromperLeitura: boolean = false; - private async avaliarArgumentosEscrevaVisuAlg(argumentos: Construto[]): Promise { let formatoTexto: string = ''; @@ -142,7 +140,7 @@ export class InterpretadorVisuAlg extends InterpretadorBase { // Verifica se a leitura deve ser interrompida antes de prosseguir - if (!this.interromperLeitura) { + if (!expressao.eParaInterromper) { for (let argumento of expressao.argumentos) { const promessaLeitura: Function = () => new Promise((resolucao) => @@ -209,7 +207,6 @@ export class InterpretadorVisuAlg extends InterpretadorBase { let retornoExecucao: any; try { - this.interromperLeitura = declaracao.corpo.declaracoes.some(dec => dec instanceof Leia); retornoExecucao = await this.executar(declaracao.corpo); } catch (error) { From 44ed39da75467f992f3ee619f81245efb14d70f4 Mon Sep 17 00:00:00 2001 From: Aristidescosta Date: Tue, 23 Jan 2024 17:07:56 +0100 Subject: [PATCH 07/12] =?UTF-8?q?refactor:=20re-corrigindo=20a=20l=C3=B3gi?= =?UTF-8?q?ca=20do=20interromper=20leitura=20leia?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../dialetos/visualg/avaliador-sintatico-visualg.ts | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts index 0d79d2b4..6c57edc8 100644 --- a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts +++ b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts @@ -1147,17 +1147,12 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase { const decoracoes = []; do { - decoracoes.push(this.resolverDeclaracaoForaDeBloco()); + const decoracao = this.resolverDeclaracaoForaDeBloco() + if(decoracao instanceof Leia) decoracao.eParaInterromper = true; + decoracoes.push(decoracao); } while (![tiposDeSimbolos.ALEATORIO, tiposDeSimbolos.FIM_ALGORITMO].includes(this.simbolos[this.atual].tipo)) - for(let decoracao of decoracoes){ - if(decoracao instanceof Leia){ - decoracao.eParaInterromper = true; - } - } - if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ALEATORIO)) { - this.consumir(tiposDeSimbolos.ALEATORIO, "Esperado palavra reservada 'aleatorio' para fechamento de declaração 'aleatorio'."); this.consumir(tiposDeSimbolos.OFF, "Esperado palavra reservada 'off' ou 'OFF' após declaração 'aleatorio'."); } From e0cc1226916caa9d0684cf4e858b04ced60d624c Mon Sep 17 00:00:00 2001 From: Aristidescosta Date: Tue, 23 Jan 2024 23:18:24 +0100 Subject: [PATCH 08/12] =?UTF-8?q?fix:=20propagando=20verifica=C3=A7=C3=A3o?= =?UTF-8?q?=20da=20declara=C3=A7=C3=A3o=20leia?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../dialetos/analisador-semantico-visualg.ts | 30 ++++++++++++++----- 1 file changed, 23 insertions(+), 7 deletions(-) diff --git a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts index c1e97f5a..d36c2cfb 100644 --- a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts +++ b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts @@ -131,6 +131,28 @@ export class AnalisadorSemanticoVisualg implements AnalisadorSemanticoInterface return Math.floor(Math.random() * (max - min) + min); } + private encontrarLeiaNoAleatorio(declaracao: Declaracao, menorNumero: number, maiorNumero: number) { + if ('declaracoes' in declaracao) { + // Se a declaração tiver um campo 'declaracoes', ela é um Bloco + const declaracoes = declaracao.declaracoes as Declaracao[] + for (const subDeclaracao of declaracoes) { + this.encontrarLeiaNoAleatorio(subDeclaracao, menorNumero, maiorNumero); + } + } else if (declaracao instanceof Leia) { + // Se encontrarmos um Leia, podemos efetuar as operações imediatamente + for (const argumento of declaracao.argumentos) { + this.atualizarVariavelComNumeroAleatorio(argumento as Variavel, menorNumero, maiorNumero); + } + } + } + + private atualizarVariavelComNumeroAleatorio(variavel: Variavel, menorNumero: number, maiorNumero: number) { + if (this.variaveis[variavel.simbolo.lexema]) { + const valor = this.gerarNumeroAleatorio(menorNumero, maiorNumero); + this.variaveis[variavel.simbolo.lexema].valor = valor; + } + } + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise { //Isso acontece quando não é informado os número máximos e mínimos let menorNumero = 0; @@ -143,13 +165,7 @@ export class AnalisadorSemanticoVisualg implements AnalisadorSemanticoInterface } for (let corpoDeclaracao of declaracao.corpo.declaracoes) { - if (corpoDeclaracao instanceof Leia) { - for (let argumento of corpoDeclaracao.argumentos) { - let variavel = argumento as Variavel; - let valor = this.gerarNumeroAleatorio(menorNumero, maiorNumero); - this.variaveis[variavel.simbolo.lexema].valor = valor; - } - } + this.encontrarLeiaNoAleatorio(corpoDeclaracao, menorNumero, maiorNumero); } return Promise.resolve(); From 2862a444c06478a6ec7645f287efa1590152cd3a Mon Sep 17 00:00:00 2001 From: Aristidescosta Date: Tue, 23 Jan 2024 23:30:13 +0100 Subject: [PATCH 09/12] refactor: adicionando palavras aleatorioas --- .../dialetos/analisador-semantico-visualg.ts | 21 ++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts index d36c2cfb..3ecc03cc 100644 --- a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts +++ b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts @@ -141,18 +141,33 @@ export class AnalisadorSemanticoVisualg implements AnalisadorSemanticoInterface } else if (declaracao instanceof Leia) { // Se encontrarmos um Leia, podemos efetuar as operações imediatamente for (const argumento of declaracao.argumentos) { - this.atualizarVariavelComNumeroAleatorio(argumento as Variavel, menorNumero, maiorNumero); + this.atualizarVariavelComValorAleatorio(argumento as Variavel, menorNumero, maiorNumero); } } } - private atualizarVariavelComNumeroAleatorio(variavel: Variavel, menorNumero: number, maiorNumero: number) { + private atualizarVariavelComValorAleatorio(variavel: Variavel, menorNumero: number, maiorNumero: number) { if (this.variaveis[variavel.simbolo.lexema]) { - const valor = this.gerarNumeroAleatorio(menorNumero, maiorNumero); + let valor: number | string = 0; + if(this.variaveis[variavel.simbolo.lexema].tipo === "inteiro") valor = this.gerarNumeroAleatorio(menorNumero, maiorNumero); + else if(this.variaveis[variavel.simbolo.lexema].tipo === "caracter" ) valor = this.palavraAleatoriaCom5Digitos() + this.variaveis[variavel.simbolo.lexema].valor = valor; } } + private palavraAleatoriaCom5Digitos(): string { + const caracteres = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; + let palavra = ""; + + for (let i = 0; i < 5; i++) { + const indiceAleatorio = Math.floor(Math.random() * caracteres.length); + palavra += caracteres.charAt(indiceAleatorio); + } + + return palavra; + } + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise { //Isso acontece quando não é informado os número máximos e mínimos let menorNumero = 0; From 089044b1a3a4465bac3deff87b0346649d2d0819 Mon Sep 17 00:00:00 2001 From: Aristidescosta Date: Wed, 24 Jan 2024 10:25:10 +0100 Subject: [PATCH 10/12] refactor: validando valores aleatorios para tipo real --- .../dialetos/analisador-semantico-visualg.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts index 3ecc03cc..f8b5ed0b 100644 --- a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts +++ b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts @@ -149,7 +149,7 @@ export class AnalisadorSemanticoVisualg implements AnalisadorSemanticoInterface private atualizarVariavelComValorAleatorio(variavel: Variavel, menorNumero: number, maiorNumero: number) { if (this.variaveis[variavel.simbolo.lexema]) { let valor: number | string = 0; - if(this.variaveis[variavel.simbolo.lexema].tipo === "inteiro") valor = this.gerarNumeroAleatorio(menorNumero, maiorNumero); + if(this.variaveis[variavel.simbolo.lexema].tipo === "inteiro" || this.variaveis[variavel.simbolo.lexema].tipo === "real") valor = this.gerarNumeroAleatorio(menorNumero, maiorNumero); else if(this.variaveis[variavel.simbolo.lexema].tipo === "caracter" ) valor = this.palavraAleatoriaCom5Digitos() this.variaveis[variavel.simbolo.lexema].valor = valor; From 981d78a69fdbea9211a1e998add7720fc1bf54b8 Mon Sep 17 00:00:00 2001 From: Aristidescosta Date: Wed, 24 Jan 2024 12:04:43 +0100 Subject: [PATCH 11/12] fix: resolvendo erro dos testes --- .../dialetos/analisador-semantico-visualg.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts index f8b5ed0b..15d43008 100644 --- a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts +++ b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts @@ -164,7 +164,6 @@ export class AnalisadorSemanticoVisualg implements AnalisadorSemanticoInterface const indiceAleatorio = Math.floor(Math.random() * caracteres.length); palavra += caracteres.charAt(indiceAleatorio); } - return palavra; } From 70d926d92cce476c0fbc1bb7c10b4f55e878c242 Mon Sep 17 00:00:00 2001 From: Aristidescosta Date: Wed, 24 Jan 2024 12:29:03 +0100 Subject: [PATCH 12/12] =?UTF-8?q?fix:=20adicionando=20declara=C3=A7=C3=A3o?= =?UTF-8?q?=20leia=20pra=20resolu=C3=A7=C3=A3o=20dos=20testes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- fontes/formatadores/formatador-delegua.ts | 15 ++++++++++----- fontes/formatadores/formatador-portugol-studio.ts | 14 +++++++++----- 2 files changed, 19 insertions(+), 10 deletions(-) diff --git a/fontes/formatadores/formatador-delegua.ts b/fontes/formatadores/formatador-delegua.ts index 4e987f03..ff91120f 100644 --- a/fontes/formatadores/formatador-delegua.ts +++ b/fontes/formatadores/formatador-delegua.ts @@ -48,6 +48,7 @@ import { Sustar, Declaracao, Falhar, + Aleatorio, } from '../declaracoes'; import { VisitanteComumInterface } from '../interfaces'; @@ -89,7 +90,7 @@ export class FormatadorDelegua implements VisitanteComumInterface { this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}${metodo.simbolo.lexema}`; this.visitarExpressaoFuncaoConstruto(metodo.funcao); } - + this.indentacaoAtual -= this.tamanhoIndentacao; this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`; @@ -465,6 +466,10 @@ export class FormatadorDelegua implements VisitanteComumInterface { this.codigoFormatado += ')'; } + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise { + throw new Error('Método não implementado.'); + } + visitarExpressaoDefinirValor(expressao: DefinirValor) { this.formatarDeclaracaoOuConstruto(expressao.objeto); this.codigoFormatado += `.${expressao.nome.lexema} = `; @@ -552,7 +557,7 @@ export class FormatadorDelegua implements VisitanteComumInterface { if (expressao.argumentos.length > 0) { this.codigoFormatado = this.codigoFormatado.slice(0, -2); } - + this.codigoFormatado += `)`; } @@ -582,7 +587,7 @@ export class FormatadorDelegua implements VisitanteComumInterface { this.codigoFormatado += ` ou `; break; } - + this.formatarDeclaracaoOuConstruto(expressao.direita); } @@ -597,7 +602,7 @@ export class FormatadorDelegua implements VisitanteComumInterface { } visitarExpressaoSuper(expressao: Super) { - // TODO: `expressao.metodo` deveria ser um `Construto`, não um `Simbolo` aqui. + // TODO: `expressao.metodo` deveria ser um `Construto`, não um `Simbolo` aqui. this.codigoFormatado += `super.${expressao.metodo.lexema}()`; console.log(expressao); } @@ -719,7 +724,7 @@ export class FormatadorDelegua implements VisitanteComumInterface { break; case 'Importar': this.visitarDeclaracaoImportar(declaracaoOuConstruto as Importar); - break; + break; case 'Isto': this.visitarExpressaoIsto(declaracaoOuConstruto as Isto); break; diff --git a/fontes/formatadores/formatador-portugol-studio.ts b/fontes/formatadores/formatador-portugol-studio.ts index 2ee586c4..893d4079 100644 --- a/fontes/formatadores/formatador-portugol-studio.ts +++ b/fontes/formatadores/formatador-portugol-studio.ts @@ -1,5 +1,5 @@ import { AcessoIndiceVariavel, AcessoMetodoOuPropriedade, Agrupamento, AtribuicaoPorIndice, Atribuir, Binario, Chamada, Construto, DefinirValor, Dicionario, ExpressaoRegular, FimPara, FormatacaoEscrita, FuncaoConstruto, Isto, Literal, Logico, Super, TipoDe, Unario, Variavel, Vetor } from "../construtos"; -import { Classe, Const, ConstMultiplo, Expressao, FuncaoDeclaracao, Enquanto, Escolha, Escreva, Fazer, Importar, Para, ParaCada, Se, Tente, Var, VarMultiplo, Bloco, Continua, EscrevaMesmaLinha, Leia, LeiaMultiplo, Retorna, Sustar, Declaracao, Falhar } from "../declaracoes"; +import { Classe, Const, ConstMultiplo, Expressao, FuncaoDeclaracao, Enquanto, Escolha, Escreva, Fazer, Importar, Para, ParaCada, Se, Tente, Var, VarMultiplo, Bloco, Continua, EscrevaMesmaLinha, Leia, LeiaMultiplo, Retorna, Sustar, Declaracao, Falhar, Aleatorio } from "../declaracoes"; import { VisitanteComumInterface } from "../interfaces"; import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from "../quebras"; @@ -38,9 +38,13 @@ export class FormatadorPortugolStudio implements VisitanteComumInterface { // throw new Error("Método não implementado"); } + visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise { + throw new Error('Método não implementado.'); + } + visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao) { this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}funcao ${declaracao.simbolo.lexema}()${this.quebraLinha}`; - + this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}{${this.quebraLinha}`; this.visitarExpressaoFuncaoConstruto(declaracao.funcao); this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}}${this.quebraLinha}`; @@ -260,7 +264,7 @@ export class FormatadorPortugolStudio implements VisitanteComumInterface { break; case 'Importar': this.visitarDeclaracaoImportar(declaracaoOuConstruto as Importar); - break; + break; case 'Isto': this.visitarExpressaoIsto(declaracaoOuConstruto as Isto); break; @@ -317,8 +321,8 @@ export class FormatadorPortugolStudio implements VisitanteComumInterface { break; } } - - + + formatar(declaracoes: Declaracao[]): string { this.indentacaoAtual = 0; this.codigoFormatado = `programa${this.quebraLinha}{${this.quebraLinha}`;