Repository: DesignLiquido/delegua
Pull request #289 (2023-02-25 07:33:41)

Portugol Studio e colaterais em Delégua
- Suporte a todos os tipos de dados do Portugol Studio (acho);
- Funções e procedimentos;
- `enquanto`, `faca ... enquanto`, `para`, etc.
- Operadores de incremento e decremento (finalmente) implementados em Delégua, como colateral para essa atividade.


Patch:
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 1bc3e5e6..9817b726 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -412,6 +412,20 @@
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
+        {
+            "name": "Testes unitários - Delégua",
+            "type": "node",
+            "request": "launch",
+            "runtimeArgs": [
+                "--inspect-brk",
+                "${workspaceRoot}/node_modules/jest/bin/jest.js",
+                "interpretador",
+                "--runInBand"
+            ],
+            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen"
+        },
         {
             "name": "Testes unitários - VisuAlg",
             "type": "node",
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
index f427cd85..51738c07 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
@@ -111,7 +111,7 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NEGACAO, tiposDeSimbolos.SUBTRACAO)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
-            return new Unario(this.hashArquivo, operador, direito);
+            return new Unario(this.hashArquivo, operador, direito, 'ANTES');
         }
 
         return this.chamar();
@@ -311,9 +311,9 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
 
             if (this.simbolos[this.atual].tipo === tiposDeSimbolos.MULTIPLICACAO) {
                 this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
-                parametro.tipo = 'estrela';
+                parametro.abrangencia = 'multiplo';
             } else {
-                parametro.tipo = 'padrao';
+                parametro.abrangencia = 'padrao';
             }
 
             parametro.nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do parâmetro.');
@@ -324,7 +324,7 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
 
             parametros.push(parametro as ParametroInterface);
 
-            if (parametro.tipo === 'estrela') break;
+            if (parametro.abrangencia === 'multiplo') break;
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
         return parametros;
     }
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts
index d0290495..2a7e247b 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts
@@ -121,14 +121,119 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
     primario(): Construto {
         const simboloAtual = this.simbolos[this.atual];
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUPER)) {
+        let valores = [];
+        switch (simboloAtual.tipo) {
+            case tiposDeSimbolos.CHAVE_ESQUERDA:
+                this.avancarEDevolverAnterior();
+                const chaves = [];
+                valores = [];
+
+                if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA)) {
+                    return new Dicionario(this.hashArquivo, Number(simboloAtual.linha), [], []);
+                }
+
+                while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA)) {
+                    const chave = this.atribuir();
+                    this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
+                    const valor = this.atribuir();
+
+                    chaves.push(chave);
+                    valores.push(valor);
+
+                    if (this.simbolos[this.atual].tipo !== tiposDeSimbolos.CHAVE_DIREITA) {
+                        this.consumir(tiposDeSimbolos.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
+                    }
+                }
+
+                return new Dicionario(this.hashArquivo, Number(simboloAtual.linha), chaves, valores);
+
+            case tiposDeSimbolos.COLCHETE_ESQUERDO:
+                this.avancarEDevolverAnterior();
+                valores = [];
+
+                if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) {
+                    return new Vetor(this.hashArquivo, Number(simboloAtual.linha), []);
+                }
+    
+                while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) {
+                    const valor = this.atribuir();
+                    valores.push(valor);
+                    if (this.simbolos[this.atual].tipo !== tiposDeSimbolos.COLCHETE_DIREITO) {
+                        this.consumir(tiposDeSimbolos.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
+                    }
+                }
+    
+                return new Vetor(this.hashArquivo, Number(simboloAtual.linha), valores);
+
+            case tiposDeSimbolos.FALSO:
+                this.avancarEDevolverAnterior();
+                return new Literal(this.hashArquivo, Number(simboloAtual.linha), false);
+
+            case tiposDeSimbolos.FUNCAO:
+            case tiposDeSimbolos.FUNÇÃO:
+                const simboloFuncao = this.avancarEDevolverAnterior();
+                return this.corpoDaFuncao(simboloFuncao.lexema);
+
+            case tiposDeSimbolos.IDENTIFICADOR:
+                const simboloIdentificador: SimboloInterface = this.avancarEDevolverAnterior();
+                // Se o próximo símbolo é um incremento ou um decremento,
+                // aqui deve retornar um unário correspondente.
+                // Caso contrário, apenas retornar um construto de variável.
+                if ([tiposDeSimbolos.INCREMENTAR, tiposDeSimbolos.DECREMENTAR].includes(this.simbolos[this.atual].tipo)) {
+                    const simboloIncrementoDecremento: SimboloInterface = this.avancarEDevolverAnterior();
+                    return new Unario(
+                        this.hashArquivo, 
+                        simboloIncrementoDecremento, 
+                        new Variavel(this.hashArquivo, simboloIdentificador), 
+                        'DEPOIS'
+                    );
+                }
+
+                return new Variavel(this.hashArquivo, simboloIdentificador);
+
+            case tiposDeSimbolos.IMPORTAR:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoImportar();
+
+            case tiposDeSimbolos.ISTO:
+                this.avancarEDevolverAnterior();
+                return new Isto(this.hashArquivo, Number(simboloAtual.linha), simboloAtual);
+
+            case tiposDeSimbolos.NULO:
+                this.avancarEDevolverAnterior();
+                return new Literal(this.hashArquivo, Number(simboloAtual.linha), null);
+
+            case tiposDeSimbolos.NUMERO:
+            case tiposDeSimbolos.TEXTO:
+                const simboloNumeroTexto: SimboloInterface = this.avancarEDevolverAnterior();
+                return new Literal(this.hashArquivo, Number(simboloNumeroTexto.linha), simboloNumeroTexto.literal);
+
+            case tiposDeSimbolos.PARENTESE_ESQUERDO:
+                this.avancarEDevolverAnterior();
+                const expressao = this.expressao();
+                this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+
+                return new Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
+
+            case tiposDeSimbolos.SUPER:
+                const simboloChave = this.avancarEDevolverAnterior();
+                this.consumir(tiposDeSimbolos.PONTO, "Esperado '.' após 'super'.");
+                const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da Superclasse.');
+                return new Super(this.hashArquivo, simboloChave, metodo);
+
+            case tiposDeSimbolos.VERDADEIRO:
+                this.avancarEDevolverAnterior();
+                return new Literal(this.hashArquivo, Number(simboloAtual.linha), true);
+        }
+        
+        /*if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUPER)) {
             const simboloChave = this.simbolos[this.atual - 1];
             this.consumir(tiposDeSimbolos.PONTO, "Esperado '.' após 'super'.");
             const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da Superclasse.');
             return new Super(this.hashArquivo, simboloChave, metodo);
-        }
+        }*/
 
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
+        /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
             const valores = [];
 
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) {
@@ -144,9 +249,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             }
 
             return new Vetor(this.hashArquivo, Number(simboloAtual.linha), valores);
-        }
+        } */
 
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA)) {
+        /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA)) {
             const chaves = [];
             const valores = [];
 
@@ -168,9 +273,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             }
 
             return new Dicionario(this.hashArquivo, Number(simboloAtual.linha), chaves, valores);
-        }
+        } */
 
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FUNÇÃO, tiposDeSimbolos.FUNCAO))
+        /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FUNÇÃO, tiposDeSimbolos.FUNCAO))
             return this.corpoDaFuncao(this.simbolos[this.atual - 1].lexema);
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FALSO))
             return new Literal(this.hashArquivo, Number(simboloAtual.linha), false);
@@ -179,9 +284,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NULO))
             return new Literal(this.hashArquivo, Number(simboloAtual.linha), null);
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ISTO))
-            return new Isto(this.hashArquivo, Number(simboloAtual.linha), this.simbolos[this.atual - 1]);
+            return new Isto(this.hashArquivo, Number(simboloAtual.linha), this.simbolos[this.atual - 1]); */
 
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NUMERO, tiposDeSimbolos.TEXTO)) {
+        /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NUMERO, tiposDeSimbolos.TEXTO)) {
             const simboloAnterior: SimboloInterface = this.simbolos[this.atual - 1];
             return new Literal(this.hashArquivo, Number(simboloAnterior.linha), simboloAnterior.literal);
         }
@@ -197,7 +302,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             return new Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
         }
 
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IMPORTAR)) return this.declaracaoImportar();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IMPORTAR)) return this.declaracaoImportar(); */
 
         throw this.erro(this.simbolos[this.atual], 'Esperado expressão.');
     }
