stdlib.h

Go to the documentation of this file.

/*---------------------------------------------------------------------------------------------
 * /
 * / apeNEXT stdlib functions for nlcc
 * /
 * / $Id: stdlib.h,v 1.19 2006/05/06 08:16:27 pleiter Exp $
 * /
 * /
 * / ISO/IEC 9899:1999 (E) Standard
 * / General utilities  <stdlib.h>
 * /
 * /
 * /
 * / IMPLEMENTATION for APEnext: partly possible (stdlib.h)
 * /-------------------------------------------------------------------------------------------*/
#ifndef _STDLIB_H
#define _STDLIB_H

#include <nlibc.h>
#include <stddef.h>
#include <float.h>

typedef struct
  {
    int quot;
    int rem;
  } div_t;

#ifndef __ldiv_t_defined
typedef struct
  {
    long int quot;
    long int rem;
  } ldiv_t;
# define __ldiv_t_defined       1
#endif

#ifndef __lldiv_t_defined
typedef struct
  {
    long long int quot;
    long long int rem;
  } lldiv_t;
# define __lldiv_t_defined      1
#endif

#define EXIT_FAILURE    1       /* Failing exit status.  */
#define EXIT_SUCCESS    0       /* Successful exit status.  */

#define RAND_MAX        INT_MAX

/*---------------------------------------------------------------------------------------------
 * / 
 * / NAME
 * /        abort - cause abnormal program termination
 * / 
 * / SYNOPSIS
 * /        #include <stdlib.h>
 * / 
 * /        void abort(void);
 * / 
 * / DESCRIPTION
 * /        The  abort()  function causes abnormal program termination
 * /        unless the signal SIGABRT is caught and the signal handler
 * /        does  not  return.  If the abort() function causes program
 * /        termination, all open streams are closed and flushed.
 * / 
 * /        If the SIGABRT signal is blocked or ignored,  the  abort()
 * /        function will still override it.
 * / 
 * / RETURN VALUE
 * /        The abort() function never returns.
 * / 
 * / IMPLEMENTATION for APEnext:
 * /            done, except for signal handling 
 * /            The function now simply unconditionedly issues a
 * /            software exception.
 * /-------------------------------------------------------------------------------------------*/
inline void abort(void){
        register int maskval;
        // fetch current mem exception mask
        asm("\tctr %0 0x21\n" : "=r" (maskval));
        // allow SEX and store back
        asm("\trtc 0x21 %0\n" : : "r" (maskval & ~0x2));
        // issue a SEX
        asm("\tsex\t!! via abort()");
} 


/*---------------------------------------------------------------------------------------------
 * Extensions implemented by Norbert:
 *-------------------------------------------------------------------------------------------*/

#include <alloca.h>

#undef __roundup
#define __roundup(x,n) (((x)+((n)-1))&(~((n)-1)))

#define sizeof_aligned(TY) __roundup(sizeof(TY),__alignof__(TY))



//---------------------------------------------------------------------------------------------
#define atof(STR)  strtod((STR), (char **)NULL)
//double atof(const char *nptr){}

//---------------------------------------------------------------------------------------------
#define atoi(nptr)  strtol(nptr, (char **)NULL, 10)
#define atol(nptr)  strtol(nptr, (char **)NULL, 10)
#define atoll(nptr) strtoll(nptr, (char **)NULL, 10)
#define atoq(nptr)  atoll(nptr);


/*--------------------------------------------------------------------------------------------
 * 
 * include strtol() and strtoll()
 */
#include <stdlib/strtol.h>

/*--------------------------------------------------------------------------------------------
 * 
 * include strtoul() and strtoull()
 */
#include <stdlib/strtoul.h>

/*--------------------------------------------------------------------------------------------
 * 
 * include strtod(), strtof() and strtold() 
 */
#include <stdlib/strtod.h>

/*--------------------------------------------------------------------------------------------
 * 
 * include rand() and srand()
 */
#include <stdlib/rand.h>

