#376 Implementação regex

fontes/analisador-semantico/analisador-semantico.ts

@@ -1,4 +1,4 @@
-import { Atribuir, Chamada, FimPara, FormatacaoEscrita, FuncaoConstruto, Literal, Super, TipoDe, Variavel, Vetor } from '../construtos';
+import { Atribuir, Chamada, ExpressaoRegular, FimPara, FormatacaoEscrita, FuncaoConstruto, Literal, Super, TipoDe, Variavel, Vetor } from '../construtos';
 import {
     Bloco,
     Classe,
@@ -58,6 +58,9 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
         this.atual = 0;
         this.erros = [];
     }
+    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
 
     erro(simbolo: SimboloInterface, mensagemDeErro: string): void {
         this.erros.push({

fontes/analisador-semantico/dialetos/analisador-semantico-birl.ts

@@ -1,4 +1,4 @@
-import { Atribuir, FimPara, FormatacaoEscrita, Literal, Super, TipoDe, Variavel } from '../../construtos';
+import { Atribuir, ExpressaoRegular, FimPara, FormatacaoEscrita, Literal, Super, TipoDe, Variavel } from '../../construtos';
 import {
     Bloco,
     Classe,
@@ -60,6 +60,9 @@ export class AnalisadorSemanticoBirl implements AnalisadorSemanticoInterface {
         this.atual = 0;
         this.erros = [];
     }
+    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
 
     visitarExpressaoTipoDe(expressao: TipoDe): Promise<any> {
         throw new Error('Método não implementado.');

fontes/avaliador-sintatico/avaliador-sintatico.ts

@@ -26,6 +26,7 @@ import {
     Variavel,
     Vetor,
     Isto,
+    ExpressaoRegular,
 } from '../construtos';
 
 import { ErroAvaliadorSintatico } from './erro-avaliador-sintatico';
@@ -271,11 +272,40 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
                     simboloAtual,
                     _expressao instanceof Literal ? _expressao.valor : _expressao
                 );
+
+            case tiposDeSimbolos.EXPRESSAO_REGULAR:
+                let valor: string = '';
+                this.avancarEDevolverAnterior();
+                while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.EXPRESSAO_REGULAR)) {
+                    valor += this.simboloAtual().lexema;
+                    this.avancarEDevolverAnterior();
+                }
+                this.avancarEDevolverAnterior();
+                const valorExpressaoRegular = this.textoParaRegex(valor);
+                return new ExpressaoRegular(
+                    this.hashArquivo,
+                    simboloAtual,
+                    valorExpressaoRegular
+                );
         }
 
         throw this.erro(this.simbolos[this.atual], 'Esperado expressão.');
     }
 
