Thread: Passing parameters to a module

If you have a pointer, you can return NULL. For example,

Code:

char *ReturnString(){
     char* String = "Test"
     String = NULL
     return String;
}

- Sean

1. I would like to return something if the file does not open? How can I return the NULL? Is this the correct way to do this?
How do I access the returned integer from the calling pgm to then exit the pgm is the file has not been opened?

If return 0 = the program returned 0.
If return 1 = the program returned 1.

You can create a quick batch file to test if your porgram returns status' properly.
If the program your trying the capture the output of returns status' properly, then your in buisness. If it doesn't, your stuck.

Batch file:

Code:

MyPgmToTest.exe
if errorlevel 1 echo Program errored
if errorlevel 0 echo Program executed properly

MyPgmToTest.exe is the program you will test the return status of. When the program returns 0 it generally means nothing was returned and everything went smoothly. If it returns 1 it generally means something went wrong. You could convert this into C code. It is similar to file existance checking and the errorlevel checking of a system call. If the program you are executing with system returns status' properly then you can capture the return status.

Examples:

Return status of file exsitance checking:

Code:

FILE * Tmp;
if ( ( Tmp = fopen("foo.txt", "r") ) == 0 )
{
    printf("file doesn't exist");
}
else
{
    printf("File does exist");
}

Return status of program executions:

Code:

if(system("foo.exe") == 1)
{
    printf("an error occured");
}
else
{
    printf("Everything went fine");
}

P.S. this was done fairly quickly so don't think to highly of it, it should present some options though..

Originally posted by Sue Paterniti

1. I would like to return something if the file does not open? How can I return the NULL? Is this the correct way to do this?
How do I access the returned integer from the calling pgm to then exit the pgm is the file has not been opened?

Have a look at this code.

Code:

#include <stdio.h>

FILE *OpenFile(char *, char *);

int main(void)
{
	FILE *fp;
	
	if ((fp = OpenFile("myfile.txt", "r")) == NULL)
	{
		perror("myfile.txt");
		return (1);
	}
	
	printf("file opened successfully");
	
	fclose(fp);
	
	return (0);
}

FILE *OpenFile(char *fn, char *mode)
{
	FILE *fp;
	
	fp = fopen(fn, mode);

	/* assumes error checking is done externally to the is function */	
	return (fp);
}

In OpenFile(), the file pointer is returned. If the fopen() failed, it value of fp will be NULL, and the calling function catches the error. It then uses perror() to print a meaningful error message.
perror() uses the int variable errno, which you can also access yourself if you want.

In my code, there's no real point in having the fopen() in a seperate function, you can just call fopen() from within main(). It just serves an example.

Also, if your ever need to return null:
>return (NULL);

Lastly, the exit code from main() shouldn't be >255 if you want to trap it in the calling shell (DOS or UNIX). I am pretty sure those environments only use 1 byte to determine the exit code of a program, hence the 255 limit.

I can see where you going with this now . Took it a bit of time going into me head, but I'm there now!

Right, your function declarations are incorrect.

Code:

FILE filebinaryopen(name_type filename, mode_type outmode) {
   fp = fopen(filename, outmode);   return(*fp); }

Here you say you should be returning FILE, but infact you are returning FILE*, a pointer. To fix this change this to:

Code:

FILE *filebinaryopen(name_type filename, mode_type outmode) {
   fp = fopen(filename, outmode);   return(*fp); }

Depending on what you are going to do with the file pointer, you could return go about the return int method, but I'd strongly suggest not. The better way is to return the FILE*, that way the caller can pass the same file pointer to another function.

For example, if you only returned an int denoting success/failure, how would you go about using the FILE* you had just opened? You couldn't, is the simple answer.

This may be irrellevant now, but in your code that seg faults, what is the e variable about? It doesn't seem to be declared.

Also, extern is spelt with a b , but I'm sure you knew that anyways.
>exterb FILE filebinaryopen(name_type filename, mode_type outmode);

Lastly, if you have a function called ...binaryopen, why do you need to pass the mode parameters? Surely you know it's "wb", or maybe "rb". Just a thought.....

Doh! Didn't spot your other minor mistake the first time round!

Code:

FILE * filebinaryopen(name_type file1) {   fp = fopen(file1, "wb");
   return(fp1):}

Note the return(fp1); bit. You must return the pointer.

Looking again though... where is fp defined?

I presume that in the file pointed to by fp is a list of filenames to go do stat()'s on? If so, you will need an array to hold the results of the stat() calls (if you only have one struct, it'll only hold only files worth of data).

Here's a suggestion (follow it if you want, there are many ways to do what you ask):

- In main (or the parent function), create an array of struct stat's.
- Open the config file.
- Pass fp, the array pointer, and the array size to the collectstat() function.
- collectstat() then reads the config, doing it's stat calls. It uses a local struct stat to store it's initial results.
- As each stat() is successfully performed, copy the local stat to the next free element in the array.
- If a stat() call fails, issue a warning or whatever. I don't know if what the local stat struct will hold in this event, but it probably won't be valid, so you best ignore it. Maybe research that one a bit more.
- Keep a count of how many successful stat()'s you do.
- collectstat() then returns the count of stat()'s successfully called.
- main() can then process the array as it wants, from element 0 to element N (as returned from collectstat() ).

To write out the data, create another function that takes a pointer to the array of structs (and the number of elements used).

It's probably all a little more complicated than you originally thought, but hey, it's good learning.

OK... sorry, I got carried away with myself!

The idea of a static variable is that the next time you enter the function, it will still hold the same data as when you last left that function. You can also return a pointer to that variable so that you can use it externally to the function it's defined in.

So, try this:

Code:

struct stat *collectstat(FILE *fp)
{
	static struct stat file_info;
	char in_file[1024]; // or whatever length
	// this doesn't print error messages if anything fails.	
	if (fgets(in_file, 1024, fp))
	{
		if (access(in_file,R_OK) == 0)
		{
			if (stat(in_file, &file_info) != -1)
				return (&file_info);
		}
	}
	return (NULL);
}

You'll need to call this multiple times to get each line. The caller can use the struct stat pointer (first testing to ensure it's not null). Let me know how you go.