/*---------------------------------------------------------------------------------------------
 * / 
 * / NAME
 * /        calloc,  malloc, free, realloc - Allocate and free dynamic
 * /        memory
 * / 
 * / SYNOPSIS
 * /        #include <stdlib.h>
 * / 
 * /        void *calloc(size_t nmemb, size_t size);
 * /        void *malloc(size_t size);
 * /        void free(void *ptr);
 * /        void *realloc(void *ptr, size_t size);
 * / 
 * / DESCRIPTION
 * /        calloc() allocates memory for an array of  nmemb  elements
 * /        of  size bytes each and returns a pointer to the allocated
 * /        memory.  The memory is set to zero.
 * / 
 * /        malloc() allocates size bytes and returns a pointer to the
 * /        allocated memory.  The memory is not cleared.
 * / 
 * /        free()  frees  the  memory  space pointed to by ptr, which
 * /        must have been returned by a previous  call  to  malloc(),
 * /        calloc()  or  realloc().   Otherwise,  or if free(ptr) has
 * /        already been called before,  undefined  behaviour  occurs.
 * /        If ptr is NULL, no operation is performed.
 * / 
 * /        realloc()  changes the size of the memory block pointed to
 * /        by ptr to size bytes.  The contents will be  unchanged  to
 * /        the minimum of the old and new sizes; newly allocated mem­
 * /        ory will be uninitialized.  If ptr is NULL,  the  call  is
 * /        equivalent  to malloc(size); if size is equal to zero, the
 * /        call is equivalent to free(ptr).  Unless ptr is  NULL,  it
 * /        must  have  been  returned by an earlier call to malloc(),
 * /        calloc() or realloc().
 * / 
 * / RETURN VALUE
 * /        For calloc() and malloc(), the value returned is a pointer
 * /        to the allocated memory, which is suitably aligned for any
 * /        kind of variable, or NULL if the request fails.
 * / 
 * /        free() returns no value.
 * / 
 * /        realloc() returns a pointer to the newly allocated memory,
 * /        which is suitably aligned for any kind of variable and may
 * /        be different from ptr, or NULL if the request fails or  if
 * /        size  was  equal  to  0.   If realloc() fails the original
 * /        block is left untouched - it is not freed or moved.
 * / 
 * / IMPLEMENTATION for APEnext:
 * /
 * /-------------------------------------------------------------------------------------------*/
#include <stdlib/bsdmalloc.h>

//---------------------------------------------------------------------------------------------
// int atexit(void (*func)(void)){} 

/*---------------------------------------------------------------------------------------------
 * / 
 * / NAME
 * /        exit - cause normal program termination
 * / 
 * / SYNOPSIS
 * /        #include <stdlib.h>
 * / 
 * /        void exit(int status);
 * / 
 * / DESCRIPTION
 * /        The  exit() function causes normal program termination and
 * /        the value of status is returned to the parent.  All  func­
 * /        tions registered with atexit() and on_exit() are called in
 * /        the reverse order of  their  registration,  and  all  open
 * /        streams are flushed and closed.
 * / 
 * / RETURN VALUE
 * /        The exit() function does not return.
 * / 
 * / IMPLEMENTATION for APEnext: possible (exit, _Exit)
 * /-------------------------------------------------------------------------------------------*/
// void exit(int status){} 
// void _Exit(int status){} 

/*---------------------------------------------------------------------------------------------
 * / 
 * / NAME
 * /        getenv - get an environment variable
 * / 
 * / SYNOPSIS
 * /        #include <stdlib.h>
 * / 
 * /        char *getenv(const char *name);
 * / 
 * / DESCRIPTION
 * /        The  getenv() function searches the environment list for a
 * /        string that matches the string pointed to  by  name.   The
 * /        strings are of the form name = value.
 * / 
 * / RETURN VALUE
 * /        The  getenv()  function  returns a pointer to the value in
 * /        the environment, or NULL if there is no match.
 * / 
 * / IMPLEMENTATION for APEnext: not possible (getenv)
 * /-------------------------------------------------------------------------------------------*/
// char *getenv(const char *name){} 

//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern int system(const char *s);
#else
#if !defined(__cflow_processed) || defined(_uses_system_stdlib_h)
int system(const char *s)
{
  register vector int retval=0;

  if (s==NULL)
    retval=1;
  else
    if( strlen(s)!=0 ) 
      {
        asm("\t$io_start\n");
        asm("\t$io_packet($SYS_IOCMD_SYSTEM, $SYS_IOFMT_VARSTR, $SYS_IORDFLG_NOP, $SYS_IODEV_MEM, 0 , $SYS_IOBS_V, 0.%0)\n" : : "r" (s) );
        asm("\t$io_end\n");
        asm("\tlmtr %0 $MEM_SYS_RVAL\n" : "=r" (retval));
      }
  
  return retval.hi;
}
#endif // system()
#endif // Has Main

