dsekai/memory_8h_source.html

#ifndef MEMORY_H

#define MEMORY_H


struct FAKE_MEMORY_HANDLE {

#if 0

   uint32_t sz;

   uint32_t offset;

#endif

#ifdef MEMORY_HANDLE_SENTINAL

   uint32_t sentinal;

#endif /* MEMORY_HANDLE_SENTINAL */

   MEMORY_PTR ptr;

   uint32_t ptr_sz;

   uint32_t locks;

   struct FAKE_MEMORY_HANDLE* next;

};


int32_t memory_init();


MEMORY_HANDLE memory_alloc( uint32_t sz, uint32_t count );


void memory_free( MEMORY_HANDLE handle );

uint32_t memory_sz( MEMORY_HANDLE );

uint32_t memory_resize( MEMORY_HANDLE*, uint32_t );

void memory_copy_ptr( MEMORY_PTR, CONST_MEMORY_PTR, uint32_t );


void memory_zero_ptr( MEMORY_PTR ptr, uint32_t sz );


WARN_UNUSED MEMORY_PTR memory_unlock( MEMORY_HANDLE handle );

char* memory_strncpy_ptr( char*, const char*, uint16_t );

int16_t memory_strncmp_ptr( const char*, const char*, uint16_t );


int16_t memory_strnlen_ptr( const char* s, uint16_t l );


void memory_debug_dump();


#if !defined( MEMORY_PLATFORM_C ) && defined( MEMORY_FAKE_TRACE_LOCKS )


#define stringify_handle( handle ) #handle


#define memory_lock( handle ) memory_lock_wrapper( handle, stringify_handle( handle ), __func__ )


#define memory_unlock( handle ) memory_unlock_wrapper( handle, stringify_handle( handle ), __func__ )


#define memory_free( handle ) memory_free_wrapper( handle, stringify_handle( handle ), __func__ )


MEMORY_PTR memory_lock_wrapper(

   MEMORY_HANDLE handle, const char* handle_name, const char* caller );


MEMORY_PTR memory_unlock_wrapper(

   MEMORY_HANDLE handle, const char* handle_name, const char* caller );


void memory_free_wrapper(

   MEMORY_HANDLE handle, const char* handle_name, const char* caller );


#else


WARN_UNUSED MEMORY_PTR memory_lock( MEMORY_HANDLE handle );


#endif /* !MEMORY_PLATFORM_C && MEMORY_FAKE_TRACE_LOCKS */


#endif /* !MEMORY_H */


CONST_MEMORY_PTR
const void * CONST_MEMORY_PTR
A read-only MEMORY_PTR.
Definition: fakem.h:45

memory_strnlen_ptr
int16_t memory_strnlen_ptr(const char *s, uint16_t l)
Get the size of a string, up to a specified maximum.

memory_unlock
WARN_UNUSED MEMORY_PTR memory_unlock(MEMORY_HANDLE handle)
Unlock a dynamic memory handle so the system can relocate it on the heap to relieve congestion.

MEMORY_PTR
void * MEMORY_PTR
A C-style memory pointer that can be safely dereferenced.
Definition: fakem.h:42

memory_lock
WARN_UNUSED MEMORY_PTR memory_lock(MEMORY_HANDLE handle)
Lock a dynamic memory handle and return a MEMORY_PTR that can be dereferenced safely.

memory_zero_ptr
void memory_zero_ptr(MEMORY_PTR ptr, uint32_t sz)
Fill a block of memory with zeros.

memory_free
void memory_free(MEMORY_HANDLE handle)
Free a block of dynamic memory previously allocated with memory_alloc().

memory_alloc
MEMORY_HANDLE memory_alloc(uint32_t sz, uint32_t count)
Request dynamic memory from operating system while protecting from overflow conditions.

FAKE_MEMORY_HANDLE
An emulated memory handle for modern systems. Overridden on most platforms.
Definition: memory.h:20