KVM移植之ITRON版

前段时间由于工作的需要对KVM做了一些研究和学习，最终的目标是要理解KVM的原理和移植要注意的问题，最终拿出一个移植成功的DEMO来。
说起JAVA也只是在大学里学过一个月，后来写了一个记事本，后来就没怎么碰JAVA了。这次要学习它的解释器有点突然，不过经过努力最终还是实现了预期的目标。
因为Itron是日本那边用得比较多的嵌入式操作系统，没有文件系统，只有内存管理和任务管理(具体也不是很了解)。庆幸的是KVM实现得很合理，都是用标准C实现的，所以移植起来费的力气并不是很大。
一，文件管理[重新实现标准库函数(fopen,fread,fgetc,feof,fsize,fseek等)]
鉴于Itron没有文件系统，而KVM的库和CLASS文件允许以ROM的形式一起编译进KVM，同时KVM的文件操作是基于标准C的，这就为我们的移植提供了方便。比方说我们有Hello.java的JAVA程序，这个Hello.java里有一个Hello的类，这个类只做一件是就是输出"Hello World"。我们把它编译成Hello.class之后把这个class文件用其他工具将其转换成二进制数组并存入一个C变量里：HelloClass[]="…"。
那么我们得重新实现fopen等函数，当KVM在执行打开文件，读取文件等文件操作时将是对HelloClass等类似的数据进行操作(最后给出了一个例子)。这样的话对loader.c就不需要做什么修改了。

二，内存管理
由于Itron有自己的内存管理，而我也发现在Itron的系统里有C++的new实现。正好，我将它的new实现移植了过来，实现了我们的malloc,calloc,realloc和free函数.代码在最后。

到这里KVM的移植工作基本完成，接下来要做的就是一些优化工作。以上只是一种移植到没有文件系统的操作系统上的解决方案，也是我能想到的最好最快的方案。因为在存储空间有限的嵌入式系统里，有一个文件系统当然会省很多事，但是文件系统的实现或移植并不是一件乘简单的事情。我们当初也考虑过用MSDOS的文件系统，但要在短时间内拿出DEMO来并非易事，所以没有采用。而文件系统在管理文件时也是将文件写在FLASH中，然后对FLASH进行管理，与其这样还不如静态连接入KVM，我觉得采用这套方案是最佳的。可能会有些不便，但是对于应用不多的嵌入式系统来说还是很值得的。
/*
* Copyright ?2003 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*/

/*=========================================================================
* KVM
*=========================================================================
* SYSTEM: KVM
* SUBSYSTEM: Itron-specific functions needed by the virtual machine
* FILE: Hello.h
* AUTHOR: yangyoufa([email protected]) (Itron port @2007/04/16)
*=======================================================================*/

#ifndef __ITRON_HELLO_H__
#define __ITRON_HELLO_H__


