compile detection of powf, etc

[Marco]

Is there a standard way using the preprocessor to detect if a given C
compiler/library environment provides the C99 <math.h> floating point
functions such as:

float powf(float x, float y);
float sqrtf(float x);
etc

so we could "provide" these prototypes or not via our

"xtra_math. h" file

Note some C environments are incomplete and may define the C90 flag but
still provide these functions. So I think we need to check each
function.

looking for any suggestions

thanks

[Walter Roberson]

In article <11************ **********@g47g 2000cwa.googleg roups.com>,
Marco <pr**********@y ahoo.com> wrote:

Is there a standard way using the preprocessor to detect if a given C
compiler/library environment provides the C99 <math.h> floating point
functions such as: float powf(float x, float y);
float sqrtf(float x); Note some C environments are incomplete and may define the C90 flag but
still provide these functions. So I think we need to check each
function.
C90 does not define any feature-test preprocessor variables,
so any such macro provided by an environment intermediate between C90
and C99 is, by definition, non-standard.

If you need to be able to determine the presence or absence of
particular routines, I suggest you consider using something like
"automake".

so we could "provide" these prototypes or not via our
"xtra_math. h" file

That hints at a commercial product; if so then if you do look at
automake, ensure that you read the accompanying licenses.
--
All is vanity. -- Ecclesiastes

[Eric Sosman]

Marco wrote On 01/30/06 10:21,:

Is there a standard way using the preprocessor to detect if a given C
compiler/library environment provides the C99 <math.h> floating point
functions such as:

float powf(float x, float y);
float sqrtf(float x);
etc

so we could "provide" these prototypes or not via our

"xtra_math. h" file

Note some C environments are incomplete and may define the C90 flag but
still provide these functions. So I think we need to check each
function.

`#if __STDC_VERSION_ _ >= 199901L' tests whether the
implementation claims to conform to C99; if it does, the
functions you're looking for are present.

I can think of no portable way to tell whether these
functions exist as extensions in earlier implementations .
You could use `#ifdef powf' to check for a "masking" macro
and assume that the corresponding function exists if the
macro is defined, but the function might also exist without
a masking macro. You may simply need to tailor your
"xtra_math. h" header to each implementation you care about,
possibly with a semi-automated tool like autoconf.

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

[Jordan Abel]

On 2006-01-30, Marco <pr**********@y ahoo.com> wrote:

Is there a standard way using the preprocessor to detect if a given C
compiler/library environment provides the C99 <math.h> floating point
functions such as:

float powf(float x, float y);
float sqrtf(float x);
etc

so we could "provide" these prototypes or not via our

"xtra_math. h" file

Note some C environments are incomplete and may define the C90 flag but
still provide these functions. So I think we need to check each
function.

looking for any suggestions

thanks

(semi-offtopic)
One way [this is highly system-specific - basically unix-only, and may
not be guaranteed even by the POSIX standard] would be to provide the
functions in a static library and link it after libm. If the link editor
finds it in libm, it won't take the one from your library.
static library

[Keith Thompson]

Eric Sosman <er*********@su n.com> writes:

Marco wrote On 01/30/06 10:21,:

Is there a standard way using the preprocessor to detect if a given C
compiler/library environment provides the C99 <math.h> floating point
functions such as:

float powf(float x, float y);
float sqrtf(float x);
etc

so we could "provide" these prototypes or not via our

"xtra_math. h" file

Note some C environments are incomplete and may define the C90 flag but
still provide these functions. So I think we need to check each
function.
`#if __STDC_VERSION_ _ >= 199901L' tests whether the
implementation claims to conform to C99; if it does, the
functions you're looking for are present.

It means that the compiler *claims* to conform to C99. If it's lying,
then it's not a conforming C compiler, and the requirements of the C
standard don't apply to it.

The compiler might not actually know whether the functions are
available. The compiler and the library are commonly separate (for
example, gcc uses whatever library is provided by the underlying
system). If the compiler is conforming and the library isn't, the
compiler *shouldn't* define __STDC_VERSION_ _ as 199901L, but it might
do so anyway.
I can think of no portable way to tell whether these
functions exist as extensions in earlier implementations .
You could use `#ifdef powf' to check for a "masking" macro
and assume that the corresponding function exists if the
macro is defined, but the function might also exist without
a masking macro. You may simply need to tailor your
"xtra_math. h" header to each implementation you care about,
possibly with a semi-automated tool like autoconf.

Or you can write a simple test as part of your build process. Try to
compile and execute a small program that uses the functions. If it
produces the expected output, you can use <math.h>; if not, you need
to use "xtra_math. h". You can generate a header file at build time,
and include the generated header in your actual program.

This is basically what autoconf does, but if this is the only test you
need it might be simpler to do it manually.

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

Keith Thompson wrote On 01/30/06 14:29,:

Eric Sosman <er*********@su n.com> writes:

Marco wrote On 01/30/06 10:21,:

Is there a standard way using the preprocessor to detect if a given C
compiler/library environment provides the C99 <math.h> floating point
functions such as:

float powf(float x, float y);
float sqrtf(float x);
etc

so we could "provide" these prototypes or not via our

"xtra_math. h" file

