コード例 #1
0
ファイル: VentanaPrincipal.cpp プロジェクト: seguame/Sendero
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;
    }
}
コード例 #2
0
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;
}
コード例 #3
0
/* 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;
}
コード例 #5
0
ファイル: VentanaPrincipal.cpp プロジェクト: seguame/Sendero
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);

}
コード例 #6
0
ファイル: parser.cpp プロジェクト: alu0100783230/RAM
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;
}
コード例 #7
0
ファイル: editor.cpp プロジェクト: ProyectoLegus/Legus
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*/
}