//------------------------------------------------------------------------------
// void *bsearch(const void *key, const void *base, size_t nmemb, \ 
//               size_t size, int (*compar)(const void *, const void *)){} 


//------------------------------------------------------------------------------
// void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)){} 

//------------------------------------------------------------------------------
#if !defined(__cflow_processed) || defined(_uses_abs_stdlib_h)
inline int abs( int i ) {
  register int a;
  where( i < 0 ) { 
    a = -i;
  } else {
    a = i;
  }
  return a;
}
#endif // abs()

#define labs(VAL) abs(VAL)
#define llabs(VAL) abs(VAL)


//------------------------------------------------------------------------------
#if !defined(__cflow_processed) || defined(_uses_div_stdlib_h)
inline div_t div(int numer, int denom)
{
  register div_t a; 

  asm("\tidiv %0 %1 %2 %3" : "=r" (a.quot), "=r" (a.rem) : "r" (numer), "r" (denom));

  return(a);
} 
#endif // _uses_div_stdlib_h

#if !defined(__cflow_processed) || defined(_uses_ldiv_stdlib_h)
inline ldiv_t ldiv(long int numer, long int denom)
{
  register ldiv_t a; 

  asm("\tidiv %0 %1 %2 %3" : "=r" (a.quot), "=r" (a.rem) : "r" (numer), "r" (denom));

  return(a);
} 
#endif // _uses_ldiv_stdlib_h

#if !defined(__cflow_processed) || defined(_uses_lldiv_stdlib_h)
inline lldiv_t lldiv(long long int numer, long long int denom)
{
  register lldiv_t a; 

  asm("\tidiv %0 %1 %2 %3" : "=r" (a.quot), "=r" (a.rem) : "r" (numer), "r" (denom));

  return(a);
} 
#endif // _uses_lldiv_stdlib_h

/*---------------------------------------------------------------------------------------------
 * / 
 * / NAME
 * /        mblen  - determine number of bytes in next multibyte char­
 * /        acter
 * / 
 * / SYNOPSIS
 * /        #include <stdlib.h>
 * / 
 * /        int mblen (const char *s, size_t n);
 * / 
 * / DESCRIPTION
 * /        If s is not a NULL pointer, the mblen function inspects at
 * /        most  n  bytes  of  the multibyte string starting at s and
 * /        extracts the next complete multibyte character. It uses  a
 * /        static anonymous shift state only known to the mblen func­
 * /        tion. If the multibyte character  is  not  the  null  wide
 * /        character,  it  returns the number of bytes that were con­
 * /        sumed from s. If the multibyte character is the null  wide
 * /        character, it returns 0.
 * / 
 * /        If  the  n  bytes  starting at s do not contain a complete
 * /        multibyte character, mblen returns  -1.  This  can  happen
 * /        even  if n >= MB_CUR_MAX, if the multibyte string contains
 * /        redundant shift sequences.
 * / 
 * /        If the multibyte string starting at s contains an  invalid
 * /        multibyte  sequence  before  the  next complete character,
 * /        mblen also returns -1.
 * / 
 * /        If s is a NULL pointer,  the  mblen  function  resets  the
 * /        shift  state,  only known to this function, to the initial
 * /        state, and returns non-zero if the encoding has  non-triv­
 * /        ial shift state, or zero if the encoding is stateless.
 * / 
 * / RETURN VALUE
 * /        The mblen function returns the number of bytes parsed from
 * /        the multibyte sequence starting at s, if a  non-null  wide
 * /        character  was  recognized.   It returns 0, if a null wide
 * /        character was recognized. It returns  -1,  if  an  invalid
 * /        multibyte sequence was encountered or if it couldn't parse
 * /        a complete multibyte character.
 * / 
 * / IMPLEMENTATION for APEnext: possible if strings are implemented  (mblen)
 * /-------------------------------------------------------------------------------------------*/
// int mblen(const char *s, size_t n){} 