@@ -248,12 +353,14 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             this.verificarSeSimboloAtualEIgualA(
                 tiposDeSimbolos.NEGACAO,
                 tiposDeSimbolos.SUBTRACAO,
-                tiposDeSimbolos.BIT_NOT
+                tiposDeSimbolos.BIT_NOT,
+                tiposDeSimbolos.INCREMENTAR,
+                tiposDeSimbolos.DECREMENTAR
             )
         ) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
-            return new Unario(this.hashArquivo, operador, direito);
+            return new Unario(this.hashArquivo, operador, direito, 'ANTES');
         }
 
         return this.chamar();
@@ -484,11 +591,16 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
         this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
 
+        // Ponto-e-vírgula é opcional aqui.
+        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
+
         return new Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
     }
 
     declaracaoExpressao(): Expressao {
         const expressao = this.expressao();
+        // Ponto-e-vírgula é opcional aqui.
+        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
         return new Expressao(expressao);
     }
 
@@ -546,7 +658,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
             this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'enquanto'.");
             const condicao = this.expressao();
-            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após condicional.");
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após condição.");
             const corpo = this.resolverDeclaracao();
 
             return new Enquanto(condicao, corpo);
@@ -576,6 +688,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
                 condicao = this.expressao();
             }
 
+            // Ponto-e-vírgula é opcional aqui.
+            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
+
             let incrementar = null;
             if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
                 incrementar = this.expressao();
@@ -596,6 +711,8 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             this.erro(this.simbolos[this.atual - 1], "'sustar' ou 'pausa' deve estar dentro de um laço de repetição.");
         }
 
+        // Ponto-e-vírgula é opcional aqui.
+        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
         return new Sustar(this.simbolos[this.atual]);
     }
 
@@ -604,6 +721,8 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             this.erro(this.simbolos[this.atual - 1], "'continua' precisa estar em um laço de repetição.");
         }
 
+        // Ponto-e-vírgula é opcional aqui.
+        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
         return new Continua(this.simbolos[this.atual]);
     }
 
@@ -628,6 +747,8 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             valor = this.expressao();
         }
 
+        // Ponto-e-vírgula é opcional aqui.
+        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
         return new Retorna(simboloChave, valor);
     }
 
@@ -774,21 +895,58 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     }
 
     resolverDeclaracao(): RetornoResolverDeclaracao {
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FAZER)) return this.declaracaoFazer();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.TENTE)) return this.declaracaoTente();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCOLHA)) return this.declaracaoEscolha();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.RETORNA)) return this.declaracaoRetorna();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CONTINUA)) return this.declaracaoContinua();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PAUSA, tiposDeSimbolos.SUSTAR))
-            return this.declaracaoSustar();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARA)) return this.declaracaoPara();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ENQUANTO)) return this.declaracaoEnquanto();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SE)) return this.declaracaoSe();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCREVA)) return this.declaracaoEscreva();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA)) {
+        switch (this.simbolos[this.atual].tipo) {
+            case tiposDeSimbolos.CHAVE_ESQUERDA:
+                const simboloInicioBloco: SimboloInterface = this.avancarEDevolverAnterior();
+                return new Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
+            case tiposDeSimbolos.CONTINUA:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoContinua();
+            case tiposDeSimbolos.ENQUANTO:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoEnquanto();
+            case tiposDeSimbolos.ESCOLHA:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoEscolha();
+            case tiposDeSimbolos.ESCREVA:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoEscreva();
+            case tiposDeSimbolos.FAZER:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoFazer();
+            case tiposDeSimbolos.PARA:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoPara();
+            case tiposDeSimbolos.PAUSA:
+            case tiposDeSimbolos.SUSTAR:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoSustar();
+            case tiposDeSimbolos.SE:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoSe();
+            case tiposDeSimbolos.RETORNA:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoRetorna();
+            case tiposDeSimbolos.TENTE:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoTente();
+            
+        }
+        // if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FAZER)) return this.declaracaoFazer();
+        // if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.TENTE)) return this.declaracaoTente();
+        // if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCOLHA)) return this.declaracaoEscolha();
+        // if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.RETORNA)) return this.declaracaoRetorna();
+        // if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CONTINUA)) return this.declaracaoContinua();
+        /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PAUSA, tiposDeSimbolos.SUSTAR))
+            return this.declaracaoSustar(); */
+        // if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARA)) return this.declaracaoPara();
+        // if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ENQUANTO)) return this.declaracaoEnquanto();
+        // if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SE)) return this.declaracaoSe();
+        // if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCREVA)) return this.declaracaoEscreva();
+        /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA)) {
             const simboloInicioBloco: SimboloInterface = this.simbolos[this.atual - 1];
             return new Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
-        }
+        } */
 
         const simboloAtual = this.simbolos[this.atual];
         if (simboloAtual.tipo === tiposDeSimbolos.IDENTIFICADOR) {
@@ -823,6 +981,8 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             inicializador = this.expressao();
         }
 
+        // Ponto-e-vírgula é opcional aqui.
+        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
         return new Var(simbolo, inicializador);
     }
 
@@ -851,9 +1011,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
             if (this.simbolos[this.atual].tipo === tiposDeSimbolos.MULTIPLICACAO) {
                 this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
-                parametro.tipo = 'estrela';
+                parametro.abrangencia = 'multiplo';
             } else {
-                parametro.tipo = 'padrao';
+                parametro.abrangencia = 'padrao';
             }
 
             parametro.nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do parâmetro.');
@@ -864,7 +1024,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
             parametros.push(parametro as ParametroInterface);
 
-            if (parametro.tipo === 'estrela') break;
+            if (parametro.abrangencia === 'multiplo') break;
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
         return parametros;
     }
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
index c6fe17cf..cead204b 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
@@ -763,7 +763,7 @@ export class AvaliadorSintaticoEguaClassico implements AvaliadorSintaticoInterfa
 
                 if (this.simboloAtual().tipo === tiposDeSimbolos.MULTIPLICACAO) {
                     this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
-                    parametro['tipo'] = 'estrela';
+                    parametro['tipo'] = 'multiplo';
                 } else {
                     parametro['tipo'] = 'padrao';
                 }
@@ -776,7 +776,7 @@ export class AvaliadorSintaticoEguaClassico implements AvaliadorSintaticoInterfa
 
                 parametros.push(parametro);
 
-                if (parametro['tipo'] === 'estrela') break;
+                if (parametro['tipo'] === 'multiplo') break;
             } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
         }
 
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
index 2e7bc143..196e1cc2 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
@@ -860,7 +860,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
 
             if (this.simboloAtual().tipo === tiposDeSimbolos.MULTIPLICACAO) {
                 this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
-                parametro['tipo'] = 'estrela';
+                parametro['tipo'] = 'multiplo';
             } else {
                 parametro['tipo'] = 'padrao';
             }
@@ -873,7 +873,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
 
             parametros.push(parametro);
 
-            if (parametro['tipo'] === 'estrela') break;
+            if (parametro['tipo'] === 'multiplo') break;
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
         return parametros;
     }
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
index bac8c55c..f9c724bf 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
@@ -6,6 +6,7 @@ import {
     Construto,
     FuncaoConstruto,
     Literal,
+    Unario,
     Variavel,
 } from '../../construtos';
 import {
@@ -25,14 +26,14 @@ import {
 import { RetornoLexador, RetornoAvaliadorSintatico } from '../../interfaces/retornos';
 import { AvaliadorSintaticoBase } from '../avaliador-sintatico-base';
 
-import { SimboloInterface } from '../../interfaces';
+import { ParametroInterface, SimboloInterface } from '../../interfaces';
 
 import tiposDeSimbolos from '../../tipos-de-simbolos/portugol-studio';
 import { RetornoDeclaracao } from '../retornos';
 import { DeleguaFuncao } from '../../estruturas';
 
 /**
- * O avaliador sintático (Parser) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
+ * 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.
  */
@@ -69,13 +70,29 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
     }
 
     primario(): Construto {
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR)) {
-            return new Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
-        }
-
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.REAL, tiposDeSimbolos.INTEIRO, tiposDeSimbolos.CADEIA)) {
-            const simboloAnterior: SimboloInterface = this.simbolos[this.atual - 1];
-            return new Literal(this.hashArquivo, Number(simboloAnterior.linha), simboloAnterior.literal);
+        switch (this.simbolos[this.atual].tipo) {
+            case tiposDeSimbolos.IDENTIFICADOR:
+                const simboloIdentificador: SimboloInterface = this.avancarEDevolverAnterior();
+                // Se o próximo símbolo é um incremento ou um decremento,
+                // aqui deve retornar um unário correspondente.
+                // Caso contrário, apenas retornar um construto de variável.
+                if ([tiposDeSimbolos.INCREMENTAR, tiposDeSimbolos.DECREMENTAR].includes(this.simbolos[this.atual].tipo)) {
+                    const simboloIncrementoDecremento: SimboloInterface = this.avancarEDevolverAnterior();
+                    return new Unario(
+                        this.hashArquivo, 
+                        simboloIncrementoDecremento, 
+                        new Variavel(this.hashArquivo, simboloIdentificador), 
+                        'DEPOIS'
+                    );
+                }
+
+                return new Variavel(this.hashArquivo, simboloIdentificador);
+            case tiposDeSimbolos.CADEIA:
+            case tiposDeSimbolos.CARACTER:
+            case tiposDeSimbolos.INTEIRO:
+            case tiposDeSimbolos.REAL:
+                const simboloVariavel: SimboloInterface = this.avancarEDevolverAnterior();
+                return new Literal(this.hashArquivo, Number(simboloVariavel.linha), simboloVariavel.literal);
         }
     }
 
