@designliquido/foles
Version:
Linguagem de folhas de estilo para documentos em geral em português
1,503 lines • 90.3 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AvaliadorSintatico = void 0;
const _1 = require(".");
const declaracoes_1 = require("../declaracoes");
const superclasse_1 = require("../modificadores/superclasse");
const valores_1 = require("../valores");
const seletor_valor_1 = require("../valores/seletor-valor");
const foles_1 = __importDefault(require("../tipos-de-simbolos/foles"));
const seletor_pseudoclasse_1 = require("../pseudoclasses/seletor-pseudoclasse");
const seletores_1 = require("../seletores");
const seletor_estruturas_lmht_1 = require("../estruturas/seletor-estruturas-lmht");
const seletor_espaco_reservado_1 = require("../seletores/seletor-espaco-reservado");
const valores_numericos_1 = require("../listas/valores-numericos");
const declaracao_variavel_1 = require("../declaracoes/declaracao-variavel");
const referencia_variavel_1 = require("../valores/referencia-variavel");
const gerais_1 = require("../modificadores/atributos/gerais");
const valores_personalizados_1 = require("../listas/valores-personalizados");
/**
* Implementação do avaliador sintático.
*/
class AvaliadorSintatico {
constructor(importador) {
this.referenciaDeclaracoes = [];
this.importador = importador;
this.simbolos = [];
}
erro(simbolo, mensagemDeErro) {
const excecao = new _1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
this.erros.push(excecao);
return excecao;
}
sincronizar() {
while (!this.estaNoFinal()) {
const tipo = this.simbolos[this.atual].tipo;
if (tipo === foles_1.default.CHAVE_DIREITA) {
this.avancarEDevolverAnterior();
return;
}
this.avancarEDevolverAnterior();
}
}
estaNoFinal() {
return this.atual === this.simbolos.length;
}
avancarEDevolverAnterior() {
if (!this.estaNoFinal())
this.atual += 1;
return this.simbolos[this.atual - 1];
}
verificarTipoSimboloAtual(tipo) {
if (this.estaNoFinal())
return false;
return this.simbolos[this.atual].tipo === tipo;
}
consumir(tipo, mensagemDeErro) {
if (this.verificarTipoSimboloAtual(tipo))
return this.avancarEDevolverAnterior();
throw this.erro(this.simbolos[this.atual], mensagemDeErro);
}
resolverMetodo(lexema) {
switch (lexema) {
case "#":
let codigoHex;
if (this.verificarTipoSimboloAtual(foles_1.default.NUMERO)) {
const numParteHex = this.avancarEDevolverAnterior();
codigoHex = numParteHex.lexema;
if (this.verificarTipoSimboloAtual(foles_1.default.IDENTIFICADOR)) {
const alphaParteHex = this.avancarEDevolverAnterior();
codigoHex += alphaParteHex.lexema;
}
}
else {
const hexSimbolo = this.consumir(foles_1.default.IDENTIFICADOR, "Esperado código HEX válido após #'.");
codigoHex = hexSimbolo.lexema;
}
return new seletor_valor_1.SeletorValor("hex", [codigoHex]);
case "anotacao":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'anotação'.");
const valorAnotacao = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método anotação.");
return new seletor_valor_1.SeletorValor(lexema, [valorAnotacao]);
case "anotação":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'anotação'.");
const valorAnotaçao = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método anotação.");
return new seletor_valor_1.SeletorValor(lexema, [valorAnotaçao]);
case "borrar":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'borrar'.");
const valorBorrar = this.avancarEDevolverAnterior();
let quantificadorBorrar;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorBorrar = this.avancarEDevolverAnterior();
}
else {
quantificadorBorrar = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'borrar'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorBorrar,
quantificadorBorrar,
]);
case "brilho":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'brilho'.");
const valorBrilho = this.avancarEDevolverAnterior();
let quantificadorBrilho;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorBrilho = this.avancarEDevolverAnterior();
}
else {
quantificadorBrilho = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'brilho'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorBrilho,
quantificadorBrilho,
]);
case "calcular":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'calcular'.");
const valorCalc1 = this.avancarEDevolverAnterior();
const quantificadorCalc1 = this.avancarEDevolverAnterior();
const operadorCalc = this.avancarEDevolverAnterior();
const valorCalc2 = this.avancarEDevolverAnterior();
const quantificadorCalc2 = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'calcular'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorCalc1,
quantificadorCalc1,
operadorCalc,
valorCalc2,
quantificadorCalc2,
]);
case "circular":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'circular'.");
const arrayValoresCircular = [];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoSimboloCircular = this.avancarEDevolverAnterior();
arrayValoresCircular.push(proximoSimboloCircular);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'circular'.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresCircular]);
case "configurar-imagem":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'configurar-imagem'.");
const arrayImagem = [];
while (this.simbolos[this.atual].tipo !== 'PONTO_E_VIRGULA') {
const proximoValorImagem = this.avancarEDevolverAnterior();
arrayImagem.push(proximoValorImagem);
}
return new seletor_valor_1.SeletorValor(lexema, [arrayImagem]);
case "conjunto-estilos":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'conjunto-estilos'.");
const valor1ConjuntoEstilos = this.avancarEDevolverAnterior();
let valor2ConjuntoEstilos;
if (this.simbolos[this.atual].tipo === "VIRGULA") {
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método conjunto-estilos.");
valor2ConjuntoEstilos = this.avancarEDevolverAnterior();
}
let valor3ConjuntoEstilos;
if (this.simbolos[this.atual].tipo === "VIRGULA") {
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método conjunto-estilos.");
valor3ConjuntoEstilos = this.avancarEDevolverAnterior();
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método conjunto-estilos.");
return new seletor_valor_1.SeletorValor(lexema, [valor1ConjuntoEstilos, valor2ConjuntoEstilos, valor3ConjuntoEstilos]);
case "contador":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'contador'.");
const nomeContador = this.avancarEDevolverAnterior();
let estiloContador = null;
if (this.simbolos[this.atual].tipo === 'VIRGULA') {
this.consumir(foles_1.default.VIRGULA, "Esperada vírgula após primeiro parâmetro do método 'contador'.");
estiloContador = this.avancarEDevolverAnterior();
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'contador'.");
return new seletor_valor_1.SeletorValor(lexema, [
nomeContador,
estiloContador,
]);
case "contraste":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'contraste'.");
const valorContraste = this.avancarEDevolverAnterior();
let quantificadorContraste;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorContraste = this.avancarEDevolverAnterior();
}
else {
quantificadorContraste = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'contraste'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorContraste,
quantificadorContraste,
]);
case "curva-cúbica":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'curva-cúbica'.");
const parametro1 = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método curva-cúbica.");
const parametro2 = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método curva-cúbica.");
const parametro3 = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após terceiro argumento do método curva-cúbica.");
const parametro4 = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após quarto argumento do método curva-cúbica.");
return new seletor_valor_1.SeletorValor(lexema, [
parametro1,
parametro2,
parametro3,
parametro4,
]);
case "curva-cubica":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'curva-cúbica'.");
const parametro1cc = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método curva-cúbica.");
const parametro2cc = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método curva-cúbica.");
const parametro3cc = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após terceiro argumento do método curva-cúbica.");
const parametro4cc = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após quarto argumento do método curva-cúbica.");
return new seletor_valor_1.SeletorValor(lexema, [
parametro1cc,
parametro2cc,
parametro3cc,
parametro4cc,
]);
case "definir-caminho":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'definir-caminho'.");
const proporcaoCaminho = this.avancarEDevolverAnterior();
let matrizCaminho = null;
if (this.simbolos[this.atual].tipo === 'TEXTO') {
matrizCaminho = this.avancarEDevolverAnterior();
}
const arrayValoresCaminho = [proporcaoCaminho];
if (matrizCaminho !== null) {
arrayValoresCaminho.push(matrizCaminho);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método 'definir-caminho'.");
return new seletor_valor_1.SeletorValor(lexema, arrayValoresCaminho);
case "definir-imagem":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'definir-imagem'.");
const linkImagem = this.avancarEDevolverAnterior();
const tamanhoImagem = this.avancarEDevolverAnterior();
const proporcaoImagem = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método 'definir-imagem'.");
return new seletor_valor_1.SeletorValor(lexema, [linkImagem, tamanhoImagem, proporcaoImagem]);
case "elemento":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'elemento'.");
const simboloElemento = this.avancarEDevolverAnterior();
const referenciaElemento = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'elemento'.");
return new seletor_valor_1.SeletorValor(lexema, [simboloElemento, referenciaElemento]);
case "elipse":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'elipse'.");
const arrayValoresElipse = [];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorElipse = this.avancarEDevolverAnterior();
arrayValoresElipse.push(proximoValorElipse);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método 'elipse'.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresElipse]);
case "encaixar-conteudo":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'encaixar-conteúdo'.");
const valorFit = this.avancarEDevolverAnterior();
const quantificadorFit = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método encaixar-conteúdo.");
return new seletor_valor_1.SeletorValor(lexema, [
valorFit["lexema"],
quantificadorFit["lexema"],
]);
case "encaixar-conteúdo":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'encaixar-conteúdo'.");
const valorFit1 = this.avancarEDevolverAnterior();
const quantificadorFit1 = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método encaixar-conteúdo.");
return new seletor_valor_1.SeletorValor(lexema, [
valorFit1["lexema"],
quantificadorFit1["lexema"],
]);
case "escala-cinza":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'escala-cinza'.");
const valorEscala = this.avancarEDevolverAnterior();
let quantificadorEscala;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorEscala = this.avancarEDevolverAnterior();
}
else {
quantificadorEscala = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'escala-cinza'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorEscala,
quantificadorEscala,
]);
case "escalamento":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'escalamento'.");
const valorScale1 = this.avancarEDevolverAnterior();
let valorScale2;
if (this.simbolos[this.atual].tipo === "VIRGULA") {
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método escalamento.");
valorScale2 = this.avancarEDevolverAnterior();
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método escalamento.");
return new seletor_valor_1.SeletorValor(lexema, [valorScale1, valorScale2]);
case "escalamento-3d":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'escalamento-3d'.");
const valorScale3d1 = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método escalamento-3d.");
const valorScale3d2 = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método escalamento-3d.");
const valorScale3d3 = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método escalamento-3d.");
return new seletor_valor_1.SeletorValor(lexema, [
valorScale3d1,
valorScale3d2,
valorScale3d3,
]);
case "escalamento-eixo-z":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'escalamento-eixo-z'.");
const valorScaleZ = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método escalamento-eixo-z.");
return new seletor_valor_1.SeletorValor(lexema, [valorScaleZ]);
case "escalamento-horizontal":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'escalamento-horizontal'.");
const valorScaleX = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método escalamento-horizontal.");
return new seletor_valor_1.SeletorValor(lexema, [valorScaleX]);
case "escalamento-vertical":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'escalamento-vertical'.");
const valorScaleY = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método escalamento-vertical.");
return new seletor_valor_1.SeletorValor(lexema, [valorScaleY]);
case "espirrar":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'espirrar'.");
const valorEspirrar = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método espirrar.");
return new seletor_valor_1.SeletorValor(lexema, [valorEspirrar]);
case "estilistico":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'estilístico'.");
const valorEstilistico = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método estilístico.");
return new seletor_valor_1.SeletorValor(lexema, [valorEstilistico]);
case "estilístico":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'estilístico'.");
const valorEstilistico1 = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método estilístico.");
return new seletor_valor_1.SeletorValor(lexema, [valorEstilistico1]);
case "formato":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'formato'.");
const arrayFormato = [];
while (this.simbolos[this.atual].tipo !== 'PONTO_E_VIRGULA') {
const proximoValorFormato = this.avancarEDevolverAnterior();
arrayFormato.push(proximoValorFormato);
}
return new seletor_valor_1.SeletorValor(lexema, [arrayFormato]);
case "gradiente-conico":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'gradiente-conico'.");
const arrayGradienteConico = [];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorGradienteConico = this.avancarEDevolverAnterior();
arrayGradienteConico.push(proximoValorGradienteConico);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método 'gradiente-conico'.");
return new seletor_valor_1.SeletorValor(lexema, [arrayGradienteConico]);
case "gradiente-cônico":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'gradiente-cônico'.");
const arrayGradienteConico1 = [];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorGradienteConico1 = this.avancarEDevolverAnterior();
arrayGradienteConico1.push(proximoValorGradienteConico1);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método 'gradiente-cônico'.");
return new seletor_valor_1.SeletorValor(lexema, [arrayGradienteConico1]);
case "gradiente-linear":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'gradiente-linear'.");
const primeiroTokenGradienteLinear = this.avancarEDevolverAnterior();
const arrayValoresGradienteLinear = [primeiroTokenGradienteLinear];
while (this.simbolos[this.atual].tipo !== foles_1.default.PARENTESE_DIREITO) {
arrayValoresGradienteLinear.push(this.avancarEDevolverAnterior());
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'gradiente-linear'.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresGradienteLinear]);
case "gradiente-radial":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'gradiente-radial'.");
const parametroGradienteRadial = this.avancarEDevolverAnterior();
const arrayValoresGradienteRadial = [parametroGradienteRadial];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorGradienteRadial = this.avancarEDevolverAnterior();
arrayValoresGradienteRadial.push(proximoValorGradienteRadial);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método 'gradiente-radial'.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresGradienteRadial]);
case "hsl":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'hsl'.");
const HdeHSL = this.avancarEDevolverAnterior();
const SdeHSL = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.QUANTIFICADOR, "Esperado símbolo percentual após argumento de saturação (S) no método 'hsl'.");
const LdeHSL = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.QUANTIFICADOR, "Esperado símbolo percentual após argumento de luminosidade (L) no método 'hsl'.");
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'hsl'.");
return new seletor_valor_1.SeletorValor(lexema, [HdeHSL, SdeHSL, LdeHSL]);
case "hsla":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'hsla'.");
const HdeHSLA = this.avancarEDevolverAnterior();
const SdeHSLA = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.QUANTIFICADOR, "Esperado símbolo percentual após argumento de saturação (S) no método 'hsla'.");
const LdeHSLA = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.QUANTIFICADOR, "Esperado símbolo percentual após argumento de luminosidade (L) no método 'hsla'.");
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'hsla'.");
return new seletor_valor_1.SeletorValor(lexema, [HdeHSLA, SdeHSLA, LdeHSLA]);
case "inclinar":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'inclinar'.");
const valorInclinar1 = this.avancarEDevolverAnterior();
let quantificadorInclinar1;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorInclinar1 = this.avancarEDevolverAnterior();
}
else {
quantificadorInclinar1 = null;
}
let valorInclinar2;
let quantificadorInclinar2;
if (this.simbolos[this.atual].tipo === "VIRGULA") {
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'inclinar'.");
valorInclinar2 = this.avancarEDevolverAnterior();
quantificadorInclinar2 = this.avancarEDevolverAnterior();
}
else {
valorInclinar2 = null;
quantificadorInclinar2 = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'inclinar'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorInclinar1,
quantificadorInclinar1,
valorInclinar2,
quantificadorInclinar2,
]);
case "inclinar-horizontal":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'inclinar-horizontal'.");
const valorInclinarX = this.avancarEDevolverAnterior();
let quantificadorInclinarX;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorInclinarX = this.avancarEDevolverAnterior();
}
else {
quantificadorInclinarX = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'inclinar-horizontal'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorInclinarX,
quantificadorInclinarX,
]);
case "inclinar-vertical":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'inclinar-vertical'.");
const valorInclinarY = this.avancarEDevolverAnterior();
let quantificadorInclinarY;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorInclinarY = this.avancarEDevolverAnterior();
}
else {
quantificadorInclinarY = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'inclinar-vertical'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorInclinarY,
quantificadorInclinarY,
]);
case "inserir":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'inserir'.");
const valorInserir1 = this.avancarEDevolverAnterior();
const quantificadorInserir1 = this.avancarEDevolverAnterior();
const arrayValoresInserir = [valorInserir1, quantificadorInserir1];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorInserir = this.avancarEDevolverAnterior();
arrayValoresInserir.push(proximoValorInserir);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método inserir.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresInserir]);
case "inverter":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'inverter'.");
const valorInverter = this.avancarEDevolverAnterior();
let quantificadorInverter;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorInverter = this.avancarEDevolverAnterior();
}
else {
quantificadorInverter = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'inverter'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorInverter,
quantificadorInverter,
]);
case "limitar":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'limitar'.");
const valorMin = this.avancarEDevolverAnterior();
const quantificadorMin = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'limitar'.");
const valorMed = this.avancarEDevolverAnterior();
const quantificadorMed = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método 'limitar'.");
const valorMax = this.avancarEDevolverAnterior();
const quantificadorMax = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método limitar.");
return new seletor_valor_1.SeletorValor(lexema, [
valorMin,
quantificadorMin,
valorMed,
quantificadorMed,
valorMax,
quantificadorMax,
]);
case "linear":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'linear'.");
const valor1 = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método linear.");
const valor2 = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após segundo argumento do método linear.");
const valor3 = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após terceiro argumento do método linear.");
return new seletor_valor_1.SeletorValor(lexema, [valor1, valor2, valor3]);
case "minmax":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'minmax'.");
const valor01 = this.avancarEDevolverAnterior();
let parametro01 = null;
if (Number(valor01["lexema"])) {
const quantificador01 = this.avancarEDevolverAnterior();
parametro01 = `${valor01["lexema"]}${quantificador01["lexema"]}`;
}
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método minmax.");
const valor02 = this.avancarEDevolverAnterior();
let parametro02 = null;
if (Number(valor02["lexema"])) {
const quantificador02 = this.avancarEDevolverAnterior();
parametro02 = `${valor02["lexema"]}${quantificador02["lexema"]}`;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método minmax.");
if (parametro01 !== null) {
return new seletor_valor_1.SeletorValor(lexema, [
parametro01,
valor02["lexema"],
]);
}
if (parametro02 !== null) {
return new seletor_valor_1.SeletorValor(lexema, [
valor01["lexema"],
parametro02,
]);
}
case "opacar":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'opacar'.");
const valorOpaco = this.avancarEDevolverAnterior();
let quantificadorOpaco;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorOpaco = this.avancarEDevolverAnterior();
}
else {
quantificadorOpaco = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'opacar'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorOpaco,
quantificadorOpaco,
]);
case "ornamentos":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'ornamentos'.");
const valorOrnamentos = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método ornamentos.");
return new seletor_valor_1.SeletorValor(lexema, [valorOrnamentos]);
case "passos":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'passos'.");
const valorNumerico = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método passos.");
const termoSalto = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após segundo argumento do método passos.");
return new seletor_valor_1.SeletorValor(lexema, [valorNumerico, termoSalto]);
case "perspectivar":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'perspectivar'.");
const valorPerspectivar = this.avancarEDevolverAnterior();
let quantificadorPerspectivar;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorPerspectivar = this.avancarEDevolverAnterior();
}
else {
quantificadorPerspectivar = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'perspectivar'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorPerspectivar,
quantificadorPerspectivar,
]);
case "pintura":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'pintura'.");
const referenciaPintura = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'pintura'.");
return new seletor_valor_1.SeletorValor(lexema, [referenciaPintura]);
case "poligono":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'poligono'.");
const valorPoligono = this.avancarEDevolverAnterior();
const quantificadorPoligono = this.avancarEDevolverAnterior();
const arrayValoresPoligono = [valorPoligono, quantificadorPoligono];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorPoligono = this.avancarEDevolverAnterior();
arrayValoresPoligono.push(proximoValorPoligono);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método 'poligono'.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresPoligono]);
case "polígono":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'polígono'.");
const valorPoligono1 = this.avancarEDevolverAnterior();
const quantificadorPoligono1 = this.avancarEDevolverAnterior();
const arrayValoresPoligono1 = [valorPoligono1, quantificadorPoligono1];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorPoligono1 = this.avancarEDevolverAnterior();
arrayValoresPoligono1.push(proximoValorPoligono1);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método 'polígono'.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresPoligono1]);
case "projetar-sombra":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'projetar-sombra'.");
let corSombra = null;
if (this.simbolos[this.atual].tipo === "QUALITATIVO") {
corSombra = this.avancarEDevolverAnterior();
}
const valorSombra1 = this.avancarEDevolverAnterior();
const quantificadorSombra1 = this.avancarEDevolverAnterior();
const valorSombra2 = this.avancarEDevolverAnterior();
const quantificadorSombra2 = this.avancarEDevolverAnterior();
let valorSombra3;
let quantificadorSombra3;
if (this.simbolos[this.atual].tipo === "NUMERO") {
valorSombra3 = this.avancarEDevolverAnterior();
quantificadorSombra3 = this.avancarEDevolverAnterior();
}
else {
valorSombra3 = null;
quantificadorSombra3 = null;
}
if (this.simbolos[this.atual].tipo === "QUALITATIVO") {
corSombra = this.avancarEDevolverAnterior();
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'projetar-sombra'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorSombra1,
quantificadorSombra1,
valorSombra2,
quantificadorSombra2,
valorSombra3,
quantificadorSombra3,
corSombra,
]);
case "raio":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'raio'.");
let posicaoRaio;
if (this.simbolos[this.atual].tipo === "QUALITATIVO") {
posicaoRaio = this.avancarEDevolverAnterior();
}
else {
posicaoRaio = null;
}
const numeroRaio = this.avancarEDevolverAnterior();
const quantificadorRaio = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'raio'.");
return new seletor_valor_1.SeletorValor(lexema, [
posicaoRaio,
numeroRaio,
quantificadorRaio,
]);
case "repetir-gradiente-conico":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'repetir-gradiente-conico'.");
const arrayValoresConico = [];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorConico = this.avancarEDevolverAnterior();
arrayValoresConico.push(proximoValorConico);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método 'repetir-gradiente-conico'.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresConico]);
case "repetir-gradiente-cônico":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'repetir-gradiente-cônico'.");
const arrayValoresConico1 = [];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorConico1 = this.avancarEDevolverAnterior();
arrayValoresConico1.push(proximoValorConico1);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método 'repetir-gradiente-cônico'.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresConico1]);
case "repetir-gradiente-linear":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'repetir-gradiente-linear'.");
const parametroLinear = this.avancarEDevolverAnterior();
const arrayValoresLinear = [parametroLinear];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorLinear = this.avancarEDevolverAnterior();
arrayValoresLinear.push(proximoValorLinear);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método 'repetir-gradiente-radial'.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresLinear]);
case "repetir-gradiente-radial":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'repetir-gradiente-radial'.");
const parametroRadial = this.avancarEDevolverAnterior();
const arrayValoresRadial = [parametroRadial];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorRadial = this.avancarEDevolverAnterior();
arrayValoresRadial.push(proximoValorRadial);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método 'repetir-gradiente-radial'.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresRadial]);
case "retangulo":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'retangulo'.");
const valorRect1 = this.avancarEDevolverAnterior();
const quantificadorRect1 = this.avancarEDevolverAnterior();
const arrayValoresRect = [valorRect1, quantificadorRect1];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorRect = this.avancarEDevolverAnterior();
arrayValoresRect.push(proximoValorRect);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método retangulo.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresRect]);
case "retângulo":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'retangulo'.");
const valorRecta1 = this.avancarEDevolverAnterior();
const quantificadorRecta1 = this.avancarEDevolverAnterior();
const arrayValoresRecta = [valorRecta1, quantificadorRecta1];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorRecta = this.avancarEDevolverAnterior();
arrayValoresRecta.push(proximoValorRecta);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método retangulo.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresRecta]);
case "rgb":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rgb'.");
const vermelho = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após argumento de cor vermelha.");
const verde = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após argumento de cor verde.");
const azul = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'rgb'.");
return new seletor_valor_1.SeletorValor(lexema, [vermelho, verde, azul]);
case "rgba":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rgba'.");
const vermelhoRgba = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após argumento de cor vermelha.");
const verdeRgba = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após argumento de cor verde.");
const azulRgba = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumentos de método 'rgba'.");
return new seletor_valor_1.SeletorValor(lexema, [
vermelhoRgba,
verdeRgba,
azulRgba,
]);
case "rotacionar":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotacionar'.");
const valorRotacionar = this.avancarEDevolverAnterior();
let quantificadorRotacionar;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorRotacionar = this.avancarEDevolverAnterior();
}
else {
quantificadorRotacionar = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotacionar'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorRotacionar,
quantificadorRotacionar,
]);
case "rotacionar-3d":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotacionar-3d'.");
const valor1Rotacionar3d = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperada vírgula após primeiro parâmetro do método 'rotacionar-3d'.");
const valor2Rotacionar3d = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperada vírgula após segundo parâmetro do método 'rotacionar-3d'.");
const valor3Rotacionar3d = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.VIRGULA, "Esperada vírgula após terceiro parâmetro do método 'rotacionar-3d'.");
const valor4Rotacionar3d = this.avancarEDevolverAnterior();
let quantificadorRotacionar3d;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorRotacionar3d = this.avancarEDevolverAnterior();
}
else {
quantificadorRotacionar3d = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotacionar-3d'.");
return new seletor_valor_1.SeletorValor(lexema, [
valor1Rotacionar3d,
valor2Rotacionar3d,
valor3Rotacionar3d,
valor4Rotacionar3d,
quantificadorRotacionar3d,
]);
case "rotacionar-eixo-z":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotacionar-eixo-z'.");
const valorRotacionarZ = this.avancarEDevolverAnterior();
let quantificadorRotacionarZ;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorRotacionarZ = this.avancarEDevolverAnterior();
}
else {
quantificadorRotacionarZ = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotacionar-eixo-z'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorRotacionarZ,
quantificadorRotacionarZ,
]);
case "rotacionar-horizontal":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotacionar-horizontal'.");
const valorRotacionarX = this.avancarEDevolverAnterior();
let quantificadorRotacionarX;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorRotacionarX = this.avancarEDevolverAnterior();
}
else {
quantificadorRotacionarX = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotacionar-horizontal'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorRotacionarX,
quantificadorRotacionarX,
]);
case "rotacionar-matiz":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotacionar-matiz'.");
const valorRotacao = this.avancarEDevolverAnterior();
let quantificadorRotacao;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorRotacao = this.avancarEDevolverAnterior();
}
else {
quantificadorRotacao = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotacionar-matiz'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorRotacao,
quantificadorRotacao,
]);
case "rotacionar-vertical":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'rotacionar-vertical'.");
const valorRotacionarY = this.avancarEDevolverAnterior();
let quantificadorRotacionarY;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorRotacionarY = this.avancarEDevolverAnterior();
}
else {
quantificadorRotacionarY = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'rotacionar-vertical'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorRotacionarY,
quantificadorRotacionarY,
]);
case "saturar":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'saturar'.");
const valorSaturar = this.avancarEDevolverAnterior();
let quantificadorSaturar;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorSaturar = this.avancarEDevolverAnterior();
}
else {
quantificadorSaturar = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'saturar'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorSaturar,
quantificadorSaturar,
]);
case "sepia":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'sepia'.");
const valorSepia = this.avancarEDevolverAnterior();
let quantificadorSepia;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorSepia = this.avancarEDevolverAnterior();
}
else {
quantificadorSepia = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'sepia'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorSepia,
quantificadorSepia,
]);
case "sépia":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'sépia'.");
const valorSépia = this.avancarEDevolverAnterior();
let quantificadorSépia;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorSépia = this.avancarEDevolverAnterior();
}
else {
quantificadorSépia = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'sépia'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorSépia,
quantificadorSépia,
]);
case "transicao-gradual":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'transicao-gradual'.");
const arrayGradienteTransicao = [];
while (this.simbolos[this.atual].tipo !== 'PONTO_E_VIRGULA') {
const proximoValorTransicao = this.avancarEDevolverAnterior();
arrayGradienteTransicao.push(proximoValorTransicao);
}
return new seletor_valor_1.SeletorValor(lexema, [arrayGradienteTransicao]);
case "transição-gradual":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'transição-gradual'.");
const arrayGradienteTransicao1 = [];
while (this.simbolos[this.atual].tipo !== 'PONTO_E_VIRGULA') {
const proximoValorTransicao1 = this.avancarEDevolverAnterior();
arrayGradienteTransicao1.push(proximoValorTransicao1);
}
return new seletor_valor_1.SeletorValor(lexema, [arrayGradienteTransicao1]);
case "translação":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação'.");
const valorTranslacao1 = this.avancarEDevolverAnterior();
let quantificadorTranslacao1;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranslacao1 = this.avancarEDevolverAnterior();
}
else {
quantificadorTranslacao1 = null;
}
let valorTranslacao2;
let quantificadorTranslacao2;
if (this.simbolos[this.atual].tipo === "VIRGULA") {
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translação'.");
valorTranslacao2 = this.avancarEDevolverAnterior();
quantificadorTranslacao2 = this.avancarEDevolverAnterior();
}
else {
valorTranslacao2 = null;
quantificadorTranslacao2 = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorTranslacao1,
quantificadorTranslacao1,
valorTranslacao2,
quantificadorTranslacao2,
]);
case "translacao":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação'.");
const valorTranslacao01 = this.avancarEDevolverAnterior();
let quantificadorTranlacao01;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranlacao01 = this.avancarEDevolverAnterior();
}
else {
quantificadorTranlacao01 = null;
}
let valorTranslacao02;
let quantificadorTranlacao02;
if (this.simbolos[this.atual].tipo === "VIRGULA") {
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translação'.");
valorTranslacao02 = this.avancarEDevolverAnterior();
quantificadorTranlacao02 = this.avancarEDevolverAnterior();
}
else {
valorTranslacao02 = null;
quantificadorTranlacao02 = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorTranslacao01,
quantificadorTranlacao01,
valorTranslacao02,
quantificadorTranlacao02,
]);
case "translação-3d":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-3d'.");
const valorTranslacao3d1 = this.avancarEDevolverAnterior();
let quantificadorTranlacao3d1;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranlacao3d1 = this.avancarEDevolverAnterior();
}
else {
quantificadorTranlacao3d1 = null;
}
let valorTranslacao3d2;
let quantificadorTranlacao3d2;
if (this.simbolos[this.atual].tipo === "VIRGULA") {
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translação-3d'.");
valorTranslacao3d2 = this.avancarEDevolverAnterior();
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranlacao3d2 =
this.avancarEDevolverAnterior();
}
else {
quantificadorTranlacao3d2 = null;
}
}
else {
valorTranslacao3d2 = null;
quantificadorTranlacao3d2 = null;
}
let valorTranslacao3d3;
let quantificadorTranlacao3d3;
if (this.simbolos[this.atual].tipo === "VIRGULA") {
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translação-3d'.");
valorTranslacao3d3 = this.avancarEDevolverAnterior();
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranlacao3d3 =
this.avancarEDevolverAnterior();
}
else {
quantificadorTranlacao3d3 = null;
}
}
else {
valorTranslacao3d3 = null;
quantificadorTranlacao3d3 = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-3d'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorTranslacao3d1,
quantificadorTranlacao3d1,
valorTranslacao3d2,
quantificadorTranlacao3d2,
valorTranslacao3d3,
quantificadorTranlacao3d3,
]);
case "translacao-3d":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-3d'.");
const valorTranslacao3d01 = this.avancarEDevolverAnterior();
let quantificadorTranlacao3d01;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranlacao3d01 =
this.avancarEDevolverAnterior();
}
else {
quantificadorTranlacao3d01 = null;
}
let valorTranslacao3d02;
let quantificadorTranlacao3d02;
if (this.simbolos[this.atual].tipo === "VIRGULA") {
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translação-3d'.");
valorTranslacao3d02 = this.avancarEDevolverAnterior();
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranlacao3d02 =
this.avancarEDevolverAnterior();
}
else {
quantificadorTranlacao3d02 = null;
}
}
else {
valorTranslacao3d02 = null;
quantificadorTranlacao3d02 = null;
}
let valorTranslacao3d03;
let quantificadorTranlacao3d03;
if (this.simbolos[this.atual].tipo === "VIRGULA") {
this.consumir(foles_1.default.VIRGULA, "Esperado vírgula após primeiro argumento do método 'translação-3d'.");
valorTranslacao3d03 = this.avancarEDevolverAnterior();
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranlacao3d03 =
this.avancarEDevolverAnterior();
}
else {
quantificadorTranlacao3d03 = null;
}
}
else {
valorTranslacao3d03 = null;
quantificadorTranlacao3d03 = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-3d'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorTranslacao3d01,
quantificadorTranlacao3d01,
valorTranslacao3d02,
quantificadorTranlacao3d02,
valorTranslacao3d03,
quantificadorTranlacao3d03,
]);
case "translação-eixo-z":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-eixo-z'.");
const valorTranslaçaoZ = this.avancarEDevolverAnterior();
let quantificadorTranslaçaoZ;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranslaçaoZ = this.avancarEDevolverAnterior();
}
else {
quantificadorTranslaçaoZ = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-eixo-z'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorTranslaçaoZ,
quantificadorTranslaçaoZ,
]);
case "translacao-eixo-z":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-eixo-z'.");
const valorTranslacaoZ = this.avancarEDevolverAnterior();
let quantificadorTranslacaoZ;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranslacaoZ = this.avancarEDevolverAnterior();
}
else {
quantificadorTranslacaoZ = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-eixo-z'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorTranslacaoZ,
quantificadorTranslacaoZ,
]);
case "translação-horizontal":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-horizontal'.");
const valorTranslaçaoX = this.avancarEDevolverAnterior();
let quantificadorTranslaçaoX;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranslaçaoX = this.avancarEDevolverAnterior();
}
else {
quantificadorTranslaçaoX = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-horizontal'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorTranslaçaoX,
quantificadorTranslaçaoX,
]);
case "translacao-horizontal":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-horizontal'.");
const valorTranslacaoX = this.avancarEDevolverAnterior();
let quantificadorTranslacaoX;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranslacaoX = this.avancarEDevolverAnterior();
}
else {
quantificadorTranslacaoX = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-horizontal'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorTranslacaoX,
quantificadorTranslacaoX,
]);
case "translação-vertical":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-vertical'.");
const valorTranslaçaoY = this.avancarEDevolverAnterior();
let quantificadorTranslaçaoY;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranslaçaoY = this.avancarEDevolverAnterior();
}
else {
quantificadorTranslaçaoY = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-vertical'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorTranslaçaoY,
quantificadorTranslaçaoY,
]);
case "translacao-vertical":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'translação-vertical'.");
const valorTranslacaoY = this.avancarEDevolverAnterior();
let quantificadorTranslacaoY;
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
quantificadorTranslacaoY = this.avancarEDevolverAnterior();
}
else {
quantificadorTranslacaoY = null;
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após método 'translação-vertical'.");
return new seletor_valor_1.SeletorValor(lexema, [
valorTranslacaoY,
quantificadorTranslacaoY,
]);
case "variar-caractere":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'variar-caractere'.");
const valorVariarCaractere = this.avancarEDevolverAnterior();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método variar-caractere.");
return new seletor_valor_1.SeletorValor(lexema, [valorVariarCaractere]);
case "url":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'url'.");
const url = this.validacaoUrl();
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após argumento do método url.");
return new seletor_valor_1.SeletorValor(lexema, [url]);
case "xywh":
this.consumir(foles_1.default.PARENTESE_ESQUERDO, "Esperado parêntese esquerdo após método 'xywh'.");
const valorXywh = this.avancarEDevolverAnterior();
const quantificadorXywh = this.avancarEDevolverAnterior();
const arrayValoresXywh = [valorXywh, quantificadorXywh];
while (this.simbolos[this.atual].tipo !== 'PARENTESE_DIREITO') {
const proximoValorXywh = this.avancarEDevolverAnterior();
arrayValoresXywh.push(proximoValorXywh);
}
this.consumir(foles_1.default.PARENTESE_DIREITO, "Esperado parêntese direito após último argumento do método xywh.");
return new seletor_valor_1.SeletorValor(lexema, [arrayValoresXywh]);
}
throw this.erro(this.simbolos[this.atual - 1], `Método '${lexema}' não reconhecido em FolEs.`);
}
validacaoUrl() {
const primeiroSimbolo = this.avancarEDevolverAnterior();
switch (primeiroSimbolo.tipo) {
case foles_1.default.IDENTIFICADOR:
return this.validacaoUrlSimbolos(primeiroSimbolo);
default:
return this.validacaoUrlTexto(primeiroSimbolo.literal);
}
}
validacaoUrlSimbolos(primeiroSimbolo) {
if (!["http", "https"].includes(primeiroSimbolo.lexema.toLowerCase())) {
throw this.erro(primeiroSimbolo, `URL inválida. URLs devem começar com 'http' ou 'https'.`);
}
this.consumir(foles_1.default.DOIS_PONTOS, `Esperado dois-pontos após '${primeiroSimbolo.lexema}'.`);
this.consumir(foles_1.default.BARRA, `Esperado barra após '${primeiroSimbolo.lexema + ":"}'`);
this.consumir(foles_1.default.BARRA, `Esperado segunda barra após '${primeiroSimbolo.lexema + ":/"}'`);
let url = `${primeiroSimbolo.lexema}://`;
while (this.simbolos[this.atual].tipo !== foles_1.default.PARENTESE_DIREITO) {
let proximoSimbolo = this.avancarEDevolverAnterior();
url += proximoSimbolo.literal || proximoSimbolo.lexema;
}
this.validacaoUrlTexto(url);
return url;
}
validacaoUrlTexto(textoUrl) {
if (!/^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$/gi.test(textoUrl)) {
throw new Error(`URL ${textoUrl} inválida.`);
}
return textoUrl;
}
valorNumerico(nomeModificador, valorModificador, ponto) {
let literalNumero = Number(valorModificador.lexema);
if (ponto) {
literalNumero = literalNumero / Math.pow(10, valorModificador.lexema.length);
}
let quantificadorNumero;
if (this.verificarTipoSimboloAtual(foles_1.default.QUANTIFICADOR)) {
const simboloQuantificadorNumero = this.avancarEDevolverAnterior();
quantificadorNumero = simboloQuantificadorNumero.lexema;
}
const valorNumerico = new valores_1.ValorNumerico(nomeModificador, literalNumero, quantificadorNumero);
return valorNumerico;
}
valoresModificador(nomeModificador) {
const valoresResolvidos = [];
do {
const valorModificador = this.avancarEDevolverAnterior();
switch (valorModificador.tipo) {
case foles_1.default.BARRA:
valoresResolvidos.push(new valores_1.ValorAbreviacao());
break;
case foles_1.default.CIFRAO:
const nomeVariavel = this.avancarEDevolverAnterior();
const referenciaVariavel = new referencia_variavel_1.ReferenciaVariavel(nomeVariavel.lexema);
valoresResolvidos.push(referenciaVariavel);
break;
case foles_1.default.METODO:
const metodo = this.resolverMetodo(valorModificador.lexema);
valoresResolvidos.push(metodo);
break;
case foles_1.default.NUMERO:
const valorNumerico = this.valorNumerico(nomeModificador, valorModificador, false);
valoresResolvidos.push(valorNumerico);
break;
case foles_1.default.PONTO:
const simboloNumero = this.consumir(foles_1.default.NUMERO, "Esperado número após ponto para valor de modificador.");
const valorNumericoComecadoPorPonto = this.valorNumerico(nomeModificador, simboloNumero, true);
valoresResolvidos.push(valorNumericoComecadoPorPonto);
break;
case foles_1.default.QUALITATIVO:
const valorQualitativo = new valores_1.ValorQualitativo(valorModificador.lexema);
valoresResolvidos.push(valorQualitativo);
break;
case foles_1.default.TEXTO:
const valorTexto = new valores_1.ValorTexto(valorModificador.lexema);
valoresResolvidos.push(valorTexto);
break;
case foles_1.default.VIRGULA:
const valorVirgula = new valores_1.ValorVirgula();
valoresResolvidos.push(valorVirgula);
break;
default:
if (valorModificador.lexema in gerais_1.valoresGerais) {
valoresResolvidos.push(new valores_1.ValorQualitativo(valorModificador.lexema));
break;
}
if (valores_personalizados_1.ModificadoresValorPersonalizado.includes(nomeModificador)) {
valoresResolvidos.push(new valores_1.ValorQualitativo(valorModificador.lexema));
break;
}
throw this.erro(valorModificador, `Modificador ou variável '${nomeModificador}' com valor '${valorModificador.lexema || valorModificador.tipo}' inválido.`);
}
} while (this.atual < this.simbolos.length &&
this.simbolos[this.atual].tipo !== foles_1.default.PONTO_E_VIRGULA);
this.consumir(foles_1.default.PONTO_E_VIRGULA, "Esperado ponto-e-vírgula após declaração de valores de modificador.");
return valoresResolvidos;
}
tratarAtribuicaoAbreviada(valoresModificador) {
let atribuicaoAbreviada = "";
for (let i = 0; i < valoresModificador.length; i += 1) {
if (i === 0) {
atribuicaoAbreviada += `${valoresModificador[i].lexema}`;
}
else {
switch (valoresModificador[i].tipo) {
case foles_1.default.QUANTIFICADOR:
atribuicaoAbreviada += `${valoresModificador[i].lexema}`;
break;
case foles_1.default.VIRGULA:
atribuicaoAbreviada += ",";
break;
default:
atribuicaoAbreviada += " ";
atribuicaoAbreviada += `${valoresModificador[i].lexema}`;
break;
}
}
}
return atribuicaoAbreviada;
}
tratarValorNumerico(modificador) {
if (!valores_numericos_1.ModificadoresDeValorNumerico.includes(modificador.lexema)) {
if (valores_numericos_1.ModificadoresDeValorNumericoComQuantificador.includes(modificador.lexema)) {
if (this.simbolos[this.atual].tipo === "QUANTIFICADOR") {
return true;
}
else {
return false;
}
}
else {
return true;
}
}
return false;
}
resolverPseudoclasse() {
let pseudoclasse;
if (this.verificarTipoSimboloAtual(foles_1.default.DOIS_PONTOS)) {
this.avancarEDevolverAnterior();
pseudoclasse = this.consumir(foles_1.default.PSEUDO_CLASSE, "Esperado nome de pseudoclasse.");
return new seletor_pseudoclasse_1.SeletorPseudoclasse(pseudoclasse.lexema, {
linha: pseudoclasse.linha,
colunaInicial: pseudoclasse.colunaInicial,
colunaFinal: pseudoclasse.colunaFinal,
});
}
return pseudoclasse;
}
seletorPorEspacoReservado() {
const simboloSeletor = this.avancarEDevolverAnterior();
// Aqui não tem problema o espaço reservado usar um nome de estrutura.
if (![
foles_1.default.IDENTIFICADOR,
foles_1.default.ESTRUTURA,
].includes(this.simbolos[this.atual].tipo)) {
throw this.erro(this.simbolos[this.atual], "Esperado identificador válido para espaço reservado.");
}
const nomeEspacoReservado = this.avancarEDevolverAnterior();
return new seletor_espaco_reservado_1.SeletorEspacoReservado(nomeEspacoReservado.lexema, {
linha: simboloSeletor.linha,
colunaInicial: simboloSeletor.colunaInicial,
colunaFinal: simboloSeletor.colunaFinal,
});
}
seletorPorEstrutura() {
const simboloSeletor = this.avancarEDevolverAnterior();
const pseudoclasse = this.resolverPseudoclasse();
return new seletores_1.SeletorEstrutura(new seletor_estruturas_lmht_1.SeletorEstruturasLmht(simboloSeletor.lexema, {
linha: simboloSeletor.linha,
colunaInicial: simboloSeletor.colunaInicial,
colunaFinal: simboloSeletor.colunaFinal,
}), pseudoclasse);
}
seletorPorId() {
this.atual += 1;
const simboloSeletor = this.avancarEDevolverAnterior();
const pseudoclasse = this.resolverPseudoclasse();
return new seletores_1.SeletorId(simboloSeletor.lexema, pseudoclasse, {
linha: simboloSeletor.linha,
colunaInicial: simboloSeletor.colunaInicial,
colunaFinal: simboloSeletor.colunaFinal,
});
}
seletorPorNomeDeClasse() {
this.atual += 1;
const simboloSeletor = this.avancarEDevolverAnterior();
const pseudoclasse = this.resolverPseudoclasse();
return new seletores_1.SeletorClasse(simboloSeletor.lexema, pseudoclasse, {
linha: simboloSeletor.linha,
colunaInicial: simboloSeletor.colunaInicial,
colunaFinal: simboloSeletor.colunaFinal,
});
}
declaracaoVariavel() {
let nomeVariavel;
this.consumir(foles_1.default.CIFRAO, "Esperado cifrão antes de declaração de variável.");
const declaracaoVariavel = this.consumir(foles_1.default.VARIAVEL, "Esperada nomenclatura para declaração de variável.");
nomeVariavel = declaracaoVariavel.lexema;
this.consumir(foles_1.default.DOIS_PONTOS, "Esperado ':' após declaração de variável.");
const valoresVariavel = this.valoresModificador(nomeVariavel);
return new declaracao_variavel_1.DeclaracaoVariavel(nomeVariavel, valoresVariavel);
}
/**
* Resolve os seletores.
* @param espacoReservado
*/
resolverSeletores(espacoReservado = null) {
const seletores = [];
do {
switch (this.simbolos[this.atual].tipo) {
case foles_1.default.ESTRUTURA:
seletores.push(this.seletorPorEstrutura());
break;
case foles_1.default.PERCENTUAL:
seletores.push(this.seletorPorEspacoReservado());
break;
case foles_1.default.PONTO:
seletores.push(this.seletorPorNomeDeClasse());
break;
case foles_1.default.CERQUILHA:
seletores.push(this.seletorPorId());
break;
}
} while (this.simbolos[this.atual].tipo === foles_1.default.VIRGULA);
return seletores;
}
resolverModificador() {
const modificador = this.consumir(foles_1.default.IDENTIFICADOR, "Esperado nome do modificador.");
this.consumir(foles_1.default.DOIS_PONTOS, "Esperado ':' após nome do modificador.");
let valoresModificador = this.valoresModificador(modificador.lexema);
let classeModificadora;
if (valoresModificador[0] instanceof referencia_variavel_1.ReferenciaVariavel) {
classeModificadora = new superclasse_1.SeletorModificador(modificador.lexema, valoresModificador, {
linha: modificador.linha,
colunaInicial: modificador.colunaInicial,
colunaFinal: modificador.colunaFinal,
}, true);
}
else {
classeModificadora = new superclasse_1.SeletorModificador(modificador.lexema, valoresModificador, {
linha: modificador.linha,
colunaInicial: modificador.colunaInicial,
colunaFinal: modificador.colunaFinal,
});
}
return classeModificadora;
}
resolverModificadoresEDeclaracoesAninhadas() {
this.consumir(foles_1.default.CHAVE_ESQUERDA, "Esperado '{' após declaração de seletor.");
const modificadores = [];
const declaracoesAninhadas = [];
while (!this.verificarTipoSimboloAtual(foles_1.default.CHAVE_DIREITA)) {
switch (this.simbolos[this.atual].tipo) {
case foles_1.default.IDENTIFICADOR:
const modificador = this.resolverModificador();
modificadores.push(modificador);
break;
default:
const declaracaoAninhada = this.declaracao();
declaracoesAninhadas.push(declaracaoAninhada);
break;
}
}
this.avancarEDevolverAnterior(); // chave direita
return {
modificadores,
declaracoesAninhadas,
};
}
declaracao() {
if (this.estaNoFinal())
return null;
switch (this.simbolos[this.atual].tipo) {
case foles_1.default.IMPORTAR:
this.avancarEDevolverAnterior();
const caminhoArquivo = this.simbolos[this.atual];
const resultadoImportacao = this.importador.importar(caminhoArquivo.literal, false);
this.simbolos.splice(this.atual - 1, 2, ...resultadoImportacao[1].simbolos);
this.atual -= 1;
return null;
case foles_1.default.CIFRAO:
return this.declaracaoVariavel();
default:
const seletores = this.resolverSeletores();
const modificadoresEDeclaracoesAninhadas = this.resolverModificadoresEDeclaracoesAninhadas();
return new declaracoes_1.BlocoDeclaracao(seletores, modificadoresEDeclaracoesAninhadas.modificadores, modificadoresEDeclaracoesAninhadas.declaracoesAninhadas);
}
}
analisar(simbolos) {
var _a;
this.simbolos = simbolos;
this.erros = [];
this.atual = 0;
const declaracoes = [];
while (!this.estaNoFinal()) {
try {
const declaracao = this.declaracao();
if (declaracao)
declaracoes.push(declaracao);
}
catch (e) {
if (!(e instanceof _1.ErroAvaliadorSintatico)) {
this.erros.push(new _1.ErroAvaliadorSintatico((_a = this.simbolos[this.atual]) !== null && _a !== void 0 ? _a : this.simbolos[this.simbolos.length - 1], e.message));
}
this.sincronizar();
}
this.referenciaDeclaracoes = declaracoes;
}
return declaracoes.filter((d) => d);
}
}
exports.AvaliadorSintatico = AvaliadorSintatico;
//# sourceMappingURL=avaliador-sintatico.js.map