@designliquido/birl 0.0.0 → 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/avaliador-sintatico/avaliador-sintatico-birl.d.ts.map +1 -1
- package/avaliador-sintatico/avaliador-sintatico-birl.js +205 -205
- package/avaliador-sintatico/avaliador-sintatico-birl.js.map +1 -1
- package/index.d.ts +5 -0
- package/index.d.ts.map +1 -0
- package/index.js +21 -0
- package/index.js.map +1 -0
- package/interpretador/comum.d.ts +6 -6
- package/interpretador/comum.d.ts.map +1 -1
- package/interpretador/comum.js +4 -0
- package/interpretador/comum.js.map +1 -1
- package/interpretador/interpretador-birl-com-depuracao.d.ts +3 -3
- package/interpretador/interpretador-birl-com-depuracao.d.ts.map +1 -1
- package/interpretador/interpretador-birl-com-depuracao.js.map +1 -1
- package/interpretador/interpretador-birl.d.ts +3 -3
- package/interpretador/interpretador-birl.d.ts.map +1 -1
- package/interpretador/interpretador-birl.js +4 -1
- package/interpretador/interpretador-birl.js.map +1 -1
- package/lexador/lexador-birl.d.ts.map +1 -1
- package/lexador/lexador-birl.js +27 -27
- package/lexador/lexador-birl.js.map +1 -1
- package/package.json +4 -2
|
@@ -7,7 +7,7 @@ exports.AvaliadorSintaticoBirl = void 0;
|
|
|
7
7
|
const construtos_1 = require("@designliquido/delegua/construtos");
|
|
8
8
|
const declaracoes_1 = require("@designliquido/delegua/declaracoes");
|
|
9
9
|
const avaliador_sintatico_base_1 = require("@designliquido/delegua/avaliador-sintatico/avaliador-sintatico-base");
|
|
10
|
-
const
|
|
10
|
+
const lexico_regular_1 = __importDefault(require("../tipos-de-simbolos/lexico-regular"));
|
|
11
11
|
/**
|
|
12
12
|
* Avaliador Sintático de BIRL
|
|
13
13
|
*/
|
|
@@ -30,13 +30,13 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
30
30
|
tratarSimbolos(simbolos) {
|
|
31
31
|
let identificador = 0, adicao = 0, subtracao = 0;
|
|
32
32
|
for (const simbolo of simbolos) {
|
|
33
|
-
if (simbolo.tipo ===
|
|
33
|
+
if (simbolo.tipo === lexico_regular_1.default.IDENTIFICADOR) {
|
|
34
34
|
identificador++;
|
|
35
35
|
}
|
|
36
|
-
else if (simbolo.tipo ===
|
|
36
|
+
else if (simbolo.tipo === lexico_regular_1.default.ADICAO) {
|
|
37
37
|
adicao++;
|
|
38
38
|
}
|
|
39
|
-
else if (simbolo.tipo ===
|
|
39
|
+
else if (simbolo.tipo === lexico_regular_1.default.SUBTRACAO) {
|
|
40
40
|
subtracao++;
|
|
41
41
|
}
|
|
42
42
|
}
|
|
@@ -62,40 +62,40 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
62
62
|
return;
|
|
63
63
|
}
|
|
64
64
|
validarSegmentoHoraDoShow() {
|
|
65
|
-
this.consumir(
|
|
66
|
-
this.consumir(
|
|
67
|
-
this.consumir(
|
|
65
|
+
this.consumir(lexico_regular_1.default.HORA, 'Esperado expressão `HORA DO SHOW` para iniciar o programa');
|
|
66
|
+
this.consumir(lexico_regular_1.default.DO, 'Esperado expressão `HORA DO SHOW` para iniciar o programa');
|
|
67
|
+
this.consumir(lexico_regular_1.default.SHOW, 'Esperado expressão `HORA DO SHOW` para iniciar o programa');
|
|
68
68
|
this.blocos += 1;
|
|
69
69
|
}
|
|
70
70
|
validarSegmentoBirlFinal() {
|
|
71
71
|
this.regredirEDevolverAtual();
|
|
72
|
-
while (!this.verificarTipoSimboloAtual(
|
|
73
|
-
this.consumir(
|
|
72
|
+
while (!this.verificarTipoSimboloAtual(lexico_regular_1.default.BIRL)) {
|
|
73
|
+
this.consumir(lexico_regular_1.default.QUEBRA_LINHA, 'Esperado expressão `QUEBRA_LINHA` após a declaração de variáveis');
|
|
74
74
|
this.regredirEDevolverAtual();
|
|
75
75
|
this.regredirEDevolverAtual();
|
|
76
76
|
}
|
|
77
|
-
this.consumir(
|
|
77
|
+
this.consumir(lexico_regular_1.default.BIRL, 'Esperado expressão `BIRL` para fechamento do programa');
|
|
78
78
|
this.blocos -= 1;
|
|
79
79
|
}
|
|
80
80
|
primario() {
|
|
81
81
|
const simboloAtual = this.simbolos[this.atual];
|
|
82
|
-
if (this.verificarSeSimboloAtualEIgualA(
|
|
82
|
+
if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.SUBTRACAO))
|
|
83
83
|
return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), false);
|
|
84
|
-
if (this.verificarSeSimboloAtualEIgualA(
|
|
84
|
+
if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.ADICAO))
|
|
85
85
|
return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), true);
|
|
86
86
|
// Simplesmente avança o símbolo por enquanto.
|
|
87
87
|
// O `if` de baixo irá tratar a referência.
|
|
88
|
-
this.verificarSeSimboloAtualEIgualA(
|
|
89
|
-
if (this.verificarSeSimboloAtualEIgualA(
|
|
88
|
+
this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.PONTEIRO);
|
|
89
|
+
if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.IDENTIFICADOR)) {
|
|
90
90
|
return new construtos_1.Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
|
|
91
91
|
}
|
|
92
|
-
if (this.verificarSeSimboloAtualEIgualA(
|
|
92
|
+
if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.NUMERO, lexico_regular_1.default.FRANGAO, lexico_regular_1.default.FRANGÃO, lexico_regular_1.default.FRANGO, lexico_regular_1.default.TEXTO)) {
|
|
93
93
|
const simboloAnterior = this.simbolos[this.atual - 1];
|
|
94
94
|
return new construtos_1.Literal(this.hashArquivo, Number(simboloAnterior.linha), simboloAnterior.literal);
|
|
95
95
|
}
|
|
96
|
-
if (this.verificarSeSimboloAtualEIgualA(
|
|
96
|
+
if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.PARENTESE_ESQUERDO)) {
|
|
97
97
|
const expressao = this.expressao();
|
|
98
|
-
this.consumir(
|
|
98
|
+
this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
|
|
99
99
|
return new construtos_1.Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
|
|
100
100
|
}
|
|
101
101
|
throw this.erro(this.simbolos[this.atual], 'Esperado expressão.');
|
|
@@ -103,7 +103,7 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
103
103
|
chamar() {
|
|
104
104
|
let expressao = this.primario();
|
|
105
105
|
while (true) {
|
|
106
|
-
if (this.verificarSeSimboloAtualEIgualA(
|
|
106
|
+
if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.PARENTESE_ESQUERDO)) {
|
|
107
107
|
expressao = this.finalizarChamada(expressao);
|
|
108
108
|
}
|
|
109
109
|
else {
|
|
@@ -114,7 +114,7 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
114
114
|
}
|
|
115
115
|
atribuir() {
|
|
116
116
|
const expressao = this.ou();
|
|
117
|
-
if (this.verificarSeSimboloAtualEIgualA(
|
|
117
|
+
if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.IGUAL)) {
|
|
118
118
|
const igual = this.simboloAnterior();
|
|
119
119
|
const valor = this.atribuir();
|
|
120
120
|
if (expressao instanceof construtos_1.Variavel) {
|
|
@@ -136,33 +136,33 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
136
136
|
throw new Error('Método não implementado.');
|
|
137
137
|
}
|
|
138
138
|
declaracaoEnquanto() {
|
|
139
|
-
const simboloNegatica = this.consumir(
|
|
140
|
-
this.consumir(
|
|
141
|
-
this.consumir(
|
|
139
|
+
const simboloNegatica = this.consumir(lexico_regular_1.default.NEGATIVA, 'Esperado expressão `NEGATIVA` para iniciar o bloco `ENQUANTO`.');
|
|
140
|
+
this.consumir(lexico_regular_1.default.BAMBAM, 'Esperado expressão `BAMBAM` após `NEGATIVA` para iniciar o bloco `ENQUANTO`.');
|
|
141
|
+
this.consumir(lexico_regular_1.default.PARENTESE_ESQUERDO, 'Esperado expressão `(` após `BAMBAM` para iniciar o bloco `ENQUANTO`.');
|
|
142
142
|
const codicao = this.expressao();
|
|
143
|
-
this.consumir(
|
|
143
|
+
this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, 'Esperado expressão `)` após a condição para iniciar o bloco `ENQUANTO`.');
|
|
144
144
|
const declaracoes = [];
|
|
145
|
-
while (!this.verificarSeSimboloAtualEIgualA(
|
|
145
|
+
while (!this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.BIRL)) {
|
|
146
146
|
declaracoes.push(this.resolverDeclaracaoForaDeBloco());
|
|
147
147
|
}
|
|
148
|
-
this.consumir(
|
|
148
|
+
this.consumir(lexico_regular_1.default.BIRL, 'Esperado expressão `BIRL` para fechar o bloco `ENQUANTO`.');
|
|
149
149
|
return new declaracoes_1.Enquanto(codicao, new declaracoes_1.Bloco(this.hashArquivo, simboloNegatica.linha, declaracoes));
|
|
150
150
|
}
|
|
151
151
|
declaracaoExpressao() {
|
|
152
152
|
const expressao = this.expressao();
|
|
153
|
-
this.consumir(
|
|
153
|
+
this.consumir(lexico_regular_1.default.PONTO_E_VIRGULA, "Esperado ';' após expressão.");
|
|
154
154
|
return new declaracoes_1.Expressao(expressao);
|
|
155
155
|
}
|
|
156
156
|
declaracaoPara() {
|
|
157
|
-
const primeiroSimbolo = this.consumir(
|
|
158
|
-
this.consumir(
|
|
159
|
-
this.consumir(
|
|
160
|
-
this.consumir(
|
|
157
|
+
const primeiroSimbolo = this.consumir(lexico_regular_1.default.MAIS, 'Esperado expressão `MAIS` para iniciar o bloco `PARA`.');
|
|
158
|
+
this.consumir(lexico_regular_1.default.QUERO, 'Esperado expressão `QUERO` após `MAIS` para iniciar o bloco `PARA`.');
|
|
159
|
+
this.consumir(lexico_regular_1.default.MAIS, 'Esperado expressão `MAIS` após `QUERO` para iniciar o bloco `PARA`.');
|
|
160
|
+
this.consumir(lexico_regular_1.default.PARENTESE_ESQUERDO, 'Esperado expressão `(` após `MAIS` para iniciar o bloco `PARA`.');
|
|
161
161
|
let declaracaoInicial = null;
|
|
162
|
-
if (this.simbolos[this.atual].tipo ===
|
|
163
|
-
const variavelLoop = this.consumir(
|
|
164
|
-
this.consumir(
|
|
165
|
-
const valor = this.consumir(
|
|
162
|
+
if (this.simbolos[this.atual].tipo === lexico_regular_1.default.IDENTIFICADOR) {
|
|
163
|
+
const variavelLoop = this.consumir(lexico_regular_1.default.IDENTIFICADOR, 'Esperado expressão `IDENTIFICADOR` após `(` para iniciar o bloco `PARA`.');
|
|
164
|
+
this.consumir(lexico_regular_1.default.IGUAL, 'Esperado expressão `=` após `IDENTIFICADOR` para iniciar o bloco `PARA`.');
|
|
165
|
+
const valor = this.consumir(lexico_regular_1.default.NUMERO, 'Esperado expressão `NUMERO` após `=` para iniciar o bloco `PARA`.');
|
|
166
166
|
declaracaoInicial = [
|
|
167
167
|
new construtos_1.Variavel(this.hashArquivo, variavelLoop),
|
|
168
168
|
new construtos_1.Literal(this.hashArquivo, Number(valor.linha), Number(valor.literal)),
|
|
@@ -177,14 +177,14 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
177
177
|
declaracaoInicial = declaracaoVetor;
|
|
178
178
|
}
|
|
179
179
|
}
|
|
180
|
-
this.consumir(
|
|
180
|
+
this.consumir(lexico_regular_1.default.PONTO_E_VIRGULA, 'Esperado expressão `;` após a inicialização do `PARA`.');
|
|
181
181
|
const condicao = this.resolverDeclaracaoForaDeBloco(); // condição de parada
|
|
182
|
-
this.consumir(
|
|
182
|
+
this.consumir(lexico_regular_1.default.PONTO_E_VIRGULA, 'Esperado expressão `;` após a condição do `PARA`.');
|
|
183
183
|
const incremento = this.resolverDeclaracaoForaDeBloco();
|
|
184
|
-
this.consumir(
|
|
185
|
-
this.consumir(
|
|
184
|
+
this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, 'Esperado expressão `)` após a condição do `PARA`.');
|
|
185
|
+
this.consumir(lexico_regular_1.default.QUEBRA_LINHA, 'Esperado expressão `QUEBRA_LINHA` após a condição do `PARA`.');
|
|
186
186
|
const declaracoes = [];
|
|
187
|
-
while (!this.verificarSeSimboloAtualEIgualA(
|
|
187
|
+
while (!this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.BIRL)) {
|
|
188
188
|
declaracoes.push(this.resolverDeclaracaoForaDeBloco());
|
|
189
189
|
}
|
|
190
190
|
const corpo = new declaracoes_1.Bloco(this.hashArquivo, Number(this.simbolos[this.atual].linha) + 1, declaracoes.filter((d) => d));
|
|
@@ -194,47 +194,47 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
194
194
|
throw new Error('Método não implementado.');
|
|
195
195
|
}
|
|
196
196
|
declaracaoEscreva() {
|
|
197
|
-
const primeiroSimbolo = this.consumir(
|
|
198
|
-
this.consumir(
|
|
199
|
-
this.consumir(
|
|
200
|
-
this.consumir(
|
|
201
|
-
this.consumir(
|
|
202
|
-
this.consumir(
|
|
203
|
-
this.consumir(
|
|
197
|
+
const primeiroSimbolo = this.consumir(lexico_regular_1.default.CE, 'Esperado expressão `CE` para escrever mensagem.');
|
|
198
|
+
this.consumir(lexico_regular_1.default.QUER, 'Esperado expressão `QUER` após `CE` para escrever mensagem.');
|
|
199
|
+
this.consumir(lexico_regular_1.default.VER, 'Esperado expressão `VER` após `QUER` para escrever mensagem.');
|
|
200
|
+
this.consumir(lexico_regular_1.default.ESSA, 'Esperado expressão `ESSA` após `VER` para escrever mensagem.');
|
|
201
|
+
this.consumir(lexico_regular_1.default.PORRA, 'Esperado expressão `PORRA` após `ESSA` para escrever mensagem.');
|
|
202
|
+
this.consumir(lexico_regular_1.default.INTERROGACAO, 'Esperado interrogação após `PORRA` para escrever mensagem.');
|
|
203
|
+
this.consumir(lexico_regular_1.default.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após interrogação para escrever mensagem.');
|
|
204
204
|
const argumentos = [];
|
|
205
205
|
argumentos.push(this.resolverDeclaracaoForaDeBloco());
|
|
206
|
-
while (this.verificarTipoSimboloAtual(
|
|
206
|
+
while (this.verificarTipoSimboloAtual(lexico_regular_1.default.VIRGULA)) {
|
|
207
207
|
this.avancarEDevolverAnterior(); // Vírgula
|
|
208
208
|
const variavelParaEscrita = this.resolverDeclaracaoForaDeBloco();
|
|
209
209
|
argumentos.push(variavelParaEscrita);
|
|
210
210
|
}
|
|
211
|
-
this.consumir(
|
|
211
|
+
this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, 'Esperado parêntese direito após argumento para escrever mensagem.');
|
|
212
212
|
return new declaracoes_1.Escreva(Number(primeiroSimbolo.linha), this.hashArquivo, argumentos);
|
|
213
213
|
}
|
|
214
214
|
declaracaoFazer() {
|
|
215
215
|
throw new Error('Método não implementado.');
|
|
216
216
|
}
|
|
217
217
|
declaracaoCaracteres() {
|
|
218
|
-
if (this.verificarTipoSimboloAtual(
|
|
219
|
-
this.consumir(
|
|
218
|
+
if (this.verificarTipoSimboloAtual(lexico_regular_1.default.BICEPS)) {
|
|
219
|
+
this.consumir(lexico_regular_1.default.BICEPS, '');
|
|
220
220
|
}
|
|
221
|
-
const simboloCaractere = this.consumir(
|
|
221
|
+
const simboloCaractere = this.consumir(lexico_regular_1.default.FRANGO, '');
|
|
222
222
|
const inicializacoes = [];
|
|
223
223
|
let eLiteral = true;
|
|
224
224
|
do {
|
|
225
|
-
const identificador = this.consumir(
|
|
225
|
+
const identificador = this.consumir(lexico_regular_1.default.IDENTIFICADOR, "Esperado identificador após palavra reservada 'FRANGO'.");
|
|
226
226
|
let valorInicializacao;
|
|
227
|
-
if (this.verificarSeSimboloAtualEIgualA(
|
|
228
|
-
if (this.verificarTipoSimboloAtual(
|
|
227
|
+
if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.IGUAL)) {
|
|
228
|
+
if (this.verificarTipoSimboloAtual(lexico_regular_1.default.AJUDA)) {
|
|
229
229
|
eLiteral = false;
|
|
230
230
|
valorInicializacao = this.resolverDeclaracaoForaDeBloco();
|
|
231
231
|
}
|
|
232
|
-
else if (this.verificarTipoSimboloAtual(
|
|
232
|
+
else if (this.verificarTipoSimboloAtual(lexico_regular_1.default.IDENTIFICADOR)) {
|
|
233
233
|
eLiteral = false;
|
|
234
234
|
valorInicializacao = this.resolverDeclaracaoForaDeBloco();
|
|
235
235
|
}
|
|
236
|
-
else if (this.verificarTipoSimboloAtual(
|
|
237
|
-
const literalInicializacao = this.consumir(
|
|
236
|
+
else if (this.verificarTipoSimboloAtual(lexico_regular_1.default.TEXTO)) {
|
|
237
|
+
const literalInicializacao = this.consumir(lexico_regular_1.default.TEXTO, "Esperado ' para começar o texto.");
|
|
238
238
|
valorInicializacao = String(literalInicializacao.literal);
|
|
239
239
|
}
|
|
240
240
|
else {
|
|
@@ -247,18 +247,18 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
247
247
|
else {
|
|
248
248
|
inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloCaractere.hashArquivo), ''), 'texto'));
|
|
249
249
|
}
|
|
250
|
-
} while (this.verificarSeSimboloAtualEIgualA(
|
|
250
|
+
} while (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.VIRGULA));
|
|
251
251
|
return inicializacoes;
|
|
252
252
|
}
|
|
253
253
|
validarTipoDeclaracaoInteiro() {
|
|
254
|
-
if (this.verificarTipoSimboloAtual(
|
|
255
|
-
return this.consumir(
|
|
254
|
+
if (this.verificarTipoSimboloAtual(lexico_regular_1.default.MONSTRO)) {
|
|
255
|
+
return this.consumir(lexico_regular_1.default.MONSTRO, '');
|
|
256
256
|
}
|
|
257
|
-
else if (this.verificarTipoSimboloAtual(
|
|
258
|
-
return this.consumir(
|
|
257
|
+
else if (this.verificarTipoSimboloAtual(lexico_regular_1.default.MONSTRINHO)) {
|
|
258
|
+
return this.consumir(lexico_regular_1.default.MONSTRINHO, '');
|
|
259
259
|
}
|
|
260
|
-
else if (this.verificarTipoSimboloAtual(
|
|
261
|
-
return this.consumir(
|
|
260
|
+
else if (this.verificarTipoSimboloAtual(lexico_regular_1.default.MONSTRAO)) {
|
|
261
|
+
return this.consumir(lexico_regular_1.default.MONSTRAO, '');
|
|
262
262
|
}
|
|
263
263
|
else {
|
|
264
264
|
throw new Error('Simbolo referente a inteiro não especificado.');
|
|
@@ -269,19 +269,19 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
269
269
|
let eLiteral = true;
|
|
270
270
|
const inicializacoes = [];
|
|
271
271
|
do {
|
|
272
|
-
const identificador = this.consumir(
|
|
272
|
+
const identificador = this.consumir(lexico_regular_1.default.IDENTIFICADOR, `Esperado identificador após palavra reservada '${simboloInteiro.lexema}'.`);
|
|
273
273
|
let valorInicializacao = 0x00;
|
|
274
|
-
if (this.verificarSeSimboloAtualEIgualA(
|
|
275
|
-
if (this.verificarTipoSimboloAtual(
|
|
274
|
+
if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.IGUAL)) {
|
|
275
|
+
if (this.verificarTipoSimboloAtual(lexico_regular_1.default.AJUDA)) {
|
|
276
276
|
eLiteral = false;
|
|
277
277
|
valorInicializacao = this.resolverDeclaracaoForaDeBloco();
|
|
278
278
|
}
|
|
279
|
-
else if (this.verificarTipoSimboloAtual(
|
|
279
|
+
else if (this.verificarTipoSimboloAtual(lexico_regular_1.default.IDENTIFICADOR)) {
|
|
280
280
|
eLiteral = false;
|
|
281
281
|
valorInicializacao = this.resolverDeclaracaoForaDeBloco();
|
|
282
282
|
}
|
|
283
|
-
else if (this.verificarTipoSimboloAtual(
|
|
284
|
-
const literalInicializacao = this.consumir(
|
|
283
|
+
else if (this.verificarTipoSimboloAtual(lexico_regular_1.default.NUMERO)) {
|
|
284
|
+
const literalInicializacao = this.consumir(lexico_regular_1.default.NUMERO, `Esperado literal de ${simboloInteiro.lexema} após símbolo de igual em declaração de variável.`);
|
|
285
285
|
valorInicializacao = Number(literalInicializacao.literal);
|
|
286
286
|
}
|
|
287
287
|
else {
|
|
@@ -294,30 +294,30 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
294
294
|
else {
|
|
295
295
|
inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloInteiro.linha), 0), 'numero'));
|
|
296
296
|
}
|
|
297
|
-
} while (this.verificarSeSimboloAtualEIgualA(
|
|
297
|
+
} while (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.VIRGULA));
|
|
298
298
|
return inicializacoes;
|
|
299
299
|
}
|
|
300
300
|
declaracaoPontoFlutuante() {
|
|
301
|
-
const simboloFloat = this.consumir(
|
|
302
|
-
if (this.verificarTipoSimboloAtual(
|
|
303
|
-
this.consumir(
|
|
301
|
+
const simboloFloat = this.consumir(lexico_regular_1.default.TRAPEZIO, '');
|
|
302
|
+
if (this.verificarTipoSimboloAtual(lexico_regular_1.default.DESCENDENTE)) {
|
|
303
|
+
this.consumir(lexico_regular_1.default.DESCENDENTE, '');
|
|
304
304
|
}
|
|
305
305
|
let eLiteral = true;
|
|
306
306
|
const inicializacoes = [];
|
|
307
307
|
do {
|
|
308
|
-
const identificador = this.consumir(
|
|
308
|
+
const identificador = this.consumir(lexico_regular_1.default.IDENTIFICADOR, "Esperado identificador após palavra reservada 'TRAPEZIO'.");
|
|
309
309
|
let valorInicializacao = 0x00;
|
|
310
|
-
if (this.verificarSeSimboloAtualEIgualA(
|
|
311
|
-
if (this.verificarTipoSimboloAtual(
|
|
310
|
+
if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.IGUAL)) {
|
|
311
|
+
if (this.verificarTipoSimboloAtual(lexico_regular_1.default.AJUDA)) {
|
|
312
312
|
eLiteral = false;
|
|
313
313
|
valorInicializacao = this.resolverDeclaracaoForaDeBloco();
|
|
314
314
|
}
|
|
315
|
-
else if (this.verificarTipoSimboloAtual(
|
|
315
|
+
else if (this.verificarTipoSimboloAtual(lexico_regular_1.default.IDENTIFICADOR)) {
|
|
316
316
|
eLiteral = false;
|
|
317
317
|
valorInicializacao = this.resolverDeclaracaoForaDeBloco();
|
|
318
318
|
}
|
|
319
|
-
else if (this.verificarTipoSimboloAtual(
|
|
320
|
-
const literalInicializacao = this.consumir(
|
|
319
|
+
else if (this.verificarTipoSimboloAtual(lexico_regular_1.default.NUMERO)) {
|
|
320
|
+
const literalInicializacao = this.consumir(lexico_regular_1.default.NUMERO, "Esperado literal de 'TRAPEZIO' após símbolo de igual em declaração de variável.");
|
|
321
321
|
valorInicializacao = parseFloat(literalInicializacao.literal);
|
|
322
322
|
}
|
|
323
323
|
else {
|
|
@@ -330,14 +330,14 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
330
330
|
else {
|
|
331
331
|
inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloFloat.linha), 0), 'numero'));
|
|
332
332
|
}
|
|
333
|
-
} while (this.verificarSeSimboloAtualEIgualA(
|
|
333
|
+
} while (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.VIRGULA));
|
|
334
334
|
return inicializacoes;
|
|
335
335
|
}
|
|
336
336
|
declaracaoRetorna() {
|
|
337
|
-
const primeiroSimbolo = this.consumir(
|
|
338
|
-
this.consumir(
|
|
339
|
-
if (this.verificarTipoSimboloAtual(
|
|
340
|
-
this.consumir(
|
|
337
|
+
const primeiroSimbolo = this.consumir(lexico_regular_1.default.BORA, 'Esperado expressão `BORA` para retornar valor.');
|
|
338
|
+
this.consumir(lexico_regular_1.default.CUMPADE, 'Esperado expressão `CUMPADE` após `BORA` para retornar valor.');
|
|
339
|
+
if (this.verificarTipoSimboloAtual(lexico_regular_1.default.INTERROGACAO)) {
|
|
340
|
+
this.consumir(lexico_regular_1.default.INTERROGACAO, 'Esperado interrogação após `CUMPADE` para retornar valor.');
|
|
341
341
|
}
|
|
342
342
|
const valor = this.resolverDeclaracaoForaDeBloco();
|
|
343
343
|
return new declaracoes_1.Retorna(primeiroSimbolo, valor);
|
|
@@ -364,73 +364,73 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
364
364
|
return tipos[tipoCaractere] || 'desconhecido';
|
|
365
365
|
}
|
|
366
366
|
declaracaoLeia() {
|
|
367
|
-
const primeiroSimbolo = this.consumir(
|
|
368
|
-
this.consumir(
|
|
369
|
-
this.consumir(
|
|
370
|
-
this.consumir(
|
|
371
|
-
this.consumir(
|
|
372
|
-
this.consumir(
|
|
373
|
-
this.consumir(
|
|
374
|
-
const textoOuSimbolo = this.consumir(
|
|
375
|
-
this.consumir(
|
|
376
|
-
this.consumir(
|
|
377
|
-
const variavel = this.consumir(
|
|
367
|
+
const primeiroSimbolo = this.consumir(lexico_regular_1.default.QUE, 'Esperado expressão `QUE` para ler valor.');
|
|
368
|
+
this.consumir(lexico_regular_1.default.QUE, 'Esperado expressão `QUE` após `QUE` para ler valor.');
|
|
369
|
+
this.consumir(lexico_regular_1.default.CE, 'Esperado expressão `CE` após `QUE` para ler valor.');
|
|
370
|
+
this.consumir(lexico_regular_1.default.QUER, 'Esperado expressão `QUER` após `CE` para ler valor.');
|
|
371
|
+
this.consumir(lexico_regular_1.default.MONSTRAO, 'Esperado expressão `MONSTRAO` após `QUER` para ler valor.');
|
|
372
|
+
this.consumir(lexico_regular_1.default.INTERROGACAO, 'Esperado interrogação após `MONSTRAO` para ler valor.');
|
|
373
|
+
this.consumir(lexico_regular_1.default.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após interrogação para ler valor.');
|
|
374
|
+
const textoOuSimbolo = this.consumir(lexico_regular_1.default.TEXTO, 'Esperado texto após parêntese esquerdo para ler valor.');
|
|
375
|
+
this.consumir(lexico_regular_1.default.VIRGULA, 'Esperado vírgula após texto para ler valor.');
|
|
376
|
+
this.consumir(lexico_regular_1.default.PONTEIRO, 'Esperado expressão `&` após texto para ler valor.');
|
|
377
|
+
const variavel = this.consumir(lexico_regular_1.default.IDENTIFICADOR, 'Esperado identificador após `&` para ler valor.');
|
|
378
378
|
const tipo = this.validaTipoDeclaracaoLeia(textoOuSimbolo.literal);
|
|
379
|
-
this.consumir(
|
|
379
|
+
this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, 'Esperado parêntese direito após identificador para ler valor.');
|
|
380
380
|
return new declaracoes_1.Leia(primeiroSimbolo, [
|
|
381
381
|
new construtos_1.Variavel(this.hashArquivo, variavel),
|
|
382
382
|
new construtos_1.Literal(this.hashArquivo, Number(textoOuSimbolo.linha), tipo),
|
|
383
383
|
]);
|
|
384
384
|
}
|
|
385
385
|
consomeSeSenao() {
|
|
386
|
-
this.consumir(
|
|
387
|
-
this.consumir(
|
|
388
|
-
this.consumir(
|
|
389
|
-
this.consumir(
|
|
390
|
-
this.consumir(
|
|
391
|
-
this.consumir(
|
|
392
|
-
this.consumir(
|
|
393
|
-
this.consumir(
|
|
386
|
+
this.consumir(lexico_regular_1.default.QUE, 'Esperado expressão `QUE` após `SE`.');
|
|
387
|
+
this.consumir(lexico_regular_1.default.NAO, 'Esperado expressão `NAO` após `QUE`.');
|
|
388
|
+
this.consumir(lexico_regular_1.default.VAI, 'Esperado expressão `VAI` após `NAO`.');
|
|
389
|
+
this.consumir(lexico_regular_1.default.DAR, 'Esperado expressão `DAR` após `VAI`.');
|
|
390
|
+
this.consumir(lexico_regular_1.default.O, 'Esperado expressão `O` após `DAR`.');
|
|
391
|
+
this.consumir(lexico_regular_1.default.QUE, 'Esperado expressão `QUE` após `O`.');
|
|
392
|
+
this.consumir(lexico_regular_1.default.INTERROGACAO, 'Esperado expressão `?` após `QUE`.');
|
|
393
|
+
this.consumir(lexico_regular_1.default.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após `?`.');
|
|
394
394
|
const condicaoSeSenao = this.resolverDeclaracaoForaDeBloco();
|
|
395
|
-
this.consumir(
|
|
395
|
+
this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, 'Esperado parêntese direito após expressão de condição.');
|
|
396
396
|
return {
|
|
397
397
|
condicaoSeSenao,
|
|
398
398
|
};
|
|
399
399
|
}
|
|
400
400
|
consomeSe() {
|
|
401
|
-
const simboloSe = this.consumir(
|
|
402
|
-
this.consumir(
|
|
403
|
-
this.consumir(
|
|
404
|
-
this.consumir(
|
|
405
|
-
this.consumir(
|
|
406
|
-
this.consumir(
|
|
407
|
-
this.consumir(
|
|
401
|
+
const simboloSe = this.consumir(lexico_regular_1.default.ELE, 'Esperado expressão `ELE`.');
|
|
402
|
+
this.consumir(lexico_regular_1.default.QUE, 'Esperado expressão `QUE` após `ELE`.');
|
|
403
|
+
this.consumir(lexico_regular_1.default.A, 'Esperado expressão `A` após `QUE`.');
|
|
404
|
+
this.consumir(lexico_regular_1.default.GENTE, 'Esperado expressão `GENTE` após `A`.');
|
|
405
|
+
this.consumir(lexico_regular_1.default.QUER, 'Esperado expressão `QUER` após `GENTE`.');
|
|
406
|
+
this.consumir(lexico_regular_1.default.INTERROGACAO, 'Esperado expressão `?` após `QUER`.');
|
|
407
|
+
this.consumir(lexico_regular_1.default.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após `?`.');
|
|
408
408
|
const condicaoSe = this.resolverDeclaracaoForaDeBloco();
|
|
409
409
|
// @TODO: Verificar se é possível consumir os dois símbolos juntos.
|
|
410
410
|
// Consumindo n == 1 || n == 2 separado.
|
|
411
|
-
this.consumir(
|
|
411
|
+
this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, 'Esperado parêntese direito após expressão de condição.');
|
|
412
412
|
return {
|
|
413
413
|
simboloSe,
|
|
414
414
|
condicaoSe,
|
|
415
415
|
};
|
|
416
416
|
}
|
|
417
417
|
consumeSenao() {
|
|
418
|
-
this.consumir(
|
|
419
|
-
this.consumir(
|
|
420
|
-
this.consumir(
|
|
421
|
-
this.consumir(
|
|
418
|
+
this.consumir(lexico_regular_1.default.NAO, 'Esperado expressão `NAO` após `SE`.');
|
|
419
|
+
this.consumir(lexico_regular_1.default.VAI, 'Esperado expressão `VAI` após `NAO`.');
|
|
420
|
+
this.consumir(lexico_regular_1.default.DAR, 'Esperado expressão `DAR` após `VAI`.');
|
|
421
|
+
this.consumir(lexico_regular_1.default.NAO, 'Esperado expressão `NAO` após `DAR`.');
|
|
422
422
|
}
|
|
423
423
|
resolveCaminhoSe() {
|
|
424
424
|
let controle = true;
|
|
425
425
|
const declaracoesEntao = [];
|
|
426
426
|
while (controle) {
|
|
427
427
|
switch (this.simbolos[this.atual].tipo) {
|
|
428
|
-
case
|
|
429
|
-
case
|
|
428
|
+
case lexico_regular_1.default.BIRL:
|
|
429
|
+
case lexico_regular_1.default.NAO:
|
|
430
430
|
controle = false;
|
|
431
431
|
break;
|
|
432
|
-
case
|
|
433
|
-
if (this.verificarTipoProximoSimbolo(
|
|
432
|
+
case lexico_regular_1.default.QUE:
|
|
433
|
+
if (this.verificarTipoProximoSimbolo(lexico_regular_1.default.NAO)) {
|
|
434
434
|
controle = false;
|
|
435
435
|
break;
|
|
436
436
|
}
|
|
@@ -444,8 +444,8 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
444
444
|
const { condicaoSe, simboloSe } = this.consomeSe();
|
|
445
445
|
const caminhoEntão = this.resolveCaminhoSe();
|
|
446
446
|
const caminhoSeSenao = [];
|
|
447
|
-
while (!this.verificarTipoSimboloAtual(
|
|
448
|
-
!this.verificarTipoSimboloAtual(
|
|
447
|
+
while (!this.verificarTipoSimboloAtual(lexico_regular_1.default.BIRL) &&
|
|
448
|
+
!this.verificarTipoSimboloAtual(lexico_regular_1.default.NAO)) {
|
|
449
449
|
const { condicaoSeSenao } = this.consomeSeSenao();
|
|
450
450
|
const caminho = this.resolveCaminhoSe();
|
|
451
451
|
caminhoSeSenao.push({
|
|
@@ -454,28 +454,28 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
454
454
|
});
|
|
455
455
|
}
|
|
456
456
|
let caminhoSenao = null;
|
|
457
|
-
if (this.verificarTipoSimboloAtual(
|
|
457
|
+
if (this.verificarTipoSimboloAtual(lexico_regular_1.default.NAO)) {
|
|
458
458
|
this.consumeSenao();
|
|
459
459
|
const declaraçõesSenao = [];
|
|
460
|
-
while (!this.verificarTipoSimboloAtual(
|
|
460
|
+
while (!this.verificarTipoSimboloAtual(lexico_regular_1.default.BIRL)) {
|
|
461
461
|
declaraçõesSenao.push(this.resolverDeclaracaoForaDeBloco());
|
|
462
462
|
}
|
|
463
463
|
caminhoSenao = new declaracoes_1.Bloco(this.hashArquivo, Number(this.simbolos[this.atual].linha), declaraçõesSenao.filter((d) => d));
|
|
464
464
|
}
|
|
465
|
-
if (this.verificarTipoSimboloAtual(
|
|
466
|
-
this.consumir(
|
|
465
|
+
if (this.verificarTipoSimboloAtual(lexico_regular_1.default.BIRL)) {
|
|
466
|
+
this.consumir(lexico_regular_1.default.BIRL, 'Esperado expressão `BIRL` após `SE`.');
|
|
467
467
|
}
|
|
468
468
|
return new declaracoes_1.Se(condicaoSe, caminhoEntão, caminhoSeSenao, caminhoSenao);
|
|
469
469
|
}
|
|
470
470
|
resolveSimboloInterfaceParaTiposDadosInterface(simbolo) {
|
|
471
471
|
switch (simbolo.tipo) {
|
|
472
|
-
case
|
|
473
|
-
this.verificarSeSimboloAtualEIgualA(
|
|
474
|
-
case
|
|
475
|
-
case
|
|
476
|
-
case
|
|
472
|
+
case lexico_regular_1.default.TRAPEZIO:
|
|
473
|
+
this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.DESCENDENTE);
|
|
474
|
+
case lexico_regular_1.default.MONSTRO:
|
|
475
|
+
case lexico_regular_1.default.MONSTRINHO:
|
|
476
|
+
case lexico_regular_1.default.MONSTRAO:
|
|
477
477
|
return 'numero';
|
|
478
|
-
case
|
|
478
|
+
case lexico_regular_1.default.FRANGO:
|
|
479
479
|
return 'texto';
|
|
480
480
|
default:
|
|
481
481
|
throw new Error('Tipo desconhecido');
|
|
@@ -500,20 +500,20 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
500
500
|
parametro.nome = this.simbolos[this.atual];
|
|
501
501
|
parametros.push(parametro);
|
|
502
502
|
this.avancarEDevolverAnterior();
|
|
503
|
-
if (this.simbolos[this.atual].tipo ===
|
|
503
|
+
if (this.simbolos[this.atual].tipo === lexico_regular_1.default.VIRGULA) {
|
|
504
504
|
this.avancarEDevolverAnterior();
|
|
505
505
|
}
|
|
506
|
-
} while (![
|
|
506
|
+
} while (![lexico_regular_1.default.PARENTESE_DIREITO].includes(this.simbolos[this.atual].tipo));
|
|
507
507
|
return parametros;
|
|
508
508
|
}
|
|
509
509
|
corpoDaFuncao(tipo) {
|
|
510
|
-
const parenteseEsquerdo = this.consumir(
|
|
510
|
+
const parenteseEsquerdo = this.consumir(lexico_regular_1.default.PARENTESE_ESQUERDO, `Esperado '(' após o nome ${tipo}`);
|
|
511
511
|
let paramentros = [];
|
|
512
|
-
if (!this.verificarTipoSimboloAtual(
|
|
512
|
+
if (!this.verificarTipoSimboloAtual(lexico_regular_1.default.PARENTESE_DIREITO)) {
|
|
513
513
|
paramentros = this.logicaComumParamentros();
|
|
514
514
|
}
|
|
515
|
-
this.consumir(
|
|
516
|
-
this.consumir(
|
|
515
|
+
this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
|
|
516
|
+
this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
|
|
517
517
|
let corpo = [];
|
|
518
518
|
do {
|
|
519
519
|
const declaracaoVetor = this.resolverDeclaracaoForaDeBloco();
|
|
@@ -523,132 +523,132 @@ class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintati
|
|
|
523
523
|
else {
|
|
524
524
|
corpo.push(declaracaoVetor);
|
|
525
525
|
}
|
|
526
|
-
} while (![
|
|
526
|
+
} while (![lexico_regular_1.default.BIRL].includes(this.simbolos[this.atual].tipo));
|
|
527
527
|
return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(parenteseEsquerdo.linha), paramentros, corpo.filter((c) => c));
|
|
528
528
|
}
|
|
529
529
|
declacacaoEnquanto() {
|
|
530
|
-
const simboloEnquanto = this.consumir(
|
|
531
|
-
this.consumir(
|
|
532
|
-
this.consumir(
|
|
530
|
+
const simboloEnquanto = this.consumir(lexico_regular_1.default.NEGATIVA, 'Esperado expressão `NEGATIVA`.');
|
|
531
|
+
this.consumir(lexico_regular_1.default.BAMBAM, 'Esperado expressão `BAMBAM` após `NEGATIVA`.');
|
|
532
|
+
this.consumir(lexico_regular_1.default.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após `BAMBAM`.');
|
|
533
533
|
const condicao = this.resolverDeclaracaoForaDeBloco(); // E para ser um binario.
|
|
534
|
-
this.consumir(
|
|
534
|
+
this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, 'Esperado parêntese direito após expressão de condição.');
|
|
535
535
|
const declaracoes = [];
|
|
536
|
-
while (!this.verificarSeSimboloAtualEIgualA(
|
|
536
|
+
while (!this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.BIRL)) {
|
|
537
537
|
declaracoes.push(this.resolverDeclaracaoForaDeBloco());
|
|
538
538
|
}
|
|
539
539
|
return new declaracoes_1.Enquanto(condicao, new declaracoes_1.Bloco(simboloEnquanto.hashArquivo, Number(simboloEnquanto.linha), declaracoes.filter((d) => d)));
|
|
540
540
|
}
|
|
541
541
|
declaracaoSustar() {
|
|
542
|
-
this.consumir(
|
|
543
|
-
this.consumir(
|
|
544
|
-
this.consumir(
|
|
545
|
-
this.consumir(
|
|
546
|
-
this.consumir(
|
|
542
|
+
this.consumir(lexico_regular_1.default.SAI, 'Esperado expressão `SAI`.');
|
|
543
|
+
this.consumir(lexico_regular_1.default.FILHO, 'Esperado expressão `FILHO` após `SAI`.');
|
|
544
|
+
this.consumir(lexico_regular_1.default.DA, 'Esperado expressão `DA` após `FILHO`.');
|
|
545
|
+
this.consumir(lexico_regular_1.default.PUTA, 'Esperado expressão `PUTA` após `DA`.');
|
|
546
|
+
this.consumir(lexico_regular_1.default.PONTO_E_VIRGULA, 'Esperado expressão `PONTO_E_VIRGULA` após `PUTA`.');
|
|
547
547
|
return new declaracoes_1.Sustar(this.simbolos[this.atual - 1]);
|
|
548
548
|
}
|
|
549
549
|
declaracaoContinua() {
|
|
550
|
-
this.consumir(
|
|
551
|
-
this.consumir(
|
|
552
|
-
this.consumir(
|
|
550
|
+
this.consumir(lexico_regular_1.default.VAMO, 'Esperado expressão `VAMO`.');
|
|
551
|
+
this.consumir(lexico_regular_1.default.MONSTRO, 'Esperado expressão `MONSTRO` após `VAMO`.');
|
|
552
|
+
this.consumir(lexico_regular_1.default.PONTO_E_VIRGULA, 'Esperado expressão `PONTO_E_VIRGULA` após `MONSTRO`.');
|
|
553
553
|
return new declaracoes_1.Continua(this.simbolos[this.atual - 1]);
|
|
554
554
|
}
|
|
555
555
|
resolveTipo(tipo) {
|
|
556
556
|
switch (tipo) {
|
|
557
|
-
case
|
|
558
|
-
this.verificarSeSimboloAtualEIgualA(
|
|
559
|
-
case
|
|
560
|
-
case
|
|
561
|
-
case
|
|
562
|
-
case
|
|
563
|
-
case
|
|
557
|
+
case lexico_regular_1.default.TRAPEZIO:
|
|
558
|
+
this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.DESCENDENTE);
|
|
559
|
+
case lexico_regular_1.default.MONSTRAO:
|
|
560
|
+
case lexico_regular_1.default.MONSTRINHO:
|
|
561
|
+
case lexico_regular_1.default.MONSTRO:
|
|
562
|
+
case lexico_regular_1.default.FRANGO:
|
|
563
|
+
case lexico_regular_1.default.BICEPS:
|
|
564
564
|
return this.simbolos[this.atual];
|
|
565
565
|
default:
|
|
566
566
|
throw new Error('Esperado tipo da função');
|
|
567
567
|
}
|
|
568
568
|
}
|
|
569
569
|
funcao(tipo) {
|
|
570
|
-
this.consumir(
|
|
571
|
-
this.consumir(
|
|
572
|
-
this.consumir(
|
|
573
|
-
this.consumir(
|
|
574
|
-
this.consumir(
|
|
575
|
-
this.consumir(
|
|
570
|
+
this.consumir(lexico_regular_1.default.OH, 'Esperado expressão `OH`.');
|
|
571
|
+
this.consumir(lexico_regular_1.default.O, 'Esperado expressão `O` após `OH`.');
|
|
572
|
+
this.consumir(lexico_regular_1.default.HOME, 'Esperado expressão `HOME` após `O`.');
|
|
573
|
+
this.consumir(lexico_regular_1.default.AI, 'Esperado expressão `AI` após `HOME`.');
|
|
574
|
+
this.consumir(lexico_regular_1.default.PO, 'Esperado expressão `PO` após `AI`.');
|
|
575
|
+
this.consumir(lexico_regular_1.default.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após `PO`.');
|
|
576
576
|
let tipoRetorno = this.resolveTipo(this.simbolos[this.atual].tipo);
|
|
577
577
|
this.avancarEDevolverAnterior();
|
|
578
|
-
const nomeFuncao = this.consumir(
|
|
578
|
+
const nomeFuncao = this.consumir(lexico_regular_1.default.IDENTIFICADOR, 'Esperado nome da função apos a declaração do tipo.');
|
|
579
579
|
return new declaracoes_1.FuncaoDeclaracao(nomeFuncao, this.corpoDaFuncao(tipo), tipoRetorno);
|
|
580
580
|
}
|
|
581
581
|
declaracaoChamaFuncao() {
|
|
582
|
-
const declaracaoInicio = this.consumir(
|
|
583
|
-
this.consumir(
|
|
584
|
-
this.consumir(
|
|
585
|
-
this.consumir(
|
|
586
|
-
this.consumir(
|
|
582
|
+
const declaracaoInicio = this.consumir(lexico_regular_1.default.AJUDA, 'Esperado expressão `AJUDA`.');
|
|
583
|
+
this.consumir(lexico_regular_1.default.O, 'Esperado expressão `O` após `AJUDA`.');
|
|
584
|
+
this.consumir(lexico_regular_1.default.MALUCO, 'Esperado expressão `MALUCO` após `O`.');
|
|
585
|
+
this.consumir(lexico_regular_1.default.TA, 'Esperado expressão `TA` após `MALUCO`.');
|
|
586
|
+
this.consumir(lexico_regular_1.default.DOENTE, 'Esperado expressão `DOENTE` após `TA`.');
|
|
587
587
|
let expressao = this.primario();
|
|
588
|
-
this.consumir(
|
|
588
|
+
this.consumir(lexico_regular_1.default.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após `DOENTE`.');
|
|
589
589
|
const paramentros = [];
|
|
590
|
-
while (!this.verificarTipoSimboloAtual(
|
|
590
|
+
while (!this.verificarTipoSimboloAtual(lexico_regular_1.default.PARENTESE_DIREITO)) {
|
|
591
591
|
paramentros.push(this.resolverDeclaracaoForaDeBloco());
|
|
592
|
-
if (this.verificarTipoSimboloAtual(
|
|
592
|
+
if (this.verificarTipoSimboloAtual(lexico_regular_1.default.VIRGULA)) {
|
|
593
593
|
this.avancarEDevolverAnterior();
|
|
594
594
|
}
|
|
595
595
|
}
|
|
596
|
-
this.consumir(
|
|
597
|
-
this.consumir(
|
|
596
|
+
this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, 'Esperado parêntese direito após lista de parâmetros.');
|
|
597
|
+
this.consumir(lexico_regular_1.default.PONTO_E_VIRGULA, 'Esperado ponto e vírgula após a chamada de função.');
|
|
598
598
|
return new construtos_1.Chamada(declaracaoInicio.hashArquivo, expressao, null, paramentros);
|
|
599
599
|
}
|
|
600
600
|
resolverDeclaracaoForaDeBloco() {
|
|
601
601
|
const simboloAtual = this.simbolos[this.atual];
|
|
602
602
|
switch (simboloAtual.tipo) {
|
|
603
|
-
case
|
|
604
|
-
case
|
|
603
|
+
case lexico_regular_1.default.INCREMENTAR:
|
|
604
|
+
case lexico_regular_1.default.DECREMENTAR:
|
|
605
605
|
let adicionaOuSubtrai;
|
|
606
|
-
if ([
|
|
607
|
-
adicionaOuSubtrai = this.consumir(
|
|
606
|
+
if ([lexico_regular_1.default.INCREMENTAR, lexico_regular_1.default.DECREMENTAR].includes(simboloAtual.tipo)) {
|
|
607
|
+
adicionaOuSubtrai = this.consumir(lexico_regular_1.default[simboloAtual.tipo], 'Esperado expressão `INCREMENTAR` ou `DECREMENTAR`.');
|
|
608
608
|
}
|
|
609
|
-
if (this.verificarTipoSimboloAtual(
|
|
610
|
-
const identificador = this.consumir(
|
|
609
|
+
if (this.verificarTipoSimboloAtual(lexico_regular_1.default.IDENTIFICADOR)) {
|
|
610
|
+
const identificador = this.consumir(lexico_regular_1.default.IDENTIFICADOR, 'Esperado expressão `IDENTIFICADOR`.');
|
|
611
611
|
return new construtos_1.Unario(this.hashArquivo, adicionaOuSubtrai, new construtos_1.Variavel(this.hashArquivo, identificador), 'ANTES');
|
|
612
612
|
}
|
|
613
613
|
return;
|
|
614
|
-
case
|
|
614
|
+
case lexico_regular_1.default.BORA:
|
|
615
615
|
return this.declaracaoRetorna();
|
|
616
|
-
case
|
|
616
|
+
case lexico_regular_1.default.SAI:
|
|
617
617
|
return this.declaracaoSustar();
|
|
618
|
-
case
|
|
618
|
+
case lexico_regular_1.default.VAMO:
|
|
619
619
|
return this.declaracaoContinua();
|
|
620
|
-
case
|
|
620
|
+
case lexico_regular_1.default.QUE:
|
|
621
621
|
return this.declaracaoLeia();
|
|
622
|
-
case
|
|
622
|
+
case lexico_regular_1.default.ELE:
|
|
623
623
|
return this.declaracaoSe();
|
|
624
|
-
case
|
|
624
|
+
case lexico_regular_1.default.NEGATIVA:
|
|
625
625
|
return this.declacacaoEnquanto();
|
|
626
|
-
case
|
|
626
|
+
case lexico_regular_1.default.MAIS:
|
|
627
627
|
return this.declaracaoPara();
|
|
628
|
-
case
|
|
629
|
-
case
|
|
630
|
-
case
|
|
628
|
+
case lexico_regular_1.default.MONSTRO:
|
|
629
|
+
case lexico_regular_1.default.MONSTRINHO:
|
|
630
|
+
case lexico_regular_1.default.MONSTRAO:
|
|
631
631
|
return this.declaracaoInteiros();
|
|
632
|
-
case
|
|
633
|
-
case
|
|
632
|
+
case lexico_regular_1.default.BICEPS:
|
|
633
|
+
case lexico_regular_1.default.FRANGO:
|
|
634
634
|
return this.declaracaoCaracteres();
|
|
635
|
-
case
|
|
635
|
+
case lexico_regular_1.default.TRAPEZIO:
|
|
636
636
|
return this.declaracaoPontoFlutuante();
|
|
637
|
-
case
|
|
637
|
+
case lexico_regular_1.default.OH:
|
|
638
638
|
return this.funcao('funcao');
|
|
639
|
-
case
|
|
639
|
+
case lexico_regular_1.default.AJUDA:
|
|
640
640
|
return this.declaracaoChamaFuncao();
|
|
641
|
-
case
|
|
641
|
+
case lexico_regular_1.default.CE:
|
|
642
642
|
return this.declaracaoEscreva();
|
|
643
|
-
case
|
|
644
|
-
case
|
|
645
|
-
case
|
|
643
|
+
case lexico_regular_1.default.PONTO_E_VIRGULA:
|
|
644
|
+
case lexico_regular_1.default.QUEBRA_LINHA:
|
|
645
|
+
case lexico_regular_1.default.BIRL:
|
|
646
646
|
this.avancarEDevolverAnterior();
|
|
647
647
|
return null;
|
|
648
|
-
case
|
|
648
|
+
case lexico_regular_1.default.IDENTIFICADOR:
|
|
649
649
|
const simboloIdentificador = this.simbolos[this.atual];
|
|
650
650
|
if (this.simbolos[this.atual + 1] &&
|
|
651
|
-
[
|
|
651
|
+
[lexico_regular_1.default.DECREMENTAR, lexico_regular_1.default.INCREMENTAR].includes(this.simbolos[this.atual + 1].tipo)) {
|
|
652
652
|
this.avancarEDevolverAnterior();
|
|
653
653
|
const simboloIncrementoDecremento = this.avancarEDevolverAnterior();
|
|
654
654
|
return new construtos_1.Unario(this.hashArquivo, simboloIncrementoDecremento, new construtos_1.Variavel(this.hashArquivo, simboloIdentificador), 'DEPOIS');
|