@@ -166,7 +183,7 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
     }
 
     declaracaoSe(): Se {
-        this.consumir(tiposDeSimbolos.SE, "");
+        this.avancarEDevolverAnterior();
         this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'se'.");
         const condicao = this.expressao();
         this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após condição do se.");
@@ -182,15 +199,82 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
     }
 
     declaracaoEnquanto(): Enquanto {
-        throw new Error('Método não implementado.');
+        try {
+            this.avancarEDevolverAnterior();
+            this.blocos += 1;
+
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'enquanto'.");
+            const condicao = this.expressao();
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após condição.");
+            const corpo = this.declaracao();
+
+            return new Enquanto(condicao, corpo);
+        } finally {
+            this.blocos -= 1;
+        }
     }
 
     declaracaoEscolha(): Escolha {
         throw new Error('Método não implementado.');
     }
 
+    /**
+     * No Portugol Studio, a palavra reservada é `faca`, sem acento.
+     */
     declaracaoFazer(): Fazer {
-        throw new Error('Método não implementado.');
+        const simboloFaca: SimboloInterface = this.avancarEDevolverAnterior();
+        try {
+            this.blocos += 1;
+
+            const caminhoFazer = this.declaracao();
+
+            this.consumir(tiposDeSimbolos.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após declaração 'enquanto'.");
+
+            const condicaoEnquanto = this.expressao();
+
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após declaração do 'enquanto'.");
+
+            return new Fazer(simboloFaca.hashArquivo, Number(simboloFaca.linha), caminhoFazer, condicaoEnquanto);
+        } finally {
+            this.blocos -= 1;
+        }
+    }
+
+    protected logicaComumParametros(): ParametroInterface[] {
+        const parametros: ParametroInterface[] = [];
+
+        do {
+            if (parametros.length >= 255) {
+                this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 parâmetros');
+            }
+
+            const parametro: Partial<ParametroInterface> = {
+                abrangencia: 'padrao'
+            };
+
+            if (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CADEIA, tiposDeSimbolos.REAL, tiposDeSimbolos.REAL)) {
+                throw this.erro(this.simbolos[this.atual], 'Esperado tipo de parâmetro válido para declaração de função.');
+            }
+
+            parametro.nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do parâmetro.');
+
+            // Em Portugol Studio, um parâmetro múltiplo é terminado por abre e fecha colchetes.
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
+                this.consumir(tiposDeSimbolos.COLCHETE_DIREITO, 
+                    'Esperado colchete direito após colchete esquerdo ao definir parâmetro múltiplo em função.');
+                parametro.abrangencia = 'multiplo';
+            }
+
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+                parametro.valorPadrao = this.primario();
+            }
+
+            parametros.push(parametro as ParametroInterface);
+
+            if (parametro.abrangencia === 'multiplo') break;
+        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+        return parametros;
     }
 
     corpoDaFuncao(tipo: string): FuncaoConstruto {
@@ -207,14 +291,94 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
         }
 
         this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
-        // this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, `Esperado '{' antes do escopo do ${tipo}.`);
 
         const corpo = this.blocoEscopo();
 
         return new FuncaoConstruto(this.hashArquivo, Number(parenteseEsquerdo.linha), parametros, corpo);
     }
 
-    declaracaoInteiro(): Var[] {
+    /**
+     * Declaração de apenas uma variável. 
+     * Neste caso, o símbolo que determina o tipo da variável já foi consumido, 
+     * e o retorno conta com apenas uma variável retornada.
+     */
+    declaracaoDeVariavel(): Var {
+        switch (this.simboloAnterior().tipo) {
+            case tiposDeSimbolos.INTEIRO:
+                const identificador = this.consumir(
+                    tiposDeSimbolos.IDENTIFICADOR,
+                    "Esperado identificador após palavra reservada 'inteiro'."
+                );
+                this.consumir(tiposDeSimbolos.IGUAL, "Esperado símbolo igual para inicialização de variável.");
+                const literalInicializacao = this.consumir(tiposDeSimbolos.INTEIRO, 
+                    'Esperado literal inteiro após símbolo de igual em declaração de variável.');
+                const valorInicializacao = Number(literalInicializacao.literal);
+                return new Var(
+                    identificador, 
+                    new Literal(this.hashArquivo, 
+                        Number(literalInicializacao.linha), 
+                        valorInicializacao
+                    )
+                );
+        }
+    }
+
+    declaracaoCadeiasCaracteres(): Var[] {
+        const simboloCadeia = this.consumir(tiposDeSimbolos.CADEIA, '');
+
+        const inicializacoes = [];
+        do {
+            const identificador = this.consumir(
+                tiposDeSimbolos.IDENTIFICADOR,
+                "Esperado identificador após palavra reservada 'cadeia'."
+            );
+
+            // Inicializações de variáveis podem ter valores definidos.
+            let valorInicializacao = 0;
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+                const literalInicializacao = this.consumir(tiposDeSimbolos.CADEIA, 
+                    'Esperado literal de cadeia de caracteres após símbolo de igual em declaração de variável.');
+                valorInicializacao = Number(literalInicializacao.literal);
+            }
+
+            inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloCadeia.linha), 0)));
+        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+
+        return inicializacoes;
+    }
+
+    declaracaoCaracteres(): Var[] {
+        const simboloCaracter = this.consumir(tiposDeSimbolos.CARACTER, '');
+
+        const inicializacoes = [];
+        do {
+            const identificador = this.consumir(
+                tiposDeSimbolos.IDENTIFICADOR,
+                "Esperado identificador após palavra reservada 'caracter'."
+            );
+
+            // Inicializações de variáveis podem ter valores definidos.
+            let valorInicializacao = 0;
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+                const literalInicializacao = this.consumir(tiposDeSimbolos.CARACTER, 
+                    'Esperado literal de caracter após símbolo de igual em declaração de variável.');
+                valorInicializacao = Number(literalInicializacao.literal);
+            }
+
+            inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloCaracter.linha), 0)));
+        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+
+        return inicializacoes;
+    }
+
+    declaracaoExpressao(): Expressao {
+        const expressao = this.expressao();
+        // Ponto-e-vírgula é opcional aqui.
+        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
+        return new Expressao(expressao);
+    }
+
+    declaracaoInteiros(): Var[] {
         const simboloInteiro = this.consumir(tiposDeSimbolos.INTEIRO, '');
 
         const inicializacoes = [];
@@ -223,7 +387,16 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
                 tiposDeSimbolos.IDENTIFICADOR,
                 "Esperado identificador após palavra reservada 'inteiro'."
             );
-            inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloInteiro.linha), 0)));
+
+            // Inicializações de variáveis podem ter valores definidos.
+            let valorInicializacao = 0;
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+                const literalInicializacao = this.consumir(tiposDeSimbolos.INTEIRO, 
+                    'Esperado literal inteiro após símbolo de igual em declaração de variável.');
+                valorInicializacao = Number(literalInicializacao.literal);
+            }
+
+            inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloInteiro.linha), valorInicializacao)));
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
         return inicializacoes;
@@ -248,11 +421,69 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
         return new Leia(simboloAtual.hashArquivo, Number(simboloAtual.linha), argumentos);
     }
 
