@designliquido/potigol 0.0.0 → 0.0.1

package/formatador/formatador-potigol.js

@@ -0,0 +1,662 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatadorPotigol = void 0;
+const construtos_1 = require("@designliquido/delegua/construtos");
+const lexico_regular_1 = __importDefault(require("../tipos-de-simbolos/lexico-regular"));
+class FormatadorPotigol {
+    constructor(quebraLinha, tamanhoIndentacao = 4) {
+        this.quebraLinha = quebraLinha;
+        this.tamanhoIndentacao = tamanhoIndentacao;
+        this.indentacaoAtual = 0;
+        this.codigoFormatado = '';
+        this.devePularLinha = true;
+        this.deveIndentar = true;
+    }
+    visitarDeclaracaoTendoComo(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarDeclaracaoInicioAlgoritmo(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarDeclaracaoCabecalhoPrograma(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoTupla(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarDeclaracaoClasse(declaracao) {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}tipo ${declaracao.simbolo.lexema}${this.quebraLinha}`;
+        this.formatarBlocoOuVetorDeclaracoes(declaracao.propriedades);
+        this.formatarBlocoOuVetorDeclaracoes(declaracao.metodos);
+        this.codigoFormatado += `fim${this.quebraLinha}`;
+    }
+    visitarExpressaoPropriedadeClasse(expressao) {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}${expressao.nome.lexema}: `;
+        if (expressao.tipo) {
+            this.codigoFormatado += `${expressao.tipo}`;
+        }
+        this.codigoFormatado += this.quebraLinha;
+    }
+    visitarDeclaracaoConst(declaracao) {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}${declaracao.simbolo.lexema}`;
+        if (declaracao.tipo) {
+            this.codigoFormatado += ": ";
+            switch (declaracao.tipo.toUpperCase()) {
+                case lexico_regular_1.default.TEXTO:
+                    this.codigoFormatado += 'Caractere = ';
+                    break;
+                case lexico_regular_1.default.INTEIRO:
+                    this.codigoFormatado += 'Inteiro = ';
+                    break;
+                case "NUMERO":
+                case lexico_regular_1.default.REAL:
+                    this.codigoFormatado += 'Real = ';
+                    break;
+                case lexico_regular_1.default.LOGICO:
+                    this.codigoFormatado += 'Logico = ';
+                    break;
+                case lexico_regular_1.default.LÓGICO:
+                    this.codigoFormatado += 'Lógico = ';
+                    break;
+                default:
+                    console.log(declaracao.tipo);
+                    break;
+            }
+        }
+        if (declaracao.inicializador && !declaracao.tipo) {
+            this.codigoFormatado += " = ";
+        }
+        if (declaracao.inicializador) {
+            this.formatarDeclaracaoOuConstruto(declaracao.inicializador);
+        }
+    }
+    visitarDeclaracaoConstMultiplo(declaracao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoDeAtribuicao(expressao) {
+        this.codigoFormatado += `${expressao.simbolo.lexema} de `;
+        this.formatarDeclaracaoOuConstruto(expressao.valor);
+        if (this.devePularLinha) {
+            this.codigoFormatado += `${this.quebraLinha}`;
+        }
+    }
+    visitarDeclaracaoDeExpressao(declaracao) {
+        this.formatarDeclaracaoOuConstruto(declaracao.expressao);
+    }
+    visitarDeclaracaoAleatorio(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarDeclaracaoDefinicaoFuncao(declaracao) {
+        if (declaracao.simbolo.tipo !== lexico_regular_1.default.CONSTRUTOR) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}${declaracao.simbolo.lexema}(`;
+            this.visitarExpressaoFuncaoConstruto(declaracao.funcao);
+        }
+    }
+    visitarDeclaracaoEnquanto(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}enquanto(`;
+        this.formatarDeclaracaoOuConstruto(declaracao.condicao);
+        this.codigoFormatado += ` ) faca`;
+        this.codigoFormatado += this.quebraLinha;
+        this.devePularLinha = true;
+        this.formatarDeclaracaoOuConstruto(declaracao.corpo);
+        this.codigoFormatado += this.quebraLinha;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}fim`;
+        this.devePularLinha = false;
+    }
+    formatarBlocoOuVetorDeclaracoes(declaracoes) {
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracaoBloco of declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+    }
+    visitarDeclaracaoEscolha(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}escolha `;
+        this.formatarDeclaracaoOuConstruto(declaracao.identificadorOuLiteral);
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let caminho of declaracao.caminhos) {
+            this.deveIndentar = false;
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}caso `;
+            this.formatarBlocoOuVetorDeclaracoes(caminho.condicoes);
+            this.codigoFormatado += ` => `;
+            this.formatarBlocoOuVetorDeclaracoes(caminho.declaracoes);
+            this.codigoFormatado += this.quebraLinha;
+            this.deveIndentar = true;
+        }
+        if (declaracao.caminhoPadrao.declaracoes.length > 0) {
+            this.deveIndentar = false;
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}caso _ => `;
+            this.formatarBlocoOuVetorDeclaracoes(declaracao.caminhoPadrao.declaracoes);
+            this.deveIndentar = true;
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${this.quebraLinha}${' '.repeat(this.indentacaoAtual)}fim${this.quebraLinha}`;
+    }
+    visitarDeclaracaoEscreva(declaracao) {
+        if (this.deveIndentar) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}escreva (`;
+        }
+        else {
+            this.codigoFormatado += `escreva (`;
+        }
+        for (let argumento of declaracao.argumentos) {
+            this.formatarDeclaracaoOuConstruto(argumento);
+        }
+        this.codigoFormatado += `)`;
+        if (this.devePularLinha) {
+            this.codigoFormatado += this.quebraLinha;
+        }
+    }
+    visitarDeclaracaoFazer(declaracao) {
+        throw new Error('Método não implementado');
+    }
+    visitarDeclaracaoImportar(declaracao) {
+        throw new Error('Método não implementado');
+    }
+    visitarDeclaracaoPara(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}para `;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        this.devePularLinha = false;
+        if (declaracao.inicializador) {
+            if (Array.isArray(declaracao.inicializador)) {
+                this.deveIndentar = false;
+                for (let declaracaoInicializador of declaracao.inicializador) {
+                    this.formatarDeclaracaoOuConstruto(declaracaoInicializador);
+                }
+                this.deveIndentar = true;
+            }
+            else {
+                this.formatarDeclaracaoOuConstruto(declaracao.inicializador);
+            }
+        }
+        if (declaracao.condicao instanceof construtos_1.Binario)
+            this.codigoFormatado += ` ate ${declaracao.condicao.direita.valor}`;
+        else
+            this.formatarDeclaracaoOuConstruto(declaracao.condicao);
+        this.codigoFormatado += ` faca${this.quebraLinha}`;
+        this.formatarDeclaracaoOuConstruto(declaracao.incrementar);
+        this.formatarBlocoOuVetorDeclaracoes(declaracao.corpo.declaracoes);
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${this.quebraLinha}${' '.repeat(this.indentacaoAtual)}fim${this.quebraLinha}`;
+    }
+    visitarDeclaracaoParaCada(declaracao) {
+        throw new Error('Método não implementado');
+    }
+    visitarDeclaracaoSe(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}se ( `;
+        this.formatarDeclaracaoOuConstruto(declaracao.condicao);
+        this.codigoFormatado += ` ) entao${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracaoBloco of declaracao.caminhoEntao.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        if (declaracao.caminhoSenao) {
+            this.codigoFormatado += `${this.quebraLinha}${' '.repeat(this.indentacaoAtual)}senao${this.quebraLinha}`;
+            this.formatarDeclaracaoOuConstruto(declaracao.caminhoSenao);
+        }
+        this.codigoFormatado += `${this.quebraLinha}${' '.repeat(this.indentacaoAtual)}fim${this.quebraLinha}`;
+    }
+    visitarDeclaracaoTente(declaracao) {
+        throw new Error('Método não implementado');
+    }
+    visitarDeclaracaoVar(declaracao) {
+        if (this.deveIndentar) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}`;
+        }
+        this.codigoFormatado += `var ${declaracao.simbolo.lexema}`;
+        if (declaracao.inicializador) {
+            this.codigoFormatado += ` := `;
+            this.formatarDeclaracaoOuConstruto(declaracao.inicializador);
+        }
+        if (this.devePularLinha) {
+            this.codigoFormatado += this.quebraLinha;
+        }
+    }
+    visitarDeclaracaoVarMultiplo(declaracao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoAcessoIndiceVariavel(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoAcessoElementoMatriz(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoAcessoMetodo(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoAgrupamento(expressao) {
+        this.codigoFormatado += '(';
+        this.formatarDeclaracaoOuConstruto(expressao.expressao);
+        this.codigoFormatado += ')';
+    }
+    visitarExpressaoAtribuicaoPorIndice(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoBinaria(expressao) {
+        /* this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}` */
+        this.formatarDeclaracaoOuConstruto(expressao.esquerda);
+        switch (expressao.operador.tipo) {
+            case lexico_regular_1.default.ADICAO:
+                this.codigoFormatado += ' + ';
+                break;
+            case lexico_regular_1.default.DIVISAO:
+                this.codigoFormatado += ' / ';
+                break;
+            case lexico_regular_1.default.DIVISAO_INTEIRA:
+                this.codigoFormatado += ' div ';
+                break;
+            case lexico_regular_1.default.IGUAL:
+                this.codigoFormatado += ' = ';
+                break;
+            case lexico_regular_1.default.MAIOR:
+                this.codigoFormatado += ' > ';
+                break;
+            case lexico_regular_1.default.MAIOR_IGUAL:
+                this.codigoFormatado += ' >= ';
+                break;
+            case lexico_regular_1.default.MENOR:
+                this.codigoFormatado += ' < ';
+                break;
+            case lexico_regular_1.default.MENOR_IGUAL:
+                this.codigoFormatado += ' <= ';
+                break;
+            case lexico_regular_1.default.SUBTRACAO:
+                this.codigoFormatado += ` - `;
+                break;
+            case lexico_regular_1.default.MULTIPLICACAO:
+                this.codigoFormatado += ` * `;
+                break;
+            case lexico_regular_1.default.MODULO:
+                this.codigoFormatado += ` mod `;
+                break;
+            case lexico_regular_1.default.EXPONENCIACAO:
+                this.codigoFormatado += ` ^ `;
+                break;
+            case lexico_regular_1.default.IGUAL_IGUAL:
+                this.codigoFormatado += ` == `;
+                break;
+            case lexico_regular_1.default.DIFERENTE:
+                this.codigoFormatado += ` <> `;
+                break;
+            default:
+                console.log(expressao.operador.tipo);
+                break;
+        }
+        this.formatarDeclaracaoOuConstruto(expressao.direita);
+    }
+    visitarExpressaoBloco(declaracao) {
+        this.formatarBlocoOuVetorDeclaracoes(declaracao.declaracoes);
+    }
+    visitarExpressaoContinua(declaracao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoDeChamada(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoDefinirValor(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoDeleguaFuncao(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoDeVariavel(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoDicionario(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoExpressaoRegular(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarDeclaracaoEscrevaMesmaLinha(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}imprima `;
+        for (let argumento of declaracao.argumentos) {
+            const argumentoTratado = argumento;
+            this.formatarDeclaracaoOuConstruto(argumentoTratado);
+            this.codigoFormatado += ', ';
+        }
+        if (declaracao.argumentos.length && this.codigoFormatado[this.codigoFormatado.length - 2] === ',') {
+            this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+        }
+    }
+    visitarExpressaoFalhar(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoFimPara(declaracao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoFormatacaoEscrita(declaracao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoFuncaoConstruto(expressao) {
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        if (expressao.parametros.length > 0) {
+            for (let parametro of expressao.parametros) {
+                if (parametro.tipoDado) {
+                    this.codigoFormatado += `${parametro.tipoDado.nome}: `;
+                    switch (parametro.tipoDado.tipo.toUpperCase()) {
+                        case lexico_regular_1.default.TEXTO:
+                            this.codigoFormatado += "Caractere";
+                            break;
+                        case lexico_regular_1.default.REAL:
+                            this.codigoFormatado += "Real";
+                            break;
+                        case lexico_regular_1.default.INTEIRO:
+                            this.codigoFormatado += "Inteiro";
+                            break;
+                        default:
+                            break;
+                    }
+                    this.codigoFormatado += `, `;
+                }
+            }
+            this.codigoFormatado = `${this.codigoFormatado.slice(0, -2)}): `;
+        }
+        for (let declaracaoCorpo of expressao.corpo) {
+            this.formatarDeclaracaoOuConstruto(declaracaoCorpo);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+    }
+    visitarExpressaoIsto(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoLeia(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoLeiaMultiplo(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoLiteral(expressao) {
+        if (typeof expressao.valor === 'string') {
+            this.codigoFormatado += `"${expressao.valor}"`;
+            return;
+        }
+        else if (typeof expressao.valor === "boolean") {
+            if (expressao.valor) {
+                this.codigoFormatado += "verdadeiro";
+            }
+            else {
+                this.codigoFormatado += "falso";
+            }
+            return;
+        }
+        this.codigoFormatado += `${expressao.valor}`;
+    }
+    visitarExpressaoLogica(expressao) {
+        this.formatarDeclaracaoOuConstruto(expressao.esquerda);
+        switch (expressao.operador.tipo) {
+            case lexico_regular_1.default.E:
+                this.codigoFormatado += ` e `;
+                break;
+            case lexico_regular_1.default.OU:
+                this.codigoFormatado += ` ou `;
+                break;
+            case lexico_regular_1.default.NEGACAO:
+                this.codigoFormatado += ` nao `;
+                break;
+        }
+        this.formatarDeclaracaoOuConstruto(expressao.direita);
+    }
+    visitarExpressaoRetornar(declaracao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoSuper(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoSustar(declaracao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoTipoDe(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarExpressaoUnaria(expressao) {
+        let operador;
+        switch (expressao.operador.tipo) {
+            case lexico_regular_1.default.SUBTRACAO:
+                operador = ` - `;
+                break;
+            case lexico_regular_1.default.ADICAO:
+                operador = ` + `;
+                break;
+            case lexico_regular_1.default.NEGACAO:
+                operador = ` nao `;
+                break;
+        }
+        switch (expressao.incidenciaOperador) {
+            case 'ANTES':
+                this.codigoFormatado += operador;
+                this.formatarDeclaracaoOuConstruto(expressao.operando);
+                break;
+            case 'DEPOIS':
+                this.formatarDeclaracaoOuConstruto(expressao.operando);
+                this.codigoFormatado += operador;
+                break;
+        }
+        if (this.devePularLinha) {
+            this.codigoFormatado += this.quebraLinha;
+        }
+    }
+    visitarExpressaoVetor(expressao) {
+        throw new Error('Método não implementado');
+    }
+    visitarDeclaracaoConstante(expressao) {
+        this.codigoFormatado += `${expressao.simbolo.lexema}`;
+    }
+    formatarDeclaraTuplas(declaracao) {
+        const declaracoes = Object.keys(declaracao);
+        this.codigoFormatado += "(";
+        for (let chaveDeclaracao of declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracao[chaveDeclaracao]);
+            this.codigoFormatado += ", ";
+        }
+        this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+        this.codigoFormatado += ")";
+    }
+    visitarExpressaoDupla(expressao) {
+        this.formatarDeclaraTuplas(expressao);
+    }
+    visitarExpressaoTrio(expressao) {
+        this.formatarDeclaraTuplas(expressao);
+    }
+    visitarExpressaoQuarteto(expressao) {
+        this.formatarDeclaraTuplas(expressao);
+    }
+    visitarExpressaoQuinteto(expressao) {
+        this.formatarDeclaraTuplas(expressao);
+    }
+    visitarExpressaoSexteto(expressao) {
+        this.formatarDeclaraTuplas(expressao);
+    }
+    visitarExpressaoSepteto(expressao) {
+        this.formatarDeclaraTuplas(expressao);
+    }
+    visitarExpressaoOcteto(expressao) {
+        this.formatarDeclaraTuplas(expressao);
+    }
+    visitarExpressaoNoneto(expressao) {
+        this.formatarDeclaraTuplas(expressao);
+    }
+    visitarExpressaoDeceto(expressao) {
+        this.formatarDeclaraTuplas(expressao);
+    }
+    formatarDeclaracaoOuConstruto(declaracaoOuConstruto) {
+        switch (declaracaoOuConstruto.constructor.name) {
+            case 'AcessoIndiceVariavel':
+                this.visitarExpressaoAcessoIndiceVariavel(declaracaoOuConstruto);
+                break;
+            case 'AcessoMetodoOuPropriedade':
+                this.visitarExpressaoAcessoMetodo(declaracaoOuConstruto);
+                break;
+            case 'Agrupamento':
+                this.visitarExpressaoAgrupamento(declaracaoOuConstruto);
+                break;
+            case 'AtribuicaoPorIndice':
+                this.visitarExpressaoAtribuicaoPorIndice(declaracaoOuConstruto);
+                break;
+            case 'Atribuir':
+                this.visitarExpressaoDeAtribuicao(declaracaoOuConstruto);
+                break;
+            case 'Binario':
+                this.visitarExpressaoBinaria(declaracaoOuConstruto);
+                break;
+            case 'Bloco':
+                this.visitarExpressaoBloco(declaracaoOuConstruto);
+                break;
+            case 'Chamada':
+                this.visitarExpressaoDeChamada(declaracaoOuConstruto);
+                break;
+            case 'Classe':
+                this.visitarDeclaracaoClasse(declaracaoOuConstruto);
+                break;
+            case 'Continua':
+                this.visitarExpressaoContinua(declaracaoOuConstruto);
+                break;
+            case 'DefinirValor':
+                this.visitarExpressaoDefinirValor(declaracaoOuConstruto);
+                break;
+            case 'Dicionario':
+                this.visitarExpressaoDicionario(declaracaoOuConstruto);
+                break;
+            case 'Dupla':
+                this.visitarExpressaoDupla(declaracaoOuConstruto);
+                break;
+            case 'Trio':
+                this.visitarExpressaoTrio(declaracaoOuConstruto);
+                break;
+            case 'Quarteto':
+                this.visitarExpressaoQuarteto(declaracaoOuConstruto);
+                break;
+            case 'Quinteto':
+                this.visitarExpressaoQuinteto(declaracaoOuConstruto);
+                break;
+            case 'Sexteto':
+                this.visitarExpressaoSexteto(declaracaoOuConstruto);
+                break;
+            case 'Septeto':
+                this.visitarExpressaoSepteto(declaracaoOuConstruto);
+                break;
+            case 'Octeto':
+                this.visitarExpressaoOcteto(declaracaoOuConstruto);
+                break;
+            case 'Noneto':
+                this.visitarExpressaoNoneto(declaracaoOuConstruto);
+                break;
+            case 'Deceto':
+                this.visitarExpressaoDeceto(declaracaoOuConstruto);
+                break;
+            case 'Escolha':
+                this.visitarDeclaracaoEscolha(declaracaoOuConstruto);
+                break;
+            case 'Enquanto':
+                this.visitarDeclaracaoEnquanto(declaracaoOuConstruto);
+                break;
+            case 'Escreva':
+                this.visitarDeclaracaoEscreva(declaracaoOuConstruto);
+                break;
+            case 'EscrevaMesmaLinha':
+                this.visitarDeclaracaoEscrevaMesmaLinha(declaracaoOuConstruto);
+                break;
+            case 'Expressao':
+                this.visitarDeclaracaoDeExpressao(declaracaoOuConstruto);
+                break;
+            case 'ExpressaoRegular':
+                this.visitarExpressaoExpressaoRegular(declaracaoOuConstruto);
+                break;
+            case 'Falhar':
+                this.visitarExpressaoFalhar(declaracaoOuConstruto);
+                break;
+            case 'Fazer':
+                this.visitarDeclaracaoFazer(declaracaoOuConstruto);
+                break;
+            case 'FuncaoConstruto':
+                this.visitarExpressaoFuncaoConstruto(declaracaoOuConstruto);
+                break;
+            case 'FuncaoDeclaracao':
+                this.visitarDeclaracaoDefinicaoFuncao(declaracaoOuConstruto);
+                break;
+            case 'Importar':
+                this.visitarDeclaracaoImportar(declaracaoOuConstruto);
+                break;
+            case 'Isto':
+                this.visitarExpressaoIsto(declaracaoOuConstruto);
+                break;
+            case 'Leia':
+                this.visitarExpressaoLeia(declaracaoOuConstruto);
+                break;
+            case 'Literal':
+                this.visitarExpressaoLiteral(declaracaoOuConstruto);
+                break;
+            case 'Logico':
+                this.visitarExpressaoLogica(declaracaoOuConstruto);
+                break;
+            case 'Para':
+                this.visitarDeclaracaoPara(declaracaoOuConstruto);
+                break;
+            case 'ParaCada':
+                this.visitarDeclaracaoParaCada(declaracaoOuConstruto);
+                break;
+            case 'Retorna':
+                this.visitarExpressaoRetornar(declaracaoOuConstruto);
+                break;
+            case 'Se':
+                this.visitarDeclaracaoSe(declaracaoOuConstruto);
+                break;
+            case 'Super':
+                this.visitarExpressaoSuper(declaracaoOuConstruto);
+                break;
+            case 'Sustar':
+                this.visitarExpressaoSustar(declaracaoOuConstruto);
+                break;
+            case 'Tente':
+                this.visitarDeclaracaoTente(declaracaoOuConstruto);
+                break;
+            case 'TipoDe':
+                this.visitarExpressaoTipoDe(declaracaoOuConstruto);
+                break;
+            case 'Unario':
+                this.visitarExpressaoUnaria(declaracaoOuConstruto);
+                break;
+            case 'Const':
+                this.visitarDeclaracaoConst(declaracaoOuConstruto);
+                break;
+            case 'Var':
+                this.visitarDeclaracaoVar(declaracaoOuConstruto);
+                break;
+            case 'Variavel':
+                this.visitarExpressaoDeVariavel(declaracaoOuConstruto);
+                break;
+            case 'Vetor':
+                this.visitarExpressaoVetor(declaracaoOuConstruto);
+                break;
+            case 'Constante':
+                this.visitarDeclaracaoConstante(declaracaoOuConstruto);
+                break;
+            case 'PropriedadeClasse':
+                this.visitarExpressaoPropriedadeClasse(declaracaoOuConstruto);
+                break;
+            default:
+                console.log(declaracaoOuConstruto.constructor.name);
+                break;
+        }
+    }
+    formatar(declaracoes) {
+        this.indentacaoAtual = 0;
+        this.codigoFormatado = "";
+        this.devePularLinha = true;
+        this.deveIndentar = true;
+        for (let declaracao of declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracao);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        return this.codigoFormatado;
+    }
+}
+exports.FormatadorPotigol = FormatadorPotigol;
+//# sourceMappingURL=formatador-potigol.js.map