#include "libc.h"

struct Libc g_libc;

// macros stolen from glibc.

#define weak_alias(name, aliasname) \

  extern __typeof (name) aliasname __attribute__ ((weak, alias (# name)))

extern "C" {

// Step 2.  Very dirty trick to force redirection to library functions

// This will work only with GCC. Number 128 was picked to be arbitrarily large to allow

// function calls with a large number of arguments.

// \see http://tigcc.ticalc.org/doc/gnuexts.html#SEC67___builtin_apply_args

// FIXME: 120925: 128 was heuristically picked to pass the test under 32bits environment.

#define NATIVE DCE

#define NATIVET DCET

#define NATIVE_WITH_ALIAS DCE_WITH_ALIAS

#define NATIVE_WITH_ALIAS2 DCE_WITH_ALIAS2

#define GCC_BUILTIN_APPLY(export_symbol, func_to_call) \

  void export_symbol (...) { \

    void *args =  __builtin_apply_args (); \

    __builtin_return (result); \

  }

#define GCC_BUILTIN_APPLYT(rtype, export_symbol, func_to_call) \

  rtype export_symbol (...) { \

    void *args =  __builtin_apply_args (); \

    __builtin_return (result); \

  }

#define DCE(name)                                                               \

  GCC_BUILTIN_APPLY (name,name)

#define DCET(rtype,name)                                                               \

  GCC_BUILTIN_APPLYT (rtype,name,name)

/* From gcc/testsuite/gcc.dg/cpp/vararg2.c */

/* C99 __VA_ARGS__ versions */

#define c99_count(...)    _c99_count1 (, ## __VA_ARGS__) /* If only ## worked.*/

#define _c99_count1(...)  _c99_count2 (__VA_ARGS__,10,9,8,7,6,5,4,3,2,1,0)

#define _c99_count2(_,x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,n,...) n

#define FULL_ARGS_0()

#define FULL_ARGS_1(X0)  X0 a0

#define FULL_ARGS_2(X0,X1)  X0 a0, X1 a1

#define FULL_ARGS_3(X0,X1,X2)  X0 a0, X1 a1, X2 a2

#define FULL_ARGS_4(X0,X1,X2,X3)  X0 a0, X1 a1, X2 a2, X3 a3

#define FULL_ARGS_5(X0,X1,X2,X3,X4)  X0 a0, X1 a1, X2 a2, X3 a3, X4 a4

#define _ARGS_0()

#define _ARGS_1(X0)  a0

#define _ARGS_2(X0,X1)   a0, a1

#define _ARGS_3(X0,X1,X2)  a0, a1, a2

#define _ARGS_4(X0,X1,X2,X3)  a0, a1, a2, a3

#define _ARGS_5(X0,X1,X2,X3,X4) a0, a1, a2, a3, a4

#define CAT(a, ...) PRIMITIVE_CAT (a, __VA_ARGS__)

#define PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__

#define  FULL_ARGS(...) CAT (FULL_ARGS_,c99_count (__VA_ARGS__)) (__VA_ARGS__)

#define  ARGS(...) CAT (_ARGS_,c99_count (__VA_ARGS__)) (__VA_ARGS__)

#define DCE_EXPLICIT(name,rtype,...)                                    \

  rtype name (FULL_ARGS (__VA_ARGS__))    \

  {                                                             \

    return g_libc.name ## _fn (ARGS (__VA_ARGS__));              \

  }

#define DCE_WITH_ALIAS(name)                                    \

  GCC_BUILTIN_APPLY (__ ## name,name)                      \

  weak_alias (__ ## name, name);

#define DCE_WITH_ALIAS2(name, internal)                 \

  GCC_BUILTIN_APPLY (internal,name)                        \

  weak_alias (internal, name);

// Note: it looks like that the stdio.h header does

// not define putc and getc as macros if you include

// them from C++ so that we do need to define the putc

// and getc functions anyway.

#undef putc

#undef getc

#include "libc-ns3.h" // do the work

// weak_alias (strtol, __strtol_internal);

// weak_alias (wctype_l, __wctype_l);

// weak_alias (strdup, __strdup);

// void exit(int status)

// {

//   g_libc.exit_fn (status);

//   int a = 0;

//   while (1)

//     {

//       // loop forever to quiet compiler warning:

//       // warning: ‘noreturn’ function does return

//       a++;

//     }

// }

// void abort(void)

// {

//   g_libc.abort_fn ();

//   int a = 0;

//   while (1)

//     {

//       // loop forever to quiet compiler warning:

//       // warning: ‘noreturn’ function does return

//       a++;

//     }

// }

char * strpbrk (const char *s, const char *a)

{

  return g_libc.strpbrk_fn (s,a);

}

char * strstr (const char *u, const char *d)

{

  return g_libc.strstr_fn (u,d);

}

int snprintf (char *s, size_t si, const char *f, ...)

{

  va_list vl;

  va_start (vl, f);

  int r =  g_libc.vsnprintf_fn (s, si, f, vl);

  va_end (vl);

  return r;

}

int vsnprintf (char *s, size_t si, const char *f, va_list v)

{

  return g_libc.vsnprintf_fn (s, si, f, v);

}

#include "libc-globals.h"

void LIBSETUP (const struct Libc *fn)

{

  /* The following assignment of fn to g_libc is a bit weird: we perform a copy of the data

   * structures by hand rather than executing g_libc = fn. This is obviously done on purpose.

   * The reason is that g_libc = fn would trigger a call to the memcpy function because the

   * Libc structure is very big. The memcpy function is resolved through the dynamic loader's

   * symbol lookup mechanism to the local memcpy function and that local memcpy function happens

   * to be calling g_libc.memcpy_fn which is set to NULL before the data structure is initialized.

   */

  const unsigned char *src = (const unsigned char *)fn;

  unsigned char *dst = (unsigned char *)&g_libc;

  unsigned int i;

  for (i = 0; i < sizeof (struct Libc); ++i)

    {

      *dst = *src;

      src++;

      dst++;

    }

  setup_global_variables ();

}

#ifdef HAVE_GETCPUFEATURES

// Below there is an exception implementation: because the libm of glibc2.14 call  __get_cpu_features during dlopen,

// and during dlopen of libm  DCE do not have yet called lib_setup so there we implement __get_cpu_features

// directly without using the global g_libc variable, we can do it only if our implementation of the method

// do not interract with any ressouces of DCE or NS3 and do no call any other libc methods ...

struct cpu_features;

extern const struct cpu_features * dce___get_cpu_features (void);

const struct cpu_features * __get_cpu_features (void)

{

  return dce___get_cpu_features ();

}

#endif

} // extern "C"