void VentanaPrincipal::actualizarVistaInformativa(QString ruta)
{
QFile archivo(ruta + ".lexemas");
if (!archivo.open(QFile::ReadOnly | QFile::Text))
return;
QTextStream flujo(&archivo);
delete modeloInformativa;
modeloInformativa = new QStandardItemModel(0, 2, this);
modeloInformativa->setHeaderData(0, Qt::Horizontal, QObject::tr("Token"));
modeloInformativa->setHeaderData(1, Qt::Horizontal, QObject::tr("Lexema"));
vistaInformativa->setModel(modeloInformativa);
int i = 0;
while(!flujo.atEnd())
{
QStringList tmp = flujo.readLine().split(",,,");
modeloInformativa->insertRow(i);
modeloInformativa->setData(modeloInformativa->index(i, 0), tmp[0]);
modeloInformativa->setData(modeloInformativa->index(i, 1), tmp[1]);
++i;
}
}
bool ReaderCoordinatesBasico::tryRead(QString pathFile)
{
QFile file(pathFile);
if(!file.open(QFile::Text | QFile::ReadOnly))
{
_error="Aquest fitxer no es pot obrir";
return false;
}
QTextStream flujo(&file);
flujo.setRealNumberPrecision(6);
QString ide=QString();
double xa=0, ya=0, xb=0, yb=0;
bool error=false;
bool ideError=false;
IdentificadorCoordenadas *identiCoor=0;
//Expresio regular per comprobar el valor de identificador
QRegExp expre("^*\w*$",Qt::CaseInsensitive);
if(!expre.isValid())
{
_error="La expresion regular no es correcta";
return false;
}
while (!flujo.atEnd() && !error)
{
flujo >> ide >> xa >> ya >> xb >> yb;
ideError=ide.contains(expre);
if (!ideError) error=true;
if (xa==0 || ya==0 || xb==0 || yb==0)
{
//error=true;
}
if (!error)
{
identiCoor=new IdentificadorCoordenadas(0,ide, xa, ya, xb, yb);
_listCoordinates << identiCoor;
}
xa=0; ya=0; xb=0; yb=0;
ide.clear();
}
if (error)
{
_listCoordinates.clear();
_error="El format del fitxer coordenades no es correcte";
qDebug()<< "false Ctryred" ;
return false;
}
qDebug()<< "true Ctryred" ;
return true;
}
/* Contiene el menú principal del programa llama al resto de las funciones */
int menu(int control, float * dperfil, float * opc, float * opp, float * opf)
{
int opcion;
if (control==0)
{
printf("\033[32m************************************************************************\n");
printf("CHMYukovski\n\nBienvenido al programa.\nElija la opción que desea ejecutar:\n\n1. Construcción del perfil del ala\n2. Calculo del flujo\n3. Opciones\n4. Salir\n");
printf("\033[32m************************************************************************");
printf("\033[0m\n");
}
scanf("%d",&opcion);
switch(opcion)
{
case 1: // Cálculo del perfil alar
perfil(dperfil, opc, opp, opf);
menu(0, dperfil, opc, opp, opf); // Llama al menú como si el programa volviese a empezar
break;
case 2: // Cálculo del flujo en el perfil
if (flujo(dperfil, opc, opp, opf)==1)
{
printf("\033[34mProyecto final en C de la asignatura de Informática\nGrado en Ingeniería Aeroespacial\n\n Adrián Delgado Marcos\n Javier Lobato Pérez\n Pablo Rodríguez Robles");
printf("\033[0m\n\n");
return 0;
}
else
menu(0, dperfil, opc, opp, opf);
break;
case 3: // Opciones
menu_opciones(opc, opp, opf);
menu(0, dperfil, opc, opp, opf);
break;
case 4: // Salir
printf("\033[34mProyecto final en C de la asignatura de Informática\nGrado en Ingeniería Aeroespacial\n\n Adrián Delgado Marcos\n Javier Lobato Pérez\n Pablo Rodríguez Robles");
printf("\033[0m\n\n");
break;
default:
menu(1, dperfil, opc, opp, opf); // Si no se selecciona ninguna opción correcta llama al menú sin imprimir las opciones hasta que se elija una que lo sea
break;
}
return 0;
}
bool usuarioCorrecto (const string &nombreUsuario, const string &dominio) {
bool correcto = false;
char c;
string tmpDominio;
istringstream flujo(nombreUsuario);
while (flujo >> c && c != '@') {
flujo >> c;
}
flujo >> tmpDominio;
if ("@" + tmpDominio == dominio)
correcto = true;
return correcto;
}
void VentanaPrincipal::actualizarVistaErrores(QString ruta)
{
QFile archivo(ruta + ".errores");
if (!archivo.open(QFile::ReadOnly | QFile::Text))
return;
QTextStream flujo(&archivo);
delete modeloErrores;
modeloErrores = new QStandardItemModel(0,5, this);
modeloErrores->setHeaderData(0, Qt::Horizontal, QObject::tr("Linea"));
modeloErrores->setHeaderData(1, Qt::Horizontal, QObject::tr("Columna"));
modeloErrores->setHeaderData(2, Qt::Horizontal, QObject::tr("Error"));
modeloErrores->setHeaderData(3, Qt::Horizontal, QObject::tr("Descripccion"));
modeloErrores->setHeaderData(4, Qt::Horizontal, QObject::tr("Linea de Error"));
vistaErrores->setModel(modeloErrores);
int i = 0;
while(!flujo.atEnd())
{
QStringList tmp = flujo.readLine().split(",,,");
modeloErrores->insertRow(i);
modeloErrores->setData(modeloErrores->index(i, 0), tmp[0]);
modeloErrores->setData(modeloErrores->index(i, 1), tmp[1]);
modeloErrores->setData(modeloErrores->index(i, 2), tmp[2]);
modeloErrores->setData(modeloErrores->index(i, 3), tmp[3]);
tmp[4] = tmp[4].trimmed();
modeloErrores->setData(modeloErrores->index(i, 4), tmp[4]);
++i;
}
vistaErrores->resizeColumnToContents(0);
vistaErrores->resizeColumnToContents(1);
vistaErrores->resizeColumnToContents(2);
vistaErrores->resizeColumnToContents(3);
}
parVectorMap parser::parsear(ifstream* fich, bool verbose) {
// Inicialización de variables implicadas
errores = 0;
countLine = 0;
estado = 0;
etiquetasCompletamenteDefinidas = 0;
etiquetasPendientes = 0;
traducirEtiqueta("string para ocupar la posición 0, no tiene utilidad");
bool comentario = false;
// Inicialización de las expresiones regulares implicadas
regex coments("(;)(.*)");
regex igual("^(.*)(=)(.*)$");
regex estrella("^(.*)(\\*)(.*)$");
regex tag("^(.*)(:)$");
regex salto("^[jJ](.*)");
regex digito("^(.*)[[:digit:]]+");
regex halt("(halt)|(HALT)");
// Declaración de variables auxiliares
string buff;
string linea;
instruccionTemp tmpIns;
std::vector<char> v;
while (getline(*fich, linea)) {
countLine++;
istringstream flujo(linea);
string token;
tmpIns = instruccionTemp();
while (flujo >> token) {
bool palabraReservada = false;
if (verbose) {
cout << endl << token << "\t";
}
if (regex_match(token, coments)) {
// si encontramos ';' saltar a la siguiente línea
if (verbose) {
cout << "Comentario, saltando línea";
}
comentario = true;
break;
} else if (regex_match(token, halt)) {
if (verbose) {
cout << "Fin del programa";
}
tmpIns.opcode = HALT;
} else {
if (regex_match(token, igual) || regex_match(token, estrella)) {
if (estado == 1 || estado == 5) {
if (estado == 1) tmpIns.opcode = traducirOpcode(buff);
// Lo siguiente será un número
if (token[0] == '=') {
if (tmpIns.opcode != 1 && tmpIns.opcode != 2) {
tmpIns.especial = IGUAL;
} else {
cout << "[!] Error, la codificación '=' es inválida para las "
"instrucciones READ Y STORE\n";
break;
}
} else {
tmpIns.especial = ESTRELLA;
}
if (verbose) {
cout << "Instrucción compleja '" << token[0] << "' ";
}
token = token.substr(1);
palabraReservada = true;
estado = 4;
} else {
errorOut(token);
}
}
if (regex_match(token, digito)) {
if (estado == 1) {
// Fin de instrucción simple
tmpIns.operando = atoi(token.c_str());
if (verbose) {
cout << "Instrucción simple, '" << buff << "' fue el opcode "
<< traducirOpcode(buff) << endl;
}
tmpIns.opcode = traducirOpcode(buff);
estado = 0;
palabraReservada = true;
} else if (estado == 5 || estado == 4) {
// Fin de instrucción compuesta
tmpIns.operando = atoi(token.c_str());
if (verbose) {
cout << " de valor " << atoi(token.c_str()) << ", '" << buff
<< "' fue el opcode " << traducirOpcode(buff) << endl;
}
tmpIns.opcode = traducirOpcode(buff);
estado = 0;
palabraReservada = true;
} else {
errorOut(token);
}
}
if (regex_match(token, tag)) {
if (estado == 1) {
// Lo siguiente será el descriptor de etiqueta
etiqueta_indice.insert(pair<short, int>(
traducirEtiqueta(buff), (vectorInstrucciones.size())));
if (verbose) {
cout << "Ahora espero un opcode, '" << buff
<< "' era la etiqueta de entrada " << traducirEtiqueta(buff);
}
estado = 3;
palabraReservada = true;
} else if (estado == 0) {
// lo siguiente será un opcode
string aux = token.substr(0, token.size() - 1);
etiqueta_indice.insert(pair<short, int>(
traducirEtiqueta(aux), (vectorInstrucciones.size())));
if (verbose) {
cout << "Ahora espero un opcode, '" << aux
<< "' es la etiqueta de entrada " << traducirEtiqueta(buff);
}
estado = 3;
palabraReservada = true;
} else {
errorOut(token);
}
}
if (regex_match(token, salto)) {
if (estado == 1 || estado == 3 || estado == 0) {
// Lo siguiente será el descriptor de etiqueta
tmpIns.opcode = traducirOpcode(token);
etiquetasPendientes++;
if (verbose) {
cout << "Esto es un salto, ahora espero una etiqueta a la que "
"saltar";
}
estado = 2;
palabraReservada = true;
} else {
errorOut(token);
}
}
if (!palabraReservada) {
if (estado == 0) {
// cargamos en el buffer el token en espera de averiguar si es una
// instrucción o una etiqueta
if (verbose) {
cout << "Guardado en buffer";
}
estado = 1;
buff = token;
} else if (estado == 3) {
// lo obtenido es el opcode de la instrucción
if (verbose) {
cout << "Este es el opcode " << traducirOpcode(token);
}
tmpIns.opcode = traducirOpcode(token);
estado = 5;
buff = token;
} else if (estado == 2) {
// lo obtenido es la etiqueta a la que se salta
tmpIns.tagSalida = traducirEtiqueta(token);
if (verbose) {
cout << "Esta es la etiqueta de salida " << tmpIns.tagSalida
<< endl;
}
estado = 0;
} else {
errorOut(token);
}
}
}
}
// construir instrucción
if (tmpIns.opcode > -1) //! comentario
vectorInstrucciones.push_back(crearInstruccion(tmpIns));
comentario = false;
}
parVectorMap resultado;
if (etiquetasCompletamenteDefinidas < etiquetasPendientes) {
cout << "[!] Error, existen saltos a etiquetas sin definir" << endl;
errores++;
}
cout << endl << endl;
if (errores == 0)
resultado = {etiqueta_indice, vectorInstrucciones};
else
resultado = {etiqueta_indice, vector<instruccion*>(0)};
return resultado;
}
void Editor::on_btnCompilar_clicked()
{
try
{
QFile archivo("prueba.txt");
if (!archivo.open(QIODevice::WriteOnly | QIODevice::Text))
return;
QTextStream flujo(&archivo);
flujo << ui->textEdit->toPlainText() << "\n";
flujo.flush();
archivo.close();
yyin = fopen("prueba.txt","rt");
//YY_BUFFER_STATE bs = yy_create_buffer(yyin,YY_BUF_SIZE);
if( yyin )
{
if( yyparse() )
{
QMessageBox::about(this,"Parsing","Error?");
return;
}
else
{
QMessageBox::about(this,"Parsing","Completado...");
}
}
fclose(yyin);
//yy_flush_buffer(bs);
/*Limpiar UI*/
ui->listUtilizar->clear();
ui->listVariables->clear();
ui->listFunciones->clear();
Instruccion *instrucciones = Programa::obtenerInstancia()->instrucciones;
Instruccion *actual = instrucciones;
while(actual!=0)
{
actual->validarSemantica();
actual = actual->obtenerSiguiente();
}
string codigo="";
actual = instrucciones;
while(actual!=0)
{
codigo += actual->generarCodigoJava();
actual = actual->obtenerSiguiente();
}
QString funcs = QString(Programa::obtenerInstancia()->obtenerCodigoFunciones().c_str()) ;
QMessageBox::about(0,"Codigo Generado",
funcs+
QString(Programa::obtenerInstancia()->obtenerCodigoVariablesADeclarar().c_str()) +
QString(codigo.c_str()) );
correlativo = 0;
vector<VariableDeclarada*> *variables = Programa::obtenerInstancia()->tablaDeVariables;
for(unsigned int i =0; i<variables->size();i++)
{
VariableDeclarada* declarada = variables->at(i);
QString res = "";
res += QString(declarada->obtenerVariable()->obtenerIdentificador()->c_str());
res += ": ID= ";
res += QString::number(declarada->obtenerIdDeExpresion());
if( declarada->obtenerTipo()->tipo == Arreglo )
{
res += " [ARREGLO]";
}
ui->listVariables->addItem(res);
}
Programa::obtenerInstancia()->limpiarInstancia();
}
catch(ExcepcionLegus exa)
{
int linea = exa.obtenerNumeroDeLinea();
QString lineaError = linea==0?"":QString("Alrededor de la linea: ")+QString::number(linea);
QMessageBox::about(0,"Error",QString(exa.obtenerMensaje().c_str())+lineaError);
}
/*Agregar optimizador de codigo, Borrar variables que no se usan, ofuscar el codigo*/
}
