@designliquido/delegua 0.15.2 → 0.15.4

package/fontes/avaliador-sintatico/avaliador-sintatico-base.js

@@ -1,216 +1,216 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvaliadorSintaticoBase = void 0;
-const construtos_1 = require("../construtos");
-const declaracoes_1 = require("../declaracoes");
-const erro_avaliador_sintatico_1 = require("./erro-avaliador-sintatico");
-const comum_1 = __importDefault(require("../tipos-de-simbolos/comum"));
-/**
- * O Avaliador Sintático Base é uma tentativa de mapear métodos em comum
- * entre todos os outros Avaliadores Sintáticos. Depende de um dicionário
- * de tipos de símbolos comuns entre todos os dialetos.
- */
-class AvaliadorSintaticoBase {
-    consumir(tipo, mensagemDeErro) {
-        if (this.verificarTipoSimboloAtual(tipo))
-            return this.avancarEDevolverAnterior();
-        throw this.erro(this.simbolos[this.atual], mensagemDeErro);
-    }
-    erro(simbolo, mensagemDeErro) {
-        const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
-        this.erros.push(excecao);
-        return excecao;
-    }
-    simboloAnterior() {
-        return this.simbolos[this.atual - 1];
-    }
-    verificarTipoSimboloAtual(tipo) {
-        if (this.estaNoFinal())
-            return false;
-        return this.simbolos[this.atual].tipo === tipo;
-    }
-    verificarTipoProximoSimbolo(tipo) {
-        return this.simbolos[this.atual + 1].tipo === tipo;
-    }
-    estaNoFinal() {
-        return this.atual === this.simbolos.length;
-    }
-    avancarEDevolverAnterior() {
-        if (!this.estaNoFinal())
-            this.atual += 1;
-        return this.simbolos[this.atual - 1];
-    }
-    verificarSeSimboloAtualEIgualA(...argumentos) {
-        for (let i = 0; i < argumentos.length; i++) {
-            const tipoAtual = argumentos[i];
-            if (this.verificarTipoSimboloAtual(tipoAtual)) {
-                this.avancarEDevolverAnterior();
-                return true;
-            }
-        }
-        return false;
-    }
-    declaracaoLeia() {
-        throw new Error('Método não implementado.');
-    }
-    finalizarChamada(entidadeChamada) {
-        const argumentos = [];
-        if (!this.verificarTipoSimboloAtual(comum_1.default.PARENTESE_DIREITO)) {
-            do {
-                if (argumentos.length >= 255) {
-                    throw this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 argumentos.');
-                }
-                argumentos.push(this.expressao());
-            } while (this.verificarSeSimboloAtualEIgualA(comum_1.default.VIRGULA));
-        }
-        const parenteseDireito = this.consumir(comum_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
-        return new construtos_1.Chamada(this.hashArquivo, entidadeChamada, parenteseDireito, argumentos);
-    }
-    unario() {
-        if (this.verificarSeSimboloAtualEIgualA(comum_1.default.NEGACAO, comum_1.default.SUBTRACAO)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.unario();
-            return new construtos_1.Unario(this.hashArquivo, operador, direito, 'ANTES');
-        }
-        return this.chamar();
-    }
-    exponenciacao() {
-        let expressao = this.unario();
-        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.EXPONENCIACAO)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.unario();
-            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
-        }
-        return expressao;
-    }
-    multiplicar() {
-        let expressao = this.exponenciacao();
-        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.DIVISAO, comum_1.default.DIVISAO_INTEIRA, comum_1.default.MULTIPLICACAO, comum_1.default.MODULO)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.unario();
-            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
-        }
-        return expressao;
-    }
-    adicaoOuSubtracao() {
-        let expressao = this.multiplicar();
-        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.SUBTRACAO, comum_1.default.ADICAO)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.multiplicar();
-            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
-        }
-        return expressao;
-    }
-    bitFill() {
-        throw new Error('Método não implementado.');
-    }
-    bitE() {
-        throw new Error('Método não implementado.');
-    }
-    bitOu() {
-        throw new Error('Método não implementado.');
-    }
-    comparar() {
-        let expressao = this.adicaoOuSubtracao();
-        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.MAIOR, comum_1.default.MAIOR_IGUAL, comum_1.default.MENOR, comum_1.default.MENOR_IGUAL)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.adicaoOuSubtracao();
-            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
-        }
-        return expressao;
-    }
-    comparacaoIgualdade() {
-        let expressao = this.comparar();
-        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.DIFERENTE, comum_1.default.IGUAL)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.comparar();
-            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
-        }
-        return expressao;
-    }
-    em() {
-        throw new Error('Método não implementado.');
-    }
-    e() {
-        let expressao = this.comparacaoIgualdade();
-        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.E)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.comparacaoIgualdade();
-            expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
-        }
-        return expressao;
-    }
-    ou() {
-        let expressao = this.e();
-        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.OU)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.e();
-            expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
-        }
-        return expressao;
-    }
-    expressao() {
-        return this.atribuir();
-    }
-    declaracaoExpressao() {
-        throw new Error('Método não implementado.');
-    }
-    declaracaoSustar() {
-        throw new Error('Método não implementado.');
-    }
-    declaracaoContinua() {
-        throw new Error('Método não implementado.');
-    }
-    declaracaoRetorna() {
-        throw new Error('Método não implementado.');
-    }
-    declaracaoImportar() {
-        throw new Error('Método não implementado.');
-    }
-    declaracaoTente() {
-        throw new Error('Método não implementado.');
-    }
-    resolverDeclaracao() {
-        throw new Error('Método não implementado.');
-    }
-    declaracaoDeVariavel() {
-        throw new Error('Método não implementado.');
-    }
-    funcao(tipo) {
-        const simboloFuncao = this.avancarEDevolverAnterior();
-        const nomeFuncao = this.consumir(comum_1.default.IDENTIFICADOR, `Esperado nome ${tipo}.`);
-        return new declaracoes_1.FuncaoDeclaracao(nomeFuncao, this.corpoDaFuncao(tipo));
-    }
-    declaracaoDeClasse() {
-        throw new Error('Método não implementado.');
-    }
-    logicaComumParametros() {
-        const parametros = [];
-        do {
-            if (parametros.length >= 255) {
-                this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 parâmetros');
-            }
-            const parametro = {};
-            if (this.simbolos[this.atual].tipo === comum_1.default.MULTIPLICACAO) {
-                this.consumir(comum_1.default.MULTIPLICACAO, null);
-                parametro.abrangencia = 'multiplo';
-            }
-            else {
-                parametro.abrangencia = 'padrao';
-            }
-            parametro.nome = this.consumir(comum_1.default.IDENTIFICADOR, 'Esperado nome do parâmetro.');
-            if (this.verificarSeSimboloAtualEIgualA(comum_1.default.IGUAL)) {
-                parametro.valorPadrao = this.primario();
-            }
-            parametros.push(parametro);
-            if (parametro.abrangencia === 'multiplo')
-                break;
-        } while (this.verificarSeSimboloAtualEIgualA(comum_1.default.VIRGULA));
-        return parametros;
-    }
-}
-exports.AvaliadorSintaticoBase = AvaliadorSintaticoBase;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvaliadorSintaticoBase = void 0;
+const construtos_1 = require("../construtos");
+const declaracoes_1 = require("../declaracoes");
+const erro_avaliador_sintatico_1 = require("./erro-avaliador-sintatico");
+const comum_1 = __importDefault(require("../tipos-de-simbolos/comum"));
+/**
+ * O Avaliador Sintático Base é uma tentativa de mapear métodos em comum
+ * entre todos os outros Avaliadores Sintáticos. Depende de um dicionário
+ * de tipos de símbolos comuns entre todos os dialetos.
+ */
+class AvaliadorSintaticoBase {
+    consumir(tipo, mensagemDeErro) {
+        if (this.verificarTipoSimboloAtual(tipo))
+            return this.avancarEDevolverAnterior();
+        throw this.erro(this.simbolos[this.atual], mensagemDeErro);
+    }
+    erro(simbolo, mensagemDeErro) {
+        const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
+        this.erros.push(excecao);
+        return excecao;
+    }
+    simboloAnterior() {
+        return this.simbolos[this.atual - 1];
+    }
+    verificarTipoSimboloAtual(tipo) {
+        if (this.estaNoFinal())
+            return false;
+        return this.simbolos[this.atual].tipo === tipo;
+    }
+    verificarTipoProximoSimbolo(tipo) {
+        return this.simbolos[this.atual + 1].tipo === tipo;
+    }
+    estaNoFinal() {
+        return this.atual === this.simbolos.length;
+    }
+    avancarEDevolverAnterior() {
+        if (!this.estaNoFinal())
+            this.atual += 1;
+        return this.simbolos[this.atual - 1];
+    }
+    verificarSeSimboloAtualEIgualA(...argumentos) {
+        for (let i = 0; i < argumentos.length; i++) {
+            const tipoAtual = argumentos[i];
+            if (this.verificarTipoSimboloAtual(tipoAtual)) {
+                this.avancarEDevolverAnterior();
+                return true;
+            }
+        }
+        return false;
+    }
+    declaracaoLeia() {
+        throw new Error('Método não implementado.');
+    }
+    finalizarChamada(entidadeChamada) {
+        const argumentos = [];
+        if (!this.verificarTipoSimboloAtual(comum_1.default.PARENTESE_DIREITO)) {
+            do {
+                if (argumentos.length >= 255) {
+                    throw this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 argumentos.');
+                }
+                argumentos.push(this.expressao());
+            } while (this.verificarSeSimboloAtualEIgualA(comum_1.default.VIRGULA));
+        }
+        const parenteseDireito = this.consumir(comum_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
+        return new construtos_1.Chamada(this.hashArquivo, entidadeChamada, parenteseDireito, argumentos);
+    }
+    unario() {
+        if (this.verificarSeSimboloAtualEIgualA(comum_1.default.NEGACAO, comum_1.default.SUBTRACAO)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.unario();
+            return new construtos_1.Unario(this.hashArquivo, operador, direito, 'ANTES');
+        }
+        return this.chamar();
+    }
+    exponenciacao() {
+        let expressao = this.unario();
+        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.EXPONENCIACAO)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.unario();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    multiplicar() {
+        let expressao = this.exponenciacao();
+        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.DIVISAO, comum_1.default.DIVISAO_INTEIRA, comum_1.default.MULTIPLICACAO, comum_1.default.MODULO)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.unario();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    adicaoOuSubtracao() {
+        let expressao = this.multiplicar();
+        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.SUBTRACAO, comum_1.default.ADICAO)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.multiplicar();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    bitFill() {
+        throw new Error('Método não implementado.');
+    }
+    bitE() {
+        throw new Error('Método não implementado.');
+    }
+    bitOu() {
+        throw new Error('Método não implementado.');
+    }
+    comparar() {
+        let expressao = this.adicaoOuSubtracao();
+        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.MAIOR, comum_1.default.MAIOR_IGUAL, comum_1.default.MENOR, comum_1.default.MENOR_IGUAL)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.adicaoOuSubtracao();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    comparacaoIgualdade() {
+        let expressao = this.comparar();
+        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.DIFERENTE, comum_1.default.IGUAL)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.comparar();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    em() {
+        throw new Error('Método não implementado.');
+    }
+    e() {
+        let expressao = this.comparacaoIgualdade();
+        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.E)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.comparacaoIgualdade();
+            expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    ou() {
+        let expressao = this.e();
+        while (this.verificarSeSimboloAtualEIgualA(comum_1.default.OU)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.e();
+            expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    expressao() {
+        return this.atribuir();
+    }
+    declaracaoExpressao() {
+        throw new Error('Método não implementado.');
+    }
+    declaracaoSustar() {
+        throw new Error('Método não implementado.');
+    }
+    declaracaoContinua() {
+        throw new Error('Método não implementado.');
+    }
+    declaracaoRetorna() {
+        throw new Error('Método não implementado.');
+    }
+    declaracaoImportar() {
+        throw new Error('Método não implementado.');
+    }
+    declaracaoTente() {
+        throw new Error('Método não implementado.');
+    }
+    resolverDeclaracao() {
+        throw new Error('Método não implementado.');
+    }
+    declaracaoDeVariavel() {
+        throw new Error('Método não implementado.');
+    }
+    funcao(tipo) {
+        const simboloFuncao = this.avancarEDevolverAnterior();
+        const nomeFuncao = this.consumir(comum_1.default.IDENTIFICADOR, `Esperado nome ${tipo}.`);
+        return new declaracoes_1.FuncaoDeclaracao(nomeFuncao, this.corpoDaFuncao(tipo));
+    }
+    declaracaoDeClasse() {
+        throw new Error('Método não implementado.');
+    }
+    logicaComumParametros() {
+        const parametros = [];
+        do {
+            if (parametros.length >= 255) {
+                this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 parâmetros');
+            }
+            const parametro = {};
+            if (this.simbolos[this.atual].tipo === comum_1.default.MULTIPLICACAO) {
+                this.consumir(comum_1.default.MULTIPLICACAO, null);
+                parametro.abrangencia = 'multiplo';
+            }
+            else {
+                parametro.abrangencia = 'padrao';
+            }
+            parametro.nome = this.consumir(comum_1.default.IDENTIFICADOR, 'Esperado nome do parâmetro.');
+            if (this.verificarSeSimboloAtualEIgualA(comum_1.default.IGUAL)) {
+                parametro.valorPadrao = this.primario();
+            }
+            parametros.push(parametro);
+            if (parametro.abrangencia === 'multiplo')
+                break;
+        } while (this.verificarSeSimboloAtualEIgualA(comum_1.default.VIRGULA));
+        return parametros;
+    }
+}
+exports.AvaliadorSintaticoBase = AvaliadorSintaticoBase;
 //# sourceMappingURL=avaliador-sintatico-base.js.map

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

@@ -1,92 +1,92 @@
-import { AvaliadorSintaticoInterface, ParametroInterface, SimboloInterface } from '../interfaces';
-import { FuncaoConstruto, Construto } from '../construtos';
-import { ErroAvaliadorSintatico } from './erro-avaliador-sintatico';
-import { Classe, Continua, Enquanto, Escolha, Escreva, Expressao, Fazer, FuncaoDeclaracao as FuncaoDeclaracao, Importar, Para, Sustar, Retorna, Se, Tente, Var, Leia } from '../declaracoes';
-import { RetornoAvaliadorSintatico } from '../interfaces/retornos/retorno-avaliador-sintatico';
-import { RetornoLexador } from '../interfaces/retornos/retorno-lexador';
-import { RetornoDeclaracao, RetornoResolverDeclaracao } from './retornos';
-/**
- * O avaliador sintático (Parser) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
- * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
- * Há dois grupos de estruturas de alto nível: Construtos e Declarações.
- */
-export declare class AvaliadorSintatico implements AvaliadorSintaticoInterface {
-    simbolos: SimboloInterface[];
-    erros: ErroAvaliadorSintatico[];
-    hashArquivo: number;
-    atual: number;
-    blocos: number;
-    performance: boolean;
-    constructor(performance?: boolean);
-    erro(simbolo: SimboloInterface, mensagemDeErro: string): ErroAvaliadorSintatico;
-    consumir(tipo: string, mensagemDeErro: string): SimboloInterface;
-    verificarTipoSimboloAtual(tipo: string): boolean;
-    verificarTipoProximoSimbolo(tipo: string): boolean;
-    simboloAtual(): SimboloInterface;
-    simboloAnterior(): SimboloInterface;
-    estaNoFinal(): boolean;
-    avancarEDevolverAnterior(): SimboloInterface;
-    verificarSeSimboloAtualEIgualA(...argumentos: string[]): boolean;
-    primario(): Construto;
-    finalizarChamada(entidadeChamada: Construto): Construto;
-    chamar(): Construto;
-    unario(): Construto;
-    exponenciacao(): Construto;
-    multiplicar(): Construto;
-    /**
-     * Se símbolo de operação é `+`, `-`, `+=` ou `-=`, monta objeto `Binario` para
-     * ser avaliado pelo Interpretador.
-     * @returns Um Construto, normalmente um `Binario`, ou `Unario` se houver alguma operação unária para ser avaliada.
-     */
-    adicaoOuSubtracao(): Construto;
-    bitFill(): Construto;
-    bitE(): Construto;
-    bitOu(): Construto;
-    comparar(): Construto;
-    comparacaoIgualdade(): Construto;
-    em(): Construto;
-    e(): Construto;
-    ou(): Construto;
-    /**
-     * Método que resolve atribuições.
-     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoSobrescrita`.
-     */
-    atribuir(): Construto;
-    expressao(): Construto;
-    declaracaoEscreva(): Escreva;
-    declaracaoExpressao(): Expressao;
-    /**
-     * Declaração para comando `leia`, para ler dados de entrada do usuário.
-     * @returns Um objeto da classe `Leia`.
-     */
-    declaracaoLeia(): Leia;
-    blocoEscopo(): Array<RetornoDeclaracao>;
-    declaracaoSe(): Se;
-    declaracaoEnquanto(): Enquanto;
-    declaracaoPara(): Para;
-    declaracaoSustar(): Sustar;
-    declaracaoContinua(): Continua;
-    declaracaoRetorna(): Retorna;
-    declaracaoEscolha(): Escolha;
-    declaracaoImportar(): Importar;
-    declaracaoTente(): Tente;
-    declaracaoFazer(): Fazer;
-    resolverDeclaracao(): RetornoResolverDeclaracao;
-    /**
-     * Caso símbolo atual seja `var`, devolve uma declaração de variável.
-     * @returns Um Construto do tipo Var.
-     */
-    declaracaoDeVariavel(): Var;
-    funcao(tipo: string): FuncaoDeclaracao;
-    logicaComumParametros(): ParametroInterface[];
-    corpoDaFuncao(tipo: string): FuncaoConstruto;
-    declaracaoDeClasse(): Classe;
-    declaracao(): RetornoDeclaracao;
-    /**
-     * Usado quando há erros na avaliação sintática.
-     * Garante que o código não entre em loop infinito.
-     * @returns Sempre retorna `void`.
-     */
-    sincronizar(): void;
-    analisar(retornoLexador: RetornoLexador, hashArquivo?: number): RetornoAvaliadorSintatico;
-}
+import { AvaliadorSintaticoInterface, ParametroInterface, SimboloInterface } from '../interfaces';
+import { FuncaoConstruto, Construto } from '../construtos';
+import { ErroAvaliadorSintatico } from './erro-avaliador-sintatico';
+import { Classe, Continua, Enquanto, Escolha, Escreva, Expressao, Fazer, FuncaoDeclaracao as FuncaoDeclaracao, Importar, Para, Sustar, Retorna, Se, Tente, Var, Leia } from '../declaracoes';
+import { RetornoAvaliadorSintatico } from '../interfaces/retornos/retorno-avaliador-sintatico';
+import { RetornoLexador } from '../interfaces/retornos/retorno-lexador';
+import { RetornoDeclaracao, RetornoResolverDeclaracao } from './retornos';
+/**
+ * O avaliador sintático (Parser) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
+ * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
+ * Há dois grupos de estruturas de alto nível: Construtos e Declarações.
+ */
+export declare class AvaliadorSintatico implements AvaliadorSintaticoInterface {
+    simbolos: SimboloInterface[];
+    erros: ErroAvaliadorSintatico[];
+    hashArquivo: number;
+    atual: number;
+    blocos: number;
+    performance: boolean;
+    constructor(performance?: boolean);
+    erro(simbolo: SimboloInterface, mensagemDeErro: string): ErroAvaliadorSintatico;
+    consumir(tipo: string, mensagemDeErro: string): SimboloInterface;
+    verificarTipoSimboloAtual(tipo: string): boolean;
+    verificarTipoProximoSimbolo(tipo: string): boolean;
+    simboloAtual(): SimboloInterface;
+    simboloAnterior(): SimboloInterface;
+    estaNoFinal(): boolean;
+    avancarEDevolverAnterior(): SimboloInterface;
+    verificarSeSimboloAtualEIgualA(...argumentos: string[]): boolean;
+    primario(): Construto;
+    finalizarChamada(entidadeChamada: Construto): Construto;
+    chamar(): Construto;
+    unario(): Construto;
+    exponenciacao(): Construto;
+    multiplicar(): Construto;
+    /**
+     * Se símbolo de operação é `+`, `-`, `+=` ou `-=`, monta objeto `Binario` para
+     * ser avaliado pelo Interpretador.
+     * @returns Um Construto, normalmente um `Binario`, ou `Unario` se houver alguma operação unária para ser avaliada.
+     */
+    adicaoOuSubtracao(): Construto;
+    bitFill(): Construto;
+    bitE(): Construto;
+    bitOu(): Construto;
+    comparar(): Construto;
+    comparacaoIgualdade(): Construto;
+    em(): Construto;
+    e(): Construto;
+    ou(): Construto;
+    /**
+     * Método que resolve atribuições.
+     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoSobrescrita`.
+     */
+    atribuir(): Construto;
+    expressao(): Construto;
+    declaracaoEscreva(): Escreva;
+    declaracaoExpressao(): Expressao;
+    /**
+     * Declaração para comando `leia`, para ler dados de entrada do usuário.
+     * @returns Um objeto da classe `Leia`.
+     */
+    declaracaoLeia(): Leia;
+    blocoEscopo(): Array<RetornoDeclaracao>;
+    declaracaoSe(): Se;
+    declaracaoEnquanto(): Enquanto;
+    declaracaoPara(): Para;
+    declaracaoSustar(): Sustar;
+    declaracaoContinua(): Continua;
+    declaracaoRetorna(): Retorna;
+    declaracaoEscolha(): Escolha;
+    declaracaoImportar(): Importar;
+    declaracaoTente(): Tente;
+    declaracaoFazer(): Fazer;
+    resolverDeclaracao(): RetornoResolverDeclaracao;
+    /**
+     * Caso símbolo atual seja `var`, devolve uma declaração de variável.
+     * @returns Um Construto do tipo Var.
+     */
+    declaracaoDeVariavel(): Var;
+    funcao(tipo: string): FuncaoDeclaracao;
+    logicaComumParametros(): ParametroInterface[];
+    corpoDaFuncao(tipo: string): FuncaoConstruto;
+    declaracaoDeClasse(): Classe;
+    declaracao(): RetornoDeclaracao;
+    /**
+     * Usado quando há erros na avaliação sintática.
+     * Garante que o código não entre em loop infinito.
+     * @returns Sempre retorna `void`.
+     */
+    sincronizar(): void;
+    analisar(retornoLexador: RetornoLexador, hashArquivo?: number): RetornoAvaliadorSintatico;
+}