buffer contents swapping

I need another pair of eyes, etc. to review my code for logic errors.

Here's what the program should do:
1. read in half of input file to buffer
2. read last half BUT swap each byte read with last byte from buffer back into

file, decrementing buffer end position each time.
3. write back buffer contents to 1st half of file.
in other words, it should reverse the contents of the file. running the program

twice should give you back the original file. AND rules 1-3 must be followed.

Problem for me is my code works OK for 2 byte as this is what I get running

program twice.
as -> sa -> as

But for 4 bytes or more, error.
For 4 bytes, this is what happens to contents
todo -> .dot -> .od.

More bytes = messed up text

I can't seem to find the logic error in my code. Can you?

functions called in this order:
readfirst()
swaphalves() //error in here?
writefirst()

Here's what I have:

Code:

//global vars
FILE *dfile; //file handle
long fsize; //var used to calculate filesize
long readto; //var used to read/write half of file

long back = -1; //for seeking
long forward = 1;

//vars in main()
long byte = 0;

fsize = FileSize(dfile);
readto = fsize/2;

char *buffer;
buffer = (char*) malloc( sizeof(char)*readto );

//this function seems to be the problem
void swaphalves(FILE* afile, long& byte, char* buffer){
	
	unsigned char chr;
	long revpos = byte-1; //counter for reversing buffer contents
	chr = fgetc(afile);
	byte++;
	while(byte < fsize){
	//while(!feof(dfile)){
		//put back last char in buffer to file, seek back 1
		fseek (afile, back, SEEK_CUR);
		fputc(buffer[revpos],afile);
		//put latest char read from file to current buffer pos & 

decrement buffer pos
		buffer[revpos--] = chr;
		//seek forward 1 for get next char
		fseek (afile, forward, SEEK_CUR);
		chr = fgetc(afile); 
		byte++;
	}
	//take care of last char
	//put back last char in buffer to file, seek back 1
	fseek (afile, back, SEEK_CUR);
	fputc(buffer[revpos],afile);
	//put latest char read from file to current buffer pos
	buffer[revpos] = chr;
	//fseek (afile, forward, SEEK_CUR);

	//for debugging
	printf("Buffer: ");
	for(int i = 0; i < readto; i++)
		printf("%c",buffer[i]);
	return;
}

//function works ok in testing
void readfirst(FILE* afile, long& byte, char* buffer){
	buffer[byte] = fgetc(afile);
	byte++;
	while(byte < readto)
		buffer[byte++] = fgetc(afile);

	//for debugging
	printf("Buffer: ");
	for(int i = 0; i < readto; i++){
		printf("%c",buffer[i]);
	}
	putchar('\n');

	return;
}

//function should be ok i believe
void writefirst(FILE* afile, const long& length, char* buffer){
	fseek (afile, 0L, SEEK_SET);
	fwrite(buffer,sizeof(char),length,afile);
	return;
}

This is not C...

Code:

