/** @file ../include/stdlib.h

@internalComponent

*/

/** @fn  abort(void)

@return   The abort function

never returns.

  The abort function causes abnormal program termination to occur, unless the

signal SIGABRT is being caught and the signal handler does not return.

 Any open streams are flushed and closed.

Examples:

@code

#include  <stdio.h>

#include  <stdlib.h>

int main( void )

{

   FILE *stream;

   if( (stream = fopen( "notexist.file", "r" )) == NULL )

   {

      perror( "Error occurred while opening file" );

      abort();

   }

   else

      fclose( stream );

   return 0;

}

@endcode

 Output

@code

Error occurred while opening file: No such file or directory

@endcode

Implementation notes: 

  The abort function is thread-safe. It is unknown whether it is async-cancel-safe.

Limitations:

The signal related functionalities are not applicable to the Symbian OS implementation

as there is no support for signals from Symbian OS.

@see exit()

@publishedAll

@externallyDefinedApi

*/

/** @fn  abs(int j)

@param j

@return   The abs function

returns

the absolute value.

  The abs function computes the absolute value of an integer j. The absolute value is always postive, it has size but not direction.

Examples:

@code

#include  <stdio.h>

#include  <stdlib.h>

int main( void )

{

   int    ix = -4, iy;

   long   lx = -41567L, ly;

   long long llx = -5343546758, lly;

   iy = abs( ix );

   printf( "The absolute value of %d is %d

", ix, iy);

   ly = labs( lx );

   printf( "The absolute value of %ld is %ld

", lx, ly);

   lly = llabs( llx );

   printf( "The absolute value of %lld is %lld

", llx, lly );

   return 0;

}

@endcode

@code

Output

The absolute value of -4 is 4

The absolute value of -41567 is 41567

The absolute value of -5343546758 is 5343546758

@endcode

@see fabs()

@see floor()

@see hypot()

@see labs()

@see llabs()

@see math()

@publishedAll

@externallyDefinedApi

*/

/** @fn  atexit(void(*)(void) func)

@param func

@return   The atexit function returns the value 0 if successful; otherwise it returns 

the value -1 and sets the global variable errno to indicate the error.

  The atexit function

registers the given function to be called at program exit, whether via exit or via return from the program's main. Functions so registered are called in reverse order;

no arguments are passed.

 These functions must not call exit . If it is necessary to terminate the process while in such a 

  function, the _exit function should be used. Alternatively, 

  the function may cause abnormal process termination, for example by calling abort

 At least 32 functions can always be registered and more are allowed as long 

  as sufficient memory can be allocated.

In Symbian app with an entry point E32Main, the registered functions will not be called unless exit() is specified explicitly.

Limitation:

atexit() is not supported on emulator.

Examples:

@code

#include <stdlib.h>

#include <stdio.h>

void fun1( void ), fun2( void ), fun3( void ), fun4( void );

int main( void )

{

   atexit( fun1 );

   atexit( fun2 );

   atexit( fun3 );

   atexit( fun4 );

   printf( "Before exiting...." );

}

void fun1()

{

   printf( " fun1 " );

}

void fun2()

{

   printf( " fun2" );

}

void fun3()

{

   printf( " fun3 " );

}

void fun4()

{

   printf( " fun4 " );

}

@endcode

@code

Output

Before exiting...

fun4

fun3

fun2

fun1

@endcode

@code

#include <stdlib.h>

#include <stdio.h>

#include <e32base.h>

void fun1(void),fun2(void),fun3(void);

LOCAL_C int MainL()

	{

	atexit( fun1 );

   	atexit( fun2 );

   	atexit( fun3 );

    	printf( "Before exiting....\n" );

  	getchar();

	exit();

	}

void fun1()

{

printf( " fun1\n " );

getchar();

}

void fun2()

{

printf( " fun2\n " );

getchar();

}

void fun3()

{

printf( " fun3\n " );

getchar();

}

GLDEF_C TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if(cleanup == NULL)

		{

		return KErrNoMemory;

		}

	TInt ret;

	TRAPD(err,ret = MainL());

	delete cleanup;

	__UHEAP_MARKEND;

	return KErrNone;

   	}

@encode

@code

Output

Before exiting...

fun3

fun2

fun1

@endcode

@see exit()

@publishedAll

@externallyDefinedApi

*/

