ml_mem.c

是一个手机功能的模拟程序

/* ====================================================================== */
#ifndef XNOPROTO
  static xmk_T_MBLOCK * __memalloc( size_t rsize ) 
#else
  static xmk_T_MBLOCK * __memalloc( rsize ) 
  size_t  rsize ;
#endif
{
  register xmk_T_MBLOCK * block,  * rover ;

  register unsigned long bsize ,
                         max ;

  block  = NULL ;
  rover  = first_block ;
  max    = -1L ;

  if( first_block == NULL )
  {
    return( NULL ) ;
  } /* END IF */

  rsize += sizeof( xmk_T_MBLOCK ) ;

  do
  {
    if( rover->used == XMK_FALSE )
    {
      bsize = ( unsigned long )rover->next - ( unsigned long )rover ;

      if( ( bsize > rsize ) &&
          ( bsize < max   )
        )
      {
        block = rover ;

        if( rsize == ( max = bsize ) )
        {
          break ; /* -> skip to the end of loop */
        } /* END IF */
      } /* END IF */

      rover = rover->next ;
    } /* END IF */

    if (rover) /* bug fix */
      rover = rover->next ;
  }
  while( rover != NULL ) ;

  /*
  ** If there was a free block found
  */
  if( block != NULL )
  {
    XMK_M_ADD_CUR_MEM(rsize);

    #ifdef XMK_ADD_PROFILE 
      block->used = rsize ;
    #else
      block->used = XMK_TRUE ;
    #endif

    __memshrink( block , rsize ) ;
  } /* END IF */

  return( block ) ;
} /* END OF FUNCTION */


/*+FHDR E*/
/*
+------------------------------------------------------------------------------+
|  Functionname : xmk_Free                                                     |
|  Author       : S&P Media GmbH Germany                                       |
+------------------------------------------------------------------------------+
|                                                                              |
|  Description  :                                                              |
|  This function is a template for the free () implementation.                 |
|                                                                              |
|  Parameter    : void  * xmk_MemPtr                                           |
|                                                                              |
|  Return       : void                                                         |
|                                                                              |
+------------------------------------------------------------------------------+
*/
/*-FHDR E*/

/*+FDEF E*/

#ifndef XNOPROTO
  void xmk_Free ( void  * xmk_MemPtr )
#else
  void xmk_Free ( xmk_MemPtr )
  void * xmk_MemPtr;
#endif

/*-FDEF E*/

{
  register xmk_T_MBLOCK * block ;

  #ifdef XMK_ADD_PRINTF_MEMORY
    XMK_FUNCTION("xmk_Free");
  #endif

  XMK_BEGIN_CRITICAL_PATH;

  #ifdef XMK_USE_MAX_ERR_CHECK
    if (! xmk_MemIsInitialized)
    {
      ErrorHandler (ERR_N_INIT_SDL_MEM);
      XMK_END_CRITICAL_PATH;
      return;
    }  
  #endif

  block = ( xmk_T_MBLOCK * )xmk_MemPtr ;

  block-- ;

  if( ( block->next->prev == block ) &&
        block->used
    )
  {
    XMK_M_DECR_ACT;
    XMK_M_SUB_CUR_MEM(block->used);

    block->used = XMK_FALSE ;

    if( !block->next->used )
    {
      block->next = block->next->next ;
      block->next->prev = block ;
    } /* END IF */

    if( ( block->prev      != NULL  ) &&
         !block->prev->used
      )
    {
      block->prev->next = block->next ;
      block->next->prev = block->prev ;
    } /* END IF */
  } /* end if( ... ) */

  else
  {
    ErrorHandler (ERR_N_MEM_ILLMBLOCK) ;
  } /* END ELSE */

  XMK_END_CRITICAL_PATH;

  #ifdef XMK_ADD_PRINTF_MEMORY
    XMK_TRACE_EXIT("xmk_Free");
  #endif
} /* END OF FUNCTION */


/*+FHDR E*/
/*
+------------------------------------------------------------------------------+
|  Functionname : xmk_Calloc                                                   |
|  Author       : S&P Media GmbH Germany                                       |
+------------------------------------------------------------------------------+
|                                                                              |
|  Description  :                                                              |
|  This function is a template for the similar calloc () implementation.       |
|                                                                              |
|  Parameter    :                                                              |
|                                                                              |
|  Return       :                                                              |
|                                                                             |
+------------------------------------------------------------------------------+
*/
/*-FHDR E*/

/*+FDEF E*/

#ifndef XNOPROTO
  void * xmk_Calloc( size_t nitems, size_t size )
#else
  void * xmk_Calloc( nitems, size )
  size_t nitems;
  size_t size;
#endif

/*-FDEF E*/

