+ 19.3 Diagnostics library, Assertions: <cassert>

[lightlibc++.git] / include / cstdlib

/*
Permission is granted to use, modify, and / or redistribute at will.

This includes removing authorship notices, re-use of code parts in
other software (with or without giving credit), and / or creating a
commercial product based on it.

This permission is not revocable by the author.

This software is provided as-is. Use it at your own risk. There is
no warranty whatsoever, neither expressed nor implied, and by using
this software you accept that the author(s) shall not be held liable
for any loss of data, loss of service, or other damages, be they
incidental or consequential. Your only option other than accepting
this is not to use the software at all.
*/
#ifndef _LIGHTLIBCPP_CSTDLIB
#define _LIGHTLIBCPP_CSTDLIB



#include <lightlibc++/compiler.hpp>    // _LIGHTLIBCPP_NORETURN
#include <stdlib.h>                    // abort, atexit, exit



// NOTE: macros EXIT_FAILURE, EXIT_SUCCESS, RAND_MAX, MB_CUR_MAX taken from C Standard library



namespace std
{
  /** \addtogroup lightlibcpp_18_5 */
  /*@{*/



  /* Types from the C Standard library header stdlib.h */

  /**
   *\english
   *  div_t type from the C Standard library
   *\endenglish
   *\german
   *  div_t Typ aus der C Standardbibliothek
   *\endgerman
   */
  typedef ::div_t            div_t;

  /**
   *\english
   *  ldiv_t type from the C Standard library
   *\endenglish
   *\german
   *  ldiv_t Typ aus der C Standardbibliothek
   *\endgerman
   */
  typedef ::ldiv_t           ldiv_t;

  /**
   *\english
   *  lldiv_t type from the C Standard library
   *\endenglish
   *\german
   *  lldiv_t Typ aus der C Standardbibliothek
   *\endgerman
   */
  typedef ::lldiv_t          lldiv_t;



  /* Functions from the C Standard library header stdlib.h */

  using ::atof;
  using ::atoi;
  using ::atol;
  using ::atoll;

  using ::strtod;
  using ::strtof;
  using ::strtold;

  using ::strtol;
  using ::strtoll;
  using ::strtoul;
  using ::strtoull;

  using ::rand;
  using ::srand;

  using ::calloc;
  using ::free;
  using ::malloc;
  using ::realloc;

  using ::abort;
  using ::atexit;
  using ::exit;
  using ::_Exit;
  using ::getenv;
  using ::system;

  using ::bsearch;
  using ::qsort;

  using ::abs;
  using ::labs;
  using ::llabs;

  using ::div;
  using ::ldiv;
  using ::lldiv;

  using ::mblen;
  using ::mbtowc;
  using ::wctomb;
  using ::mbstowcs;
  using ::wcstombs;



#ifndef _LIGHTLIBCPP_CPP03_STRICT

  /**
   *\english
   *  The at_quick_exit() functions register the function pointed to by f to be
   *  called without arguments when quick_exit is called. The at_quick_exit()
   *  functions shall be thread safe.
   *
   *  The at_quick_exit() registrations are distinct from the atexit()
   *  registrations, and applications may need to call both registration
   *  functions with the same argument.
   *
   *  Implementation limits: The implementation shall support the registration
   *  of at least 32 functions.
   *
   *  \param[in] f pointer to the function that should be registered
   *  \return zero if the registration succeeds, non-zero if it fails.
   *\endenglish
   *\german
   *  Die at_quick_exit() Funktion registriert die Funktion f, damit diese von
   *  quick_exit() aufgerufen werden kann. Diese Funktion ist threadsicher.
   *
   *  Die Registrierung über at_quick_exit() is verschieden von der
   *  Registrierung über atexit(). Folglich muss eine Anwendung eventuell beide
   *  Funktionen mit dem gleichen Argument aufrufen.
   *
   *  Eine Implementation dieser Funktion muss mindestens 32 Registrationen
   *  unterstützen.
   *  \param[in] f Zeiger auf die zu registrierende Funktion
   *  \return 0, falls erfolgreich, nicht 0 andernfalls
   *\endgerman
   */
  int at_quick_exit(void (*f)(void));

  /**
   *\english
   *  Functions registered by calls to at_quick_exit() are called in the reverse
   *  order of their registration, except that a function shall be called
   *  after any previously registered functions that had already been called
   *  at the time it was registered. Objects shall not be destroyed as a result
   *  of calling quick_exit(). If control leaves a registered function called by
   *  quick_exit() because the function does not provide a handler for a thrown
   *  exception, terminate() shall be called.
   *
   *  After calling registered functions, quick_exit() shall call _Exit(status).
   *
   *  The function quick_exit() never returns to its caller.
   *  \param[in] status the status code that is passed to _Exit
   *\endenglish
   *\german
   *  Die Funktionen, die durch einen Aufruf von at_quick_exit() registriert
   *  wurden, werden in der umgekehrten Reihenfolge ihrer Registration
   *  aufferufen. Ausgenommen davon sind Funktionen die registriert wurden,
   *  nachdem bereits ein Teil der registrierten Funktionen aufgerufen wurden.
   *  In diesem Fall wird die neu registrierte Funktion direkt nach allen
   *  bereits aufgerufenen aufgerufen.
   *
   *  Falls eine der registrierten Funktionen eine Ausnahme wirft, wird
   *  terminate() aufgerufen.
   *
   *  Nachdem alle registrierten Funktionen aufgerufen wurden wird
   *  _Exit(status) aufgerufen.
   *
   *  Diese Funktion kehrt nicht zum Aufrufenden zurück.
   *  \param[in] status der Statuscode der _Exit als Parameter übergeben wird
   *\endgerman
   */
  void quick_exit(int status) _LIGHTLIBCPP_NORETURN;

#endif



  /*@}*/
}



#endif