stringizing a hex value in the preprocessor

[Henry Townsend]

Consider the little program below. It simply attempts to determine what
version of what compiler it was built with via documented preprocessor
macros and print out the result. When the compiler is gcc it works fine,
because __VERSION__ is supplied as a string. But identifying the Sun
compiler is harder because it provides __SUNPRO_C as a numerical value
(equal in my case to 0x580). My attempt to stringify it produces an error:

% cc -g -o foo foo.c
"foo.c", line 13: invalid source character: '#'
"foo.c", line 13: syntax error before or at: 0x580
cc: acomp failed for foo.c

Is there a way to do this?

Thanks,
HT

--------------------------------------------------------------
#include <stdio.h>

#if defined(__GNUC_ _)
#define COMPILER_STRING "gcc " __VERSION__
#elif defined(__SUNPR O_C)
#define COMPILER_STRING "SunStudio " #__SUNPRO_C
#else
#define COMPILER_STRING "unknown compiler/version"
#endif

int main(void)
{
printf("Compile d with %s\n", COMPILER_STRING );
return 0;
}

[Suman]

Henry Townsend wrote:

Consider the little program below. It simply attempts to determine what
version of what compiler it was built with via documented preprocessor
macros and print out the result. When the compiler is gcc it works fine,
because __VERSION__ is supplied as a string. But identifying the Sun
compiler is harder because it provides __SUNPRO_C as a numerical value
(equal in my case to 0x580). My attempt to stringify it produces an error:

Here's my try:

#include <stdio.h>

#define str(x) #x
#define xstr(x) str(x)
#define paste(x, y) x ## y

#define __SUNPRO_C 0x580
#if defined(__IGNUC __)
#define COMPILER_STRING "gcc " __VERSION__
#elif defined(__SUNPR O_C)
#define COMPILER_STRING xstr(paste(SunS tudio, xstr(__SUNPRO_C )))
#else
#define COMPILER_STRING "unknown compiler/version"
#endif

int main(void)
{
printf("Compile d with %s\n", COMPILER_STRING );
return 0;
}

and this was compiled with gcc -std=c99 -Wall.

[Suman]

Suman wrote:

Henry Townsend wrote:

Consider the little program below. It simply attempts to determine what
version of what compiler it was built with via documented preprocessor
macros and print out the result. When the compiler is gcc it works fine,
because __VERSION__ is supplied as a string. But identifying the Sun
compiler is harder because it provides __SUNPRO_C as a numerical value
(equal in my case to 0x580). My attempt to stringify it produces an error:

Here's my try:

a tad improved:
--------------------------------------><----------------------------------------------------------------
#include <stdio.h>

#define str(x) #x
#define xstr(x) str(x)
#define paste(x, y) x ## y

#define __SUNPRO_C 0x580
#if defined(__IGNUC __)
#define COMPILER_STRING "gcc " __VERSION__
#elif defined(__SUNPR O_C)
#define COMPILER_STRING xstr(SunStudio xstr(__SUNPRO_C ))
#else
#define COMPILER_STRING "unknown compiler/version"
#endif

int main(void)
{
printf("Compile d with %s\n", COMPILER_STRING );
return 0;
}
--------------------------------------><----------------------------------------------------------------
gcc -std=c99 -Wall -pedantic -ansi. And, excuse the ignominious
__IGNU__.
I don't have a Sun compiler to play with :)

HTH

[Henry Townsend]

Suman wrote:

Here's my try:

a tad improved:
[snip]

Yes, that works. Actually it prints:

Compiled with SunStudio "0x580"

and a tweak I made to use the line:

#define COMPILER_STRING "SunStudio " ## xstr(__SUNPRO_C )

removes the quotes to give:

Compiled with SunStudio 0x580

Which is what I was looking for. Thanks!

HT

[Raghu]

Here is My try :

#include <stdio.h>

#define str(x) #x
#define paste(x,y) x##y
#define Mystr(x) str(x)
#define __SUNPRO_C 0x580

#if defined(__IGNUC __)

#define COMPILER_STRING "gcc " __VERSION__

#elif defined(__SUNPR O_C)

#define COMPILER_STRING paste("SunStudi o",Mystr(__SUNP RO_C))

#else

#define COMPILER_STRING "unknown compiler/version"

#endif

int main(void)
{
printf("Compile d with %s\n", COMPILER_STRING );
return 0;
}
-- Raghu.
"Henry Townsend" <he************ @not.here> wrote in message
news:fu******** ************@co mcast.com...

Suman wrote:

Here's my try:

a tad improved:
[snip]

Yes, that works. Actually it prints:

Compiled with SunStudio "0x580"

and a tweak I made to use the line:

#define COMPILER_STRING "SunStudio " ## xstr(__SUNPRO_C )

removes the quotes to give:

Compiled with SunStudio 0x580

Which is what I was looking for. Thanks!

HT

[Hubble]

Except that I would not use small letters for macros. Or did I miss
something? The solution is good but hard to read for me.

Hubble

[Maxim Yegorushkin]

Henry Townsend wrote:

Consider the little program below. It simply attempts to determine what
version of what compiler it was built with via documented preprocessor
macros and print out the result. When the compiler is gcc it works fine,
because __VERSION__ is supplied as a string. But identifying the Sun
compiler is harder because it provides __SUNPRO_C as a numerical value
(equal in my case to 0x580). My attempt to stringify it produces an error:

Why not just use a simple shell script invoked by makefile to do just
that?

$ cat build_string
#! /bin/bash

echo "namespace $1 { "
echo "extern char const build_string[] = "
echo \"$(date -u +"%F %T UTC") \"
echo \"$(g++ --version | head -n 1)\"
echo ";"
echo "}"

bash-3.00$ cat Makefile

....
all: app
app: dirs build_string $(app_obj)
$(CXX) -o $(bin_dir)app $(app_obj) $(LDFLAGS)
....
..PHONY : dirs clean build_string install
build_string:
./build_string app > $(src_dir)build _string.cpp
....

[Keith Thompson]

"Hubble" <re****@huober. de> writes:

Except that I would not use small letters for macros. Or did I miss
something? The solution is good but hard to read for me.

What solution?

Please read <http://cfaj.freeshell. org/google/>.

--
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.

[Hubble]

Keith Thompson writes:

What solution Please read <http://cfaj.freeshell. org/google/>.
Sorry for using google:

Suman writes:
#define str(x) #x
#define xstr(x) str(x)
#define paste(x, y) x ## y

I would not use small letters for macros. Or did I miss
something? These macros is good but hard to read for me.

Hubble

[pete]

Hubble wrote:

Suman writes:

#define str(x) #x
#define xstr(x) str(x)
#define paste(x, y) x ## y

I would not use small letters for macros. Or did I miss
something? These macros is good but hard to read for me.

The first two of those macros are copied from the C standard.
That makes it easy to look them up in the standard
if you want to see what the standard has to say about them.
Otherwise, neither would I write them that way.

--
pete