static char Helloclass[] = {

0xCA, 0xFE, 0xBA, 0xBE, 0x00, 0x03, 0x00, 0x2D,
0x00, 0x1D, 0x0A, 0x00, 0x06, 0x00, 0x0F, 0x09,
0x00, 0x10, 0x00, 0x11, 0x08, 0x00, 0x12, 0x0A,
0x00, 0x13, 0x00, 0x14, 0x07, 0x00, 0x15, 0x07,
0x00, 0x16, 0x01, 0x00, 0x06, 0x3C, 0x69, 0x6E,
0x69, 0x74, 0x3E, 0x01, 0x00, 0x03, 0x28, 0x29,
0x56, 0x01, 0x00, 0x04, 0x43, 0x6F, 0x64, 0x65,
0x01, 0x00, 0x0F, 0x4C, 0x69, 0x6E, 0x65, 0x4E,
0x75, 0x6D, 0x62, 0x65, 0x72, 0x54, 0x61, 0x62,
0x6C, 0x65, 0x01, 0x00, 0x04, 0x6D, 0x61, 0x69,
0x6E, 0x01, 0x00, 0x16, 0x28, 0x5B, 0x4C, 0x6A,
0x61, 0x76, 0x61, 0x2F, 0x6C, 0x61, 0x6E, 0x67,
0x2F, 0x53, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x3B,
0x29, 0x56, 0x01, 0x00, 0x0A, 0x53, 0x6F, 0x75,
0x72, 0x63, 0x65, 0x46, 0x69, 0x6C, 0x65, 0x01,
0x00, 0x0A, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x2E,
0x6A, 0x61, 0x76, 0x61, 0x0C, 0x00, 0x07, 0x00,
0x08, 0x07, 0x00, 0x17, 0x0C, 0x00, 0x18, 0x00,
0x19, 0x01, 0x00, 0x0D, 0x48, 0x65, 0x6C, 0x6C,
0x6F, 0x20, 0x57, 0x6F, 0x72, 0x6C, 0x64, 0x21,
0x0A, 0x07, 0x00, 0x1A, 0x0C, 0x00, 0x1B, 0x00,
0x1C, 0x01, 0x00, 0x05, 0x48, 0x65, 0x6C, 0x6C,
0x6F, 0x01, 0x00, 0x10, 0x6A, 0x61, 0x76, 0x61,
0x2F, 0x6C, 0x61, 0x6E, 0x67, 0x2F, 0x4F, 0x62,
0x6A, 0x65, 0x63, 0x74, 0x01, 0x00, 0x10, 0x6A,
0x61, 0x76, 0x61, 0x2F, 0x6C, 0x61, 0x6E, 0x67,
0x2F, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x01,
0x00, 0x03, 0x6F, 0x75, 0x74, 0x01, 0x00, 0x15,
0x4C, 0x6A, 0x61, 0x76, 0x61, 0x2F, 0x69, 0x6F,
0x2F, 0x50, 0x72, 0x69, 0x6E, 0x74, 0x53, 0x74,
0x72, 0x65, 0x61, 0x6D, 0x3B, 0x01, 0x00, 0x13,
0x6A, 0x61, 0x76, 0x61, 0x2F, 0x69, 0x6F, 0x2F,
0x50, 0x72, 0x69, 0x6E, 0x74, 0x53, 0x74, 0x72,
0x65, 0x61, 0x6D, 0x01, 0x00, 0x07, 0x70, 0x72,
0x69, 0x6E, 0x74, 0x6C, 0x6E, 0x01, 0x00, 0x15,
0x28, 0x4C, 0x6A, 0x61, 0x76, 0x61, 0x2F, 0x6C,
0x61, 0x6E, 0x67, 0x2F, 0x53, 0x74, 0x72, 0x69,
0x6E, 0x67, 0x3B, 0x29, 0x56, 0x00, 0x21, 0x00,
0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00,
0x02, 0x00, 0x01, 0x00, 0x07, 0x00, 0x08, 0x00,
0x01, 0x00, 0x09, 0x00, 0x00, 0x00, 0x1D, 0x00,
0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x2A,
0xB7, 0x00, 0x01, 0xB1, 0x00, 0x00, 0x00, 0x01,
0x00, 0x0A, 0x00, 0x00, 0x00, 0x06, 0x00, 0x01,
0x00, 0x00, 0x00, 0x01, 0x00, 0x09, 0x00, 0x0B,
0x00, 0x0C, 0x00, 0x01, 0x00, 0x09, 0x00, 0x00,
0x00, 0x25, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00,
0x00, 0x09, 0xB2, 0x00, 0x02, 0x12, 0x03, 0xB6,
0x00, 0x04, 0xB1, 0x00, 0x00, 0x00, 0x01, 0x00,
0x0A, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x02, 0x00,
0x00, 0x00, 0x03, 0x00, 0x08, 0x00, 0x04, 0x00,
0x01, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x02, 0x00,
0x0E };

#endif /* __ITRON_HELLO_H__ */

/*
* Copyright ?2003 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*/

/*=========================================================================
* KVM
*=========================================================================
* SYSTEM: KVM
* SUBSYSTEM: Itron-specific functions needed by the virtual machine
* FILE: classes.h
* AUTHOR: yangyoufa([email protected]) (Itron port @2007/04/16)
*=======================================================================*/

#ifndef __ITRON_CLASSES_H__
#define __ITRON_CLASSES_H__

#include "classes/hello.class.h"

/**
* The type of file, may be class and (jar or zip)
*
**/
typedef enum file_type {
ITRON_UNKNOW = -1,
ITRON_CLASS = 0,
ITRON_JAR
} file_type_t;