/*---------------------------------------------------------------------------------------------
 * / 
 * / NAME
 * /        mbtowc - convert a multibyte sequence to a wide character
 * / 
 * / SYNOPSIS
 * /        #include <stdlib.h>
 * / 
 * /        int mbtowc (wchar_t *pwc, const char *s, size_t n);
 * / 
 * / DESCRIPTION
 * /        The  main case for this function is when s is not NULL and
 * /        pwc is  not  NULL.  In  this  case,  the  mbtowc  function
 * /        inspects  at most n bytes of the multibyte string starting
 * /        at s, extracts the next complete multibyte character, con­
 * /        verts  it  to  a  wide character and stores it at *pwc. It
 * /        updates an internal shift state only known to  the  mbtowc
 * /        function.  If  s does not point to a '\0' byte, it returns
 * /        the number of bytes that were consumed from  s,  otherwise
 * /        it returns 0.
 * / 
 * /        If  the  n  bytes  starting at s do not contain a complete
 * /        multibyte character, or if they contain an invalid  multi­
 * /        byte  sequence, mbtowc returns -1. This can happen even if
 * /        n >= MB_CUR_MAX, if the multibyte string  contains  redun­
 * /        dant shift sequences.
 * / 
 * /        A different case is when s is not NULL but pwc is NULL. In
 * /        this case the mbtowc function behaves  as  above,  excepts
 * /        that  it  does  not  store the converted wide character in
 * /        memory.
 * / 
 * /        A third case is when s is NULL. In this case,  pwc  and  n
 * /        are  ignored.  The mbtowc function resets the shift state,
 * /        only known to this function, to  the  initial  state,  and
 * /        returns  non-zero  if  the  encoding has non-trivial shift
 * /        state, or zero if the encoding is stateless.
 * / 
 * / RETURN VALUE
 * /        If s is not NULL, the mbtowc function returns  the  number
 * /        of  consumed  bytes  starting  at s, or 0 if s points to a
 * /        null byte, or -1 upon failure.
 * / 
 * /        If s is NULL, the mbtowc function returns non-zero if  the
 * /        encoding  has  non-trivial  shift  state,  or  zero if the
 * /        encoding is stateless.
 * / 
 * / IMPLEMENTATION for APEnext: possible if strings are implemented  (mbtowc)
 * /-------------------------------------------------------------------------------------------*/
// int mbtowc(wchar_t * /* restrict */ pwc, const char * /* restrict */ s, size_t n){} 

/*---------------------------------------------------------------------------------------------
 * / 
 * / NAME
 * /        wctomb - convert a wide character to a multibyte sequence
 * / 
 * / SYNOPSIS
 * /        #include <stdlib.h>
 * / 
 * /        int wctomb (char *s, wchar_t wc);
 * / 
 * / DESCRIPTION
 * /        If  s  is  not NULL, the wctomb function converts the wide
 * /        character wc to its multibyte representation and stores it
 * /        at  the  beginning of the character array pointed to by s.
 * /        It updates the shift state, which is stored  in  a  static
 * /        anonymous  variable only known to the wctomb function, and
 * /        returns the length of said multibyte representation,  i.e.
 * /        the number of bytes written at s.
 * / 
 * /        The programmer must ensure that there is room for at least
 * /        MB_CUR_MAX bytes at s.
 * / 
 * /        If s is NULL, the wctomb function resets the shift  state,
 * /        only  known  to  this  function, to the initial state, and
 * /        returns non-zero if the  encoding  has  non-trivial  shift
 * /        state, or zero if the encoding is stateless.
 * / 
 * / RETURN VALUE
 * /        If  s  is not NULL, the wctomb function returns the number
 * /        of bytes that have been written to the byte array at s. If
 * /        wc can not be represented as a multibyte sequence (accord­
 * /        ing to the current locale), -1 is returned.
 * / 
 * /        If s is NULL, the wctomb function returns non-zero if  the
 * /        encoding  has  non-trivial  shift  state,  or  zero if the
 * /        encoding is stateless.
 * / 
 * / IMPLEMENTATION for APEnext: possible if strings are implemented  (wctomb)
 * /-------------------------------------------------------------------------------------------*/
// int wctomb(char *s, wchar_t wchar){} 

