/*
* Copyright (c) 2003 - 2004 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/


/***************************************************************************
**   File: cxml_mem.c
**   Purpose:  Provides the implementation to memory management
**************************************************************************/

#include "cxml_internal.h"

#ifdef FEATURE_MEMORY_PROFILE
typedef struct _MemProfile
{
    struct _MemProfile  *next;  // ptr to next mem block
    struct _MemProfile  *prev;  // ptr to previous mem block
    char                *file;  // filename of memory allocator
    CXML_Int32               line;   // line # in filename of memory allocator
    CXML_Int32               size;   // size of requested memory
    CXML_Int32               seq;    // sequence number for allocation 
} MemProfile;
#endif

/*
**-------------------------------------------------------------------------
**  External Public (Exported) Functions
**-------------------------------------------------------------------------
*/

void *CXML_Mem_memset(void *s, CXML_Uint32 c, CXML_Uint32 n)
{
  unsigned char *myPtr  = (unsigned char *)s;
  unsigned char fill    = (unsigned char)c;
  while (n > 0) {
    *myPtr = fill;
    myPtr++;
    n--;
  }
  return s;
}


void *CXML_Mem_memcpy(void *s1, const void *s2, CXML_Uint32 n)
{
  unsigned char *myDest   = (unsigned char *)s1;
  unsigned char *mySource = (unsigned char *)s2;

  if (n==0) return NULL;

  while (n > 0) {
    *myDest = *mySource;
    n--;
    myDest++;
    mySource++;
  }
  return s1;
}


void *CXML_Mem_memmove(void *s1, const void *s2, CXML_Uint32 n)
{
  unsigned char *myDest;
  unsigned char *mySource;

  if (n == 0) return NULL;

  if (s1 <= s2) {
    /* We can always copy from higher address to */
    /* lower address, even if buffer overlaps */
    myDest    = (unsigned char *)s1;
    mySource  = (unsigned char *)s2;
    while (n > 0) {
      *myDest = *mySource;
      myDest++;
      mySource++;
      n--;
    }

  } else {
    /* We can always copy in reverse order from */
    /* lower address to higher address, even if */
    /* buffer overlaps */
    myDest    = (unsigned char *)s1 + n;
    mySource  = (unsigned char *)s2 + n;
    while (n > 0) {
      n--;
      myDest--;
      mySource--;
      *myDest = *mySource;
    }

  }

  return s1;
}


CXML_Int32 CXML_Mem_memcmp(const void *s1, const void *s2, CXML_Uint32 n)
{
  unsigned char *myDest   = (unsigned char *)s1;
  unsigned char *mySource = (unsigned char *)s2;

  /* If s1 == s2, then immediately return 0. */
  if ( s1 == s2 )
    return 0 ;

  while (n > 0) {
    if (*myDest != *mySource) {
      return (*myDest - *mySource);
    }
    myDest++;
    mySource++;
    n--;
  }
  
  return 0;
}

/*********************************************************
**  Name:   CXML_Mem_Malloc
**  Description:  Allocates memory.
**  Parameters:   nbytes - number of bytes to allocate
**  Return Value: pointer to the allocated memory or NULL 
**********************************************************/
void *CXML_Mem_Malloc(CXML_Uint32 nbytes)
{
	return malloc(nbytes);
}

/************************************************************************
**  Name:   CXML_Mem_Free
**  Description:  Frees allocated memory.
**  Parameters:   mem - pointer to the memory to free
**  Return Value: void
**************************************************************************/
void CXML_Mem_Free(void *buffer)
{
  if (buffer != NULL) {
    /* Note: os_block_dealloc() will free both heap and block-table memory */
		free(buffer);
  }
  return;
}


#ifdef FEATURE_MEMORY_PROFILE
CXML_Uint32 Asc_strlen(const char *s)
{
  CXML_Uint32 i = 0;
  while (*s != '\0')
  {
    s++;
    i++;
  }
  return i;
}

/*****************************************************************
**  Name:  Asc_strcpy
**  Description:  Copies ascii string
**  Parameters:   s1 destination string
**                s2 source string
**  Return Value: pointer to s1
******************************************************************/
char *Asc_strcpy(char *s1, const char *s2)
{
  while (*s2 != '\0') {
    *s1 = *s2;
    s1++;
    s2++;
  }
  *s1 = *s2;
  return s1;
}

/*********************************************************
**  Name:   CXML_Mem_Malloc
**  Description:  Allocates memory.
**  Parameters:   nbytes - number of bytes to allocate
**  Return Value: pointer to the allocated memory or NULL 
**********************************************************/
void *CXML_Mem_Malloc_Pro(CXML_Uint32 nbytes, char *file, CXML_Uint32 line)
{
	void *buf;
    MemProfile  *pblock, *last;  
    CXML_Int32   len = nbytes + sizeof(MemProfile);
    CXML_Int32   seqno;

    pblock = malloc(len);
    
    // Store profile block data 

    if ((CXML_Uint32) file > 0xf000)
    {
        pblock->file = (char*)malloc(Asc_strlen(file) + 1);
        Asc_strcpy(pblock->file, file);
    }
    else
    {
        // no filename since this may be called via a function ptr
        pblock->file = NULL;
    }
    pblock->line = line;
    pblock->size = nbytes;

    // Set List Pointers
    // Get last ptr
    last = (MemProfile *) NW_Ctx_Get(NW_CTX_MEM_PRO_LAST_PTR, 0); 

    if (last == NULL)
    {
        pblock->prev = NULL;
        pblock->seq = 0;
    }
    else
    {
        pblock->prev = last;
        last->next = pblock;
        // can't use last-> because free my remove block (along with
        // seq numbers, need a context
        seqno = (CXML_Uint32) NW_Ctx_Get(NW_CTX_MEM_PRO_SEQ_NO, 0); 
        seqno += 1;
        pblock->seq = seqno;
        NW_Ctx_Set(NW_CTX_MEM_PRO_SEQ_NO, 0, seqno); 
    }
    pblock->next = NULL;

    // last = pblock
    last = pblock;
    NW_Ctx_Set(NW_CTX_MEM_PRO_LAST_PTR, 0, last);

    
    // return mem block to caller              
    buf = (void *) ((CXML_Byte *) pblock + sizeof(MemProfile));
    return (buf);
}

/************************************************************************
**  Name:   CXML_Mem_Free
**  Description:  Frees allocated memory.
**  Parameters:   mem - pointer to the memory to free
**  Return Value: void
**************************************************************************/
void CXML_Mem_Free_Pro(void *buffer, char *file, CXML_Uint32 line)
{
 MemProfile  *pblock, *last, *prevp, *nextp;  
    
    if (buffer == NULL)
    {
        return;
    }
                                                         
    pblock = (MemProfile *) ((CXML_Byte *) buffer - sizeof(MemProfile));

    // Get last ptr
    last = (MemProfile *) NW_Ctx_Get(NW_CTX_MEM_PRO_LAST_PTR, 0); 

    if ( pblock == last )
    {
        last = last->prev;
        NW_Ctx_Set(NW_CTX_MEM_PRO_LAST_PTR, 0, last);
    }
    else
    {
        prevp = pblock->prev; 
        nextp = pblock->next;
        if (prevp)
        {
            prevp->next = nextp;
        }
        if (nextp)
        {
            nextp->prev = prevp;
        }
    }

    // Free Filename pointer and memory block
    free(pblock->file);
    free(pblock);
    return;
}
#endif