int main() {
char* fichero_existente = "/FICHEROS/lectura/leer_escritura_varios_tamanyos256";
char* fichero_no_existente = "/FICHEROS/lectura/leer_escritura_varios_tamanyos64";
//Montar disco.
printf("abrir_fichero_exista_noexista -> Montando el disco en la particion /FICHEROS/lectura con discoFS\n");
if(montar("disco", "lectura", "discoFS") < 0) {
printf("abrir_fichero_exista_noexista -> Error al montar particion lectura en disco con discoFS.\n");
}
//Abrir ficheros
int fd64 = abrir(fichero_no_existente, T_FICHERO);
if(fd64 < 0) {
printf("abrir_fichero_exista_noexista: Error al abrir fichero origen %s\n", fichero_no_existente);
return -1;
}
int fd256 = abrir(fichero_existente, T_FICHERO);
if(fd256 < 0) {
printf("abrir_fichero_exista_noexista: Error al abrir fichero origen %s\n", fichero_existente);
return -1;
}
printf("abrir_fichero_exista_noexista -> %s -> fd = %d", fichero_no_existente, fd64);
printf("abrir_fichero_exista_noexista -> %s -> fd = %d", fichero_existente, fd256);
//Mostrar ficheros.
char buffer[TAM_BUFFER + 1];
int leidos;
bzero(buffer, TAM_BUFFER + 1);
leidos = leer(fd256, buffer, TAM_BUFFER);
int leidos256 = leidos;
while(leidos > 0) {
printf("%s",buffer);
bzero(buffer, TAM_BUFFER + 1);
leidos = leer(fd256, buffer, TAM_BUFFER);
leidos256 += leidos;
}
printf("Leidos(%s): %d\n", fichero_existente, leidos256);
bzero(buffer, TAM_BUFFER + 1);
leidos = leer(fd64, buffer, TAM_BUFFER);
int leidos64 = leidos;
while(leidos > 0) {
printf("%s",buffer);
bzero(buffer, TAM_BUFFER + 1);
leidos = leer(fd64, buffer, TAM_BUFFER);
leidos64 += leidos;
}
printf("Leidos(%s): %d\n", fichero_no_existente, leidos64);
//Cerrar ficheros
cerrar(fd64);
cerrar(fd256);
return 0;
}
void main(){
flujo = 0;
abrir();
leer();
cerrar();
printf("buffer leido: %s \n", databuffer);
system("pause");
while(flujo == 0){
intentos = 10;
clearScreen();
copy_from_buffer_to_local();
rellena_cadenaRevelada(); //rellenar con guiones
implementar_mouse();
imprimeAbecedario();
if(game_over == 0){
printf("se acabaron los intentos \n");
printf("llegaste a formar: %s\n", cadenaRevelada);
//flujo = 1;
}
printf("volver a jugar? (presiona ENTER)\n");
printf("salir de la aplicacion? (presiona ESC)\n");
teclaLetra();
}
system("pause");
}
int main() {
/*
ESCRITURA FICHEROS
*/
//Abrir fichero.
int fd512 = abrir("/FICHEROS/lectura/fichero_mul_child512", T_FICHERO);
printf("escribir_fichero_mul_child(%d) -> fd = %d", obtener_id_proceso(), fd512);
if(fd512 < 0) {
printf("escribir_fichero_mul_child(%d) -> Error al abrir fichero origen fichero_mul_child512\n", obtener_id_proceso());
return -1;
}
//Llenar bloque.
char buffer512[512];
char letra = (char) ('A' + obtener_id_proceso());
llenar_bloque(letra, buffer512, 512);
//Escribir bloque.
int escritos512 = escribir(fd512, buffer512, 512);
printf("escribir_fichero_mul_child(%d) -> Escritos(512%c): %d\n", obtener_id_proceso(), letra, escritos512);
//Cerrar fichero.
cerrar(fd512);
/*
SINCRONIZADO DISCOFS
*/
printf("escribir_fichero_mul_child(%d) -> Sincronizando el volumen montado en /FICHEROS/lectura\n", obtener_id_proceso());
if(sincronizar("lectura") < 0) {
printf("escribir_fichero_mul_child(%d) -> Error al sincronizar el volumen\n", obtener_id_proceso());
}
return 0;
}
StreamVariable::~StreamVariable(){
free(this->nombre);
// delete(this->listaVacios);
delete(this->archivoVacios);
if(this->archivo.is_open())
cerrar();
}
int main(){
char bloque[1025];
int fd_disco;
int ret;
int num_bloque=0;
int error_encontrado = 0;
int id_actual = obtener_id_proceso();
printf("Comprobando lectura por bloques (%d)\n", id_actual);
/* limpiar el bloque */
for(ret = 0; ret < 1024; ret ++){
bloque[ret] = 'n';
}
bloque[1024] = '\0';
/* abrir fichero origen */
fd_disco = abrir ("/DISPOSITIVOS/disco",0);
if (0 > fd_disco) {
printf("test_bloque_cdrom(%d): Error al abrir el cdrom\n", id_actual);
printf("### Result: Fail\n");
return (-1);
}
/* mostra cdrom por pantalla */
printf("test_disco_cdrom (%d) leyendo bloque %d\n", id_actual, num_bloque);
ret = leer(fd_disco, bloque, 1024);
error_encontrado = comprobar_valores(bloque, num_bloque);
while ((0 < ret) && !error_encontrado) {
fprintf(stdout, "{%s}FIN\n", bloque);
num_bloque++;
printf("test_disco_cdrom (%d) leyendo bloque %d\n", id_actual, num_bloque);
ret = leer(fd_disco, bloque, 1024);
if(ret > 0){
error_encontrado = comprobar_valores(bloque, num_bloque);
}
}
printf("Bloque final: %d, error_encontrado: %d\n", num_bloque, error_encontrado);
/* El Ãltimo bloque leido no deberÃa sobrepasar la imagen. */
if(num_bloque != 10){
printf("### Result: Fail\n");
}else{
if(!error_encontrado){
printf("### Result: OK\n");
}else{
printf("### Result: Fail\n");
}
}
/* cerrar cdrom */
cerrar (fd_disco);
return (0);
}
int main(){
char bloque[TAM_BLOQUE];
int fd_cdrom;
int ret;
int num=0;
printf("mostrar el cdrom por pantalla");
/* abrir fichero origen */
fd_cdrom = abrir ("/DISPOSITIVOS/cdrom",0);
if (0 > fd_cdrom) {
printf("copiar_disco: Error al abrir el cdrom\n");
return (-1);
}
/* mostra cdrom por pantalla */
printf("mostrar_disco: leyendo bloque %d\n\n\n",num);
ret = leer(fd_cdrom,bloque,TAM_BLOQUE);
while (0 < ret) {
printf("%s",bloque);
num=num+1;
printf("\n\nmostrar_disco: leyendo bloque %d\n\n\n",num);
ret = leer(fd_cdrom,bloque,TAM_BLOQUE);
}
/* cerrar cdrom */
cerrar (fd_cdrom);
return (0);
}
Inet_DI_4::Inet_DI_4(QWidget *parent) :
QWidget(parent),
ui(new Ui::Inet_DI_4)
{
ui->setupUi(this);
//Activamos el seguimiento del raton, solo interesan los eventos al dar click izquierdo
setMouseTracking( false );
//Emitimos una señal para identificar a cada widget cuando este sea clickeado por el usuario
connect(this,SIGNAL(clicked(int )),this,SLOT(idWindow(int)));
connect(ui->btCerrar,SIGNAL(clicked()),this,SLOT(cerrar()));
}
EVLista::EVLista( QWidget *parent, QObject *child, Qt::WFlags fl )
: EVentana( parent, fl )
{
QGridLayout *layout = new QGridLayout( this );
vista = new QTableView(this);
vista->setSizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding );
layout->addWidget( vista );
this->setLayout( layout );
// Propiedades varias
vista->setSelectionMode( QAbstractItemView::SingleSelection );
vista->horizontalHeader()->setResizeMode( QHeaderView::Stretch );
vista->setTextElideMode( Qt::ElideRight );
//////////////////////////////////////////////////////////////////////////////////////////
// Acciones Genericas
////////////////////////////////////////////////////////////////////////////////////////
ActAgregar = new QAction( "&Agregar", this );
ActAgregar->setIcon( QIcon( ":/imagenes/add.png" ) );
ActAgregar->setShortcut( QKeySequence( "Ctrl+a" ) );
ActAgregar->setToolTip( "Agregar un nuevo item ( Ctrl + a )" );
connect( ActAgregar, SIGNAL( triggered() ), child, SLOT( agregar() ) );
ActModificar = new QAction( "&Modificar", this );
ActModificar->setIcon( QIcon( ":/imagenes/editar.png" ) );
ActModificar->setShortcut( QKeySequence( "Ctrl+m" ) );
ActModificar->setToolTip( "Modifica el item actual ( Ctrl + m )" );
connect( ActModificar, SIGNAL( triggered() ), child, SLOT( modificar() ) );
ActImprimir = new QAction( "&Imprimir", this );
ActImprimir->setIcon( QIcon( ":/imagenes/impresora.png" ) );
ActImprimir->setToolTip( "Imprime el/los items seleccionados ( Ctrl + i )" );
ActImprimir->setShortcut( QKeySequence( "Ctrl+i" ) );
connect( ActImprimir, SIGNAL( triggered() ), child, SLOT( imprimir() ) );
ActEliminar = new QAction( "&Eliminar", this );
ActEliminar->setIcon( QIcon( ":/imagenes/eliminar.png" ) );
ActEliminar->setShortcut( QKeySequence( "Ctrl+e" ) );
ActEliminar->setToolTip( "Eliminar el o los items seleccionados ( Ctrl + e )" );
connect( ActEliminar, SIGNAL( triggered() ), child, SLOT( eliminar() ) );
ActBuscar = new QAction( "&Buscar", this );
ActBuscar->setIcon( QIcon( ":/imagenes/buscar.png" ) );
ActBuscar->setShortcut( QKeySequence( "Ctrl+b" ) );
ActBuscar->setToolTip( "Buscar items ( Ctrl + b )" );
connect( ActBuscar, SIGNAL( triggered() ), child, SLOT( buscar() ) );
ActCerrar = new QAction( "Cer&rar", this );
ActCerrar->setIcon( QIcon( ":/imagenes/fileclose.png" ) );
ActCerrar->setShortcut( QKeySequence( "Ctrl+r" ) );
ActCerrar->setToolTip( "Cierra esta ventana ( Ctrl + r )" );
connect( ActCerrar, SIGNAL( triggered() ), child, SLOT( cerrar() ) );
}
void borrar_cola_mensaje(DescriptorColas* cola, int worker, char tipo)
{
char nombre[7];
switch(tipo) {
case 'w':
cerrar(cola->worker);
cerrar(cola->anillo);
sprintf(nombre, "/cola%d", worker);
borrar(nombre);
break;
case 'd':
cerrar(cola->disp);
cerrar(cola->worker);
sprintf(nombre, "/cola%d", (worker+NUM_WORKER)%(2*NUM_WORKER));
borrar(nombre);
break;
}
free(cola);
}
//------------------------------------------------------
// void bucleMain(void)
//
// Descripción:
// Función del programa principal
//------------------------------------------------------
int
main (int argc, char* argv[])
{
//char tecla;
init();
while (1) {
enciendeLeds(0,8);
sleep(5);
enciendeLeds(1,7);
sleep(5);
enciendeLeds(2,6);
sleep(5);
enciendeLeds(3,5);
sleep(5);
enciendeLeds(4,4);
sleep(5);
enciendeLeds(5,3);
sleep(5);
enciendeLeds(6,2);
sleep(5);
enciendeLeds(0,1);
sleep(5);
enciendeLeds(1,0);
sleep(5);
}
//MenuPrincipal();
cerrar();
/**while (1){
tecla = teclado();
estado=tecla -'0';
switch (estado){
case MENU: // se queda dando vueltas GestionMenuPrincipal();
break;
case CARACTERIZACION: //Caracterizacion
GestionCaracterizacion();
break;
case ECUALIZACION: //Ecualizacion
GestionEcualizacion();
break;
case REVERBERACION: //Reverb
GestionReverb();
break;
default:
printf("\n*** Opcion elegida erronea. Vuelva a intentarlo. ***\n");
MenuPrincipal();
break;
}
} **/
return 0;
}
// Intenta moverse en una direccion
int intentar(paso_t ** S, char D) {
int c;
c = camino(*S, D);
// Encontramos la salida
if(c == SALIDA) {
printf("Encontramos la salida!\n");
}
// El camino esta cerrado
else if (c == CERRADO) {
cerrar(*S, D); // Si no se puede seguir, cerramos
printf("Intento hacia %c, camino cerrado.\n", D);
}
// Se puede continuar
else {
cerrar(*S, D);
avanzar(S, nodo());
cerrar(*S, opuesto(D));
printf("Avanzando hacia %c...\n", D);
}
return c;
}
// Soluciona la mazmorra
int solucion(void) {
int i;
paso_t * L = NULL;
paso_t * p = NULL;
// Agrego paso inicial, ingresando al laberinto hacia el norte
p = nodo();
cerrar(p, 'S');
avanzar(&L,p);
// Ciclo hasta salir del laberinto
do {
usleep(PAUSA);
if(L==NULL) {
printf("Volvimos a la entrada, el laberinto no tiene salida!\n");
exit(1);
}
if(L->N == ABIERTO) {
i=intentar(&L,'N');
}
else if (L->S == ABIERTO) {
i=intentar(&L,'S');
}
else if (L->O == ABIERTO) {
i=intentar(&L, 'O');
}
else if (L->E == ABIERTO) {
i=intentar(&L, 'E');
}
else {
printf("No se puede avanzar, retrocediendo un paso...\n");
retroceder(&L);
}
} while (i!=SALIDA);
return 0;
}
int main(){
char origen[MAX_STRING];
char buffer[TAM_BUFFER];
int escritos;
int ret;
int fd_origen;
printf("Montando el disco en la particion /FICHEROS/lectura con discoFS\n");
ret=montar("disco", "lectura", "discoFS");
if (0 > ret) {
printf("escribir_fichero: Error al montar particion lectura en disco con discoFS\n");
}
/* obtener los nombre de los ficheros */
printf("Introduzca el fichero destino EJ: /FICHEROS/lectura/datos:");
scanf("%s",origen);
/* abrir fichero origen */
fd_origen = abrir (origen,T_FICHERO);
if (0 > fd_origen) {
printf("escribir_fichero: Error al abrir fichero destino %s\n", origen);
return (-1);
}
llenar_bloque('A', buffer);
escritos = escribir(fd_origen,buffer,TAM_BUFFER);
printf("%d\n", escritos);
cerrar(fd_origen);
return (0);
}
MODBUSPuerto::~MODBUSPuerto() {
if (ctx != NULL ) cerrar();
}
int main(){
char origen[MAX_STRING];
char destino[MAX_STRING];
char buffer[TAM_BUFFER];
int fd_origen, fd_destino;
int leidos, escritos;
int ret;
/* montar debugfs */
printf("Montando la depuracion en la particion /FICHEROS/proc con debugFS\n");
ret=montar("", "proc", "debugFS");
if (0 > ret) {
printf("mostrar_fichero: Error al montar particion de depuracion con debugFS\n");
return (-1);
}
/* montar cdrom */
printf("Montando el cdrom en la particion /FICHEROS/lectura con cdromFS\n");
ret=montar("cdrom","lectura", "cdromFS");
if (0 > ret) {
printf("Copiar_fichero: Error al montar particion lectura en cdrom con cdromFS\n");
return (-1);
}
/* montar disco */
printf("Montando el disco en la particion /FICHEROS/escritura con discoFS\n");
ret=montar("disco","escritura", "discoFS");
if (0 > ret) {
printf("Copiar_fichero: Error al montar particion escritura en disco con discoFS\n");
return (-1);
}
/* obtener los nombre de los ficheros */
printf("Introduzca el fichero origen EJ: /FICHEROS/lectura/datos:");
scanf("%s",origen);
printf("Introduzca el fichero destino EJ: /FICHEROS/escritura/resultado:");
scanf("%s",destino);
/* abrir fichero origen */
fd_origen = abrir (origen, T_FICHERO);
if (0 > fd_origen) {
printf("Copiar_fichero: Error al abrir fichero origen %s\n", origen);
return (-1);
}
/* abrir fichero destino */
fd_destino = abrir (destino, T_FICHERO);
if (0 > fd_destino) {
printf("Copiar_fichero: Error al abrir fichero destino %s\n", destino);
return (-1);
}
/* copiar origen en destino */
leidos = leer(fd_origen,buffer,TAM_BUFFER);
while (0 < leidos) {
escritos = escribir(fd_destino,buffer,leidos);
if (leidos != escritos) {
printf("Copiar_fichero: Error al escribir fichero destino %s\n", destino);
return (-1);
}
leidos = leer(fd_origen,buffer,TAM_BUFFER);
}
/* cerrar fichero origen */
cerrar (fd_origen);
/* cerrar fichero destino */
cerrar (fd_destino);
/* sincronizar las escrituras */
printf("Escribiendo los cambios de la particion /FICHEROS/escritura en el disco\n");
sincronizar("escritura");
return 0;
}
int main(){
int retDebug;
int fd_origen = -1;
int fd_disco = -1;
int leidos = -1;
int seek = 0;
//PUEDE NECESITAR CAMBIO EN FUNCION DEL NUMERO DE DESCRIPTOR Y DEL NUMERO DE DISPOSITIVO
char cadenaDescFichero[200] = "DESCFICHERO:\tID=2, tipo=0, inodo=-1, montaje=-1, Dispositivo=3\n";
//char cadenaDescFichero[200] = "DESCFICHERO:\tID=2, tipo=0, inodo=-1, montaje=-1, Dispositivo=2\n";
char buffer[1024];
char *encontrado = NULL;
buffer[1023] = '\0';
/* montar debugfs */
//printf("Montando la depuracion en la particion /FICHEROS/proc con debugFS\n");
retDebug=montar("", "proc", "debugFS");
if (0 > retDebug) {
printf("test_e2_1_abrir_disco: Error al montar particion de depuracion con debugFS\n");
printf("### Result: Fail\n");
return (-1);
}
/* abrir fichero disco */
fd_disco = abrir ("/DISPOSITIVOS/disco", 0);
if (0 > fd_disco) {
printf("test_e2_1_abrir_disco: Error al abrir el disco \n");
printf("### Result: Fail\n");
return (-1);
}
/* abrir fichero tabla de descriptores (tabla_procesos) */
fd_origen = abrir ("/FICHEROS/proc/tabla_procesos", T_FICHERO);
if (0 > fd_origen) {
printf("test_e2_1_abrir_disco: Error al abrir fichero tabla_descriptores \n");
printf("### Result: Fail\n");
return (-1);
}
/*leemos la tabla de descriptores*/
bzero(buffer, 1023);
seek = 0;
leidos = leer(fd_origen,buffer,1023);
while (0 < leidos && leidos != 1023) {
seek += leidos;
leidos = leer(fd_origen,&(buffer[seek]),1023-seek);
}
printf("%s\n\n\n", buffer); //Falla con ficheros de imagen que tengan archivos de tamaño mayor que un bloque
cerrar(fd_origen);
cerrar(fd_disco);
/*buscamos datos en la tabla de descriptores*/
encontrado = strstr(buffer, cadenaDescFichero);
if(encontrado == NULL)
{
printf("test_e2_1_abrir_disco: Datos en la tabla de descriptores no encontrados \n");
printf("### Result: Fail\n");
return -1;
}
printf("### Result: OK\n");
return 0;
}
Buffer::~Buffer (){
if(archivo)
cerrar();
}
ui_new_compra_orden::ui_new_compra_orden(QWidget *parent) :
QWidget(parent),
ui(new Ui::ui_new_compra_orden)
{
ui->setupUi(this);
global = new ui_global_manager_articulos;
search_proveedor = new ui_search_proveedor;
search_transportista = new ui_search_transportista;
widget_tipo_cambio = new ui_tipo_cambio_dolar;
numRowsVisible = 0;
QPushButton *pb = ((ui_global_manager_articulos*)global)->getPB_add();
connect(pb, SIGNAL(clicked()), this, SLOT(on_external_pushButton_add()));
((ui_global_manager_articulos*)global)->set_cb_modalidad(ui->comboBox_modalidad);
((ui_global_manager_articulos*)global)->set_cb_tipo_moneda(ui->comboBox_tipo_moneda);
connect(((ui_tipo_cambio_dolar*)widget_tipo_cambio), SIGNAL(cerrar()), this, SLOT(on_widget_tipo_cambio_closing()));
QRegExp regExp_ruc("[0-9]{11,11}");
ui->lineEdit_codigoProveedor->setValidator(new QRegExpValidator(regExp_ruc));
init_lineEdit_proveedorNombre();
ui->lineEdit_codigoTransportista->setValidator(new QRegExpValidator(regExp_ruc));
init_lineEdit_transportistaNombre();
QRegExp regExp_serie("[0-9]{3,3}");
QRegExp regExp_numero("[0-9]{6,6}");
QRegExp regExp_decimal("[0-9]+.[0-9]{2,2}");
//ui->lineEdit_codigo->setReadOnly(true);
ui->dateEdit_emision->setDate(QDate::currentDate());
ui->dateEdit_sistema->setDate(QDate::currentDate());
ui->lineEdit_serie->setValidator(new QRegExpValidator(regExp_serie));
ui->lineEdit_numero->setValidator(new QRegExpValidator(regExp_numero));
//ui->lineEdit_numeroPercepcion->setValidator(new QRegExpValidator(regExp_decimal));
ui->lineEdit_subtotal->setValidator(new QRegExpValidator(regExp_decimal));
ui->lineEdit_igv->setValidator(new QRegExpValidator(regExp_decimal));
ui->lineEdit_total->setValidator(new QRegExpValidator(regExp_decimal));
ui->tableWidget_articulos->setColumnCount(7);
ui->tableWidget_articulos->setColumnWidth(0, 80);
ui->tableWidget_articulos->setColumnWidth(1, 120);
ui->tableWidget_articulos->setColumnWidth(2, 80);
ui->tableWidget_articulos->setColumnWidth(3, 80);
ui->tableWidget_articulos->setColumnWidth(4, 80);
ui->tableWidget_articulos->setColumnWidth(5, 80);
ui->tableWidget_articulos->setColumnWidth(6, 80);
//ui->tableWidget_articulos->setColumnWidth(7, 80);
ui->tableWidget_articulos->setHorizontalHeaderItem(0, new QTableWidgetItem("Codigo"));
ui->tableWidget_articulos->setHorizontalHeaderItem(1, new QTableWidgetItem("Descripcion"));
ui->tableWidget_articulos->setHorizontalHeaderItem(2, new QTableWidgetItem("Marca"));
ui->tableWidget_articulos->setHorizontalHeaderItem(3, new QTableWidgetItem("Medida"));
ui->tableWidget_articulos->setHorizontalHeaderItem(4, new QTableWidgetItem("Cantidad"));
ui->tableWidget_articulos->setHorizontalHeaderItem(5, new QTableWidgetItem("Precio Unit."));
ui->tableWidget_articulos->setHorizontalHeaderItem(6, new QTableWidgetItem("Precio Total"));
//ui->tableWidget_articulos->setHorizontalHeaderItem(7, new QTableWidgetItem("Precio Total"));
//global->setAttribute(Qt::WA_DeleteOnClose);
((ui_global_manager_articulos*)(global))->setTableWidget(ui->tableWidget_articulos);
/*
cart = new ui_shopping_cart;
cart->setAttribute(Qt::WA_DeleteOnClose);
shoppingCart = new shoppingCart;
shoppingCart->carritoDeCompras(global, cart, );
*/
//global->show();
}