Way to determine type of variable?

[Walter L. Preuninger II]

I would like to write a generic procedure that will take string or numeric
variables. I can not think of a way to make this more clear except to show
what I want.

int main(void)
{
int i=7;
char *s="/etc/filesystems";

generic(i);
generic(s);
generic("Hello" );
generic(2048);
exit(0);
}

should return:
7
/etc/filesystems
Hello
2048

so...

void generic( ???????)
{
???
}

I have looked at sprintf, varargs etc.

Could someone point me in the right direction?

Thanks,

Walter

[jacob navia]

The version I posted contained a serious error:
The type of the union should not be stored in the
union itself!

Here is a corrected version.
Sorry for this error.

Within standard C you can write a function like this:

#define INTEGER 1
#define STRING 2
#define DOUBLE 3
struct data { int Type; // Type OUTSIDE the union
union u { int integer;
double doublefloat;
float floatfloat;
char *string;
// add other cases here
}u;
};

void generic(union data Data)
{
switch (Data.Type) {
case INTEGER:
printf("%d\n",D ata.u.integer);
break;
case STRING:
printf("%s\n",D ata.u.string);
break;
// Add the other cases here
}
}

int main(void)
{
union data Data;
Data.u.integer = 7;
Data.Type = INTEGER;
generic(Data);
Data.u.string = "/etc/path";
Data.Type = STRING;
generic(Data);
Data.Type = DOUBLE;
Data.u.doublefl oat = 67.987;
generic(DOUBLE, Data);
/// etc
}

[Jens.Toerring]

Walter L. Preuninger II <wa*****@texram p.net> wrote:

I needed a generic error printing routine, better than what perror()
provides. incomplete code follows char *filename="X";
char *buffer;
int size=65536; file=fopen(file name,"rt");
if (file==NULL)
{
xerror("fopen failed",filenam e);
exit(1);
}
buffer=(char *)malloc(size);
if(buffer == NULL) {
xerror("malloc failed, size=",size);
} I guess I could use sprintf to fill a buffer and print/pass that, but I
wanted to lessen the amount of code written.

I guess the cleanest way would be to add printf-like format
information to the string you send to xerror(), e.g.

xerror( "fopen failed for:%s", filename );
xerror( "malloc failed: size=%ld", size );

etc. and in xerror() you then would have

#include <stdarg.h>

void xerror( const char *fmt, ... )
{
va_list ap;

/* Put printing argv[0], __FILE__ and __LINE__ in here */

va_start( ap, fmt );
vfprintf( stderr, fmt, ap );
va_end( ap );
}

It doesn't cost you too much in typing and works without lots of
complicated (and error prone) macros or extremely ugly code.

Regards, Jens
--
\ Jens Thoms Toerring ___ Je***********@p hysik.fu-berlin.de
\______________ ____________ http://www.toerring.de

[Keith Thompson]

"Walter L. Preuninger II" <wa*****@texram p.net> writes:

I would like to write a generic procedure that will take string or numeric
variables. I can not think of a way to make this more clear except to show
what I want.

int main(void)
{
int i=7;
char *s="/etc/filesystems";

generic(i);
generic(s);
generic("Hello" );
generic(2048);
exit(0);
}

should return:
7
/etc/filesystems
Hello
2048
By "should return", I think you mean "should print".
so...

void generic( ???????)
{
???
}

I have looked at sprintf, varargs etc.

You're asking about function overloading, which C doesn't support.
<OT>C++ does.</OT>

You can do something similar with variable argument lists
(<stdarg.h>), but you have to have an initial argument specifying the
type(s) of the following argument(s). For example, you could have
something like

generic(INT, i);
generic(STRING, s);
generic(STRING, "Hello");
generic(INT, 2048);

(given appropriate declarations of INT, STRING, etc.)

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Walter L. Preuninger II]

<Je***********@ physik.fu-berlin.de> wrote in message
news:2l******** ****@uni-berlin.de...

Walter L. Preuninger II <wa*****@texram p.net> wrote:
[snip]

/* Put printing argv[0], __FILE__ and __LINE__ in here */

only problem here is that __FILE__ and __LINE__ represent the filename and
line number of the source file, in which would be xerror.c and not main.c or
what ever, but thanks for the info and I will see how I can apply it to my
needs
Thanks!

Walter

[Malcolm]

"Walter L. Preuninger II" <wa*****@texram p.net> wrote

I would like to write a generic procedure that will take string or numeric
variables. I can not think of a way to make this more clear except to
show what I want.

int main(void)
{
int i=7;
char *s="/etc/filesystems";

generic(i);
generic(s);
generic("Hello" );
generic(2048);
exit(0);
}

should return:
7
/etc/filesystems
Hello
2048

so...

void generic( ???????)
{
???
}

I have looked at sprintf, varargs etc.

So you should know that you can write a function

void generic(char *type, ...)

generic("int", 123);
generic("char *", "Hello");
etc.

Then in generic you decode the first argument, which tells you what to pass
to va_arg() to get the argument. If you try to write printf() it is done in
a similar manner, excpet that the format string uses a "%" specifier to tell
you the argument type instead of passing a name.

If you have any problem implementing the variable argument list, just post
back.

[Jens.Toerring]