+    declaracaoLogicos(): Var[] {
+        const simboloLogico = this.consumir(tiposDeSimbolos.LOGICO, '');
+
+        const inicializacoes = [];
+        do {
+            const identificador = this.consumir(
+                tiposDeSimbolos.IDENTIFICADOR,
+                "Esperado identificador após palavra reservada 'logico'."
+            );
+
+            // Inicializações de variáveis podem ter valores definidos.
+            let valorInicializacao = 0;
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+                if (![tiposDeSimbolos.VERDADEIRO, tiposDeSimbolos.FALSO].includes(this.simbolos[this.atual].tipo)) {
+                    throw this.erro(this.simbolos[this.atual], 'Esperado literal verdadeiro ou falso após símbolo de igual em declaração de variável.');
+                }
+                const literalInicializacao = this.avancarEDevolverAnterior();
+                valorInicializacao = Number(literalInicializacao.literal);
+            }
+
+            inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloLogico.linha), 0)));
+        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+
+        return inicializacoes;
+    }
+
     declaracaoPara(): Para {
-        throw new Error('Método não implementado.');
+        try {
+            const simboloPara: SimboloInterface = this.avancarEDevolverAnterior();
+            this.blocos += 1;
+
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'para'.");
+
+            let inicializador: Var | Expressao;
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA)) {
+                inicializador = null;
+            } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.INTEIRO)) {
+                inicializador = this.declaracaoDeVariavel();
+            } else {
+                inicializador = this.declaracaoExpressao();
+            }
+
+            let condicao = null;
+            if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PONTO_E_VIRGULA)) {
+                condicao = this.expressao();
+            }
+
+            let incrementar = null;
+            if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
+                incrementar = this.expressao();
+            }
+
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após cláusulas");
+
+            const corpo = this.declaracao();
+
+            return new Para(this.hashArquivo, Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
+        } finally {
+            this.blocos -= 1;
+        }
     }
 
-    declaracaoReal(): Var[] {
+    declaracaoReais(): Var[] {
         const simboloReal = this.consumir(tiposDeSimbolos.REAL, '');
 
         const inicializacoes = [];
@@ -261,6 +492,15 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
                 tiposDeSimbolos.IDENTIFICADOR,
                 "Esperado identificador após palavra reservada 'real'."
             );
+
+            // Inicializações de variáveis podem ter valores definidos.
+            let valorInicializacao = 0;
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+                const literalInicializacao = this.consumir(tiposDeSimbolos.REAL, 
+                    'Esperado literal real após símbolo de igual em declaração de variável.');
+                valorInicializacao = Number(literalInicializacao.literal);
+            }
+
             inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloReal.linha), 0)));
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
@@ -272,26 +512,60 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
         return this.atribuir();
     }
 