/**
* File entry of class or jar package
*
**/
typedef struct file_entry {
const char* filename;
UI32 size;
void* data;
file_type_t type;
} file_entry_t;

/**
* All entry of files
**/
static file_entry_t CLASS_FILES[] = {
{"./Hello.class", sizeof(Helloclass), &Helloclass, ITRON_CLASS},
{"./HelloHello.class", sizeof(HelloHelloclass), &HelloHelloclass, ITRON_CLASS},
{NULL, 0, "", ITRON_UNKNOW}
};

#define CLASS_FILES_SIZE (sizeof(CLASS_FILES))
#if 1
#define CLASS_FILES_LEN ((CLASS_FILES_SIZE)/(sizeof(file_entry_t)) - 1 )
#else
#define CLASS_FILES_LEN 1
#endif

#endif /* __ITRON_CLASSES_H__ */


/*
* Copyright ?2003 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*/

/*=========================================================================
* KVM
*=========================================================================
* SYSTEM: KVM
* SUBSYSTEM: Itron-specific functions needed by the virtual machine
* FILE: itron_io.h
* AUTHOR: yangyoufa([email protected]) (Itron port @2007/04/13)
*=======================================================================*/

#ifndef __ITRON_IO_H__
#define __ITRON_IO_H__

#if 0 /* FILE structure */
typedef struct _iobuf {
unsigned char *_io_next; /* next character to be read from buffer or
next position to put a character in buffer */
unsigned char *_io_base; /* start of buffer */
long _io_left; /* number of characters left in buffer */
unsigned _io_channel:14; /* OS I/O channel number */ /* GWW: was short */
unsigned _io_ivbuf: 1; /* the read buffer differs from disk (ungetc called) */
unsigned _io_append: 1; /* should do seeks to eof before writing */
char _io_tmp; /* used by ungetc on unbuffered files */
unsigned _io_buffering:2; /* _IONBF,_IOFBF,_IOLBF */
unsigned _io_eof: 1; /* have read end of file */
unsigned _io_error:1; /* have detected io error in file */
unsigned _io_stdio_buffer:1; /* buffer for this file created by stdio */
unsigned _io_readable:1; /* file may be read at this time */
unsigned _io_writable:1; /* file may be written at this time */
unsigned _io_readwrite:1; /* file opened for both reading and writing */
#if __CHAR_BIT > 8
unsigned _io_binary:1; /* file opened in binary mode */
unsigned _io_text:1; /* file opened in text mode */
#endif
} FILE;
#endif

/*=========================================================================
* Include files
*=======================================================================*/
/* For macros or definitions */
#include <stdio.h>
#include <stdlib.h>

/* RTOS Interface */
#include "mmac/rtos.h"

FILE *itron_fopen(const char *path, const char *mode);
int itron_fclose(FILE *stream);

UI32 itron_fread(void *ptr, UI32 size, UI32 nmemb, FILE *stream);
UI32 itron_fwrite(const void *ptr, UI32 size, UI32 nmemb, FILE* stream);

int itron_fseek(FILE *stream, long offset, int whence);
long itron_ftell(FILE *stream);
int itron_getc(FILE *stream);

#endif /* __ITRON_IO_H__ */


/*
* Copyright ?2003 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*/

/*=========================================================================
* KVM
*=========================================================================
* SYSTEM: KVM
* SUBSYSTEM: Itron-specific functions needed by the virtual machine
* FILE: itron_io.c
* AUTHOR: yangyoufa([email protected]) (Itron port @2007/04/13)
*=======================================================================*/

/*=========================================================================
* Include files
*=======================================================================*/
#include "itron_io.h"
#include "itron_mem.h"

#include "classes.h"

#include <global.h>

static file_entry_t* find_entry(const char* path) {
int i;

if(path == NULL) {
return NULL;
}

for(i=0; i<CLASS_FILES_LEN; i++) {
if(strcmp(CLASS_FILES[i].filename, path) == 0) {
return &CLASS_FILES[i];
}
}

return NULL;
}

