1 /*

     2 ** Copyright (c) 2001-2007 Expat maintainers.

     3 **

     4 ** Permission is hereby granted, free of charge, to any person obtaining

     5 ** a copy of this software and associated documentation files (the

     6 ** "Software"), to deal in the Software without restriction, including

     7 ** without limitation the rights to use, copy, modify, merge, publish,

     8 ** distribute, sublicense, and/or sell copies of the Software, and to

     9 ** permit persons to whom the Software is furnished to do so, subject to

    10 ** the following conditions:

    11 ** 

    12 ** The above copyright notice and this permission notice shall be included

    13 ** in all copies or substantial portions of the Software.

    14 ** 

    15 ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    16 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    17 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

    18 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

    19 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

    20 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

    21 ** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

    22 */

    23 

    24 #include <stdlib.h>

    25 #include <exec/memory.h>

    26 #include <proto/exec.h>

    27 #include <proto/utility.h>

    28 

    29 void * malloc (size_t len)

    30 {

    31 	uint32 size = sizeof(uint32) + len;

    32 

    33 	uint32 *mem = AllocMem(size, MEMF_SHARED);

    34 	if ( mem != 0 )  {

    35 		*mem = size;

    36 		++mem;

    37 	}

    38 

    39 	return mem;

    40 }

    41 

    42 

    43 void * realloc (void * mem, size_t len2)

    44 {

    45 	if ( mem == 0 )  {

    46 		return malloc(len2);

    47 	}

    48 

    49 	if ( len2 == 0 )  {

    50 		free(mem);

    51 		return 0;

    52 	}

    53 

    54 	void * new_mem = malloc(len2);

    55 	if ( new_mem == 0 )  {

    56 		return 0;

    57 	}

    58 

    59 	uint32 mem_size = *(((uint32*)mem) - 1);

    60 	CopyMem(mem, new_mem, mem_size);

    61 	free(mem);

    62 

    63 	return new_mem;

    64 }

    65 

    66 

    67 void free (void * mem)

    68 {

    69 	if ( mem != 0 )  {

    70 		uint32 * size_ptr = ((uint32*)mem) - 1;

    71 		FreeMem(size_ptr, *size_ptr);

    72 	}

    73 }

    74 

    75 

    76 int memcmp (const void * a, const void * b, size_t len)

    77 {

    78 	size_t i;

    79 	int diff;

    80 

    81 	for ( i = 0; i < len; ++i )  {

    82 		diff = *((uint8 *)a++) - *((uint8 *)b++);

    83 		if ( diff )  {

    84 			return diff;

    85 		}

    86 	}

    87 

    88 	return 0;

    89 }

    90 

    91 

    92 void * memcpy (void * t, const void * a, size_t len)

    93 {

    94 	CopyMem((APTR)a, t, len);

    95 	return t;

    96 }

    97 

    98 

    99 void * memmove (void * t1, const void * t2, size_t len)

   100 {

   101 	MoveMem((APTR)t2, t1, len);

   102 	return t1;

   103 }

   104 

   105 

   106 void * memset (void * t, int c, size_t len)

   107 {

   108 	return SetMem(t, c, len);

   109 }