Visualizzazione dei risultati da 1 a 9 su 9
  1. #1
    Utente di HTML.it
    Registrato dal
    Oct 2008
    Messaggi
    10

    [C] - Problema con ciclo for

    Salve a tutti, ho realizzato un buffer per operazioni di I/O su di un file a livello di bit. Il buffer prevede le funzioni di apertura, chiusura, lettura e scrittura.
    Per testare il buffer ho creato un main in cui riempio il buffer con valori tra 0 e 499 e poi li leggo. Il problema sta che quando eseguo la read sul buffer all'interno di un ciclo for il programma effettua la lettura ma non incrementa il contatore del for. Potreste aiutarmi sto letteralmente sbattendo la testa da 2 giorni.
    Ecco il codice del main:
    codice:
    int main() {
    	BITFILE* WBUF=bitfile_open("/home/enzo/Scrivania/test_buffer.txt",MODE_WRITE);
    	for (int var = 0; var < 500; ++var)
    	{
    		bitfile_write(&WBUF,&var,9);
    	}
    	bitfile_close(WBUF);
    	BITFILE* RBUF=bitfile_open("/home/enzo/Scrivania/test_buffer.txt",MODE_READ);
    	int i;
    	int letti;
    	for(i=0;i<10;i++)
    	{
    		printf("i: %d\n",i);
    		int result=bitfile_read(&RBUF,&letti,9);
    		if(result!=-1)
    		printf("letti: %d\n",letti);
    		else
    		printf("err\n");
    	}
    }
    questo e' il codice del buffer:
    codice:
    int minimo(int a,int b)
    {
    	return (a<=b)?a:b;
    }
    
    BITFILE* bitfile_open(char* filename,int mode)
    {
    	int fd;
    	BITFILE* p;
    	if(mode!=0 && mode !=1)
    	{
    		errno=EINVAL;
    		return NULL;
    	}
    	fd=open(filename,(mode==0?O_RDONLY: ( O_WRONLY | O_CREAT )),0644);
    	if(fd<0)
    	{
    		return NULL;
    	}
    	p=calloc(1,sizeof(BITFILE));
    	if(p==NULL)
    	{
    		close(fd);
    		errno=ENOMEM;
    		return NULL;
    	}
    	p->FD=fd;
    	p->mode=mode;
    	p->POS=0;
    	return p;
    }
    
    int bitfile_read(BITFILE** _P,uint64_t* D,int LEN)
    {
    	BITFILE* P=*_P;
    	if(P->mode!=MODE_READ)
    	{
    		printf("Lettura non consentita buffer aperto in modalita' scrittura");
    		return -1;
    	}
    	int LEN2=LEN;
    	int bit_letti=0;
    	int pos=P->POS;
    	uint64_t D1;
    	int bit_D=0;
    	if(P->LEN==BITBUF_SIZE_IN_BITS || P->POS==0 )
    	{
    		//printf("carico \n");
    		int temp=read(P->FD,P->BUF,BITBUF_SIZE);
    		if(temp<=0)
    			return -1;
    		P->LEN=0;
    		P->POS=8*temp;
    		pos=P->POS;
    		LEN2=minimo(LEN2,pos-P->LEN);
    	}
    	while (LEN>0)
    	{
    		LEN2=LEN;
    		if(pos-P->LEN<=0)
    		{
    			int temp=read(P->FD,P->BUF,BITBUF_SIZE);
    			if(temp<=0)
    				return -1;
    			P->LEN=0;
    			P->POS=8*temp;
    			pos=P->POS;
    			D1=*D;
    			bit_D=bit_letti;
    			LEN2=minimo(LEN2,pos-P->LEN);
    		}
    		int to_read=minimo(LEN2,pos-P->LEN);
    		int ultimo=P->LEN+to_read-1;
    		int OFS=ultimo/8; int sx_ofs=ultimo%8;
    		int dx_ofs=0;
    		if(sx_ofs+1<=to_read)
    			to_read=sx_ofs+1; // devo leggere + di quello che posso => leggo solo quello che posso
    		else
    			dx_ofs=sx_ofs-to_read+1; // devo leggere - di quello che posso => leggo solo quello che serve
    		uint8_t MASK=(1<<(sx_ofs+1))-1;
    		*D<<=to_read;
    		*D|=((P->BUF[OFS]&MASK)>>dx_ofs);
    		LEN-=to_read;
    		bit_letti+=to_read;
    		pos-=to_read;
    	}
    	if(bit_D>0)
    	{
    		uint64_t mask;
    		mask=(uint64_t)pow(2,bit_D)-1;
    		while(bit_D>31)
    		{
    			*D<<=31;
    			bit_D-=31;
    		}
    		*D<<=bit_D;
    		*D|=D1 & mask;
    	}
    	P->LEN+=bit_letti-bit_D;
    	*D&=(uint64_t)pow(2,bit_letti)-1;
    	*_P=P;
    	return bit_letti;
    }
    
    int bitfile_write(BITFILE** _P,uint64_t *SRC,int LEN)
    {
    	BITFILE* P=*_P;
    	uint64_t D=*SRC;
    	if(P->mode!=MODE_WRITE)
    	{
    		printf("Scrittura non consentita buffer aperto in modalita' lettura");
    		return -1;
    	}
    	uint8_t mask=0;
    	int OFS,K,RES,LEN2;
    	int err;
    	LEN2=LEN;
    	while(LEN2>0)
    	{
    		OFS=P->POS/8;
    		K=P->POS%8;
    		RES=8-K;
    		if(LEN2<RES) //devo scrivere meno di quello che posso
    			RES=LEN2; //segnalo che devo scrivere solo LEN2
    		mask=(1<<RES)-1;
    		P->BUF[OFS]&=(1<<K)-1; //azzereo i bit da scrivere
    		P->BUF[OFS]|=(D & mask)<<K; //scrivo
    		LEN2-=RES;
    		P->POS+=RES;
    		D>>=RES;
    		if(P->POS >= BITBUF_SIZE_IN_BITS)
    		{
    			err=safe_write(P->FD,P->BUF,BITBUF_SIZE_IN_BITS);
    			P->POS=0;
    		}
    	}
    *_P=P;
    return LEN;
    }
    
    int bitfile_close(BITFILE* P)
    {
    	int err=0;
    	if(P->mode==MODE_WRITE)
    	{
    	 err=safe_write(P->FD,P->BUF,P->POS);
    	}
    	close(P->FD);
    	bzero(P,sizeof(BITFILE));
    	free(P);
    	return err;
    }
    
    int safe_write(int fd,uint8_t* buf,int pos)
    {
    if(pos>0)
     {
      int OFS=pos/8;
      if (pos%8!=0)
      	{
      	  int K=pos%8;
      	  buf[OFS]&=(1<<K)-1;
      	  OFS+=1;
      	}
      int err=write(fd,buf,OFS);
      return err;
     }
    else
      return 0;
    }
    vi posto anche il punto h
    codice:
    #ifndef BITFILE_H_
    #define BITFILE_H_
    #include <stdint.h>
    
    // dimensione del buffer in byte
    #define BITBUF_SIZE 1
    // dimensione del buffer in bit
    #define BITBUF_SIZE_IN_BITS (BITBUF_SIZE * 8)
    #define MODE_WRITE 1
    #define MODE_READ 0
    
    typedef struct
    {
    	int POS	; // primo bit libero per scrivere
    	int LEN;  // primo bit utilie per leggere
    	int mode; // 0 = READ; 1 = WRITE
    	int FD;   // riferimento al file
    	uint8_t BUF[BITBUF_SIZE]; // buffer
    }BITFILE;
    
    
    BITFILE* bitfile_open(char* nome,int mode);
    int bitfile_read(BITFILE** P,uint64_t* dst,int LEN);
    int bitfile_write(BITFILE** P,uint64_t *D,int LEN);
    int bitfile_close(BITFILE* P);
    int safe_write(int fd,uint8_t* buf,int byte);
    int minimo(int a,int b);
    
    #endif
    grazie mille!!

  2. #2
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,480
    Intendi che in questa for

    codice:
    	for(i=0;i<10;i++)
    	{
    		printf("i: %d\n",i);
    		int result=bitfile_read(&RBUF,&letti,9);
    		if(result!=-1)
    		printf("letti: %d\n",letti);
    		else
    		printf("err\n");
    	}
    la variabile i non risulta incrementata?
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  3. #3
    Utente di HTML.it
    Registrato dal
    Oct 2008
    Messaggi
    10
    esatto quando stampo a video la variabile i questa rimane sempre allo stesso valore per quindi risulta un ciclo for infinito ma la cosa ancora piu' strana che termina automaticamente quando legge tutto il buffer fino a quando la variabile result non diventa -1.

  4. #4
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,480
    Se scrivi

    int result=1; //bitfile_read(&RBUF,&letti,9);

    il ciclo si comporta regolarmente?
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  5. #5
    Utente di HTML.it
    Registrato dal
    Oct 2008
    Messaggi
    10
    si senza l'istruzione read il ciclo funziona regolarmente!

  6. #6
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,480
    Quindi, quella funzione "sporca" lo stack in maniera tale che anche la memoria dove è memorizzata la variabile i viene modificata tra una chiamata e l'altra.

    Non ho ancora controllato il codice della bitfile_read ma è lì dentro il problema ...
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  7. #7
    Utente di HTML.it
    Registrato dal
    Oct 2008
    Messaggi
    10
    in che senso sporca lo stack???

  8. #8
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,480
    Nel senso che viene scritto oltre la fine di un buffer dove il buffer non esiste ...
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  9. #9
    Utente di HTML.it
    Registrato dal
    Oct 2008
    Messaggi
    10
    ho controllato e nn mi sembra che ci siano di questi problemi!!

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.