@designliquido/potigol 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Design Liquido
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+# potigol
+
+Nossa implementação do dialeto Potigol, usando TypeScript. 
+
+## Sobre este dialeto
+
+Este dialeto tenta implementar da forma mais fidedigna possível todos os comportamentos de execução do pacote Potigol, originalmente implementado em Scala. O pacote original possui o ciclo de execução inteiramente implementado, pode executar em qualquer sistema operacional, mas possui limitações para executar em navegadores de internet. No mais, componentes como um formatador ou analisador semântico não existem.
+
+Inicialmente, este dialeto foi implementado dentro do núcleo de Delégua, já que tínhamos a ideia de implementar algumas funcionalidades que Potigol tem também em Delégua, como os mecanismos de interpolação de texto e tuplas. Com a incorporação de mais dialetos ao núcleo, a manutenção do monolito começou a trazer impactos ao núcleo como um todo, com instruções que sequer existem em um dialeto tendo que ser implementadas porque outro dialeto a possui. Portanto, este dialeto foi separado do núcleo de Delégua, mas ainda o utiliza como dependência. 
+
+## Componentes implementados
+
+Este dialeto implementa os seguintes componentes:
+
+- **Lexador**: responsável pela análise léxica da linguagem: converte um texto em símbolos (_tokens_) que são utilizados na avaliação sintática;
+- **Avaliador Sintático**: responsável por converter símbolos em estruturas de alto nível. Essas estruturas de alto nível podem ser usadas para execução de código, formatação de código, tradução do fonte em outra linguagem de programação e análise semântica;
+- **Interpretador**: recebe estruturas de alto nível da avaliação sintática e as executa como instruções;
+- **Formatador**: recebe estruturas de alto nível da avaliação sintática e devolve um fonte do VisuAlg formatado conforme o manual de estilo de código da Design Líquido;
+- **Tradutor**: recebe estruturas de alto nível da avaliação sintática e o traduz para outra linguagem de programação. Nesta implementação, temos o tradutor de VisuAlg para Delégua;
+- **Analisador Semântico**: recebe estruturas de alto nível e verifica se a execução do código correspondente faz sentido ou não. O código de entrada pode estar perfeitamente escrito quanto ao léxico e sintaxe, mas podem haver problemas como variáveis que não existem, funções que retornam um tipo incorreto, execuções impossíveis como divisões por zero, entre outras heurísticas.
+
+## Finalidade educacional
+
+A finalidade educacional deste dialeto serve a dois grandes propósitos:
+
+- Permitir a qualquer pessoa executar código em Potigol, independente de sistema operacional e dispositivo;
+- Possibilitar a alunos que estejam estudando disciplinas de ciência da computação ou tecnologia da informação, como compiladores, a entender como esses componentes funcionando, já que boa parte deles faz parte do currículo eletivo de diversas instituições de ensino pelo mundo. O material disponível para tal é farto na língua inglesa, mas não na língua portuguesa.
+
+## Compatibilidade com JavaScript e Node.js
+
+Este dialeto é distribuído como um pacote do [NPM](https://npmjs.com), e é compatível com qualquer versão de JavaScript e Node.js. O código é escrito em TypeScript, mas transpilado para JavaScript ES5, virtualmente compatível com 100% dos navegadores de internet disponíveis atualmente.
+
+Este dialeto pode ser utilizado como base para construir outras aplicações, como _sites_ de internet, aplicativos para dispositivos móveis e até mesmo scripts executados por linha de comando. É também agregado ao [pacote de Delégua para Node.js](https://github.com/DesignLiquido/delegua-node), o que permite a execução de fontes por linha de comando.

package/avaliador-sintatico/avaliador-sintatico-potigol.d.ts

@@ -0,0 +1,125 @@
+import { Constante, ConstanteOuVariavel, Construto, FuncaoConstruto } from '@designliquido/delegua/construtos';
+import { Escreva, Declaracao, Se, Enquanto, Para, Escolha, Fazer, EscrevaMesmaLinha, Const, Var, FuncaoDeclaracao, Classe, ConstMultiplo } from '@designliquido/delegua/declaracoes';
+import { RetornoLexador, RetornoAvaliadorSintatico } from '@designliquido/delegua/interfaces/retornos';
+import { AvaliadorSintaticoBase } from '@designliquido/delegua/avaliador-sintatico/avaliador-sintatico-base';
+import { ParametroInterface, SimboloInterface } from '@designliquido/delegua/interfaces';
+import { RetornoDeclaracao } from '@designliquido/delegua/avaliador-sintatico/retornos';
+import { MicroAvaliadorSintaticoPotigol } from './micro-avaliador-sintatico-potigol';
+/**
+ * TODO: Pensar numa forma de avaliar múltiplas constantes sem
+ * transformar o retorno de `primario()` em um vetor.
+ */
+export declare class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
+    microAvaliadorSintatico: MicroAvaliadorSintaticoPotigol;
+    tiposPotigolParaDelegua: {
+        Caractere: string;
+        Inteiro: string;
+        Logico: string;
+        Lógico: string;
+        Real: string;
+        Texto: string;
+        undefined: any;
+    };
+    declaracoesAnteriores: {
+        [identificador: string]: any[];
+    };
+    /**
+     * Testa se o primeiro parâmetro na lista de símbolos
+     * pertence a uma declaração ou não.
+     * @param simbolos Os símbolos que fazem parte da lista de argumentos
+     * de uma chamada ou declaração de função.
+     * @returns `true` se parâmetros são de declaração. `false` caso contrário.
+     */
+    protected testePrimeiroParametro(simbolos: SimboloInterface[]): boolean;
+    /**
+     * Retorna uma declaração de função iniciada por igual,
+     * ou seja, com apenas uma instrução.
+     * @param simboloPrimario O símbolo que identifica a função (nome).
+     * @param parenteseEsquerdo O parêntese esquerdo, usado para fins de pragma.
+     * @param parametros A lista de parâmetros da função.
+     * @param tipoRetorno O tipo de retorno da função.
+     * @returns Um construto do tipo `FuncaoDeclaracao`.
+     */
+    protected declaracaoFuncaoPotigolIniciadaPorIgual(simboloPrimario: SimboloInterface, parenteseEsquerdo: SimboloInterface, parametros: ParametroInterface[], tipoRetorno?: SimboloInterface): FuncaoDeclaracao;
+    /**
+     * Retorna uma declaração de função terminada por fim,
+     * ou seja, com mais de uma instrução.
+     * @param simboloPrimario O símbolo que identifica a função (nome).
+     * @param parenteseEsquerdo O parêntese esquerdo, usado para fins de pragma.
+     * @param parametros A lista de parâmetros da função.
+     * @param tipoRetorno O tipo de retorno da função.
+     * @returns Um construto do tipo `FuncaoDeclaracao`.
+     */
+    protected declaracaoFuncaoPotigolTerminadaPorFim(simboloPrimario: SimboloInterface, parenteseEsquerdo: SimboloInterface, parametros: ParametroInterface[], tipoRetorno?: SimboloInterface): FuncaoDeclaracao;
+    corpoDaFuncao(nomeFuncao: string, simboloPragma?: SimboloInterface, parametros?: any[]): FuncaoConstruto;
+    protected declaracaoDeFuncaoOuMetodo(construtoPrimario: ConstanteOuVariavel): FuncaoDeclaracao;
+    finalizarChamada(entidadeChamada: Construto): Construto;
+    /**
+     * Verificação comum de tipos.
+     * Avança o símbolo se não houver erros.
+     * @param simbolo O símbolo sendo analisado.
+     * @param mensagemErro A mensagem de erro caso o símbolo atual não seja de tipo.
+     */
+    protected verificacaoTipo(simbolo: SimboloInterface, mensagemErro: string): void;
+    protected logicaComumParametrosPotigol(simbolos: SimboloInterface[]): {
+        parametros: ParametroInterface[];
+        tipagemDefinida: boolean;
+    };
+    primario(): Construto;
+    /**
+     * Em Potigol, só é possível determinar a diferença entre uma chamada e uma
+     * declaração de função depois dos argumentos.
+     *
+     * Chamadas não aceitam dicas de tipos de parâmetros.
+     * @returns Um construto do tipo `AcessoMetodo`, `AcessoIndiceVariavel` ou `Constante`,
+     * dependendo dos símbolos encontrados.
+     */
+    chamar(): Construto;
+    comparacaoIgualdade(): Construto;
+    declaracaoEscreva(): Escreva;
+    declaracaoImprima(): EscrevaMesmaLinha;
+    /**
+     * Blocos de escopo em Potigol existem quando:
+     *
+     * - Em uma declaração de função ou método, após fecha parênteses, o próximo
+     * símbolo obrigatório não é `=` e há pelo menos um `fim` até o final do código;
+     * - Em uma declaração `se`;
+     * - Em uma declaração `enquanto`;
+     * - Em uma declaração `para`.
+     * @returns Um vetor de `Declaracao`.
+     */
+    blocoEscopo(): Array<RetornoDeclaracao>;
+    declaracaoSe(): Se;
+    declaracaoEnquanto(): Enquanto;
+    declaracaoPara(): Para;
+    declaracaoEscolha(): Escolha;
+    protected declaracaoDeConstantes(): ConstMultiplo | Const[];
+    protected declaracaoDeVariaveis(): Var[];
+    protected logicaAtribuicaoComDicaDeTipo(expressao: Constante): SimboloInterface<string>;
+    declaracaoFazer(): Fazer;
+    /**
+     * Uma declaração de tipo nada mais é do que um declaração de classe.
+     * Em Potigol, classe e tipo são praticamente a mesma coisa.
+     *
+     * @returns Um construto do tipo `Classe`.
+     */
+    protected declaracaoTipo(): Classe;
+    atribuir(): any | any[];
+    /**
+     * Em Potigol, uma definição de função normalmente começa com um
+     * identificador - que não é uma palavra reservada - seguido de parênteses.
+     * Este ponto de entrada verifica o símbolo atual e o próximo.
+     *
+     * Diferentemente dos demais dialetos, verificamos logo de cara se
+     * temos uma definição ou chamada de função, isto porque definições
+     * nunca aparecem do lado direito de uma atribuição, a não ser que
+     * estejam entre parênteses (_currying_).
+     *
+     * Se o próximo símbolo for parênteses, ou é uma definiçao de função,
+     * ou uma chamada de função.
+     */
+    expressaoOuDefinicaoFuncao(): any;
+    resolverDeclaracaoForaDeBloco(): Declaracao | Declaracao[] | Construto | Construto[] | any;
+    analisar(retornoLexador: RetornoLexador<SimboloInterface>, hashArquivo: number): RetornoAvaliadorSintatico<Declaracao>;
+}
+//# sourceMappingURL=avaliador-sintatico-potigol.d.ts.map

package/avaliador-sintatico/avaliador-sintatico-potigol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avaliador-sintatico-potigol.d.ts","sourceRoot":"","sources":["../../fontes/avaliador-sintatico/avaliador-sintatico-potigol.ts"],"names":[],"mappings":"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"}