[potigol] > #553 a, b, c = leia_inteiro deve inicializar múltiplas variáveis

fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts

@@ -454,6 +454,7 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
         return expressao;
     }
 
+
     declaracaoEscreva(): Escreva {
         const simboloAtual = this.avancarEDevolverAnterior();
 
@@ -462,7 +463,7 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
         this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO)
 
         do {
-            argumentos.push(this.expressao());
+            argumentos.push(this.ou());
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
         this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_DIREITO)
@@ -800,7 +801,7 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
             if (inicializador instanceof Leia && identificadores.length > 1) {
                 inicializador = new LeiaMultiplo(
                     inicializador.simbolo,
-                    inicializador.argumentos[0],
+                    new Literal(this.hashArquivo, Number(inicializador.simbolo.linha), identificadores.length)
                 );
             }
 
@@ -994,10 +995,10 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
             simboloTipo.linha,
             propriedades.map(
                 (p) =>
-                    ({
-                        abrangencia: 'padrao',
-                        nome: p.nome,
-                    } as ParametroInterface)
+                ({
+                    abrangencia: 'padrao',
+                    nome: p.nome,
+                } as ParametroInterface)
             ),
             instrucoesConstrutor
         );

fontes/declaracoes/leia-multiplo.ts

@@ -10,10 +10,9 @@ import { Declaracao } from './declaracao';
 export class LeiaMultiplo extends Declaracao {
     simbolo: SimboloInterface;
     id: string;
+    argumento?: Construto;
 
-    argumento: Construto;
-
-    constructor(simbolo: SimboloInterface, argumento: Construto) {
+    constructor(simbolo: SimboloInterface, argumento?: Construto) {
         super(simbolo.linha, simbolo.hashArquivo);
         this.simbolo = simbolo;
         this.id = uuidv4();

fontes/interpretador/dialetos/potigol/interpretador-potigol.ts

@@ -1,7 +1,7 @@
 import { InterpretadorBase } from '../../interpretador-base';
 
 import { registrarBibliotecaGlobalPotigol } from '../../../bibliotecas/dialetos/potigol/biblioteca-global';
-import { AcessoMetodo, Binario, ConstanteOuVariavel, Literal, QualTipo, Unario, Variavel } from '../../../construtos';
+import { AcessoMetodo, Binario, ConstanteOuVariavel, Construto, Literal, QualTipo, Unario, Variavel } from '../../../construtos';
 
 import * as comum from './comum';
 import { ObjetoPadrao } from '../../../estruturas';
@@ -79,4 +79,23 @@ export class InterpretadorPotigol extends InterpretadorBase implements Interpret
 
          return inferirTipoVariavel(qualTipo?.valores || qualTipo);
     }
+
+    protected async avaliarArgumentosEscreva(argumentos: Construto[]): Promise<string> {
+        let formatoTexto: string = '';
+
+        for (const argumento of argumentos) {
+            const resultadoAvaliacao = await this.avaliar(argumento);
+            let valor = resultadoAvaliacao?.hasOwnProperty('valor') ? resultadoAvaliacao.valor : resultadoAvaliacao;
+            formatoTexto += `${this.paraTexto(valor)},`;
+        }
+
+        formatoTexto = formatoTexto.slice(0, -1);
+
+        if (argumentos.length > 1) {
+            formatoTexto = `(${formatoTexto})`;
+        }
+
+        return formatoTexto;
+    }
+
 }

testes/interpretador.test.ts

@@ -352,6 +352,23 @@ describe('Interpretador', () => {
 
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
+
+                it('Escreva múltiplas variáveis', async () => {                    
+                    const retornoLexador = lexador.mapear([
+                        "const a = 'batata'",
+                        "const b = 'arroz'",
+                        "escreva(a, b)"
+                    ], -1);
+
+                    interpretador.funcaoDeRetorno = (saida: any) => {
+                        expect(saida).toEqual("batata arroz");
+                    }
+
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
+                })
             });
 
             describe('Operações matemáticas', () => {

testes/potigol/interpretador.test.ts

@@ -156,7 +156,121 @@ describe('Interpretador', () => {
             });
         })
 
-        describe('Leia Multiplo', () => {
+        describe('Leia', () => {
+            it('Dado um leia_inteiro, escreva deve imprimir o valor lido', async () => {
+                const retornoLexador = lexador.mapear([
+                    'escreva(leia_inteiro)'
+                ], -1);
+
+                const resposta = 1;
+                interpretador.interfaceEntradaSaida = {
+                    question: (mensagem: string, callback: Function) => {
+                        callback(resposta);
+                    }
+                };
+
+                interpretador.funcaoDeRetorno = (saida: any) => {
+                    expect(saida).toEqual('1');
+                };
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Dado um leia_real, escreva deve imprimir o valor lido', async () => {
+                const retornoLexador = lexador.mapear([
+                    'escreva(leia_real)'
+                ], -1);
+
+                const resposta = 1.2;
+                interpretador.interfaceEntradaSaida = {
+                    question: (mensagem: string, callback: Function) => {
+                        callback(resposta);
+                    }
+                };
+
+                interpretador.funcaoDeRetorno = (saida: any) => {
+                    expect(saida).toEqual('1.2');
+                };
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Dado um leia_texto, escreva deve imprimir o valor lido', async () => {
+                const retornoLexador = lexador.mapear([
+                    'escreva(leia_texto)'
+                ], -1);
+
+                const resposta = "texto";
+                interpretador.interfaceEntradaSaida = {
+                    question: (mensagem: string, callback: Function) => {
+                        callback(resposta);
+                    }
+                };
+
+                interpretador.funcaoDeRetorno = (saida: any) => {
+                    expect(saida).toEqual('texto');
+                };
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Dado um leia_inteiro, escreva deve imprimir os valores inicializados', async () => {
+                const retornoLexador = lexador.mapear([
+                    'a, b, c = leia_inteiro',
+                    'escreva(a, b, c)'
+                ], -1);
+
+                const resposta = [1, 2, 3];
+                interpretador.interfaceEntradaSaida = {
+                    question: (mensagem: string, callback: Function) => {
+                        callback(resposta.shift());
+                    }
+                };
+
+                interpretador.funcaoDeRetorno = (saida: any) => {
+                    expect(saida).toEqual('(1,2,3)');
+                };
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Dado um leia_inteiro, escreva deve imprimir o valor inicializado', async () => {
+                const retornoLexador = lexador.mapear([
+                    'a = leia_inteiro',
+                    'escreva(a)'
+                ], -1);
+
+                const resposta = [1];
+                interpretador.interfaceEntradaSaida = {
+                    question: (mensagem: string, callback: Function) => {
+                        callback(resposta.shift());
+                    }
+                };
+
+                interpretador.funcaoDeRetorno = (saida: any) => {
+                    expect(saida).toEqual('1');
+                };
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+        });
+
+        describe('Leia vetores', () => {
             it('Dado um leia_inteiros separador por virgula, escreva deve imprimir o valor lido', async () => {
                 const retornoLexador = lexador.mapear([
                     'escreva(leia_inteiros(","))'