Check if a system implements a function

Question

I'm creating a cross-system application. It uses, for example, the function itoa, which is implemented on some systems but not all. If I simply provide my own itoa implementation:

header.h:115:13: error: conflicting types for 'itoa'
 extern void itoa(int, char[]);

In file included from header.h:2:0,
                 from file.c:2:0,
c:\path\to\mingw\include\stdlib.h:631:40: note: previous declaration of 'itoa' was here
 _CRTIMP __cdecl __MINGW_NOTHROW  char* itoa (int, char*, int);

I know I can check if macros are predefined and define them if not:

#ifndef _SOME_MACRO
#define _SOME_MACRO 45
#endif

Is there a way to check if a C function is pre-implemented, and if not, implement it? Or to simply un-implement a function?

Answer 1

Given you have already written your own implementation of itoa(), I would recommend that you rename it and use it everywhere. At least you are sure you will get the same behavior on all platforms, and avoid the linking issue.

Don't forget to explain your choice in the comments of your code...

Answer 2

I assume you are using GCC, as I can see MinGW in your path... there's one way the GNU linker can take care of this for you. So you don't know whether there is an itoa implementation or not. Try this:

Create a new file (without any headers) called my_itoa.c:

char *itoa (int, char *, int);

char *my_itoa (int a, char *b, int c)
{
    return itoa(a, b, c);
}

Now create another file, impl_itoa.c. Here, write the implementation of itoa but add a weak alias:

char* __attribute__ ((weak)) itoa(int a, char *b, int c)
{
     // implementation here
}

Compile all of the files, with impl_itoa.c at the end.

This way, if itoa is not available in the standard library, this one will be linked. You can be confident about it compiling whether or not it's available.

Answer 3

Ajay Brahmakshatriya's suggestion is a good one, but unfortunately MinGW doesn't support weak definition last I checked (see https://groups.google.com/forum/#!topic/mingwusers/44B4QMPo8lQ, for instance).

However, I believe weak references do work in MinGW. Take this minimal example:

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

__attribute__ ((weak)) char* itoa (int, char*, int);

char* my_itoa (int a, char* b, int c)
{
    if(itoa != NULL) {
        return itoa(a, b, c);
    } else {
        // toy implementation for demo purposes
        // replace with your own implementation
        strcpy(b, "no itoa");
        return b;
    }        
}

int main()
{
    char *str = malloc((sizeof(int)*3+1));

    my_itoa(10, str, 10);
    printf("str: %s\n", str);
    return 0;
}

If the system provides an itoa implementation, that should be used and the output would be

str: 10

Otherwise, you'll get

str: no itoa

Answer 4

There are two really important related points worth making here along the "don't do it like this" lines:

• Don't use atoi because it's not safe.
• Don't use atoi because it's not a standard function, and there are good standard functions (such as snprintf) which are available to do what you want.

But, putting all this aside for one moment, I want to introduce you to autoconf, part of the GNU build system. autoconf is part of a very comprehensive, very portable set of tools which aim to make it easier to write code which can be built successfully on a wide range of target systems. Some would argue that autoconf is too complex a system to solve just the one problem you pose with just one library function, but as any program grows, it's likely to face more hurdles like this, and getting autoconf set up for your program now will put you in a much stronger position for the future.

Start with a file called Makefile.in which contains:

CFLAGS=--ansi --pedantic -Wall -W

program: program.o
program.o: program.c

clean:
  rm -f program.o program

and a file called configure.ac which contains:

AC_PREREQ([2.69])
AC_INIT(program, 1.0)
AC_CONFIG_SRCDIR([program.c])
AC_CONFIG_HEADERS([config.h])

# Checks for programs.
AC_PROG_CC

# Checks for library functions.
AH_TEMPLATE([HAVE_ITOA], [Set to 1 if function atoi() is available.])
AC_CHECK_FUNC([itoa],
              [AC_DEFINE([HAVE_ITOA], [1])]
              )

AC_CONFIG_FILES([Makefile])
AC_OUTPUT

and a file called program.c which contains:

#include <stdio.h>
#include "config.h"

#ifndef HAVE_ITOA

/*
 * WARNING: This code is for demonstration purposes only. Your
 * implementation must have a way of ensuring that the size of the string
 * produced does not overflow the buffer provided.
 */

void itoa(int n, char* p) {
  sprintf(p, "%d", n);
}
#endif

int main(void) {
  char buffer[100];
  itoa(10, buffer);
  printf("Result: %s\n", buffer);
  return 0;
}

Now run the following commands in turn:

1. autoheader: This generates a new file called config.h.in which we'll need later.
2. autoconf: This generates a configuration script called configure
3. ./configure: This runs some tests, including checking that you have a working C compiler and, because we've asked it to, whether an itoa function is available. It writes its results into the file config.h for later.
4. make: This compiles and links the program.
5. ./program: This finally runs the program.

During the ./configure step, you'll see quite a lot of output, including something like:

checking for itoa... no

In this case, you'll see that the config.h find contains the following lines:

/* Set to 1 if function atoi() is available. */
/* #undef HAVE_ITOA */

Alternatively, if you do have atoi available, you'll see:

checking for itoa... yes

and this in config.h:

/* Set to 1 if function atoi() is available. */
#define HAVE_ITOA 1

You'll see that the program can now read the config.h header and choose to define itoa if it's not present.

Yes, it's a long way round to solve your problem, but you've now started using a very powerful tool which can help you in a great number of ways.

Good luck!