public override bool Procesar(string cadena, DeclaraciónDeContexto contexto, int desplazamiento)
{
if (base.Procesar(cadena, contexto, desplazamiento))
{
return(true);
}
else
{
if (Sucesor != null)
{
(bool ContinuarEjecución, string MensajeDeError)comprobación = ComprobaciónAntesDeDelegar();
if (comprobación.ContinuarEjecución)
{
return(Sucesor.Procesar(cadena, contexto, desplazamiento));
}
else
{
throw new InvalidOperationException(comprobación.MensajeDeError);
}
}
else
{
return(false);
}
}
}
public void ProcesadorDeDeclaraciónDeBoolDeclaraSinValor()
{
ILenguaje lenguaje = new LenguajeBase();
IRepositorioDeProcesadores repositorio = new RepositorioDeProcesadores(lenguaje);
var procesador = new ProcesadorDeDeclaraciónDeBool(lenguaje, repositorio);
var declaración = new DeclaraciónDeContexto(lenguaje);
procesador.Procesar(@"bool a", declaración, 0);
}
public void ProcesadorDeEvaluaciónLeeBienLasCadenasLiterales()
{
ILenguaje lenguaje = new LenguajeBase();
IRepositorioDeProcesadores repositorio = new RepositorioDeProcesadores(lenguaje);
var procesador = new ProcesadorDeEvaluación(repositorio);
var declaración = new DeclaraciónDeContexto(lenguaje);
bool resultado = procesador.Procesar(@"""pa""mplinas""", declaración, 0);
Assert.IsTrue(resultado);
}
public void ProcesadorDeEvaluaciónNoSeFumaLosValoresInválidos()
{
ILenguaje lenguaje = new LenguajeBase();
IRepositorioDeProcesadores repositorio = new RepositorioDeProcesadores(lenguaje);
var procesador = new ProcesadorDeEvaluación(repositorio);
var declaración = new DeclaraciónDeContexto(lenguaje);
bool resultado = procesador.Procesar(@"2Pamplinas", declaración, 0);
Assert.IsFalse(resultado);
}
public void ProcesadorDeEvaluaciónLeeBienLasPosiblesLlamadasAFuncionesConParámetros()
{
ILenguaje lenguaje = new LenguajeBase();
IRepositorioDeProcesadores repositorio = new RepositorioDeProcesadores(lenguaje);
var procesador = new ProcesadorDeEvaluación(repositorio);
var declaración = new DeclaraciónDeContexto(lenguaje);
bool resultado = procesador.Procesar(@"NombreDeFuncion(string paramtero1, int parametro2)", declaración, 0);
Assert.IsTrue(resultado);
}
public void ProcesadorDeEvaluaciónLeeBienLosPosiblesNombreDeVariables()
{
ILenguaje lenguaje = new LenguajeBase();
IRepositorioDeProcesadores repositorio = new RepositorioDeProcesadores(lenguaje);
var procesador = new ProcesadorDeEvaluación(repositorio);
var declaración = new DeclaraciónDeContexto(lenguaje);
bool resultado = procesador.Procesar(@"NombreDeVariable23", declaración, 0);
Assert.IsTrue(resultado);
}
public void ProcesadorDeDeclaraciónDeParámetrosFunciona()
{
ILenguaje lenguaje = new LenguajeBase();
IRepositorioDeProcesadores repositorio = new RepositorioDeProcesadores(lenguaje);
var manejador = new ManejadorDeProcesadores(repositorio, null);
var procesador = new ProcesadorDeCuerpoDeExpresiones(manejador);
var declaración = new DeclaraciónDeContexto(lenguaje);
procesador.Procesar(@"int entero = 0;string cadena = ""texto"";", declaración, 0);
}
public virtual bool Procesar(string cadena, DeclaraciónDeContexto declaración, int desplazamiento)
{
var expresión = new Regex(Expresión);
var coincidencias = expresión.Matches(cadena);
if (coincidencias.Count > 0 && ComprobaciónAdicional(cadena, coincidencias, declaración, desplazamiento))
{
ProcesarCadena(cadena, coincidencias, declaración, desplazamiento);
return(declaración.Correcto);
}
return(false);
}
protected override void CrearComportamiento(string cadena, DeclaraciónDeContexto declaración, int desplazamiento)
{
var variable = new Variable
{
Tipo = TipoDeVariable,
Nombre = NombreDeVariable
//Valor = string.IsNullOrEmpty(ValorDeVariable) ? TipoDeVariable.ValorPorDefecto : ValorDeVariable
};
var instrucción = new DeclaraciónDeVariable(variable, cadena)
{
Inicio = desplazamiento
};
declaración.Instrucciones.Enqueue(instrucción);
declaración.VariablesDeclaradas.Add(variable);
}
protected override void CrearComportamiento(string cadena, DeclaraciónDeContexto declaración, int desplazamiento)
{
var variable = new Variable
{
Tipo = TipoDeVariable,
Nombre = NombreDeVariable
//El valor en lugar de pasárselo, tengo que construir instrucciones para obtenerlo
//Valor = string.IsNullOrEmpty(ValorDeVariable) ? TipoDeVariable.ValorPorDefecto : ValorDeVariable
};
//Igual un CrearVariable y uego un AsignarValorDeVariable
var instrucción = new DeclaraciónDeVariable(variable, cadena) //Este puede que simplemente haga un pop de algun sitio y coja el valor
{
Inicio = desplazamiento
};
declaración.Instrucciones.Enqueue(instrucción);
declaración.VariablesDeclaradas.Add(variable);
}
protected override void CrearComportamiento(string cadena, DeclaraciónDeContexto declaración, int desplazamiento)
{
var parámetro = new Parámetro
{
Tipo = TipoDeVariable,
Nombre = NombreDeVariable
};
declaración.CrearParámetro(parámetro);
base.CrearComportamiento(cadena, declaración, desplazamiento);
var cargarDatoDeParámetro = new CargarDatoEnVariable(NombreDeVariable, cadena)
{
Inicio = desplazamiento
};
declaración.Instrucciones.Enqueue(cargarDatoDeParámetro);
}
protected override void ProcesarCadena(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
}
protected sealed override void ProcesarCadena(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
_coincidencia = coincidencias[0];
TipoDeVariable = CrearTipo();
if (cadena.Length != _coincidencia.Value.Length)
{
throw new ErrorDeCompilación(
new ErrorDeDeclaración(
cadena,
string.Format(ERROR_TIPO_INVALIDO, TipoDeVariable.Nombre),
coincidencias[0].Index + desplazamiento,
cadena.Length));
}
if (declaración.VariablesDeclaradas.Where(v => v.Nombre == NombreDeVariable).Count() > 0)
{
throw new ErrorDeCompilación(
new ErrorDeDeclaración(
cadena,
ERROR_VARIABLE_EXISTENTE,
coincidencias[0].Index + desplazamiento,
cadena.Length));
}
var valorDeVariable = _coincidencia.Groups[NOMBRE_GRUPO_VALOR_DE_VARIABLE];
if (string.IsNullOrEmpty(valorDeVariable.Value))
{
if (cadena.Contains(Lenguaje.OperadorDeAsignación))
{
throw new ErrorDeCompilación(
new ErrorDeDeclaración(
cadena,
ERROR_DECLARACION_SIN_VALOR,
coincidencias[0].Index + desplazamiento,
cadena.Length));
}
//else
//{
// var instrucción = new ApilarDato(TipoDeVariable.ValorPorDefecto, cadena)
// {
// Inicio = desplazamiento
// };
// declaración.Instrucciones.Enqueue(instrucción);
//}
}
else
{
_evaluador.Procesar(valorDeVariable.Value, declaración, desplazamiento + valorDeVariable.Index);
if (TipoDeVariable.Nombre != _evaluador.TipoDeSalida.Nombre)
{
string mensaje = string.Format(ERROR_TIPO_INVALIDO, TipoDeVariable.Nombre);
throw new ErrorDeCompilación(
new ErrorDeDeclaración(
cadena,
mensaje,
coincidencias[0].Index + desplazamiento,
cadena.Length));
}
}
CrearComportamiento(coincidencias[0].Value, declaración, desplazamiento);
if (!string.IsNullOrEmpty(valorDeVariable.Value))
{
var cargarValorEnVariable = new CargarDatoEnVariable(NombreDeVariable, cadena)
{
Inicio = desplazamiento
};
declaración.Instrucciones.Enqueue(cargarValorEnVariable);
}
}
protected override bool ComprobaciónAdicional(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
return(coincidencias[0].Index == 0); //No está al principio, asi que pasa algo raro
}
protected abstract void CrearComportamiento(string cadena, DeclaraciónDeContexto contexto, int desplazamiento);
protected override void ProcesarCadena(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
//Aqui tengo que enlazarlo de alguna forma con un evaluador externo para ver que los tipos coinciden
var evaluador = new ProcesadorDeEvaluación(Repositorio);
var valorDeRetorno = coincidencias[0].Groups[NOMBRE_GRUPO_VALOR_DE_RETORNO].Value;
evaluador.Procesar(valorDeRetorno, declaración, desplazamiento + coincidencias[0].Groups[NOMBRE_GRUPO_VALOR_DE_RETORNO].Index);
}
protected override void ProcesarCadena(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
foreach (Match coincidencia in coincidencias)
{
_procesadorDeDeclaraciónDeParámetros.Procesar(coincidencia.Value, declaración, desplazamiento + coincidencia.Index);
}
}
public bool Procesar(string cadena, DeclaraciónDeContexto contexto, int desplazamiento)
{
return(_inicial.Procesar(cadena, contexto, desplazamiento));
}
protected override void ProcesarCadena(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
//_evaluador = new ProcesadorDeEvaluación(Repositorio);
var nombreDeFunción = coincidencias[0].Groups[NOMBRE_GRUPO_NOMBRE_DE_FUNCION].Value;
bool esNativa = true;
var función = declaración.FuncionesNativas[nombreDeFunción];
if (función == null)
{
función = declaración.Funciones[nombreDeFunción];
esNativa = false;
}
if (función == null)
{
GenerarExcepción(cadena, ERROR_FUNCION_NO_ENCONTRADA, coincidencias[0].Index + desplazamiento, cadena.Length);
}
//Esto queda cerdo que no veas
if (_evaluador == null)
{
_evaluador = new ProcesadorDeEvaluación(Repositorio);
}
int índice = función.Parámetros.Total - 1;
string subexpresion = $@"{SEPARADORES}(?<valor>{FORMATO_VALIDO_VALOR_DE_INT}|{FORMATO_VALIDO_VALOR_DE_STRING}|{FORMATO_VALIDO_NOMBRE_DE_VARIABLE}){SEPARADORES}";
Regex separadorDeValores = new Regex($@"{SEPARADOR_DE_PARAMETROS}{subexpresion}");
MatchCollection valoresEncontrados = separadorDeValores.Matches(SEPARADOR_DE_PARAMETROS + coincidencias[0].Groups[NOMBRE_GRUPO_PARAMETROS].Value);
Stack <Match> pilaDeValores = new Stack <Match>();
foreach (Match valorEncontrado in valoresEncontrados)
{
pilaDeValores.Push(valorEncontrado);
}
while (pilaDeValores.Count > 0)
{
Match coincidencia = pilaDeValores.Pop();
var valor = coincidencia.Groups["valor"].Value;
_evaluador.Procesar(valor, declaración, desplazamiento + coincidencias[0].Groups[NOMBRE_GRUPO_PARAMETROS].Index + coincidencia.Groups["valor"].Index - 1);
var declaraciónDeParámetro = función.Parámetros[índice];
if (declaraciónDeParámetro == null)
{
GenerarExcepción(
valor,
"Parámetro no declarado",
coincidencias[0].Groups[NOMBRE_GRUPO_PARAMETROS].Index + desplazamiento + coincidencia.Groups["valor"].Index,
valor.Length);
}
else if (declaraciónDeParámetro.Tipo.Nombre != _evaluador.TipoDeSalida.Nombre)
{
GenerarExcepción(
valor,
string.Format(ERROR_VALOR_DE_PARAMETRO_INVALIDO, declaraciónDeParámetro.Tipo.Nombre),
coincidencias[0].Groups[NOMBRE_GRUPO_PARAMETROS].Index + desplazamiento + coincidencia.Groups["valor"].Index,
valor.Length);
}
índice--;
}
_evaluador.TipoDeSalida = función.TipoDeRetorno;
if (esNativa)
{
Instrucción instrucción = new LlamadaAFunciónNativa(nombreDeFunción, cadena)
{
Inicio = desplazamiento
};
declaración.Instrucciones.Enqueue(instrucción);
}
else
{
Instrucción instrucción = new LlamadaAFunción(nombreDeFunción, cadena)
{
Inicio = desplazamiento
};
declaración.Instrucciones.Enqueue(instrucción);
}
}
protected override bool ComprobaciónAdicional(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
return(coincidencias[0].Index == 0);
}
protected override void ProcesarCadena(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
string nombre = coincidencias[0].Groups[NOMBRE_GRUPO_NOMBRE_DE_VARIABLE].Value,
valor = coincidencias[0].Groups[NOMBRE_GRUPO_VALOR_DE_VARIABLE].Value;
}
protected override void ProcesarCadena(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
string nombreDeVariable = coincidencias[0].Value;
var variable = declaración.VariablesDeclaradas.Where(v => v.Nombre == nombreDeVariable).First();
if (variable != null)
{
var instrucción = new ApilarDatoDesdeVariable(coincidencias[0].Value, cadena)
{
Inicio = desplazamiento
};
_evaluador.TipoDeSalida = variable.Tipo;
declaración.Instrucciones.Enqueue(instrucción);
}
else
{
//EXCEPCION: Variable no existe
}
}
protected override void ProcesarCadena(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
foreach (Match coincidencia in coincidencias)
{
var resultado = new Función(_lenguaje)
{
TipoDeRetorno = new TipoVoid(_lenguaje),
Nombre = coincidencia.Groups[NOMBRE_GRUPO_NOMBRE_DE_FUNCION].Value,
InicioEnElCódigo = coincidencia.Index,
LongitudDeDeclaración = coincidencia.Value.Length,
FuncionesNativas = declaración.FuncionesNativas,
Funciones = declaración.Funciones
};
if (!string.IsNullOrEmpty(coincidencia.Groups[NOMBRE_GRUPO_TIPO_DE_RETORNO].Value))
{
//Si el manejador no tiene tipo es que no existe!!
var manejador = new ManejadorDeTipoDeRetorno(Repositorio);
manejador.Procesar(coincidencia.Groups[NOMBRE_GRUPO_TIPO_DE_RETORNO].Value, declaración, desplazamiento + coincidencia.Groups[NOMBRE_GRUPO_TIPO_DE_RETORNO].Index);
resultado.TipoDeRetorno = manejador.TipoDeSalida;
}
//En lugar de crear variables voy a crear un stack de Parámetro y al procesar la llamada creo las variables ya con los valores
if (!string.IsNullOrEmpty(coincidencia.Groups[NOMBRE_GRUPO_PARAMETROS].Value))
{
//Este debería ser de variables
_procesadorDeParámetros.Procesar(coincidencia.Groups[NOMBRE_GRUPO_PARAMETROS].Value, resultado, desplazamiento + coincidencia.Groups[NOMBRE_GRUPO_PARAMETROS].Index);
}
//Comprobar que hay un return. Puede ser que este sea evaluador y los procesadores le asignen
//si al final es void y el tipo definido es otro la liamos (ya, y cuando lleguen los ifs me descojono)
//Compruebo si hay funciones declaradas dentro
Procesar(coincidencia.Groups[NOMBRE_GRUPO_CUERPO_DE_FUNCION].Value, resultado, desplazamiento);
//Por problemas tecnicos, si hago esto en el ctor se mete en un bucle infinito
_procesadorDeCuerpo = Repositorio.ObtenerProcesadorDeCuerpoDeExpresiones();
_procesadorDeCuerpo.Procesar(coincidencia.Groups[NOMBRE_GRUPO_CUERPO_DE_FUNCION].Value, resultado, desplazamiento + coincidencia.Groups[NOMBRE_GRUPO_CUERPO_DE_FUNCION].Index);
declaración.Funciones.Añadir(resultado);
}
}
public virtual bool Procesar(string cadena, DeclaraciónDeContexto contexto)
{
return(Procesar(cadena, contexto, 0));
}
protected override void ProcesarCadena(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
string declaracion = coincidencias[0].Groups[NOMBRE_GRUPO_DECLARACION].Value,
comprobacion = coincidencias[0].Groups[NOMBRE_GRUPO_COMPROBACION].Value,
accionFinal = coincidencias[0].Groups[NOMBRE_GRUPO_ACCION_FINAL].Value,
cuerpo = coincidencias[0].Groups[NOMBRE_GRUPO_CUERPO].Value;
//Aqui me interesa un repo en lugar de un chain porque tengo que discriminar según el tipo, que ya me sepo
//IProcesador procesador = Repositorio.ObtenerProcesadorDeDeclaraciónDeVariables();
_procesadorDeclaraciónDeVariables.Procesar(declaracion, declaración, desplazamiento);
}
protected virtual bool ComprobaciónAdicional(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
return(true);
}
protected override void ProcesarCadena(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
_evaluador.TipoDeSalida = new TipoInt(_lenguaje);
}
protected override void ProcesarCadena(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
try
{
foreach (Match coincidencia in coincidencias)
{
if (!_manejador.Procesar(coincidencia.Value, declaración, desplazamiento))
{
//Variable rara
declaración.Correcto = false;
declaración.Error = new ErrorDeDeclaración(coincidencia.Value, ERROR_DE_DECLARACION, coincidencia.Index + desplazamiento, coincidencia.Length);
}
}
}
catch (InvalidOperationException)
{
//Aqui estoy jodido porque no sé que coño de variable han definido
}
}
protected override void ProcesarCadena(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
_evaluador.TipoDeSalida = new TipoBool(_lenguaje);
var dato = coincidencias[0].Value;
if (_evaluador.TipoDeSalida.ComprobarValor(dato))
{
var instrucción = new ApilarDato(dato, cadena)
{
Inicio = desplazamiento
};
declaración.Instrucciones.Enqueue(instrucción);
}
else
{
//EXCEPCION: Tipo inválido
}
}
protected override void ProcesarCadena(string cadena, MatchCollection coincidencias, DeclaraciónDeContexto declaración, int desplazamiento)
{
//Tengo que pasarle this como evaluador para que le ponga el tipo de salida
//aunque si la funcion tiene tipo devuelto debería ser ese
_manejador.Procesar(cadena, declaración, desplazamiento);
//Revisar que el contexto no venga con Correcto a false porque ha petado algo.
}