/*---------------------------------------------------------------------------------------------
 * / 
 * / NAME
 * /        mbstowcs  - convert a multibyte string to a wide character
 * /        string
 * / 
 * / SYNOPSIS
 * /        #include <stdlib.h>
 * / 
 * /        size_t mbstowcs (wchar_t *dest, const char *src, size_t n);
 * / 
 * / DESCRIPTION
 * /        If dest is not a NULL pointer, the mbstowcs function  con­
 * /        verts  the multibyte string src to a wide-character string
 * /        starting at dest.  At most n wide characters  are  written
 * /        to  dest.  The conversion starts in the initial state. The
 * /        conversion can stop for three reasons:
 * / 
 * /        1. An invalid multibyte sequence has been encountered.  In
 * /        this case (size_t)(-1) is returned.
 * / 
 * /        2.  n  non-L'\0' wide characters have been stored at dest.
 * /        In this case the number of wide characters written to dest
 * /        is returned, but the shift state at this point is lost.
 * / 
 * /        3.  The  multibyte  string  has been completely converted,
 * /        including the terminating '\0'. In this case the number of
 * /        wide characters written to dest, excluding the terminating
 * /        L'\0' character, is returned.
 * / 
 * /        The programmer must ensure that there is room for at least
 * /        n wide characters at dest.
 * / 
 * /        If dest is NULL, n is ignored, and the conversion proceeds
 * /        as above, except that the converted  wide  characters  are
 * /        not  written  out  to  memory,  and  that  no length limit
 * /        exists.
 * / 
 * /        In order to avoid the case 2 above, the programmer  should
 * /        make sure n is greater or equal to mbstowcs(NULL,src,0)+1.
 * / 
 * / RETURN VALUE
 * /        The mbstowcs function returns the number of  wide  charac­
 * /        ters that make up the converted part of the wide character
 * /        string, not including the terminating null wide character.
 * /        If   an   invalid   multibyte  sequence  was  encountered,
 * /        (size_t)(-1) is returned.
 * / 
 * / IMPLEMENTATION for APEnext: possible if strings are implemented  (mbstowcs)
 * /-------------------------------------------------------------------------------------------*/
// size_t mbstowcs(wchar_t * /* restrict */ pwcs, const char * /* restrict */ s, size_t n){} 

/*---------------------------------------------------------------------------------------------
 * / 
 * / NAME
 * /        wcstombs  - convert a wide character string to a multibyte
 * /        string
 * / 
 * / SYNOPSIS
 * /        #include <stdlib.h>
 * / 
 * /        size_t wcstombs (char *dest, const wchar_t *src, size_t n);
 * / 
 * / DESCRIPTION
 * /        If dest is not a NULL pointer, the wcstombs function  con­
 * /        verts  the wide-character string src to a multibyte string
 * /        starting at dest. At most n bytes are written to dest. The
 * /        conversion starts in the initial state. The conversion can
 * /        stop for three reasons:
 * / 
 * /        1. A wide character has been encountered that can  not  be
 * /        represented as a multibyte sequence (according to the cur­
 * /        rent locale). In this case (size_t)(-1) is returned.
 * / 
 * /        2. The length limit forces a stop. In this case the number
 * /        of  bytes written to dest is returned, but the shift state
 * /        at this point is lost.
 * / 
 * /        3. The wide-character  string  has  been  completely  con­
 * /        verted,  including the terminating L'\0'. In this case the
 * /        conversion ends in the initial state.  The number of bytes
 * /        written  to  dest, excluding the terminating '\0' byte, is
 * /        returned.
 * / 
 * /        The programmer must ensure that there is room for at least
 * /        n bytes at dest.
 * / 
 * /        If dest is NULL, n is ignored, and the conversion proceeds
 * /        as above, except that the converted bytes are not  written
 * /        out to memory, and that no length limit exists.
 * / 
 * /        In  order to avoid the case 2 above, the programmer should
 * /        make sure n is greater or equal to wcstombs(NULL,src,0)+1.
 * / 
 * / RETURN VALUE
 * /        The  wcstombs  function  returns  the number of bytes that
 * /        make up the converted  part  of  multibyte  sequence,  not
 * /        including  the terminating null byte.  If a wide character
 * /        was encountered which could not be converted, (size_t)(-1)
 * /        is returned.
 * / 
 * / IMPLEMENTATION for APEnext: possible if strings are implemented  (wcstombs)
 * /-------------------------------------------------------------------------------------------*/
// size_t wcstombs(char * /* restrict */ s, const wchar_t * /* restrict */ pwcs, size_t n){} 



#endif /* ifndef _STDLIB_H  */

---