static void Main(string[] args)
{
Compilador lc = new Compilador(@"
1 Nuestra nuestro DP1FSP DP pos=determiner|type=possessive|person=1|gen=feminine|num=singular|possessornum=plural - - (S:0(sn:2(espec-fs:1(pos-fs:1)) - - - -
2 Agrupación agrupación NP00000 NP pos=noun|type=proper - - (grup-nom-fs:2(w-fs:2))) - - - -
3 llevará llevar VMIF3S0 VMI pos=verb|type=main|mood=indicative|tense=future|person=3|num=singular - - (grup-verb:3(verb:3)) - - - -
4 el el DA0MS0 DA pos=determiner|type=article|gen=masculine|num=singular - - (sn:5(espec-ms:4(j-ms:4)) - - - -
5 control control NCMS000 NC pos=noun|type=common|gen=masculine|num=singular - - (grup-nom-ms:5(n-ms:5))) - - - -
6 de de SP SP pos=adposition|type=preposition - - (sp-de:6 - - - -
7 asistencia asistencia NCFS000 NC pos=noun|type=common|gen=feminine|num=singular - - (sn:7(grup-nom-fs:7(n-fs:7)))) - - - -
8 de de SP SP pos=adposition|type=preposition - - (sp-de:8 - - - -
9 el el DA0MS0 DA pos=determiner|type=article|gen=masculine|num=singular - - (sn:10(espec-ms:9(j-ms:9)) - - - -
10 personal personal NCMS000 NC pos=noun|type=common|gen=masculine|num=singular - - (grup-nom-ms:10(n-ms:10) - - - -
11 contratado contratar VMP00SM VMP pos=verb|type=main|mood=participle|num=singular|gen=masculine - - (s-a-ms:11(parti-ms:11))))) - - - -
12 . . Fp Fp pos=punctuation|type=period - - (F-term:12)) - - - -
");
//Console.WriteLine(lc.result + "\n");
Console.WriteLine(lc.result1 + "\n");
int line = 1;
foreach (string postag in lc.POSTAGS)
{
Console.WriteLine(line++ + " " + postag);
}
Console.ReadKey();
}
public bool Compila(string tipo, string expressaoArquivo)
{
try
{
Dictionary <string, object> contexto = new Dictionary <string, object>();
/*
* Toda variável é precedida por @
* Tipos suportados: int, flot e string
* Operadores lógicos suportados: and or
* Operadores relacionais suportados: <, >, <=, >=, !=
* Aceita o uso de parenteses para determinar a precedência
*/
tipoEntidade = tipo;
contexto.Add("@tipoEntidadeReconhecida", tipoEntidade);
//string expressao = "@tipoEntidadeReconhecida = \"NomePessoa\"";
//string expressao = "@a=@b or @nome=\"Joao\"";
expressao = expressaoArquivo;
Compilador c = new Compilador();
ExpressaoLogica el = c.compila(expressao);
el.setContexto(contexto);
//Console.WriteLine("Resultado: " + el.getValor());
return(el.getValor());
}
catch (Exception ex)
{
throw ex;
}
}
private void View()
{
var linha = Console.ReadLine();
if (!string.IsNullOrEmpty(linha))
{
try
{
var resultado = Compilador.ExecuteComando(linha);
Show(resultado);
}
catch (Exception ex)
{
Show(ex.Message);
}
}
if (string.IsNullOrEmpty(linha))
{
View();
}
if ("sair,exit".Contains(linha.ToLower().Trim()))
{
return;
}
View();
}
public void CompilacionGarGarVacia()
{
Compilador compilador = new Compilador();
ResultadoCompilacion res = compilador.Compilar("");
Assert.IsFalse(res.CompilacionGarGarCorrecta);
}
public void CompilacionGarGarIncorrectaConTexto()
{
Compilador compilador = new Compilador();
ResultadoCompilacion res = compilador.Compilar(PROGRAMA_ERRONEO);
Assert.IsFalse(res.CompilacionGarGarCorrecta);
}
public ISuscriptor GetSuscriptor()
{
if (singleCompilador == null)
{
singleCompilador = new Compilador();
}
return(singleCompilador);
}
public void CompilacionGarGarCorrectaBasica()
{
Compilador compilador = new Compilador(true, "basica");
ResultadoCompilacion res = compilador.Compilar(PROGRAMA_BASICO);
Assert.IsTrue(res.CompilacionGarGarCorrecta, ObtenerErrores(res));
Assert.IsTrue(res.ResultadoCompPascal.CompilacionPascalCorrecta);
}
public static void Main(string[] args)
{
//Instancia de
AzureDevOps azureDevOps = new AzureDevOps();
Compilador compilador = new Compilador();
EjecutorPruebasUnitarias ejecutorPruebasUnitarias = new EjecutorPruebasUnitarias();
Instalador instalador = new Instalador();
Notificador notificador = new Notificador();
bool salir = true;
while (salir)
{
Console.WriteLine("*******************************************");
Console.WriteLine("******** Suscriptores disponibles *********");
Console.WriteLine("* 1) Compilador *");
Console.WriteLine("* 2) Pruebas unitarias *");
Console.WriteLine("* 3) Instalador *");
Console.WriteLine("* 4) Notificador *");
Console.WriteLine("******** Suscriptores disponibles *********");
Console.WriteLine("0) Ejecutar acción principal");
Console.WriteLine("5) Salir del programa");
Console.WriteLine("");
int resultado = int.Parse(Console.ReadLine());
switch (resultado)
{
case 0:
azureDevOps.SubirCodigo();
break;
case 1:
azureDevOps.AgregarSuscriptor(compilador);
break;
case 2:
azureDevOps.AgregarSuscriptor(ejecutorPruebasUnitarias);
break;
case 3:
azureDevOps.AgregarSuscriptor(instalador);
break;
case 4:
azureDevOps.AgregarSuscriptor(notificador);
break;
case 5:
salir = false;
break;
}
}
Console.ReadLine();
}
private static UC CriaUC(List <string> codigo)
{
var compilado = Compilador.Compilar(codigo);
UC comp = new UC(new Logger(), compilado.CodigoXBinario);
foreach (var item in compilado.Codigo)
{
comp.Memoria.AddCodigo(item);
}
return(comp);
}
static void Main(string[] args)
{
var subject = new TareasObservador();
Console.WriteLine("Tareas" +
"\n 1.Subir el código." +
"\n 2.Agregar Notificador." +
"\n 3.Agregar Compilador." +
"\n 4.Agregar Ejecutor de Pruebas Unitarias." +
"\n 5.Agregar Instalador." +
"\n 6.Salir.\n");
int Tarea;
do
{
Console.Write("Seleccione una opción: ");
Tarea = Convert.ToInt32(Console.ReadLine());
switch (Tarea)
{
case 1:
var subirCodigo = new SubirCodigo();
subject.AgregarObservador(subirCodigo);
subject.SubirCambios();
break;
case 2:
var enviarCorreo = new EnviarCorreo();
subject.AgregarObservador(enviarCorreo);
break;
case 3:
var compilador = new Compilador();
subject.AgregarObservador(compilador);
break;
case 4:
var ejecutorPruebasU = new EjecutorPruebasU();
subject.AgregarObservador(ejecutorPruebasU);
break;
case 5:
var instalador = new Instalador();
subject.AgregarObservador(instalador);
break;
}
} while (Tarea != 6);
Console.ReadKey();
}
public void CompilacionCorrectaTest()
{
Compilador compilador = new Compilador();
string resourceName = "UnitTestCompiladorGarGar.Programas.test.gar";
string programa = Utilidades.FileManager.LeerArchivoEnteroDeAssembly(Assembly.GetExecutingAssembly(), resourceName);
ResultadoCompilacion res = compilador.Compilar(programa);
Assert.IsTrue(res.CompilacionGarGarCorrecta, ObtenerErrores(res));
Assert.IsTrue(res.ResultadoCompPascal.CompilacionPascalCorrecta);
}
public void CompilacionErrorLexicoPrimerCaracter()
{
Compilador compilador = new Compilador();
string resourceName = "UnitTestCompiladorGarGar.Programas.testErrorLexico.gar";
string programa = Utilidades.FileManager.LeerArchivoEnteroDeAssembly(Assembly.GetExecutingAssembly(), resourceName);
ResultadoCompilacion res = compilador.Compilar(programa);
Assert.IsTrue(res.ListaErrores[0].Mensaje.CodigoGlobal == 43);
}
private void PruebaSintactica(int errorPretendido, string pruebaBis = "")
{
Compilador compilador = new Compilador();
string resourceName = string.Format("UnitTestCompiladorGarGar.Programas.ErroresSintacticos.error{0}{1}.gar", errorPretendido, pruebaBis);
string programa = Utilidades.FileManager.LeerArchivoEnteroDeAssembly(Assembly.GetExecutingAssembly(), resourceName);
ResultadoCompilacion res = compilador.Compilar(programa);
Assert.IsFalse(res.CompilacionGarGarCorrecta,
string.Format("La compilacion da correcta y esperaba error {0}", errorPretendido));
Assert.IsTrue(res.ListaErrores[0].Mensaje.CodigoGlobal == errorPretendido,
string.Format("Error {0} y esperaba {1}. Error: {2}",
res.ListaErrores[0].Mensaje.CodigoGlobal, errorPretendido, res.ListaErrores[0].Mensaje.Descripcion));
}
public void CompilacionMenorTresSegundos()
{
Compilador compilador = new Compilador("validacionesSemanticasCorrectas");
string resourceName = "UnitTestCompiladorGarGar.Programas.validacionesSemanticasCorrectas.gar";
string programa = Utilidades.FileManager.LeerArchivoEnteroDeAssembly(Assembly.GetExecutingAssembly(), resourceName);
ResultadoCompilacion res = compilador.Compilar(programa);
Assert.IsTrue(res.CompilacionGarGarCorrecta, ObtenerErrores(res));
Assert.IsTrue(res.ResultadoCompPascal.CompilacionPascalCorrecta);
Assert.IsTrue(res.TiempoCompilacionTotal < 3);
}
public IActionResult CreateMachine([FromBody] List <string> code)
{
var compilado = Compilador.Compilar(code);
if (compilado.Erros.Count > 0)
{
return(BadRequest(compilado.Erros));
}
var newUc = CriaUC(code, compilado);
var virtualUc = new MachineData();
virtualUc.codigo = code;
virtualUc.Key = Guid.NewGuid();
virtualUc.uc = newUc;
_data.Add(virtualUc);
return(Ok(PcToResult(virtualUc)));
}
private static void ValidaCódigo(List <string> l, List <string> codigo)
{
var c = Compilador.Compilar(codigo);
var compilado = c.Codigo;
if (compilado.Count != l.Count)
{
throw new Exception();
}
for (int i = 0; i < compilado.Count; i++)
{
if (compilado[i] != l[i])
{
throw new Exception();
}
}
}
public async Task <bool> ValidarFormulaGuardar(string formula)
{
try
{
Compilador a = new Compilador(apiServicio, constantesNomina);
try
{
var b = await a.Evaluar(formula);
return(true);
}
catch (Exception)
{
return(false);
}
}
catch (Exception)
{
return(false);
}
}
public static string ErrorAlCompilar(Compilador compilador, string comando, string descripcion)
{
string mensaje = string.Empty;
if (compilador is CompiladorAsm)
{
mensaje = "Error de compilación ASM: ";
}
if (compilador is CompiladorC)
{
mensaje = "Error de compilación C: ";
}
if (mensaje == string.Empty)
{
mensaje = "Error en enlace: ";
}
mensaje += "\nComando: " + comando;
mensaje += "\nDescripción: \n" + descripcion + "\n\n";
return(mensaje);
}
public async Task <JsonResult> ValidarFormula(string formula)
{
try
{
Compilador a = new Compilador(apiServicio, constantesNomina);
try
{
var b = await a.Evaluar(formula);
return(Json(b));
}
catch (Exception)
{
return(Json(false));
}
}
catch (Exception)
{
return(Json(false));
}
}
/// <summary>
/// The main entry point for the application.
/// </summary>
private static void Main(string[] args)
{
try
{
//Compilador comp = new Compilador();
//Application.Run(comp);
var options = new Options();
var result = CommandLine.Parser.Default.ParseArguments <Options>(args);
if (!result.Errors.Any())
{
if (File.Exists(result.Value.InputFile))
{
using (StreamReader reader = new StreamReader(result.Value.InputFile))
{
string textoCompilar = reader.ReadToEnd();
//Compilador compilador = new Compilador(false, Globales.ConstantesGlobales.PathEjecucionAplicacion, Globales.ConstantesGlobales.PathEjecucionAplicacion, result.Value.ExeFile);
Compilador compilador = new Compilador(false, Path.GetTempPath(), Path.GetTempPath(), result.Value.ExeFile);
ResultadoCompilacion res = compilador.Compilar(textoCompilar);
if (res.CompilacionGarGarCorrecta && res.ResultadoCompPascal != null &&
res.ResultadoCompPascal.CompilacionPascalCorrecta)
{
Console.WriteLine("Compilacion exitosa");
}
else
{
Console.WriteLine("Error de compilacion");
foreach (var error in res.ListaErrores)
{
Console.WriteLine(string.Format("<{0},{1}> {2}", error.Fila, error.Columna, error.Mensaje.Descripcion));
}
}
}
}
}
//if (args != null)
//{
// if (args.Length > 0)
// {
// List<string> argumentos = new List<string>(args);
// }
// else
// {
// Console.WriteLine("Coloque el parametro -? para ayuda");
// }
//}
//else
//{
// Console.WriteLine("Coloque el parametro -? para ayuda");
//}
}
catch (Exception ex)
{
Console.WriteLine("Error fatal en el compilador.");
Console.WriteLine(ex.Message);
}
}
private void invocarCompiladorApk(object path)
{
Compilador.CompilarApk(path, checkAgregarPlataforma.Checked, checkFirmarApk.Checked, entorno);
EnabledButton(true);
}
public void Dispose()
{
Compilador.Dispose();
}
public void InstanciarCompilador()
{
Compilador compilador = new Compilador();
Assert.IsNotNull(compilador);
}
private void invocarCompilador(object path)
{
Compilador.Compilar(path, checkConsola.Checked);
EnabledButton(true);
}
public MainViewModel(IMessageBoxService servMsgBox, IFileManagerDialogService servFileManager,
IProcessStarterService servProcess, IPrinterService servImpr)
{
////if (IsInDesignMode)
////{
//// // Code runs in Blend --> create design time data.
////}
////else
////{
//// // Code runs "for real"
////}
ArchivoActual = new Archivo();
ListaMensajesCompilacion = new ObservableCollection<MensajeCompilacion>();
CommandNew = new RelayCommand(New);
CommandOpen = new RelayCommand(Open);
CommandSave = new RelayCommand(Save);
CommandSaveAs = new RelayCommand(SaveAs);
CommandPrint = new RelayCommand(Print);
CommandExit = new RelayCommand(Exit);
CommandCompilar = new RelayCommand(Compilar);
CommandEjecutar = new RelayCommand(Ejecutar);
CommandAbrirManual = new RelayCommand(AbrirManual);
CommandAboutUs = new RelayCommand(AboutUs);
servicioMessageBox = servMsgBox;
servicioFileManager = servFileManager;
servicioImpresion = servImpr;
servicioProcesos = servProcess;
compilador = new Compilador();
}
public static void CompilarYEjecutar()
{
CompiladorAsm compiladorAsm;
CompiladorC compiladorC;
Compilador compilador;
compiladorAsm = new CompiladorAsm("", "nasm.exe");
compiladorC = new CompiladorC("", "gcc.exe");
compilador = new Compilador("", "gcc.exe", "salida.txt", "error.txt");
try {
Ejecutor.ArchivoSalida = salidaPorArchivo? archSalida : "salida.txt";
Ejecutor.ArchivoError = "errorEjecucion.txt";
// if( esAssembler )
compiladorAsm.Compilar("-fcoff", "timer.asm");
compiladorC.Compilar("-c -o codigoProbador.o", "codigoProbador.c");
/*
* string[] archivos = new string[2];
* archivos[1] = "codigoProbador.o";
* if( esAssembler )
* archivos[0] = "timer.o";
* else
* archivos[0] = archFuncion;
* */
string[] archivos;
if (esAssembler)
{
archivos = new string[2];
archivos[0] = "timer.o";
archivos[1] = "codigoProbador.o";
}
else
{
archivos = new string[3];
archivos[0] = archFuncion;
archivos[1] = "timer.o";
archivos[2] = "codigoProbador.o";
}
//Genera un .exe resultado de enlazar los 2 anteriores.
compilador.Enlazar("prueba.exe", archivos);
Ejecutor.Ejecutar("prueba.exe");
Console.Write(Ejecutor.ObtenerSalida());
}
finally
{
if (esAssembler)
{
compiladorAsm.BorrarArchivosSalidaYError();
}
compiladorC.BorrarArchivosSalidaYError();
compilador.BorrarArchivosSalidaYError();
Ejecutor.BorrarArchivosTemporales(!salidaPorArchivo);
File.Delete("codigoProbador.o");
File.Delete("timer.o");
}
}
public static string ErrorAlCompilar(Compilador compilador, string comando, Exception excepcion)
{
return(ErrorAlCompilar(compilador, comando, MA.ExcepcionCompleta(excepcion)));
}
private string CallAnalyzer(string TextToAnalyze)
{
if (!buttonAnalyzer.Label.Equals("Analyzer Abierto")) return ("Server not running");
// Data buffer for incoming data.
byte[] bytes = new byte[1000000];
/*
IPEndPoint remoteEP;
if (ipaddress.Text.Equals(""))
{
remoteEP = new IPEndPoint(Globals.ThisAddIn.ipAddress, 5000);
}
else
{
IPAddress ipdir = parse(ipaddress.Text);
if (ipdir.Equals(IPAddress.None))
{
MessageBox.Show("Error en la forma de la dirección IP");
}
remoteEP = new IPEndPoint(ipdir, 5000);
}
// Create a TCP/IP socket.
Socket sender1 = new Socket(Globals.ThisAddIn.ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
*/
// Connect the socket to the remote endpoint. Catch any errors.
try
{
//sender1.Connect(remoteEP);
// Encode the data string into a byte array.
byte[] msg = Encoding.UTF8.GetBytes("RESET_STATS" + char.MinValue);
// Send the data through the socket.
int bytesSent = sender1.Send(msg);
// Receive the response from the remote device.
int bytesRec = sender1.Receive(bytes);
string response = Encoding.UTF8.GetString(bytes, 0, bytesRec);
if (response.Equals("FL-SERVER-READY" + char.MinValue))
{
buttonAnalyzer.Label = "Analyzer Abierto";
}
else
{
buttonAnalyzer.Label = "Analyzer Cerrado";
}
msg = Encoding.UTF8.GetBytes(TextToAnalyze + char.MinValue);
bytesSent = sender1.Send(msg);
bytesRec = sender1.Receive(bytes);
// Release the socket.
//sender1.Shutdown(SocketShutdown.Both);
//sender1.Close();
Compilador lc = new Compilador(Encoding.UTF8.GetString(bytes, 0, bytesRec));
return /* "\n" + lc.result + */ "\n" + lc.result1; // + "\n" + lc.result2;
}
catch (ArgumentNullException ane)
{
return("ArgumentNullException : " + ane.ToString());
}
catch (SocketException se)
{
return("SocketException : " + se.ToString());
}
catch (Exception ex)
{
return("Unexpected exception : " + ex.ToString());
}
}
private void ANALIZAR_COMPILAR()
{
Compilador compilador = new Compilador();
AnalizadorSemantico semantico = new AnalizadorSemantico();
List <string> CodigoComputado = new List <string>();
System.IO.Stream str = Properties.Resources.chumsound;
SoundPlayer ChumpeSound = new SoundPlayer(str);
ChumpeSound.Load();
toolErrorSintaxis.Text = "";
try
{
toolProgreso.Increment(20);
toolnotificaciones.Text = "Analizando codigo... (20%)";
List <string> Codigo = new List <string>();
Codigo.AddRange(richTextBox1.Lines);
semantico.SetCodigoAnalizar(Codigo);
semantico.Computar(out CodigoComputado);
toolProgreso.Increment(30);
List <string> Errores = semantico.MostrarErrores();
if (Errores.Count != 0)
{
ChumpeSound.Play();
toolErrorSintaxis.Text = "Error al compilar... ";
FormMostrarErrores.ListaErrores = Errores;
FormMostrarErrores FrmError = new FormMostrarErrores();
FrmError.Show();
toolnotificaciones.Text = "sin notificaciones...";
toolProgreso.Increment(100);
return;
}
string direccion = Archivos.Direccion;
if (direccion == null || direccion == "")
{
GetCodigoEscrito();
Archivos.Guardar(CodigoEscrito);
direccion = Archivos.Direccion;
}
string[] trozo_direccion = direccion.Split(new string[] { "\\", ".chumpe" }, StringSplitOptions.RemoveEmptyEntries);
string nombre = trozo_direccion[trozo_direccion.Length - 1];
if (nombre == "" || string.IsNullOrEmpty(nombre))
{
nombre = "Chompipe";
}
toolnotificaciones.Text = "Compilando... (60%)";
toolProgreso.Increment(60);
var d = compilador.CheckCodigoAcompilar(CodigoComputado);
var k = compilador.GenerarCodigoCsharp(d, "__IL_SISTEMA_INT");
List <string> ILerr = new List <string>();
bool compilado = compilador.CompilarCodigo(k, nombre + ".exe", out ILerr);
if (compilado)
{
Process p = new Process();
ProcessStartInfo psi = new ProcessStartInfo(System.IO.Directory.GetCurrentDirectory() + @"\" + nombre + ".exe");
p.StartInfo = psi;
p.Start();
toolErrorSintaxis.Text = "UN CHUMPE SE HA COMPILADO... ";
toolnotificaciones.Text = "sin notificaciones...";
}
else
{
if (ILerr.Count >= 1)
{
FormMostrarErrores.ListaErrores = ILerr;
FormMostrarErrores FrmError = new FormMostrarErrores();
FrmError.Show();
}
ChumpeSound.Play();
toolErrorSintaxis.Text = "Compilacion exitosa pero con error en IL";
}
toolProgreso.Increment(100);
}
catch (Exception ex)
{
ChumpeSound.Play();
toolProgreso.Increment(0);
MessageBox.Show(ex.Message);
}
}