Walter L. Preuninger II <wa*****@texram p.net> wrote:

<Je***********@ physik.fu-berlin.de> wrote in message
news:2l******** ****@uni-berlin.de...

Walter L. Preuninger II <wa*****@texram p.net> wrote:

[snip]

/* Put printing argv[0], __FILE__ and __LINE__ in here */

only problem here is that __FILE__ and __LINE__ represent the filename and
line number of the source file, in which would be xerror.c and not main.c or
what ever, but thanks for the info and I will see how I can apply it to my
needs

Unless you have a C99 compliant compiler, allowing macros with a
variable number of arguments, that's going to be more messy. The
simplest approach probably would be to define

#define AFL argv[0], __FILE__, __LINE__

and use it as

xerror( AFL, "File not found: %s", filename );

and declare xerror as

void xerror( const char *prog_name, const char *file_name, int line_number,
const char *fmt, .... );

That way you would get at the file name and line number without too
much hassle (well, it's not beautiful, but it should work). And if
you're too lazy to write that AFL stuff into code 'sed' or something
similar can be quite useful for such mindnumbing tasks;-)

Regards, Jens
--
\ Jens Thoms Toerring ___ Je***********@p hysik.fu-berlin.de
\______________ ____________ http://www.toerring.de

[Eric Sosman]

Walter L. Preuninger II wrote:

<Je***********@ physik.fu-berlin.de> wrote in message
news:2l******** ****@uni-berlin.de...

Walter L. Preuninger II <wa*****@texram p.net> wrote:

[snip]

/* Put printing argv[0], __FILE__ and __LINE__ in here */

only problem here is that __FILE__ and __LINE__ represent the filename and
line number of the source file, in which would be xerror.c and not main.c or
what ever, but thanks for the info and I will see how I can apply it to my
needs

If you have a C99-conforming compiler you can write
macros with variable numbers of arguments, and that eases
the task of adding __FILE__ and __LINE__ to an XERROR macro
that in turn invokes the xerror() function. Failing that,
gcc has its own pre-C99 way of writing "varargs macros."
And if even that isn't acceptable, you can use the dodge
described in Question 10.26 of the FAQ

http://www.eskimo.com/~scs/C-faq/top.html

--
Er*********@sun .com

[Sam Dennis]

Walter L. Preuninger II wrote:

<Je*********** @physik.fu-berlin.de> wrote:

void xerror( const char *fmt, ... )
{
/* Put printing argv[0], __FILE__ and __LINE__ in here */

only problem here is that __FILE__ and __LINE__ represent the filename and
line number of the source file, in which would be xerror.c and not main.c

That's easily solved with a small macro wrapper for the function, which
would substitute the file and line number for the invocation, e.g.:

#define xerror( fmt, ... ) xerror( "%s:%d - " fmt, __FILE__, __LINE, \
__VA_ARGS__ )

However, this has several limitations (other than requiring C99 macros)
so I'm sure that you'll want to try to make something better. Perhaps,
even, something that doesn't affect the arguments to xerror...

--
++acr@,ka"

[Keith Thompson]

Je***********@p hysik.fu-berlin.de writes:
[...]

Unless you have a C99 compliant compiler, allowing macros with a
variable number of arguments, that's going to be more messy. The
simplest approach probably would be to define

#define AFL argv[0], __FILE__, __LINE__

and use it as

xerror( AFL, "File not found: %s", filename );

If it refers to argv[0], you can only use it within main() (assuming
the usual declarations).

You can have main() save the value of argv[0] to a global variable and
refer to that variable in the AFL macro.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Eric Sosman]

Sam Dennis wrote:

Walter L. Preuninger II wrote:

<Je********** *@physik.fu-berlin.de> wrote:

void xerror( const char *fmt, ... )
{
/* Put printing argv[0], __FILE__ and __LINE__ in here */

only problem here is that __FILE__ and __LINE__ represent the filename and
line number of the source file, in which would be xerror.c and not main.c

That's easily solved with a small macro wrapper for the function, which
would substitute the file and line number for the invocation, e.g.:

#define xerror( fmt, ... ) xerror( "%s:%d - " fmt, __FILE__, __LINE, \
__VA_ARGS__ )

However, this has several limitations (other than requiring C99 macros)
so I'm sure that you'll want to try to make something better. Perhaps,
even, something that doesn't affect the arguments to xerror...

Another approach is to print the location information and
the error-specific information with two functions instead of
trying to do it all with one. In addition to Jens' xerror(),
you'd also write

void xwhere(const char *file, int line) {
fprintf (stderr, "%s line %d: ", file, line);
}

Then you'd use

#define XERROR xwhere(__FILE__ , __LINE__) , xerror
...
XERROR ("Can't open %s\n", filename);
XERROR ("Supercalifrag ilisticexpialid ocious!\n");
XERROR ("Invalid co-ordinates (%g,%g)\n", x, y);

You could, of course, dispense with xwhere() and call fprintf()
directly from the macro expansion, if you can be sure that
<stdio.h> has been included everwhere XERROR is used. And there
are other variations, too -- but the essential idea here is to
avoid all hassles with variable-length macro arguments by defining
XERROR as an object-like macro with no arguments at all.

--
Er*********@sun .com