Formas de uso funcao aleatorio

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<any> {
+        return Promise.resolve();
+    }
+
     visitarExpressaoAcessoElementoMatriz(expressao: any) {
         return Promise.resolve();
     }

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<any>{
+        return Promise.resolve();
+    }
+
     visitarDeclaracaoDeAtribuicao(expressao: Atribuir) {
         if (!this.variaveis.hasOwnProperty(expressao.simbolo.lexema)) {
             this.diagnosticos.push({

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,
@@ -59,6 +60,10 @@ export class AnalisadorSemanticoMapler implements AnalisadorSemanticoInterface {
         return Promise.resolve();
     }
 
+    visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise<any>{
+        return Promise.resolve();
+    }
+
     erro(simbolo: SimboloInterface, mensagem: string): void {
         this.diagnosticos.push({
             simbolo: simbolo,

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,
@@ -116,6 +117,65 @@ export class AnalisadorSemanticoVisuAlg implements AnalisadorSemanticoInterface
         }
     }
 
+
+    private gerarNumeroAleatorio(min: number, max: number) {
+        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.atualizarVariavelComValorAleatorio(argumento as Variavel, menorNumero, maiorNumero);
+            }
+        }
+    }
+
+    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" || 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;
+        }
+    }
+
+    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<any> {
+        //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 corpoDeclaracao of declaracao.corpo.declaracoes) {
+            this.encontrarLeiaNoAleatorio(corpoDeclaracao, menorNumero, maiorNumero);
+        }
+
+        return Promise.resolve();
+    }
+
     visitarDeclaracaoVar(declaracao: Var): Promise<any> {
         this.variaveis[declaracao.simbolo.lexema] = {
             imutavel: false,

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;
@@ -342,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.");
     }
 
     comparacaoIgualdade(): Construto {
@@ -1115,9 +1116,56 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         );
     }
 
+    declaracaoAleatorio(): Aleatorio {
+        const simboloAleatorio: SimboloInterface = this.avancarEDevolverAnterior();
+
+        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);
+
+        } 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.");
+
+        const decoracoes = [];
+
+        do {
+            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))
+
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.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)
+
+    }
+
     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:

fontes/declaracoes/aleatorio.ts

@@ -0,0 +1,19 @@
+import { VisitanteComumInterface } from "../interfaces";
+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, argumentos: { min: number, max: number } | null) {
+        super(linha, hashArquivo);
+
+        this.corpo = corpo
+        this.argumentos = argumentos;
+    }
+
+    async aceitar(visitante: VisitanteComumInterface): Promise<any> {
+        return await visitante.visitarDeclaracaoAleatorio(this);
+    }
+}

fontes/declaracoes/index.ts

@@ -24,3 +24,4 @@ export * from './se';
 export * from './tente';
 export * from './var';
 export * from './var-multiplo';
+export * from './aleatorio';

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);

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<any> {
+        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;

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<any> {
+        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}`;

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<any>
     visitarDeclaracaoClasse(declaracao: Classe): any;
     visitarDeclaracaoConst(declaracao: Const): Promise<any>;
     visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise<any>;

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<any> {
+        throw new Error('Método não implementado')
+    }
+
     eVerdadeiro(objeto: any): boolean {
         if (objeto === null) return false;
         if (typeof objeto === 'boolean') return Boolean(objeto);