FILE *itron_fopen(const char *path, const char *mode) {
FILE* fp;
file_entry_t* file;

if(path==NULL || mode==NULL) {
return NULL;
}

if( (file = find_entry(path)) != NULL) {
if((fp = (FILE*) malloc(sizeof(FILE))) != NULL) {
memset(fp, 0x00, sizeof(FILE));
fp->_io_base = fp->_io_next = file->data;

fp->_io_left = file->size;

/*
fp->_io_channel = 0;
fp->_io_ivbuf = 0;
fp->_io_append = 0;
fp->_io_tmp = 0;
fp->_io_buffering = 0;
fp->_io_eof = 0;
fp->_io_error = 0;
fp->_io_stdio_buffer= 0;
*/

/* Read only */
fp->_io_readable = 1;
/*
fp->_io_writable = 0;
fp->_io_readwrite = 0;
*/

/* Binary only */
#if __CHAR_BIT > 8
fp->_io_binary = 1;
/*fp->_io_text = 0;*/
#endif

return fp;
} else {
return NULL;
}
} else {
return NULL;
}
}

int itron_fclose(FILE *stream) {
if(stream != NULL) {
free(stream);
}

return 0;
}

UI32 itron_fread(void *ptr, UI32 size, UI32 nmemb, FILE *stream) {
UI32 length;
FILE* fp = stream;

if(ptr==NULL || size<=0 || nmemb<=0 || stream==NULL) {
return 0;
}

length = size * nmemb;
if(!fp->_io_eof) { /* Not eof */
if(length <= fp->_io_left) {
memcpy(ptr, fp->_io_next, length);
fp->_io_left -= length;
fp->_io_next += length;
} else {
memcpy(ptr, fp->_io_next, fp->_io_left);
}

if(length >= fp->_io_left) {
fp->_io_eof = 1;
if(length > fp->_io_left) {
return 0; /* Or other value */
}
}
} else {
return -1;
}

return nmemb;
}

UI32 itron_fwrite(const void *ptr, UI32 size, UI32 nmemb, FILE* stream) {

}

int itron_fseek(FILE *stream, long offset, int whence) {
FILE* fp = stream;
UI32 size;

if(fp != NULL) {
size = fp->_io_left + (fp->_io_next - fp->_io_base);
switch(whence) {
case SEEK_SET: {/* errors? */
if(offset < 0) {
return -1;
}
fp->_io_next = (fp->_io_base + offset);
if(fp->io_next >= fp->_io_base &&
fp->_io_next <= fp->_io_base + size) {
fp->_io_left = size - offset;
return 0;
}
}
break;

case SEEK_CUR: {
fp->_io_next += offset;
if(fp->io_next >= fp->_io_base &&
fp->_io_next <= fp->_io_base + size) {
if(offset >= 0) {
fp->_io_left -= offset;
} else {
fp->_io_left += offset;
}
return 0;
}
}
break;

case SEEK_END: {
if(offset > 0) {
return -1;
}
fp->_io_next -= offset;
if(fp->io_next >= fp->_io_base &&
fp->_io_next <= fp->_io_base + size) {
fp->_io_left += (-1*offset);
return 0;
}
}
break;

default:
break;
}
}

return -1;
}

long itron_ftell(FILE *stream) {
FILE* fp = stream;

if(fp != NULL) {
return (fp->_io_next - fp->_io_base);
}

return -1;
}

int itron_getc(FILE *stream) {
char ch;
FILE* fp = stream;


if(fp != NULL && fp->_io_left) { /* Best */
ch = (char)(*(fp->_io_next));
fp->_io_next++;
fp->_io_left--;
if(!fp->_io_left) {
fp->_io_eof = 1;
}

return ch;
}

return EOF;
}

void itron_rewind(FILE *stream) {
FILE* fp = stream;
UI32 size = fp->_io_left + (fp->_io_next - fp->_io_base);

if(fp == NULL) {
return ;
}

fp->_io_next = fp->_io_base;

fp->_io_left = size;

fp->_io_eof = 0;
/*fp->_io_channel = 0;
fp->_io_ivbuf = 0;
fp->_io_append = 0;
fp->_io_tmp = 0;
fp->_io_buffering = 0;
fp->_io_eof = 0;
fp->_io_error = 0;
fp->_io_stdio_buffer= 0;
*/

/* Read only */
fp->_io_readable = 1;
/*
fp->_io_writable = 0;
fp->_io_readwrite = 0;
*/
/* Binary only */
#if __CHAR_BIT > 8
fp->_io_binary = 1;
/*fp->_io_text = 0;*/
#endif
}