+    //https://stackoverflow.com/a/66751666/9043143
+    textoParaRegex(texto) : RegExp {
+        const match = texto.match(/^([\/~@;%#'])(.*?)\1([gimsuy]*)$/);
+        return match ? 
+          new RegExp(
+            match[2],
+            match[3]
+              .split('')
+              .filter((char, pos, flagArr) => flagArr.indexOf(char) === pos)
+              .join('')
+          ) 
+          : new RegExp(texto);
+    }
+
     finalizarChamada(entidadeChamada: Construto): Construto {
         const argumentos: Array<Construto> = [];
 

fontes/construtos/expressao-regular.ts

@@ -0,0 +1,21 @@
+import { VisitanteComumInterface, SimboloInterface, VariavelInterface } from '../interfaces';
+import { Construto } from './construto';
+
+export class ExpressaoRegular implements Construto {
+    linha: number;
+    hashArquivo: number;
+    valor: any;
+
+    simbolo: SimboloInterface;
+
+    constructor(hashArquivo: number, simbolo: SimboloInterface, valor: any) {
+        this.linha = Number(simbolo.linha);
+        this.hashArquivo = hashArquivo;
+        this.valor = valor;
+        this.simbolo = simbolo;
+    }
+
+    async aceitar(visitante: VisitanteComumInterface): Promise<VariavelInterface> {
+        return Promise.resolve(visitante.visitarExpressaoExpressaoRegular(this));
+    }
+}

fontes/construtos/index.ts

@@ -1,21 +1,22 @@
+export * from './acesso-indice-variavel';
+export * from './acesso-metodo';
+export * from './agrupamento';
 export * from './atribuicao-por-indice';
 export * from './atribuir';
 export * from './binario';
 export * from './chamada';
 export * from './constante';
 export * from './constante-ou-variavel';
+export * from './construto';
 export * from './definir-valor';
 export * from './dicionario';
-export * from './construto';
+export * from './expressao-regular';
 export * from './fim-para';
 export * from './formatacao-escrita';
 export * from './funcao';
-export * from './acesso-metodo';
-export * from './agrupamento';
 export * from './isto';
 export * from './literal';
 export * from './logico';
-export * from './acesso-indice-variavel';
 export * from './super';
 export * from './tipo-de';
 export * from './unario';

fontes/interfaces/visitante-comum-interface.ts

@@ -1,4 +1,4 @@
-import { Atribuir, FimPara, Literal, Super, TipoDe } from '../construtos';
+import { Atribuir, ExpressaoRegular, FimPara, Literal, Super, TipoDe } from '../construtos';
 import {
     Bloco,
     Classe,
@@ -58,6 +58,7 @@ export interface VisitanteComumInterface {
     visitarExpressaoDeleguaFuncao(expressao: any): any;
     visitarExpressaoDeVariavel(expressao: any): any;
     visitarExpressaoDicionario(expressao: any): any;
+    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any>;
     visitarExpressaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): any;
     visitarExpressaoFalhar(expressao: any): Promise<any>;
     visitarExpressaoFimPara(declaracao: FimPara): any;

fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts

@@ -11,6 +11,7 @@ import {
     AcessoIndiceVariavel,
     Atribuir,
     Construto,
+    ExpressaoRegular,
     FimPara,
     FormatacaoEscrita,
     Literal,
@@ -89,6 +90,9 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
 
         carregarBibliotecaGlobal(this, this.pilhaEscoposExecucao);
     }
+    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
 
     visitarExpressaoTipoDe(expressao: TipoDe): Promise<any> {
         throw new Error('Método não implementado.');

fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts

@@ -1,4 +1,4 @@
-import { AcessoMetodo, Construto, FimPara, FormatacaoEscrita, Super, TipoDe, Variavel } from '../../../../construtos';
+import { AcessoMetodo, Construto, ExpressaoRegular, FimPara, FormatacaoEscrita, Super, TipoDe, Variavel } from '../../../../construtos';
 import {
     Bloco,
     Const,
@@ -75,6 +75,10 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
         this.classeAtual = TipoClasse.NENHUM;
         this.cicloAtual = TipoClasse.NENHUM;
     }
+
+    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
 
     visitarExpressaoTipoDe(expressao: TipoDe): Promise<any> {
         throw new Error('Método não implementado.');

fontes/interpretador/dialetos/mapler/interpretador-mapler.ts

@@ -1,4 +1,4 @@
-import { Binario, Construto, Logico, Variavel } from '../../../construtos';
+import { Binario, Construto, ExpressaoRegular, Logico, Variavel } from '../../../construtos';
 import { Const, Escreva, EscrevaMesmaLinha, Fazer, Leia } from '../../../declaracoes';
 import { InterpretadorBase } from '../..';
 import { ContinuarQuebra, Quebra } from '../../../quebras';
@@ -18,6 +18,10 @@ export class InterpretadorMapler extends InterpretadorBase {
         this.mensagemPrompt = '> ';
     }
 
+    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
+
     visitarDeclaracaoConst(declaracao: Const): Promise<any> {
         throw new Error('Método não implementado.');
     }

fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts

@@ -1,4 +1,4 @@
-import { Atribuir, Construto, FimPara, FormatacaoEscrita, Literal, Super, TipoDe, Variavel } from '../../../construtos';
+import { Atribuir, Construto, ExpressaoRegular, FimPara, FormatacaoEscrita, Literal, Super, TipoDe, Variavel } from '../../../construtos';
 import {
     Bloco,
     Classe,
@@ -73,6 +73,9 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         };
         this.pilhaEscoposExecucao.empilhar(escopoExecucao);
     }
+    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
 
     visitarExpressaoTipoDe(expressao: TipoDe): Promise<any> {
         throw new Error('Método não implementado.');

fontes/interpretador/interpretador-base.ts

@@ -50,6 +50,7 @@ import {
     Binario,
     Chamada,
     Construto,
+    ExpressaoRegular,
     FimPara,
     FormatacaoEscrita,
     Literal,
@@ -135,6 +136,9 @@ export class InterpretadorBase implements InterpretadorInterface {
 
         carregarBibliotecasGlobais(this, this.pilhaEscoposExecucao);
     }
+    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any> {
+        return expressao.valor;
+    }
 
     async visitarExpressaoTipoDe(expressao: TipoDe): Promise<string> {
         let tipoDe = expressao.valor;

fontes/lexador/lexador.ts

@@ -323,8 +323,13 @@ export class Lexador implements LexadorInterface<SimboloInterface> {
                 break;
 
             case '|':
-                this.adicionarSimbolo(tiposDeSimbolos.BIT_OR);
                 this.avancar();
+                if (this.simboloAtual() === '|') {
+                    this.adicionarSimbolo(tiposDeSimbolos.EXPRESSAO_REGULAR, '||');
+                    this.avancar();
+                } else {
+                    this.adicionarSimbolo(tiposDeSimbolos.BIT_OR);
+                }
                 break;
 
             case '^':

fontes/tipos-de-simbolos/delegua.ts

@@ -29,6 +29,7 @@ export default {
     ESCOLHA: 'ESCOLHA',
     ESCREVA: 'ESCREVA',
     EXPONENCIACAO: 'EXPONENCIACAO',
+    EXPRESSAO_REGULAR: 'EXPRESSAO_REGULAR',
     FALHAR: 'FALHAR',
     FALSO: 'FALSO',
     FAZER: 'FAZER',

testes/interpretador.test.ts

@@ -994,6 +994,21 @@ describe('Interpretador', () => {
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
             })
+
+            describe('Expressão Regular', () => {
+                it('Método substituir()', async () => {
+                    const retornoLexador = lexador.mapear([
+                        "var str = \"olá mundo, olá universo\";",
+                        "var novaStr = str.substituir(||/olá/g||, \"oi\");",
+                        "escreva(novaStr);",
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
+                });
+            })
         });
 
         describe('Cenários de falha', () => {