/** @fn  atof(const char *nptr)

@param nptr

@return   The atof function

returns

the converted value if the value can be represented.

  The atof function converts the initial portion of the string pointed to by nptr to double

representation.

@code

 It is equivalent to: strtod(nptr, (char **)NULL);

The decimal point

character is defined in the program's locale (category LC_NUMERIC).

@endcode

Examples:

@code

#include <stdlib.h>

#include <stdio.h>

void main( void )

{

 /* Test of atof */

 double d = atof("  86778E-2");

 printf( "result of atof: %f

", d );

}

@endcode

@code

Output

result of atof: 867.78

@endcode

Implementation notes:

The atof function is not thread-safe and also not async-cancel-safe. The atof function has been deprecated. Use strtod instead.

@see atoi()

@see atol()

@see strtod()

@see strtol()

@see strtoul()

@publishedAll

@externallyDefinedApi

*/

/** @fn  atoi(const char *nptr)

@param nptr

@return   The atoi function

returns

the converted value if the value can be represented.

  The atoi function converts the initial portion of the string pointed to by nptr to int

representation.

@code

 It is equivalent to: (int)strtol(nptr, (char **)NULL, 10);

@endocde

Examples:

@code

#include <stdlib.h>

#include <stdio.h>

void main( void )

{

  /* call to atoi */

  char *str = "  -56957jdhfjk";    

  int i = atoi( str );

  printf( "result of atoi: %d

", i );

}

@endcode

@code

Output

result of atoi: -56957

@endcode

Implementation notes:

The atoi function is not thread-safe and also not async-cancel safe. The atoi function has been deprecated. Use strtol instead.

@see atof()

@see atol()

@see strtod()

@see strtol()

@see strtoul()

@publishedAll

@externallyDefinedApi

*/

/** @fn  atol(const char *nptr)

@param nptr

Note: 

This description also covers the following functions -

 atoll() 

@return   The atol and atoll functions

return

the converted value if the value can be represented.

  The atol function converts the initial portion of the string pointed to by nptr to long

integer

representation.

 It is equivalent to:

@code

    strtol(nptr, (char **)NULL, 10); 

@endcode

The atoll function converts the initial portion of the string pointed to by nptr to long long

integer representation. It is equivalent to:    

@code

    strtoll(nptr, (char **)NULL, 10);

@endcode

Examples:

@code

#include <stdlib.h>

#include <stdio.h>

void main( void )

{

 /* call to atol */

 long l = atol( "-000002344" );

 printf( "result of atol: %ld

", l );

}

@endcode

@code

Output

result of atol: -2344

@endcode

@code

#include <stdlib.h>

#include <stdio.h>

void main( void )

{

 /* call to atoll */

 long long l = atoll("454756356bs");

 printf( "result of atoll: %ld

", l );

}

@endcode

@code

Output

result of atoll: 454756356

@endcode

@see atof()

@see atoi()

@see strtod()

@see strtol()

@see strtoul()

@publishedAll

@externallyDefinedApi

*/

/** @fn  bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar) (const void *, const void *))

@param key

@param base

@param nmemb

@param size

@param compar

@return   The bsearch function returns a pointer to a matching member of the array, 

or a null pointer if no match is found. If two or more matching members are found 

the result is unspecified.

  The bsearch function searches an array of nmemb objects, the initial member of which is

pointed to by base, for a member that matches the object pointed to by key. The size of each member of the array is specified by size.

 The contents of the array should be in ascending sorted order according to 

  the comparison function referenced by compar. The compar routine is expected to have two arguments which point to the key object and to an array member, in that order. It return an integer 

  less than, equal to, or greater than zero if the key object is found, respectively, to be less than, to match, or be 

  greater than the array member.

Examples:

@code

#include<stdlib.h>

#include<stdio.h>

int search_function(const void* a,const void* b)

{

    return(*(int *)a - *(int *)b);

}

int main()

{

int arr[] = {3,5,7,8,10};

int key = 7;

int i = 5;

int *ele;

ele  = ( int* ) bsearch(&key;, (void *)arr, i, sizeof(arr[0]), search_function);

if (ele != NULL)

        printf("

element found: %d", *ele);

else

        printf("

element not found");

return 0;

}

@endcode

@code

Output

element found: 7

@endcode

@see qsort()

@publishedAll

@externallyDefinedApi

*/

/** @fn  calloc(size_t number, size_t size)

@param number

@param size

Refer to  malloc() for the documentation

@see brk()

@see mmap()

@see getpagesize()

@publishedAll

@externallyDefinedApi

*/

/** @fn  div(int num, int denom)

@param num

@param denom

@return   The div function

returns a structure of type div_t that contains two int

members named quot (quotient)

and rem (remainder).

  The div function