UI32 itron_fsize(FILE* fp) {
if(fp != NULL) {
return (fp->_io_left + (fp->_io_next - fp->_io_base));
}

return -1;
}
/* 当然我们得对global.h做些相应的修改，就是将标准库函数的调用指向我们自己的实现如：

#ifdef ITRON /* Reimplemention of file I/O functions (Add @2007/04/16 by yangyoufa) */
#define fopen itron_fopen
#define fclose itron_fclose
#define fread itron_fread
#define fwrite itron_fwrite
#define fseek itron_fseek
#define ftell itron_ftell
#define getc itron_getc
#define rewind itron_rewind

#define malloc itron_malloc
#define calloc itron_calloc
#define realloc itron_realloc
#define free itron_free
#endif

*/

/*
* Copyright ?2003 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*/

/*=========================================================================
* KVM
*=========================================================================
* SYSTEM: KVM
* SUBSYSTEM: Itron-specific functions needed by the virtual machine
* FILE: itron_mem.h
* AUTHOR: yangyoufa([email protected]) (Itron port @2007/04/16)
*=======================================================================*/

#ifndef __ITRON_MEM_H__
#define __ITRON_MEM_H__

/*=========================================================================
* Include files
*=======================================================================*/
#include "mmac/rtos.h" /* RTOS Interface */

/*=========================================================================
* FUNCTION: 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.
* TYPE: Memory control
* OVERVIEW:
* INTERFACE
* parameters: nmemb members
* size the size of array
* returns: If success returns a pointer to the start address of
* the array, or NULL when fail.
*=======================================================================*/
void *itron_calloc(UI32 nmemb, UI32 size);

/*=========================================================================
* FUNCTION: allocates size bytes and returns a pointer to the
* allocated memory. The memory is not cleared.
*
* TYPE: Memory control
* OVERVIEW:
* INTERFACE
* parameters: size the size of array
* returns: If success returns a pointer to the start address of
* the array, or NULL when fail.
*=======================================================================*/
void *itron_malloc(UI32 size);

/*=========================================================================
* FUNCTION: frees the memory space pointed to by ptr, which must have
* been returned by a previous call to malloc(), calloc() or
* realloc(). Other- wise, or if free(ptr) has already
* been called before, undefined behaviour occurs.
* If ptr is NULL, no operation is performed.
*
* TYPE: Memory control
* OVERVIEW:
* INTERFACE
* parameters: ptr The start address of memory will be freed.
* returns:
*=======================================================================*/
void itron_free(void *ptr);

/*=========================================================================
* FUNCTION: 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 memory 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().
*
* TYPE: Memory control
* OVERVIEW:
* INTERFACE
* parameters: ptr The start address of memory will be freed.
* size the new size of array
* returns:
*=======================================================================*/
void *itron_realloc(void *ptr, UI32 size);


#endif /* __ITRON_IO_H__ */

/*
* Copyright ?2003 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*/

/*=========================================================================
* KVM
*=========================================================================
* SYSTEM: KVM
* SUBSYSTEM: Itron-specific functions needed by the virtual machine
* FILE: itron_mem.h
* AUTHOR: yangyoufa([email protected]) (Itron port @2007/04/16)
*=======================================================================*/

/*=========================================================================
* Include files
*=======================================================================*/
#include "itron_mem.h"
#include "mmac/rtos.h" /* RTOS Interface */

/****************************************************************/
/* MACROS/DEFINES */
/****************************************************************/

#ifdef ITRON
#define ASSERT(x) assert(x)
#else
#define ASSERT(x)
#endif

#define DYNAMIC_POOL_SIZE (0x80000)
#define POOL_OVERHEAD_SIZE (0x20)
#define ALLOC_OVERHEAD_SIZE (0x00)

#define MIN_BLOCK_ALLOCATION (0)


extern MMAC_RTOS_MEMORY_POOL RTOS_systemHeap;
MMAC_RTOS_MEMORY_POOL localPool = 0;