Note some C environments are incomplete and may define the C90 flag but
still provide these functions. So I think we need to check each
function.
`#if __STDC_VERSION_ _ >= 199901L' tests whether the
implementatio n claims to conform to C99; if it does, the
functions you're looking for are present.

It means that the compiler *claims* to conform to C99. If it's lying,
then it's not a conforming C compiler, and the requirements of the C
standard don't apply to it.

That's more or less why I wrote "claims" to begin with.
The compiler might not actually know whether the functions are
available. The compiler and the library are commonly separate (for
example, gcc uses whatever library is provided by the underlying
system). If the compiler is conforming and the library isn't, the
compiler *shouldn't* define __STDC_VERSION_ _ as 199901L, but it might
do so anyway.

If the compiler lies to me, I will get my revenge ;-)
My only vehicle for vendetta may be to demand my money back
and to bad-mouth the vendor in every forum I can find, but
somehow I will get my revenge. Mwa-ha-haaah!

Note that the compiler and library are not separable
(in hosted implementations ): Both are simply parts of "the
implementation" as far as the Standard is concerned. Thus,
__STDC_VERSION_ _ (and indeed, __STDC__ itself) assert things
not only about the compiler but also about the library and
about support routines that take care of things like opening
stdin before main() is called. All the pieces must cooperate;
it invites error to try to isolate them.

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

[Keith Thompson]

Eric Sosman <er*********@su n.com> writes:
[...]

If the compiler lies to me, I will get my revenge ;-)
My only vehicle for vendetta may be to demand my money back
and to bad-mouth the vendor in every forum I can find, but
somehow I will get my revenge. Mwa-ha-haaah!

Note that the compiler and library are not separable
(in hosted implementations ): Both are simply parts of "the
implementation" as far as the Standard is concerned. Thus,
__STDC_VERSION_ _ (and indeed, __STDC__ itself) assert things
not only about the compiler but also about the library and
about support routines that take care of things like opening
stdin before main() is called. All the pieces must cooperate;
it invites error to try to isolate them.

As far as the standard is concerned, yes. But there *are* cases where
the compiler and library are implemented separately. The compiler is
responsible for defining __STD__ and __STDC_VERSION_ _ appropriately to
reflect the conformance of the implementation as a whole. Whether all
compilers actually do this properly is another question.

I have seen cases (not necessarily tied to library issues) where a
compiler's definition of __STDC__ was inconsistent with reality.
There's not a whole lot you can do to defend against that, other than
thorough testing.

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

[Jack Klein]

On Mon, 30 Jan 2006 19:29:04 GMT, Keith Thompson <ks***@mib.or g> wrote
in comp.lang.c:

Eric Sosman <er*********@su n.com> writes:

Marco wrote On 01/30/06 10:21,:

Is there a standard way using the preprocessor to detect if a given C
compiler/library environment provides the C99 <math.h> floating point
functions such as:

float powf(float x, float y);
float sqrtf(float x);
etc

so we could "provide" these prototypes or not via our

"xtra_math. h" file

Note some C environments are incomplete and may define the C90 flag but
still provide these functions. So I think we need to check each
function.

`#if __STDC_VERSION_ _ >= 199901L' tests whether the
implementation claims to conform to C99; if it does, the
functions you're looking for are present.

It means that the compiler *claims* to conform to C99. If it's lying,
then it's not a conforming C compiler, and the requirements of the C
standard don't apply to it.

The compiler might not actually know whether the functions are
available. The compiler and the library are commonly separate (for
example, gcc uses whatever library is provided by the underlying
system). If the compiler is conforming and the library isn't, the
compiler *shouldn't* define __STDC_VERSION_ _ as 199901L, but it might
do so anyway.

[snip]

I don't agree with the statement that the "compiler and the library
are commonly separate". I don't know of a single other implementation
other than some gcc variants where this is so.

Do you know of any others?

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Keith Thompson]

Jack Klein <ja*******@spam cop.net> writes:

On Mon, 30 Jan 2006 19:29:04 GMT, Keith Thompson <ks***@mib.or g> wrote
in comp.lang.c:

Eric Sosman <er*********@su n.com> writes: [...]

> `#if __STDC_VERSION_ _ >= 199901L' tests whether the
> implementation claims to conform to C99; if it does, the
> functions you're looking for are present.

It means that the compiler *claims* to conform to C99. If it's lying,
then it's not a conforming C compiler, and the requirements of the C
standard don't apply to it.

The compiler might not actually know whether the functions are
available. The compiler and the library are commonly separate (for
example, gcc uses whatever library is provided by the underlying
system). If the compiler is conforming and the library isn't, the
compiler *shouldn't* define __STDC_VERSION_ _ as 199901L, but it might
do so anyway.

[snip]

I don't agree with the statement that the "compiler and the library
are commonly separate". I don't know of a single other implementation
other than some gcc variants where this is so.

Do you know of any others?

Intel's icc is very similar to gcc. I suspect there are other
third-party compilers for Linux that use glibc as well.

But apart from those examples, I actually have very little idea how
common it is.

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

[Ed Vogel]

"Jack Klein" <ja*******@spam cop.net> wrote in message
news:ak******** *************** *********@4ax.c om...

I don't agree with the statement that the "compiler and the library
are commonly separate". I don't know of a single other implementation
other than some gcc variants where this is so.

Do you know of any others?

--

Jack,

All HP C compiler implementations (HP-UX, Tru64 UNIX, and OpenVMS)
ship separately from the libraries. The libraries ship with the O.S. as
they
are needed by many applications that do not require the compilers.

Ed Vogel
HP C/C++ Engineering.