Variadic function

Hi everyone. I'm trying to create a function called 'safeprint' which will always check whether the string to be printed actually made it out to the screen. It should be called like this:

int result = safeprint ( __FILE__ , __LINE__ , "Blah blah\n", ... ) ;
if (result < 0 ) // something bad happened

I am doing this partly to make up for my pedantic error checking habit. The problem is that since printf is a variadic function, my function has to be too. How do I make this code work ?

Richard

Code:

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

#include "Error.h"

static const unsigned int StringMax = 100 ;

int safeprint ( const char* file , const unsigned int line , const char* pstring , ... )
{
	char buffer [ StringMax ] ;
	int ilength = snprintf ( buffer , StringMax , pstring , ... ) ;
	int icharsprinted = printf ( "%s" , buffer ) ;
	if ( ilength != icharsprinted )
	{
		ErrorMessage ( "Couldn't print to screen." , file , line ) ;
		return -1 ;
	}

	return 0 ;
}

Richard... believe me, no offense is intended by this, but man you are so over the top on this error checking thing. Seriously, this is more than a tad ridiculous...

Lets say your text doesn't make it to the screen...
What will be your first clue?
Could it be that blank spot on the screen?
If you have no access to the screen, how do you plan to report the error?

Moreover, all that error checking --that never gets triggered-- does little more than slow your code down.

To answer your question about variadic functions... Question 15.4

Mate, I know I'm over the top. Maybe it's obsessive-compulsive disorder. If there's a potential error that goes unchecked I can't concentrate on anything else until it's checked.

I'd like to point out, though, that printf goes to stdout and my ErrorMessage() goes to stderr. Indeed, ErrorMessage() could start playing the Toccata and Fugue in D Minor or flash a lightbulb. This is a Wikipedia bot, intended to run unattended at high speed and where unexpected behaviour could cause massive damage.

Richard

Originally Posted by Richardcavell

Mate, I know I'm over the top. Maybe it's obsessive-compulsive disorder. If there's a potential error that goes unchecked I can't concentrate on anything else until it's checked.

Yep, I'd class that as a disorder alright.

In fact, some of the *worst* programs I've run are the ones that error check every last thing. They are sluggish, annoying with all their constant pop-ups and beeps and generally harder to live with.

I will agree that some error checking is indeed necessary... "Is this file open?", "Did this time out?", etc. but building wrappers around perfectly safe functions out of sheer paranoia is definately not good. In my experience printf() is 100% reliable, once you have your format string set correctly and the text appears correctly on the screen, it will keep right on working 'til the cows come home...

I'd like to point out, though, that printf goes to stdout and my ErrorMessage() goes to stderr. Indeed, ErrorMessage() could start playing the Toccata and Fugue in D Minor or flash a lightbulb. This is a Wikipedia bot, intended to run unattended at high speed and where unexpected behaviour could cause massive damage.

Richard

Massive damage to what?
Tell me... how is a printf() that somehow doesn't make it to the screen going to harm Wikipedia's website?

Really... my friend, you need to give this a whole lot more thought.

What if ErrorMessage() fails?

If ErrorMessage() fails, it returns -1. My program gracefully shuts down, letting go of all resources it's borrowed so far.

Now, as to the variadic function question,

It doesn't seem possible to do something like:

Code:

int safeprint ( char* string , ... ) 
{
   printf ( string , ... )
}

The only way to deal with the different possibilities is to manually step through the input string and printf each item as it comes up. This means that my safeprint function will have to be able to cope with every conceivable format specifier that printf can handle.

I think it would be easier to have different functions, like :

Code:

int safeprint ( char* string ) ;
int safeprint2s ( char* string1 , char* string2 ) ;
int safeprintui ( unsigned int i ) ;

Is that the best idea? (Other than getting treatment for OCD)

Check out vprintf et al.

Code:

int safeprint ( char* string , ... ) 
{
   va_list va;

   va_start(va, string);
   count = vprintf(string, va);
   va_end(va);
   // insert silly error checking here
}

Also see vsprintf, vfprintf, vsnprintf, etc.

As far as OCD, I'd never joke about it. My brother suffers terribly from it.

Behold my masterpiece. safeprint () is a special case when there's just a string. safeprintf () works the same as printf ().

Code:

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

#include "Error.h"

int safeprint ( const char* file , const unsigned int line , const char* pstring )
{
	int ilength = strlen ( pstring ) ;
	int icharsprinted = printf ( "%s" , pstring ) ; 
	if ( ilength != icharsprinted )
	{
		ErrorMessage ( "Couldn't print to screen." , file , line ) ;
		return -1 ;
	}

	return 0 ;
}

static const unsigned int buffersize = 200 ;

int safeprintf ( const char* file , const unsigned int line , char* formatstring , ... )
{
	va_list va ;
	va_start ( va , formatstring ) ;

	int icharsprinted = vprintf ( formatstring , va ) ;
	if ( icharsprinted < 0 )
	{
		ErrorMessage ( "Couldn't print to screen." , file , line ) ;
		return -1 ;
	}

	va_start ( va , formatstring ) ;
	char buffer [ buffersize ] ;
	int ilength = vsnprintf ( buffer , buffersize , formatstring , va ) ;
	if ( ilength < 0 )
	{
		ErrorMessage ( "Couldn't print to screen." , file , line ) ;
		return -1 ;
	}

	va_end ( va ) ;

	if ( ilength != icharsprinted )
	{
		ErrorMessage ( "Couldn't print to screen." , file , line ) ;
		return -1 ;
	}

	return 0 ;
}

Originally Posted by Richardcavell

Behold my masterpiece. safeprint () is a special case when there's just a string. safeprintf () works the same as printf ().

That's a silly thing to do. safeprintf will work just fine if there's only a string.

Won't it choke if you do:

safeprintf ( __FILE__ , __LINE__ , "I am now 25% better at programming C." ) ;

owing to the % in the string?

Originally Posted by Richardcavell

Won't it choke if you do:

safeprintf ( __FILE__ , __LINE__ , "I am now 25% better at programming C." ) ;

owing to the % in the string?

So will safeprint. My point was that safeprint is useless if you have safeprintf.

You sure? I think safeprint is safe for strings that include %s.

Richard

Originally Posted by Richardcavell

You sure? I think safeprint is safe for strings that include %s.

Richard

Might be a good idea to error trap it for that, just in case...