{
  char * pMemBlock ;
  unsigned long RequestedSize;

  #ifdef XMK_ADD_PRINTF_MEMORY
    XMK_FUNCTION("xmk_Calloc");
  #endif

  RequestedSize = nitems * size;

  if (RequestedSize > XMK_MAX_MALLOC_SIZE )
      return NULL;

  pMemBlock = xmk_Malloc( RequestedSize ) ;

  if( pMemBlock != NULL )
  {
    register char* _pMemBlock ;

    _pMemBlock = ( char *)pMemBlock ;

    for( ; RequestedSize ; _pMemBlock[ --RequestedSize ] = 0 ) ;
  } /* END IF */

  #ifdef XMK_ADD_PRINTF_MEMORY
    XMK_TRACE_EXIT("xmk_Calloc");
  #endif

  return( pMemBlock ) ;
} /* END OF FUNCTION */

#ifdef XMK_USE_memshrink

/*+FHDR E*/
/*
+------------------------------------------------------------------------------+
|  Functionname : xmk_Memshrink                                                |
|  Author       : S&P Media GmbH Germany                                       |
+------------------------------------------------------------------------------+
|                                                                              |
|  Description  :                                                              |
|  This function is a template for an extension of the Standard of the dynamic |
|  Memory Management supported by an ordinary C-Compiler. It allows you to     |
|  shrink down a memory area previously requested with xmk_Malloc.             |
|                                                                              |
|  Parameter    :                                                              |
|                                                                              |
|    pMemBlock :                                                               |
|                                                                              |
|    NewSize   :                                                               |
|                                                                              |
|  Return       :                                                              |
|                                                                              |
+------------------------------------------------------------------------------+
*/
/*-FHDR E*/

/*+FDEF E*/

#ifndef XNOPROTO
  void xmk_Memshrink( void * pMemBlock, size_t NewSize )
#else
  void xmk_Memshrink(pMemBlock, NewSize )
  void    * pMemBlock ;
size_t    NewSize ;
#endif

/*-FDEF E*/

{
  xmk_T_MBLOCK * _pMemBlock ;

  #ifdef XMK_ADD_PRINTF_MEMORY
    XMK_FUNCTION("xmk_Memshrink");
  #endif

  XMK_BEGIN_CRITICAL_PATH;

  _pMemBlock = ( xmk_T_MBLOCK * )pMemBlock ;

  _pMemBlock-- ;

  if( ( _pMemBlock->next->prev == _pMemBlock ) &&
        _pMemBlock->used
    )
  {
    __memshrink( _pMemBlock, NewSize ) ;
  } /* END IF */

  else
  {
    ErrorHandler (ERR_N_MEM_ILLMBLOCK) ;
  } /* END ELSE */

  XMK_END_CRITICAL_PATH;

  #ifdef XMK_ADD_PRINTF_MEMORY
    XMK_TRACE_EXIT("xmk_Memshrink");
  #endif
} /* END OF FUNCTION */

#endif /* ... XMK_USE_memshrink */

/* ====================================================================== */
/* =                                                                    = */
/* =   _memshrink                                                       = */
/* =                                                                    = */
/* ====================================================================== */
#ifndef XNOPROTO
  static void __memshrink( xmk_T_MBLOCK * pMemBlock, size_t NewSize )
#else
  static void __memshrink( pMemBlock, NewSize )
  xmk_T_MBLOCK * pMemBlock;
  size_t    NewSize
#endif
{
  register xmk_T_MBLOCK  * pNewBlock ;
  register unsigned long BlockSize ;

  BlockSize = ( unsigned long )pMemBlock->next - ( unsigned long )pMemBlock ;

  if( BlockSize > ( sizeof( xmk_T_MBLOCK ) + NewSize + 50 ) )
  {
    pNewBlock = ( xmk_T_MBLOCK * )( ( char * )pMemBlock + NewSize ) ;

    pNewBlock->next       = pMemBlock->next ;
    pNewBlock->prev       = pMemBlock ;
    pNewBlock->prev->next = pNewBlock->next->prev = pNewBlock ;

    pNewBlock->used = XMK_FALSE ;
  } /* END IF */
} /* END OF FUNCTION */


#if defined(XMK_ADD_PROFILE) && defined(XMK_USE_EXPANDED_KERNEL)

/*+FHDR E*/
/*
+------------------------------------------------------------------------------+
|  Functionname : xmk_GetOccupiedMem                                           |
|  Author       : S&P Media GmbH Germany                                       |
+------------------------------------------------------------------------------+
|                                                                              |
|  Description  :                                                              |
|  This function returns the amount of occupied memory.                        |
|                                                                              |
|  Parameter    : void                                                         |
|                                                                              |
|  Return       : size_t                                                       |
|                                                                              |
+------------------------------------------------------------------------------+
*/
/*-FHDR E*/

/*+FDEF E*/

#ifndef XNOPROTO
  size_t xmk_GetOccupiedMem ( void )
#else
  size_t xmk_GetOccupiedMem (  )
#endif

/*-FDEF E*/

{
  return (xmk_cur_memory_fill);