void swaphalves(FILE* afile, long& byte, char* buffer){

Are you compiling with a C++ compiler or something?

yes, it's a mix of C & C++, technically. I know, I know that's bad...

"A mix of C & C++" makes it C++. As such, it should be posted on that forum.

Quzah.

Given a suitable buffer

Code:

fread( &buff[size/2], size/2, 1, fp );
fread( buff[0], size/2, 1, fp );
fwrite( buff, size, 1, out );

I looked over my code and refined it as best I could. I pinpointed the problem to swaphalves(). my buffer read & write functions are ok.

for an input file content of: todo
(which is 4 bytes)

if i run read buffer function and swaphalves but don't call a buffer write, I get : tooto

when the result should be: toot
because a final write buffer should produce: odot
if I call write buffer now, i get: odoto

I can't make out where the extra character at the end comes from. Can you help me trace its source?

Here's the refined swaphalves code:

Code:

void swaphalves(char* buffer){

	int nread = (int) readto;  //counter to check EOF
	int fend = (int) fsize;	   //indicates EOF
	int byte;				   //tmp var to stor a byte
	long back = -1L;		   //var for seeking back 1 byte
	int revpos = (int) readto; //counter for reversing buffer contents
	revpos--;					//workaround as ((int) readto) - 1 gave bad result
	
	while(((byte = fgetc(dfile)) != EOF) && (nread < fend)){
		
		//loop to swap a byte from current file pos with current buffer pos

		//put back last byte in buffer to file, seek back 1
		fseek(dfile,back,SEEK_CUR);
		fputc(buffer[revpos],dfile);
		//file ptr will auto mov to original pos after call to fputc
		
		//put latest byte read from file to end of buffer & decrement buffer position
		buffer[revpos--] = (char) byte;
		
		//get next byte in file in next while loop
		nread++; //increment # bytes read indicator
	}

	return;
}

last, how might I go about moving a post to another forum say C++ without double posting?

Posting to another fourm, the mods will do that for you. As to your code. Please post your refactored program so we can see it in full.

pardon the possibly messy code, it's in testing phase:

Code:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

/*fncs*/
long FileSize (FILE *stream);
void readfirst(char* buffer);
void writefirst(char* buffer);
void swaphalves(char* buffer);

//Declare global variables
//Global variables used to avoid passing variables into functions
FILE *dfile; //file handle for database file
long fsize; //var used to calculate filesize
long readto; //var used to read/write half of file

int main(int argc,char *argv[])
{	
	//1 - check input
	if (argc<2)
	{
		puts("No input file specified. Please type command again with filename.\n");
		return 0;//Self explanatory
	}
	
	//2 - Open input file
	dfile = fopen(argv[1], "rb+");
	//Abort program & display error if file open fails
	if(dfile==NULL)
	{
		printf("Bad filename or file does not exist.\n");
		return 1;
	}

	//3 - Get file size
	fsize = FileSize(dfile);
	readto = fsize/2;
	//not dealing with ODD file size cases at present
	
	char *buffer;
	buffer = (char*) malloc( sizeof(char)*readto );
	
	//4 - read in half of file contents
	readfirst(buffer);

	//5 - swap contents in buffer w/ content in 2nd half of file
	swaphalves(buffer);

	//6 - write back swapped half of file to 1st half of file
	//writefirst(buffer);	

	//7 - Notify operation complete
	puts("Half file swap operation completed.\n");
	
	//8 - Exit program
	free(buffer);
	fclose(dfile);
	return 0;
}

long FileSize (FILE *stream)
{
	long length;//temp variable
	fseek (stream, 0L, SEEK_END);//seek to EOF
	length = ftell(stream);//store EOF byte position which is filesize
	//reset file for future reading by seeking to origin
	fseek (stream, 0L, SEEK_SET);
	return length;//return filesize
}

void swaphalves(char* buffer){

	int nread = (int) readto;  //counter to check EOF
	int fend = (int) fsize;	   //indicates EOF
	int byte;		   //tmp var to stor a byte
	long back = -1L;	   //var for seeking back 1 byte
	int revpos = (int) readto; //counter for reversing buffer contents
	revpos--;		   //workaround as ((int) readto) - 1 gave bad result
	
	while(((byte = fgetc(dfile)) != EOF) && (nread < fend)){
		
		//loop to swap a byte from current file pos with current buffer pos

		//put back last byte in buffer to file, seek back 1
		fseek(dfile,back,SEEK_CUR);
		fputc(buffer[revpos],dfile);
		//file ptr will auto mov to original pos after call to fputc
		
		//put latest byte read from file to end of buffer & decrement buffer position
		buffer[revpos--] = (char) byte;
		
		//get next byte in file in next while loop
		nread++; //increment # bytes read indicator
	}
	return;
}

void writefirst(char* buffer){
	fseek (dfile, 0L, SEEK_SET);
	fwrite(buffer,readto,1,dfile);
	return;
}

void readfirst(char* buffer){
	fread(buffer,readto,1,dfile);
	return;
}