+    funcao(tipo: string): FuncaoDeclaracao {
+        const simboloFuncao: SimboloInterface = this.avancarEDevolverAnterior();
+
+        // No Portugol Studio, se temos um símbolo de tipo após `função`, 
+        // teremos um retorno no corpo da função.
+        if (
+            [
+                tiposDeSimbolos.REAL, 
+                tiposDeSimbolos.INTEIRO, 
+                tiposDeSimbolos.CADEIA,
+                tiposDeSimbolos.CARACTER,
+                tiposDeSimbolos.LOGICO
+            ].includes(this.simbolos[this.atual].tipo)
+        ) {
+            // Por enquanto apenas consumimos o símbolo sem ações adicionais.
+            this.avancarEDevolverAnterior();
+        }
+
+        const nomeFuncao: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome ${tipo}.`);
+        return new FuncaoDeclaracao(nomeFuncao, this.corpoDaFuncao(tipo));
+    }
+
     declaracao(): Declaracao | Declaracao[] | Construto | Construto[] | any {
         const simboloAtual = this.simbolos[this.atual];
         switch (simboloAtual.tipo) {
+            case tiposDeSimbolos.CADEIA:
+                return this.declaracaoCadeiasCaracteres();
+            case tiposDeSimbolos.CARACTER:
+                return this.declaracaoCaracteres();
             case tiposDeSimbolos.CHAVE_ESQUERDA:
                 const simboloInicioBloco: SimboloInterface = this.simbolos[this.atual];
                 return new Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
+            case tiposDeSimbolos.ENQUANTO:
+                return this.declaracaoEnquanto();
             case tiposDeSimbolos.ESCREVA:
                 return this.declaracaoEscreva();
+            case tiposDeSimbolos.FACA:
+                return this.declaracaoFazer();
             case tiposDeSimbolos.FUNCAO:
                 return this.funcao('funcao');
             case tiposDeSimbolos.INTEIRO:
-                return this.declaracaoInteiro();
+                return this.declaracaoInteiros();
             case tiposDeSimbolos.LEIA:
-                return this.declaracaoLeia();            
+                return this.declaracaoLeia();
+            case tiposDeSimbolos.LOGICO:
+                return this.declaracaoLogicos();
+            case tiposDeSimbolos.PARA:
+                return this.declaracaoPara();        
             case tiposDeSimbolos.PROGRAMA:
             case tiposDeSimbolos.CHAVE_DIREITA:
                 this.avancarEDevolverAnterior();
                 return null;
             case tiposDeSimbolos.REAL:
-                return this.declaracaoReal();
+                return this.declaracaoReais();
             case tiposDeSimbolos.SE:
                 return this.declaracaoSe();
             default:
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
index a734d94b..234a8e7e 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
@@ -744,7 +744,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
                 const dadosParametros = this.logicaComumParametroVisuAlg();
                 for (let parametro of dadosParametros.identificadores) {
                     parametros.push({
-                        tipo: 'padrao',
+                        abrangencia: 'padrao',
                         nome: parametro
                     });
                 }
diff --git a/fontes/construtos/unario.ts b/fontes/construtos/unario.ts
index d2f11171..7432a342 100644
--- a/fontes/construtos/unario.ts
+++ b/fontes/construtos/unario.ts
@@ -6,14 +6,21 @@ export class Unario implements Construto {
     hashArquivo?: number;
 
     operador: SimboloInterface;
-    direita: any;
+    operando: any;
+    incidenciaOperador: 'ANTES' | 'DEPOIS';
 
-    constructor(hashArquivo: number, operador: SimboloInterface, direita: any) {
+    constructor(
+        hashArquivo: number, 
+        operador: SimboloInterface, 
+        operando: any, 
+        incidenciaOperador: 'ANTES' | 'DEPOIS' = 'ANTES'
+    ) {
         this.linha = operador.linha;
         this.hashArquivo = hashArquivo;
 
         this.operador = operador;
-        this.direita = direita;
+        this.operando = operando;
+        this.incidenciaOperador = incidenciaOperador;
     }
 
     async aceitar(visitante: InterpretadorInterface): Promise<any> {
diff --git a/fontes/interfaces/parametro-interface.ts b/fontes/interfaces/parametro-interface.ts
index 9cf651b9..b67927a4 100644
--- a/fontes/interfaces/parametro-interface.ts
+++ b/fontes/interfaces/parametro-interface.ts
@@ -1,7 +1,7 @@
 import { SimboloInterface } from './simbolo-interface';
 
 export interface ParametroInterface {
-    tipo: 'estrela' | 'padrao';
+    abrangencia: 'padrao' | 'multiplo';
     nome: SimboloInterface;
     valorPadrao?: any;
 }
diff --git a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
index 0e9d4461..cb50c620 100644
--- a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
+++ b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
@@ -304,7 +304,7 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
                 argumentos.push(null);
             }
         } else {
-            if (parametros && parametros.length > 0 && parametros[parametros.length - 1]['tipo'] === 'estrela') {
+            if (parametros && parametros.length > 0 && parametros[parametros.length - 1]['tipo'] === 'multiplo') {
                 const novosArgumentos = argumentos.slice(0, parametros.length - 1);
                 novosArgumentos.push(argumentos.slice(parametros.length - 1, argumentos.length));
                 argumentos = novosArgumentos;
diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts
index 9c8d2e5b..fbe05934 100644
--- a/fontes/interpretador/interpretador-base.ts
+++ b/fontes/interpretador/interpretador-base.ts
@@ -204,8 +204,8 @@ export class InterpretadorBase implements InterpretadorInterface {
     }
 
     async visitarExpressaoUnaria(expressao: Unario): Promise<any> {
-        const direita = await this.avaliar(expressao.direita);
-        const valor: any = direita.hasOwnProperty('valor') ? direita.valor : direita;
+        const operando = await this.avaliar(expressao.operando);
+        let valor: any = operando.hasOwnProperty('valor') ? operando.valor : operando;
 
         switch (expressao.operador.tipo) {
             case tiposDeSimbolos.SUBTRACAO:
@@ -215,6 +215,36 @@ export class InterpretadorBase implements InterpretadorInterface {
                 return !this.eVerdadeiro(valor);
             case tiposDeSimbolos.BIT_NOT:
                 return ~valor;
+            // Para incrementar e decrementar, primeiro precisamos saber se o operador
+            // veio antes do literal ou variável.
+            // Se veio antes e o operando é uma variável, precisamos incrementar/decrementar,
+            // armazenar o valor da variável pra só então devolver o valor.
+            case tiposDeSimbolos.INCREMENTAR:
+                if (expressao.incidenciaOperador === 'ANTES') {
+                    valor++;
+                    if (expressao.operando instanceof Variavel) {
+                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
+                    }
+                    
+                    return valor;
+                } 
+                
+                const valorAnteriorIncremento = valor;
+                this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, ++valor);
+                return valorAnteriorIncremento;
+            case tiposDeSimbolos.DECREMENTAR:
+                if (expressao.incidenciaOperador === 'ANTES') {
+                    valor--;
+                    if (expressao.operando instanceof Variavel) {
+                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
+                    }
+
+                    return valor;
+                } 
+                
+                const valorAnteriorDecremento = valor;
+                this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, --valor);
+                return valorAnteriorDecremento;
         }
 
         return null;
@@ -448,7 +478,7 @@ export class InterpretadorBase implements InterpretadorInterface {
                     argumentos.push(null);
                 }
             } else {
-                if (parametros && parametros.length > 0 && parametros[parametros.length - 1].tipo === 'estrela') {
+                if (parametros && parametros.length > 0 && parametros[parametros.length - 1].abrangencia === 'multiplo') {
                     const novosArgumentos = argumentos.slice(0, parametros.length - 1);
                     novosArgumentos.push(argumentos.slice(parametros.length - 1, argumentos.length));
                     argumentos = novosArgumentos;
diff --git a/fontes/lexador/dialetos/lexador-portugol-studio.ts b/fontes/lexador/dialetos/lexador-portugol-studio.ts
index cb5b3062..78364555 100644
--- a/fontes/lexador/dialetos/lexador-portugol-studio.ts
+++ b/fontes/lexador/dialetos/lexador-portugol-studio.ts
@@ -10,9 +10,13 @@ import tiposDeSimbolos from '../../tipos-de-simbolos/portugol-studio';
  * Cada token de linguagem é representado por um tipo, um lexema e informações da linha de código em que foi expresso.
  * Também é responsável por mapear as palavras reservadas da linguagem, que não podem ser usadas por outras
  * estruturas, tais como nomes de variáveis, funções, literais, classes e assim por diante.
+ * 
+ * O Lexador de Portugol Studio possui algumas particularidades:
+ * - Aspas simples são para caracteres individuais, e aspas duplas para cadeias de caracteres.
+ * - Literais de vetores usam chaves, e não colchetes.
  */
 export class LexadorPortugolStudio extends LexadorBase {
-    analisarTexto(delimitador: string): void {
+    protected logicaComumCaracteres(delimitador: string) {
         while (this.simboloAtual() !== delimitador && !this.eFinalDoCodigo()) {
             this.avancar();
         }
@@ -27,6 +31,16 @@ export class LexadorPortugolStudio extends LexadorBase {
         }
 
         const valor = this.codigo[this.linha].substring(this.inicioSimbolo + 1, this.atual);
+        return valor;
+    }
+
+    analisarCaracter() {
+        const valor = this.logicaComumCaracteres("'");
+        this.adicionarSimbolo(tiposDeSimbolos.CARACTER, valor);
+    }
+
+    analisarTexto(): void {
+        const valor = this.logicaComumCaracteres('"');
         this.adicionarSimbolo(tiposDeSimbolos.CADEIA, valor);
     }
 
@@ -101,33 +115,50 @@ export class LexadorPortugolStudio extends LexadorBase {
                 this.avancar();
                 break;
             case '-':
-                this.adicionarSimbolo(tiposDeSimbolos.SUBTRACAO);
+                this.inicioSimbolo = this.atual;
                 this.avancar();
-                break;
+                if (this.simboloAtual() === '=') {
+                    this.adicionarSimbolo(tiposDeSimbolos.MENOS_IGUAL);
+                    this.avancar();
+                } else if (this.simboloAtual() === '-') {
+                    this.adicionarSimbolo(tiposDeSimbolos.DECREMENTAR);
+                    this.avancar();
+                } else {
+                    this.adicionarSimbolo(tiposDeSimbolos.SUBTRACAO);
+                }
             case '+':
-                this.adicionarSimbolo(tiposDeSimbolos.ADICAO);
+                this.inicioSimbolo = this.atual;
                 this.avancar();
+                if (this.simboloAtual() === '=') {
+                    this.adicionarSimbolo(tiposDeSimbolos.MAIS_IGUAL);
+                    this.avancar();
+                } else if (this.simboloAtual() === '+') {
+                    this.adicionarSimbolo(tiposDeSimbolos.INCREMENTAR);
+                    this.avancar();
+                } else {
+                    this.adicionarSimbolo(tiposDeSimbolos.ADICAO);
+                }
+
                 break;
 
-            /* case '%':
+            case '%':
+                this.adicionarSimbolo(tiposDeSimbolos.MODULO);
+                this.avancar();
+                break;
+            case '*':
                 this.inicioSimbolo = this.atual;
                 this.avancar();
                 switch (this.simboloAtual()) {
                     case '=':
                         this.avancar();
-                        this.adicionarSimbolo(tiposDeSimbolos.MODULO_IGUAL);
+                        this.adicionarSimbolo(tiposDeSimbolos.MULTIPLICACAO_IGUAL);
                         break;
                     default:
-                        this.adicionarSimbolo(tiposDeSimbolos.MODULO);
+                        this.adicionarSimbolo(tiposDeSimbolos.MULTIPLICACAO);
                         break;
                 }
-
-                break; */
-            case '*':
-                this.adicionarSimbolo(tiposDeSimbolos.MULTIPLICACAO);
-                this.avancar();
                 break;
-            /* case '!':
+            case '!':
                 this.avancar();
                 if (this.simboloAtual() === '=') {
                     this.adicionarSimbolo(tiposDeSimbolos.DIFERENTE);
@@ -136,7 +167,7 @@ export class LexadorPortugolStudio extends LexadorBase {
                     this.adicionarSimbolo(tiposDeSimbolos.NEGACAO);
                 }
 
-                break; */
+                break;
             case '=':
                 this.avancar();
                 if (this.simboloAtual() === '=') {
@@ -197,6 +228,10 @@ export class LexadorPortugolStudio extends LexadorBase {
                     case '*':
                         this.encontrarFimComentarioAsterisco();
                         break;
+                    case '=':
+                        this.adicionarSimbolo(tiposDeSimbolos.DIVISAO_IGUAL);
+                        this.avancar();
+                        break;
                     default:
                         this.adicionarSimbolo(tiposDeSimbolos.DIVISAO);
                         break;
@@ -216,13 +251,13 @@ export class LexadorPortugolStudio extends LexadorBase {
 
             case '"':
                 this.avancar();
-                this.analisarTexto('"');
+                this.analisarTexto();
                 this.avancar();
                 break;
 
             case "'":
                 this.avancar();
-                this.analisarTexto("'");
+                this.analisarCaracter();
                 this.avancar();
                 break;
 
diff --git a/fontes/lexador/dialetos/palavras-reservadas/portugol-studio.ts b/fontes/lexador/dialetos/palavras-reservadas/portugol-studio.ts
index 632b9952..b5f5449e 100644
--- a/fontes/lexador/dialetos/palavras-reservadas/portugol-studio.ts
+++ b/fontes/lexador/dialetos/palavras-reservadas/portugol-studio.ts
@@ -1,12 +1,24 @@
 import tiposDeSimbolos from '../../../tipos-de-simbolos/portugol-studio';
 
 export default {
+    cadeia: tiposDeSimbolos.CADEIA,
+    caracter: tiposDeSimbolos.CARACTER,
+    const: tiposDeSimbolos.CONSTANTE,
+    enquanto: tiposDeSimbolos.ENQUANTO,
     escreva: tiposDeSimbolos.ESCREVA,
+    e: tiposDeSimbolos.E,
+    faca: tiposDeSimbolos.FACA,
+    falso: tiposDeSimbolos.FALSO,
     funcao: tiposDeSimbolos.FUNCAO,
     inteiro: tiposDeSimbolos.INTEIRO,
     leia: tiposDeSimbolos.LEIA,
+    logico: tiposDeSimbolos.LOGICO,
+    ou: tiposDeSimbolos.OU,
+    para: tiposDeSimbolos.PARA,
     programa: tiposDeSimbolos.PROGRAMA,
     real: tiposDeSimbolos.REAL,
     se: tiposDeSimbolos.SE,
     senao: tiposDeSimbolos.SENAO,
+    vazio: tiposDeSimbolos.VAZIO,
+    verdadeiro: tiposDeSimbolos.VERDADEIRO
 }
\ No newline at end of file
diff --git a/fontes/lexador/lexador.ts b/fontes/lexador/lexador.ts
index e9c88579..44c294c0 100644
--- a/fontes/lexador/lexador.ts
+++ b/fontes/lexador/lexador.ts
@@ -394,15 +394,20 @@ export class Lexador implements LexadorInterface {
                 break;
 
             // Esta sessão ignora espaços em branco na tokenização.
-            // Ponto-e-vírgula é opcional em Delégua, então pode apenas ser ignorado.
+            
             case ' ':
             case '\0':
             case '\r':
             case '\t':
-            case ';':
                 this.avancar();
                 break;
 
+            // Ponto-e-vírgula é opcional em Delégua, mas em alguns casos pode ser
+            // necessário. Por exemplo, declaração de `para` sem inicializador.
+            case ';':
+                this.adicionarSimbolo(tiposDeSimbolos.PONTO_E_VIRGULA);
+                this.avancar();
+                break;
             case '"':
                 this.avancar();
                 this.analisarTexto('"');
diff --git a/fontes/tipos-de-simbolos/portugol-studio.ts b/fontes/tipos-de-simbolos/portugol-studio.ts
index 6821095a..ef02e8ee 100644
--- a/fontes/tipos-de-simbolos/portugol-studio.ts
+++ b/fontes/tipos-de-simbolos/portugol-studio.ts
@@ -1,36 +1,52 @@
 export default {
     ADICAO: 'ADICAO',
     CADEIA: 'CADEIA',
+    CARACTER: 'CARACTER',
     CHAVE_ESQUERDA: 'CHAVE_ESQUERDA',
     CHAVE_DIREITA: 'CHAVE_DIREITA',
     COLCHETE_ESQUERDO: 'COLCHETE_ESQUERDO',
     COLCHETE_DIREITO: 'COLCHETE_DIREITO',
+    CONSTANTE: 'CONSTANTE',
+    DECREMENTAR: 'DECREMENTAR',
     DIFERENTE: 'DIFERENTE',
     DIVISAO: 'DIVISAO',
+    DIVISAO_IGUAL: 'DIVISAO_IGUAL',
     DIVISAO_INTEIRA: 'DIVISAO_INTEIRA',
     E: 'E',
+    ENQUANTO: 'ENQUANTO',
     ESCREVA: 'ESCREVA',
+    FACA: 'FACA',
+    FALSO: 'FALSO',
     FUNCAO: 'FUNCAO',
     IDENTIFICADOR: 'IDENTIFICADOR',
     IGUAL: 'IGUAL',
     IGUAL_IGUAL: 'IGUAL_IGUAL',
+    INCREMENTAR: 'INCREMENTAR',
     INTEIRO: 'INTEIRO',
     LEIA: 'LEIA',
+    LOGICO: 'LOGICO',
     MAIOR: 'MAIOR',
     MAIOR_IGUAL: 'MAIOR_IGUAL',
+    MAIS_IGUAL: 'MAIS_IGUAL',
     MENOR: 'MENOR',
     MENOR_IGUAL: 'MENOR_IGUAL',
+    MENOS_IGUAL: 'MENOS_IGUAL',
     MODULO: 'MODULO',
     MULTIPLICACAO: 'MULTIPLICACAO',
+    MULTIPLICACAO_IGUAL: 'MULTIPLICACAO_IGUAL',
     NEGACAO: 'NEGACAO',
     OU: 'OU',
+    PARA: 'PARA',
     PARENTESE_ESQUERDO: 'PARENTESE_ESQUERDO',
     PARENTESE_DIREITO: 'PARENTESE_DIREITO',
     PONTO: 'PONTO',
+    PONTO_E_VIRGULA: 'PONTO_E_VIRGULA',
     PROGRAMA: 'PROGRAMA',
     REAL: 'REAL',
     SUBTRACAO: 'SUBTRACAO',
     VIRGULA: 'VIRGULA',
     SE: 'SE',
     SENAO: 'SENAO',
+    VAZIO: 'VAZIO',
+    VERDADEIRO: 'VERDADEIRO'
 };
diff --git a/fontes/tradutores/tradutor-javascript.ts b/fontes/tradutores/tradutor-javascript.ts
index c4cc1651..b58eae0c 100644
--- a/fontes/tradutores/tradutor-javascript.ts
+++ b/fontes/tradutores/tradutor-javascript.ts
@@ -537,7 +537,7 @@ export class TradutorJavaScript implements TradutorInterface {
     traduzirConstrutoUnario(unario: Unario): string {
         let resultado = '';
         resultado += this.traduzirSimboloOperador(unario.operador);
-        resultado += unario.direita.valor ?? unario.direita.simbolo.lexema;
+        resultado += unario.operando.valor ?? unario.operando.simbolo.lexema;
         return resultado;
     }
 


Test patch:
diff --git a/testes/avaliador-sintatico.test.ts b/testes/avaliador-sintatico.test.ts
index 72c295bd..63e820c7 100644
--- a/testes/avaliador-sintatico.test.ts
+++ b/testes/avaliador-sintatico.test.ts
@@ -6,129 +6,148 @@ describe('Avaliador sintático', () => {
         let lexador = new Lexador();
         let avaliadorSintatico = new AvaliadorSintatico();
 
-        it('Sucesso - Olá Mundo', () => {
-            const retornoLexador = lexador.mapear(["escreva('Olá mundo')"], -1);
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
-            expect(retornoAvaliadorSintatico).toBeTruthy();
-            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
-        });
-
-        it('Sucesso - Vetor vazio', () => {
-            const retornoLexador = lexador.mapear(['var vetorVazio = []'], -1);
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
-            expect(retornoAvaliadorSintatico).toBeTruthy();
-            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
-        });
-
-        it('Sucesso - Dicionário vazio', () => {
-            const retornoLexador = lexador.mapear(['var dicionarioVazio = {}'], -1);
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
-            expect(retornoAvaliadorSintatico).toBeTruthy();
-            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
-        });
-
-        it('Sucesso - Undefined', () => {
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(undefined as any);
-
-            expect(retornoAvaliadorSintatico).toBeTruthy();
-            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
-        });
-
-        it('Sucesso - Null', () => {
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(null as any);
-
-            expect(retornoAvaliadorSintatico).toBeTruthy();
-            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
-        });
-
-        it('Sucesso - leia sem parametro', () => {
-            const retornoLexador = lexador.mapear(['var nome = leia()'], -1);
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
-            expect(retornoAvaliadorSintatico).toBeTruthy();
-            expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
-        });
-
-        it('Sucesso - leia com parametro', () => {
-            const retornoLexador = lexador.mapear(["var nome = leia('Digite seu nome:')"], -1);
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
-            expect(retornoAvaliadorSintatico).toBeTruthy();
-            expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
-        });
-
-        it.only('Sucesso - para/sustar', async () => {
-            const retornoLexador = lexador.mapear(
-                [
-                    'para (var i = 0; i < 10; i = i + 1) {',
-                    '   se (i == 5) { sustar; }',
-                    "   escreva('Valor: ', i)",
-                    '}',
-                ],
-                -1
-            );
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
-            expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
-        });
-
-        it('Falha - sustar fora de laço de repetição', async () => {
-            const retornoLexador = lexador.mapear(['sustar;'], -1);
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
-            expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
-            expect(retornoAvaliadorSintatico.erros[0].message).toBe(
-                "'sustar' ou 'pausa' deve estar dentro de um laço de repetição."
-            );
-        });
-
-        it('Falha - continua fora de laço de repetição', async () => {
-            const retornoLexador = lexador.mapear(['continua;'], -1);
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
-            expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
-            expect(retornoAvaliadorSintatico.erros[0].message).toBe(
-                "'continua' precisa estar em um laço de repetição."
-            );
-        });
-
-        it('Falha - Não é permitido ter dois identificadores seguidos na mesma linha', () => {
-            const retornoLexador = lexador.mapear(["escreva('Olá mundo') identificador1 identificador2"], -1);
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
-            expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
-            expect(retornoAvaliadorSintatico.erros[0].message).toBe(
-                'Não é permitido ter dois identificadores seguidos na mesma linha.'
-            );
-        });
-
-        describe('Funções Anônimas', () => {
-            it('Função anônima com mais de 255 parâmetros', () => {
-                let acumulador = '';
-                for (let i = 1; i <= 256; i++) {
-                    acumulador += 'a' + i + ', ';
-                }
+        describe('Cenários de sucesso', () => {
+            it('Sucesso - Olá Mundo', () => {
+                const retornoLexador = lexador.mapear(["escreva('Olá mundo')"], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+    
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+            });
+    
+            it('Sucesso - Vetor vazio', () => {
+                const retornoLexador = lexador.mapear(['var vetorVazio = []'], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+    
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+            });
+    
+            it('Sucesso - Dicionário vazio', () => {
+                const retornoLexador = lexador.mapear(['var dicionarioVazio = {}'], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+    
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+            });
+    
+            it('Sucesso - Undefined', () => {
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(undefined as any);
+    
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
+            });
+    
+            it('Sucesso - Null', () => {
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(null as any);
+    
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
+            });
 
-                acumulador = acumulador.substring(0, acumulador.length - 2);
+            it('Sucesso - Incremento e decremento após variável ou literal', () => {
+                const retornoLexador = lexador.mapear([
+                    'var a = 1',
+                    'a++',
+                    'a--',
+                    '++5',
+                    '--5'
+                ], -1);
 
-                const funcaoCom256Argumentos = 'var f = funcao(' + acumulador + ') {}';
-                const retornoLexador = lexador.mapear([funcaoCom256Argumentos], -1);
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
+    
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
+            });
+    
+            it('Sucesso - leia sem parametro', () => {
+                const retornoLexador = lexador.mapear(['var nome = leia()'], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+    
                 expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.erros).toHaveLength(1);
-                expect(retornoAvaliadorSintatico.erros[0].message).toBe('Não pode haver mais de 255 parâmetros');
+                expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
+            });
+    
+            it('Sucesso - leia com parametro', () => {
+                const retornoLexador = lexador.mapear(["var nome = leia('Digite seu nome:')"], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+    
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
+            });
+    
+            it('Sucesso - para/sustar', async () => {
+                const retornoLexador = lexador.mapear(
+                    [
+                        'para (var i = 0; i < 10; i = i + 1) {',
+                        '   se (i == 5) { sustar; }',
+                        "   escreva('Valor: ', i)",
+                        '}',
+                    ],
+                    -1
+                );
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+    
+                expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
             });
         });
 
-        it('Declaração `tente`', () => {
-            const retornoLexador = lexador.mapear(['tente { i = i + 1 } pegue (erro) { escreva(erro) }'], -1);
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
-            expect(retornoAvaliadorSintatico).toBeTruthy();
+        describe('Cenários de falha', () => {
+            it('Falha - sustar fora de laço de repetição', async () => {
+                const retornoLexador = lexador.mapear(['sustar;'], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+    
+                expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
+                expect(retornoAvaliadorSintatico.erros[0].message).toBe(
+                    "'sustar' ou 'pausa' deve estar dentro de um laço de repetição."
+                );
+            });
+    
+            it('Falha - continua fora de laço de repetição', async () => {
+                const retornoLexador = lexador.mapear(['continua;'], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+    
+                expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
+                expect(retornoAvaliadorSintatico.erros[0].message).toBe(
+                    "'continua' precisa estar em um laço de repetição."
+                );
+            });
+    
+            it('Falha - Não é permitido ter dois identificadores seguidos na mesma linha', () => {
+                const retornoLexador = lexador.mapear(["escreva('Olá mundo') identificador1 identificador2"], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+    
+                expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
+                expect(retornoAvaliadorSintatico.erros[0].message).toBe(
+                    'Não é permitido ter dois identificadores seguidos na mesma linha.'
+                );
+            });
+    
+            describe('Funções Anônimas', () => {
+                it('Função anônima com mais de 255 parâmetros', () => {
+                    let acumulador = '';
+                    for (let i = 1; i <= 256; i++) {
+                        acumulador += 'a' + i + ', ';
+                    }
+    
+                    acumulador = acumulador.substring(0, acumulador.length - 2);
+    
+                    const funcaoCom256Argumentos = 'var f = funcao(' + acumulador + ') {}';
+                    const retornoLexador = lexador.mapear([funcaoCom256Argumentos], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+    
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.erros).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico.erros[0].message).toBe('Não pode haver mais de 255 parâmetros');
+                });
+            });
+    
+            it('Declaração `tente`', () => {
+                const retornoLexador = lexador.mapear(['tente { i = i + 1 } pegue (erro) { escreva(erro) }'], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+    
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+            });
         });
     });
 });
diff --git a/testes/egua-classico/biblioteca-global.test.ts b/testes/egua-classico/biblioteca-global.test.ts
index 3d176bc0..7a76ecfa 100644
--- a/testes/egua-classico/biblioteca-global.test.ts
+++ b/testes/egua-classico/biblioteca-global.test.ts
@@ -27,7 +27,7 @@ describe('Biblioteca Global', () => {
     describe('aleatorioEntre()', () => {
         it('Trivial', () => {
             const resultado = funcoes['aleatorioEntre'](2, 10);
-            expect(resultado).toBeGreaterThan(2);
+            expect(resultado).toBeGreaterThanOrEqual(2);
             expect(resultado).toBeLessThan(10);
         });
     });
diff --git a/testes/interpretador.test.ts b/testes/interpretador.test.ts
index 706b065a..776ee371 100644
--- a/testes/interpretador.test.ts
+++ b/testes/interpretador.test.ts
@@ -63,6 +63,24 @@ describe('Interpretador', () => {
 
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
+
+                it('Incremento e decremento após variável ou literal', async () => {
+                    const retornoLexador = lexador.mapear([
+                        'var a = 1',
+                        'escreva(a++)',
+                        'escreva(a--)',
+                        'escreva(++a)',
+                        'escreva(--a)',
+                        'escreva(++5)',
+                        'escreva(--5)'
+                    ], -1);
+    
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+        
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
+                });
             });
 
             describe('Acesso a variáveis e objetos', () => {
diff --git a/testes/lexador.test.ts b/testes/lexador.test.ts
index 2cf7a39b..7ead9484 100644
--- a/testes/lexador.test.ts
+++ b/testes/lexador.test.ts
@@ -22,7 +22,7 @@ describe('Lexador', () => {
                 const resultado = lexador.mapear([';;;;;;;;;;;;;;;;;;;;;'], -1);
 
                 expect(resultado).toBeTruthy();
-                expect(resultado.simbolos).toHaveLength(0);
+                expect(resultado.simbolos).toHaveLength(21);
             });
 
             it('Sucesso - Olá mundo', () => {
diff --git a/testes/portugol-studio/avaliador-sintatico.test.ts b/testes/portugol-studio/avaliador-sintatico.test.ts
index 1a4879b6..ef836d29 100644
--- a/testes/portugol-studio/avaliador-sintatico.test.ts
+++ b/testes/portugol-studio/avaliador-sintatico.test.ts
@@ -2,7 +2,7 @@ import { AvaliadorSintaticoPortugolStudio } from '../../fontes/avaliador-sintati
 import { ErroAvaliadorSintatico } from '../../fontes/avaliador-sintatico/erro-avaliador-sintatico';
 import { LexadorPortugolStudio } from '../../fontes/lexador/dialetos';
 
-describe.skip('Avaliador sintático (Portugol Studio)', () => {
+describe('Avaliador sintático (Portugol Studio)', () => {
     describe('analisar()', () => {
         let lexador: LexadorPortugolStudio;
         let avaliadorSintatico: AvaliadorSintaticoPortugolStudio;
@@ -32,6 +32,32 @@ describe.skip('Avaliador sintático (Portugol Studio)', () => {
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
             });
 
+            it('Sucesso - Estruturas de dados', () => {
+                const retornoLexador = lexador.mapear(
+                    [
+                        'programa',
+                        '{',
+                        '    inteiro variavel',
+                        '    ',
+                        '    funcao inicio()',
+                        '    {',
+                        '        inteiro outra_variavel',
+                        '        real altura = 1.79',
+                        '        cadeia frase = "Isso é uma variável do tipo cadeia"',
+                        '        caracter inicial = \'P\'',  
+                        '        logico exemplo = verdadeiro',
+                        '        escreva(altura)',
+                        '    }',
+                        '}'
+                    ],
+                    -1
+                );
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
+            });
+
             it('Sucesso - Leia', () => {
                 const retornoLexador = lexador.mapear(
                     [
@@ -53,6 +79,154 @@ describe.skip('Avaliador sintático (Portugol Studio)', () => {
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
             });
+
+            it('Sucesso - Funções', () => {
+                const retornoLexador = lexador.mapear([
+                    'programa',
+                    '{',
+                    '    funcao inicio()',
+                    '    {',
+                    '      mensagem("Bem Vindo")',
+                    '      escreva("O resultado do primeiro cálculo é: ", calcula (3.0, 4.0))',
+                    '      escreva("\nO resultado do segundo cálculo é: ", calcula (7.0, 2.0), "\n")',
+                    '      mensagem("Tchau")',
+                    '    }',
+                    '',
+                    '    funcao mensagem (cadeia texto)',
+                    '    {',
+                    '        inteiro i',
+                    '        ',
+                    '        para (i = 0; i < 50; i++)',
+                    '        {',
+                    '          escreva ("-")',
+                    '        }',
+                    '        ',
+                    '        escreva ("\n", texto, "\n")',
+                    '        ',
+                    '        para (i = 0; i < 50; i++)',
+                    '        {',
+                    '          escreva ("-")',
+                    '        }',
+                    '        ',
+                    '        escreva("\n")',
+                    '    }',
+                    '',
+                    '    funcao real calcula (real a, real b)',
+                    '    {',
+                    '        real resultado',
+                    '        resultado = a * a + b * b',
+                    '        retorne resultado',
+                    '    }',
+                    '}'
+                ], -1);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+    
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
+            });
+
+            it('Estrutura condicional - se e senao.', () => {
+                const resultado = lexador.mapear(
+                    [
+                        'programa',
+                        '{',
+                        '    funcao inicio()',
+                        '    {',
+                        '        real numeroUm, numeroDois, soma',
+                        '        numeroUm = 12.0',
+                        '        numeroDois = 20.0',
+                        '        soma = numeroUm + numeroDois',
+                        '        se (soma > 20)',
+                        '        {',
+                        '            escreva("Numero maior que 20")',
+                        '        }',
+                        '        senao',
+                        '        {',
+                        '            escreva("Numero menor que 20")',
+                        '        }',
+                        '    }',
+                        '}',
+                    ],
+                    -1
+                );
+    
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(resultado);
+    
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
+            });
+    
+            it('Estruturas de repetição - Enquanto', () => {
+                const resultado = lexador.mapear([
+                    'programa',
+                    '{',
+                    '    funcao inicio()',
+                    '    {',
+                    '        inteiro numero, atual = 1, fatorial = 1',
+                    '        ',
+                    '        escreva("Digite um numero: ")',
+                    '        leia(numero)',
+                    '        ',
+                    '        enquanto (atual <= numero)',
+                    '        {',
+                    '            fatorial = fatorial * atual',
+                    '            atual = atual + 1',
+                    '        }',
+                    '        ',
+                    '        escreva("O fatorial de ", numero, " é: ", fatorial, "\n")',
+                    '    }',
+                    '}'
+                ], -1);
+    
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(resultado);
+    
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
+            });
+
+            it('Estruturas de repetição - Faca ... Enquanto', () => {
+                const resultado = lexador.mapear([
+                    'programa',
+                    '{',
+                    '    funcao inicio()',
+                    '    {',
+                    '        inteiro idade',
+                    '        ',
+                    '        faca',
+                    '        {',
+                    '            escreva ("Informe sua idade (valores aceitos de 5 a 150): ")',
+                    '            leia (idade)',
+                    '        }',
+                    '        enquanto (idade < 5 ou idade > 120)',
+                    '        ',
+                    '        escreva ("\nCorreto!\n")',
+                    '    }',
+                    '}'
+                ], -1);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(resultado);
+    
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
+            });
+
+            it('Estruturas de repetição - Para', () => {
+                const resultado = lexador.mapear([
+                    'programa {',
+                    '    funcao inicio() {',
+                    '      para (inteiro i = 1; i <= 10; i++) {',
+                    '        escreva(i)',
+                    '      }',
+                    '    }',
+                    '  }'
+                ], -1);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(resultado);
+    
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
+            });
         });
 
         describe('Casos de Falha', () => {
@@ -78,35 +252,6 @@ describe.skip('Avaliador sintático (Portugol Studio)', () => {
             });
         });
 
-        it('Estrutura condicional - se e senao.', () => {
-            const resultado = lexador.mapear(
-                [
-                    'programa',
-                    '{',
-                    '    funcao inicio()',
-                    '    {',
-                    '        real numeroUm, numeroDois, soma',
-                    '        numeroUm = 12.0',
-                    '        numeroDois = 20.0',
-                    '        soma = numeroUm + numeroDois',
-                    '        se (soma > 20)',
-                    '        {',
-                    '            escreva("Numero maior que 20")',
-                    '        }',
-                    '        senao',
-                    '        {',
-                    '            escreva("Numero menor que 20")',
-                    '        }',
-                    '    }',
-                    '}',
-                ],
-                -1
-            );
-
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(resultado);
-
-            expect(resultado).toBeTruthy();
-            expect(resultado.simbolos).toHaveLength(45);
-        });
+        
     });
 });
diff --git a/testes/portugol-studio/interpretador.test.ts b/testes/portugol-studio/interpretador.test.ts
index 6011aa67..7a95ae0a 100644
--- a/testes/portugol-studio/interpretador.test.ts
+++ b/testes/portugol-studio/interpretador.test.ts
@@ -2,7 +2,7 @@ import { AvaliadorSintaticoPortugolStudio } from '../../fontes/avaliador-sintati
 import { LexadorPortugolStudio } from '../../fontes/lexador/dialetos';
 import { InterpretadorPortugolStudio } from '../../fontes/interpretador/dialetos';
 
-describe.skip('Interpretador (Portugol Studio)', () => {
+describe('Interpretador (Portugol Studio)', () => {
     describe('interpretar()', () => {
         let lexador: LexadorPortugolStudio;
         let avaliadorSintatico: AvaliadorSintaticoPortugolStudio;
@@ -15,7 +15,7 @@ describe.skip('Interpretador (Portugol Studio)', () => {
         });
 
         describe('Cenários de sucesso', () => {
-            it.skip('Trivial', async () => {
+            it('Trivial', async () => {
                 const retornoLexador = lexador.mapear([
                     'programa',
                     '{',
@@ -33,7 +33,7 @@ describe.skip('Interpretador (Portugol Studio)', () => {
                 expect(retornoInterpretador.erros).toHaveLength(0);
             });
 
-            it.skip('Sucesso - Leia', async () => {
+            it('Sucesso - Leia', async () => {
                 // Aqui vamos simular a resposta para cinco variáveis de `leia()`.
                 const respostas = [1, 2, 3, 4, 5];
                 interpretador.interfaceEntradaSaida = {
diff --git a/testes/portugol-studio/lexador.test.ts b/testes/portugol-studio/lexador.test.ts
index 89b1ad08..a719ee9e 100644
--- a/testes/portugol-studio/lexador.test.ts
+++ b/testes/portugol-studio/lexador.test.ts
@@ -61,7 +61,7 @@ describe('Lexador (Portugol Studio)', () => {
                 ], -1);
 
                 expect(resultado).toBeTruthy();
-                expect(resultado.simbolos).toHaveLength(15);
+                expect(resultado.simbolos).toHaveLength(16);
             });
 
             it('Operação matematica - multiplicação', () => {
@@ -122,6 +122,47 @@ describe('Lexador (Portugol Studio)', () => {
                 expect(resultado).toBeTruthy();
                 expect(resultado.simbolos).toHaveLength(45);
             });
+
+            it('Enquanto', () => {
+                const resultado = lexador.mapear([
+                    'programa',
+                    '{',
+                    '    funcao inicio()',
+                    '    {',
+                    '        inteiro numero, atual = 1, fatorial = 1',
+                    '        ',
+                    '        escreva("Digite um numero: ")',
+                    '        leia(numero)',
+                    '        ',
+                    '        enquanto (atual <= numero)',
+                    '        {',
+                    '            fatorial = fatorial * atual',
+                    '            atual = atual + 1',
+                    '        }',
+                    '        ',
+                    '        escreva("O fatorial de ", numero, " é: ", fatorial, "\n")',
+                    '    }',
+                    '}'
+                ], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(57);
+            });
+
+            it('Para', () => {
+                const resultado = lexador.mapear([
+                    'programa {',
+                    '    funcao inicio() {',
+                    '      para (inteiro i = 1; i <= 10; i++) {',
+                    '        escreva(i)',
+                    '      }',
+                    '    }',
+                    '  }'
+                ], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(27);
+            });
         });
     });
 });