static void* itron_getmem (UI32 sizeInBytes)
{
MMAC_RTOS_RESULT_CODE result;
void * memoryBlock;
char * pFreeMemory;

#if 0
if (0 == localPool)
{
result = MMAC_RTOS_AllocMemory (RTOS_systemHeap,
DYNAMIC_POOL_SIZE +
POOL_OVERHEAD_SIZE +
ALLOC_OVERHEAD_SIZE,
((void**)&pFreeMemory));
ASSERT (MMAC_RTOS_OK == result);

localPool = (MMAC_RTOS_MEMORY_POOL) pFreeMemory;

pFreeMemory += POOL_OVERHEAD_SIZE;

result = MMAC_RTOS_CreateMemoryPool ((I8*)"kvmHeap",
pFreeMemory,
DYNAMIC_POOL_SIZE,
MIN_BLOCK_ALLOCATION,
localPool);
ASSERT (MMAC_RTOS_OK == result);
}

result = MMAC_RTOS_AllocMemory (localPool, sizeInBytes, (void**)&memoryBlock);
if (MMAC_RTOS_OK != result)
{
memoryBlock = NULL;
}
#endif
result = MMAC_RTOS_AllocMemory (RTOS_systemHeap, sizeInBytes, (void**)&memoryBlock);
ASSERT (MMAC_RTOS_OK == result);

#if (MMAC_ICE_OPERATOR_RESULT_DEBUG_ENABLE == MMAC_YES)
MMAC_DEBUG_Print(MMAC_DEBUG_MSG, "localGetMemory: memoryBlock = 0x%x/n/r", memoryBlock);
#endif
return memoryBlock;
}

static void itron_freemem (void * memPtr)
{
MMAC_RTOS_RESULT_CODE result;

#if (MMAC_ICE_OPERATOR_FUNCTION_DEBUG_ENABLE == MMAC_YES)
MMAC_DEBUG_Print(MMAC_DEBUG_MSG, "localFreeMemory: memPtr = 0x%x/n/r", memPtr);
#endif
if(memPtr != NULL)
{
result = MMAC_RTOS_FreeMemory (memPtr);
ASSERT (MMAC_RTOS_OK == result);
}

return;
}

/*=========================================================================
* FUNCTION: 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.
* TYPE: Memory control
* OVERVIEW:
* INTERFACE
* parameters: nmemb members
* size the size of array
* returns: If success returns a pointer to the start address of
* the array, or NULL when fail.
*=======================================================================*/
void *itron_calloc(UI32 nmemb, UI32 size) {
void* mem;
UI32 length;

if(nmemb<=0 || size<=0) {
return NULL;
}

length = nmemb * size;
mem = itron_getmem(length );
if(mem != NULL) {
memset(mem, 0x00, length);
return mem;
}

return NULL;
}

/*=========================================================================
* FUNCTION: allocates size bytes and returns a pointer to the
* allocated memory. The memory is not cleared.
*
* TYPE: Memory control
* OVERVIEW:
* INTERFACE
* parameters: size the size of array
* returns: If success returns a pointer to the start address of
* the array, or NULL when fail.
*=======================================================================*/
void *itron_malloc(UI32 size) {
if(size<=0) {
return NULL;
}

return itron_getmem(size );
}

/*=========================================================================
* FUNCTION: frees the memory space pointed to by ptr, which must have
* been returned by a previous call to malloc(), calloc() or
* realloc(). Other- wise, or if free(ptr) has already
* been called before, undefined behaviour occurs.
* If ptr is NULL, no operation is performed.
*
* TYPE: Memory control
* OVERVIEW:
* INTERFACE
* parameters: ptr The start address of memory will be freed.
* returns:
*=======================================================================*/
void itron_free(void *ptr) {
if(ptr != NULL) {
itron_freemem(ptr);
}
}

/*=========================================================================
* FUNCTION: 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 memory 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().
*
* TYPE: Memory control
* OVERVIEW:
* INTERFACE
* parameters: ptr The start address of memory will be freed.
* size the new size of array
* returns:
*=======================================================================*/
void *itron_realloc(void *ptr, UI32 size) {
return realloc(ptr, size); /* Not support current */
}