--- /dev/null
+# ----------------------------------------------------------------------------
+# Hyper Operating System Application Framework
+# makefile for ARM V4T
+#
+# Copyright (C) 1998-2008 by Project HOS
+# http://sourceforge.jp/projects/hos/
+# ----------------------------------------------------------------------------
+
+
+# %jp{ターゲット名}
+TARGET = hosaplfw
+
+
+# %jp{ディレクトリ定義}
+TOP_DIR = ..\..\..\..\..
+KERNEL_DIR = $(TOP_DIR)\kernel
+KERNEL_MAKINC_DIR = $(KERNEL_DIR)\build\common\nmake
+HOSAPLFW_DIR = $(TOP_DIR)\aplfw
+HOSAPLFW_MKINK_DIR = $(HOSAPLFW_DIR)/build\common\nmake
+
+
+# %jp{共通定義読込み}
+!include $(KERNEL_MAKINC_DIR)\common.inc
+
+
+# %jp{インクルードパス設定}
+INC_DIRS = $(INC_DIRS) $(KERNEL_DIR)\include
+
+
+# %jp{オプションフラグ}
+CFLAGS =
+AFLAGS =
+ARFLAGS =
+
+
+# %jp{リンク制御対象制御}
+LINK_AT91USART = Yes
+LINK_MX1UART = Yes
+
+
+# %jp{コンパイラ依存の設定読込み}
+!include $(KERNEL_MAKINC_DIR)\armcc_d.inc
+
+# %jp{共通設定読込み}
+!include $(KERNEL_MAKINC_DIR)\maklib_d.inc
+
+
+
+all: makelib_all
+
+clean: makelib_clean
+ -$(CMD_RM) *.lst
+
+
+
+# %jp{HOS-APLFWソース設定読込み}
+!include $(HOSAPLFW_MKINK_DIR)\aplfwsrc.inc
+
+# %jp{共通設定読込み}
+!include $(KERNEL_MAKINC_DIR)\maklib_r.inc
+
+# %jpMコンパイラ依存のルール定義読込み}
+!include $(KERNEL_MAKINC_DIR)\armcc_r.inc
+
+# %jp{依存関係定義読込み}
+!include $(HOSAPLFW_MKINK_DIR)\aplfwdep.inc
+
+
+# end of file
$(OBJS_DIR)/system_requestproc.$(EXT_OBJ): $(SYSTEM_DIR)/system_requestproc.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/system_process.$(EXT_OBJ): $(SYSTEM_DIR)/system_process.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/system_getnextprocess.$(EXT_OBJ): $(SYSTEM_DIR)/system_getnextprocess.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
+$(OBJS_DIR)/system_getsystemprocess.$(EXT_OBJ): $(SYSTEM_DIR)/system_getsystemprocess.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/sysapi_initialize.$(EXT_OBJ): $(SYSAPI_DIR)/sysapi_initialize.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/sysctx_isisr.$(EXT_OBJ): $(SYSAPI_DIR)/sysctx_isisr.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/sysloc_lock.$(EXT_OBJ): $(SYSAPI_DIR)/sysloc_lock.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/sysisr_delete.$(EXT_OBJ): $(SYSAPI_DIR)/sysisr_delete.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/sysmem_alloc.$(EXT_OBJ): $(SYSAPI_DIR)/sysmem_alloc.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/sysmem_free.$(EXT_OBJ): $(SYSAPI_DIR)/sysmem_free.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
-$(OBJS_DIR)/sysmem_getmemif.$(EXT_OBJ): $(SYSAPI_DIR)/sysmem_getmemif.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
+$(OBJS_DIR)/sysmem_getmemheap.$(EXT_OBJ): $(SYSAPI_DIR)/sysmem_getmemheap.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/sysmem_getsize.$(EXT_OBJ): $(SYSAPI_DIR)/sysmem_getsize.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/sysmem_realloc.$(EXT_OBJ): $(SYSAPI_DIR)/sysmem_realloc.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
-$(OBJS_DIR)/sysmem_allociomem.$(EXT_OBJ): $(SYSAPI_DIR)/sysmem_allociomem.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
-$(OBJS_DIR)/sysmem_freeiomem.$(EXT_OBJ): $(SYSAPI_DIR)/sysmem_freeiomem.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/sysmtx_create.$(EXT_OBJ): $(SYSAPI_DIR)/sysmtx_create.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/sysmtx_delete.$(EXT_OBJ): $(SYSAPI_DIR)/sysmtx_delete.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/sysmtx_lock.$(EXT_OBJ): $(SYSAPI_DIR)/sysmtx_lock.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/systim_getcputime.$(EXT_OBJ): $(SYSAPI_DIR)/systim_getcputime.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/systim_cputimetosecond.$(EXT_OBJ): $(SYSAPI_DIR)/systim_cputimetosecond.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/systim_cputimetonanosecond.$(EXT_OBJ): $(SYSAPI_DIR)/systim_cputimetonanosecond.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
+$(OBJS_DIR)/sysio_allociomem.$(EXT_OBJ): $(SYSAPI_DIR)/sysio_allociomem.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
+$(OBJS_DIR)/sysio_freeiomem.$(EXT_OBJ): $(SYSAPI_DIR)/sysio_freeiomem.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/syshos_hook.$(EXT_OBJ): $(SYSAPI_DIR)/syshos_hook.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/handle_close.$(EXT_OBJ): $(HANDLE_DIR)/handle_close.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/handleobj_create.$(EXT_OBJ): $(HANDLE_DIR)/handleobj_create.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/volumeobj_makedir.$(EXT_OBJ): $(FILE_DIR)/volumeobj_makedir.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/volumeobj_remove.$(EXT_OBJ): $(FILE_DIR)/volumeobj_remove.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)/command.$(EXT_OBJ): $(COMMAND_DIR)/command.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
-$(OBJS_DIR)/mempol.$(EXT_OBJ): $(MEMPOL_DIR)/mempol.c $(COMMON_HEADERS)
+$(OBJS_DIR)/valmemheap_constructor.$(EXT_OBJ): $(VALMEMHEAP_DIR)/valmemheap_constructor.c $(COMMON_HEADERS)
+$(OBJS_DIR)/valmemheap_alloc.$(EXT_OBJ): $(VALMEMHEAP_DIR)/valmemheap_alloc.c $(COMMON_HEADERS)
+$(OBJS_DIR)/valmemheap_realloc.$(EXT_OBJ): $(VALMEMHEAP_DIR)/valmemheap_realloc.c $(COMMON_HEADERS)
+$(OBJS_DIR)/valmemheap_free.$(EXT_OBJ): $(VALMEMHEAP_DIR)/valmemheap_free.c $(COMMON_HEADERS)
+$(OBJS_DIR)/valmemheap_getalign.$(EXT_OBJ): $(VALMEMHEAP_DIR)/valmemheap_getalign.c $(COMMON_HEADERS)
+$(OBJS_DIR)/valmemheap_getsize.$(EXT_OBJ): $(VALMEMHEAP_DIR)/valmemheap_getsize.c $(COMMON_HEADERS)
+$(OBJS_DIR)/valmemheap_alignsize.$(EXT_OBJ): $(VALMEMHEAP_DIR)/valmemheap_alignsize.c $(COMMON_HEADERS)
+$(OBJS_DIR)/fixmemheap_create.$(EXT_OBJ): $(FIXMEMHEAP_DIR)/fixmemheap_create.c $(COMMON_HEADERS)
+$(OBJS_DIR)/fixmemheap_delete.$(EXT_OBJ): $(FIXMEMHEAP_DIR)/fixmemheap_delete.c $(COMMON_HEADERS)
+$(OBJS_DIR)/fixmemheap_constructor.$(EXT_OBJ): $(FIXMEMHEAP_DIR)/fixmemheap_constructor.c $(COMMON_HEADERS)
+$(OBJS_DIR)/fixmemheap_alloc.$(EXT_OBJ): $(FIXMEMHEAP_DIR)/fixmemheap_alloc.c $(COMMON_HEADERS)
+$(OBJS_DIR)/fixmemheap_realloc.$(EXT_OBJ): $(FIXMEMHEAP_DIR)/fixmemheap_realloc.c $(COMMON_HEADERS)
+$(OBJS_DIR)/fixmemheap_free.$(EXT_OBJ): $(FIXMEMHEAP_DIR)/fixmemheap_free.c $(COMMON_HEADERS)
+$(OBJS_DIR)/fixmemheap_getalign.$(EXT_OBJ): $(FIXMEMHEAP_DIR)/fixmemheap_getalign.c $(COMMON_HEADERS)
+$(OBJS_DIR)/fixmemheap_getsize.$(EXT_OBJ): $(FIXMEMHEAP_DIR)/fixmemheap_getsize.c $(COMMON_HEADERS)
+$(OBJS_DIR)/fixmemheap_alignsize.$(EXT_OBJ): $(FIXMEMHEAP_DIR)/fixmemheap_alignsize.c $(COMMON_HEADERS)
$(OBJS_DIR)/assoc.$(EXT_OBJ): $(ASSOC_DIR)/assoc.c $(COMMON_HEADERS)
$(OBJS_DIR)/list_create.$(EXT_OBJ): $(LIST_DIR)/list_create.c $(COMMON_HEADERS)
$(OBJS_DIR)/list_createex.$(EXT_OBJ): $(LIST_DIR)/list_createex.c $(COMMON_HEADERS)
LINK_COMMAND ?= Yes
# Librarys
-LINK_MEMPOL ?= Yes
+LINK_VALMEMHEAP ?= Yes
+LINK_FIXMEMHEAP ?= Yes
LINK_ASSOC ?= Yes
LINK_LIST ?= Yes
LINK_STREAMBUF ?= Yes
CSRCS += $(SYSTEM_DIR)/system_requestproc.c
CSRCS += $(SYSTEM_DIR)/system_process.c
CSRCS += $(SYSTEM_DIR)/system_getnextprocess.c
+CSRCS += $(SYSTEM_DIR)/system_getsystemprocess.c
endif
CSRCS += $(SYSAPI_DIR)/sysisr_delete.c
CSRCS += $(SYSAPI_DIR)/sysmem_alloc.c
CSRCS += $(SYSAPI_DIR)/sysmem_free.c
-CSRCS += $(SYSAPI_DIR)/sysmem_getmemif.c
+CSRCS += $(SYSAPI_DIR)/sysmem_getmemheap.c
CSRCS += $(SYSAPI_DIR)/sysmem_getsize.c
CSRCS += $(SYSAPI_DIR)/sysmem_realloc.c
-CSRCS += $(SYSAPI_DIR)/sysmem_allociomem.c
-CSRCS += $(SYSAPI_DIR)/sysmem_freeiomem.c
CSRCS += $(SYSAPI_DIR)/sysmtx_create.c
CSRCS += $(SYSAPI_DIR)/sysmtx_delete.c
CSRCS += $(SYSAPI_DIR)/sysmtx_lock.c
CSRCS += $(SYSAPI_DIR)/systim_getcputime.c
CSRCS += $(SYSAPI_DIR)/systim_cputimetosecond.c
CSRCS += $(SYSAPI_DIR)/systim_cputimetonanosecond.c
+CSRCS += $(SYSAPI_DIR)/sysio_allociomem.c
+CSRCS += $(SYSAPI_DIR)/sysio_freeiomem.c
CSRCS += $(SYSAPI_DIR)/syshos_hook.c
endif
# Librarys
# --------------------------------------------------
-# Memory Pool
-ifeq ($(LINK_MEMPOL),Yes)
-MEMPOL_DIR = $(HOSAPLFW_DIR)/library/container/mempol
-SRC_DIRS += $(MEMPOL_DIR)
-CSRCS += $(MEMPOL_DIR)/mempol.c
+# Valiable size memory heap
+ifeq ($(LINK_VALMEMHEAP),Yes)
+VALMEMHEAP_DIR = $(HOSAPLFW_DIR)/library/container/valmemheap
+SRC_DIRS += $(VALMEMHEAP_DIR)
+CSRCS += $(VALMEMHEAP_DIR)/valmemheap_constructor.c
+CSRCS += $(VALMEMHEAP_DIR)/valmemheap_alloc.c
+CSRCS += $(VALMEMHEAP_DIR)/valmemheap_realloc.c
+CSRCS += $(VALMEMHEAP_DIR)/valmemheap_free.c
+CSRCS += $(VALMEMHEAP_DIR)/valmemheap_getalign.c
+CSRCS += $(VALMEMHEAP_DIR)/valmemheap_getsize.c
+CSRCS += $(VALMEMHEAP_DIR)/valmemheap_alignsize.c
+endif
+
+
+# Fixed size memory heap
+ifeq ($(LINK_FIXMEMHEAP),Yes)
+FIXMEMHEAP_DIR = $(HOSAPLFW_DIR)/library/container/fixmemheap
+SRC_DIRS += $(FIXMEMHEAP_DIR)
+CSRCS += $(FIXMEMHEAP_DIR)/fixmemheap_create.c
+CSRCS += $(FIXMEMHEAP_DIR)/fixmemheap_delete.c
+CSRCS += $(FIXMEMHEAP_DIR)/fixmemheap_constructor.c
+CSRCS += $(FIXMEMHEAP_DIR)/fixmemheap_alloc.c
+CSRCS += $(FIXMEMHEAP_DIR)/fixmemheap_realloc.c
+CSRCS += $(FIXMEMHEAP_DIR)/fixmemheap_free.c
+CSRCS += $(FIXMEMHEAP_DIR)/fixmemheap_getalign.c
+CSRCS += $(FIXMEMHEAP_DIR)/fixmemheap_getsize.c
+CSRCS += $(FIXMEMHEAP_DIR)/fixmemheap_alignsize.c
endif
$(OBJS_DIR)\system_getnextprocess.c : $(SYSTEM_DIR)\system_getnextprocess.c
$(CMD_CP) $(SYSTEM_DIR)\system_getnextprocess.c $(OBJS_DIR)\
+$(OBJS_DIR)\system_getsystemprocess.c : $(SYSTEM_DIR)\system_getsystemprocess.c
+ $(CMD_CP) $(SYSTEM_DIR)\system_getsystemprocess.c $(OBJS_DIR)\
+
$(OBJS_DIR)\sysapi.h : $(SYSAPI_DIR)\sysapi.h
$(CMD_CP) $(SYSAPI_DIR)\sysapi.h $(OBJS_DIR)\
$(OBJS_DIR)\sysmem_free.c : $(SYSAPI_DIR)\sysmem_free.c
$(CMD_CP) $(SYSAPI_DIR)\sysmem_free.c $(OBJS_DIR)\
-$(OBJS_DIR)\sysmem_getmemif.c : $(SYSAPI_DIR)\sysmem_getmemif.c
- $(CMD_CP) $(SYSAPI_DIR)\sysmem_getmemif.c $(OBJS_DIR)\
+$(OBJS_DIR)\sysmem_getmemheap.c : $(SYSAPI_DIR)\sysmem_getmemheap.c
+ $(CMD_CP) $(SYSAPI_DIR)\sysmem_getmemheap.c $(OBJS_DIR)\
$(OBJS_DIR)\sysmem_getsize.c : $(SYSAPI_DIR)\sysmem_getsize.c
$(CMD_CP) $(SYSAPI_DIR)\sysmem_getsize.c $(OBJS_DIR)\
$(OBJS_DIR)\sysmem_realloc.c : $(SYSAPI_DIR)\sysmem_realloc.c
$(CMD_CP) $(SYSAPI_DIR)\sysmem_realloc.c $(OBJS_DIR)\
-$(OBJS_DIR)\sysmem_allociomem.c : $(SYSAPI_DIR)\sysmem_allociomem.c
- $(CMD_CP) $(SYSAPI_DIR)\sysmem_allociomem.c $(OBJS_DIR)\
-
-$(OBJS_DIR)\sysmem_freeiomem.c : $(SYSAPI_DIR)\sysmem_freeiomem.c
- $(CMD_CP) $(SYSAPI_DIR)\sysmem_freeiomem.c $(OBJS_DIR)\
-
$(OBJS_DIR)\sysmtx_create.c : $(SYSAPI_DIR)\sysmtx_create.c
$(CMD_CP) $(SYSAPI_DIR)\sysmtx_create.c $(OBJS_DIR)\
$(OBJS_DIR)\systim_cputimetonanosecond.c : $(SYSAPI_DIR)\systim_cputimetonanosecond.c
$(CMD_CP) $(SYSAPI_DIR)\systim_cputimetonanosecond.c $(OBJS_DIR)\
+$(OBJS_DIR)\sysio_allociomem.c : $(SYSAPI_DIR)\sysio_allociomem.c
+ $(CMD_CP) $(SYSAPI_DIR)\sysio_allociomem.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\sysio_freeiomem.c : $(SYSAPI_DIR)\sysio_freeiomem.c
+ $(CMD_CP) $(SYSAPI_DIR)\sysio_freeiomem.c $(OBJS_DIR)\
+
$(OBJS_DIR)\syshos_hook.c : $(SYSAPI_DIR)\syshos_hook.c
$(CMD_CP) $(SYSAPI_DIR)\syshos_hook.c $(OBJS_DIR)\
$(CMD_CP) $(COMMAND_DIR)\command.c $(OBJS_DIR)\
-$(OBJS_DIR)\mempol.h : $(MEMPOL_DIR)\mempol.h
- $(CMD_CP) $(MEMPOL_DIR)\mempol.h $(OBJS_DIR)\
+$(OBJS_DIR)\valmemheap.h : $(VALMEMHEAP_DIR)\valmemheap.h
+ $(CMD_CP) $(VALMEMHEAP_DIR)\valmemheap.h $(OBJS_DIR)\
+
+$(OBJS_DIR)\valmemheap_local.h : $(VALMEMHEAP_DIR)\valmemheap_local.h
+ $(CMD_CP) $(VALMEMHEAP_DIR)\valmemheap_local.h $(OBJS_DIR)\
+
+$(OBJS_DIR)\valmemheap_constructor.c : $(VALMEMHEAP_DIR)\valmemheap_constructor.c
+ $(CMD_CP) $(VALMEMHEAP_DIR)\valmemheap_constructor.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\valmemheap_alloc.c : $(VALMEMHEAP_DIR)\valmemheap_alloc.c
+ $(CMD_CP) $(VALMEMHEAP_DIR)\valmemheap_alloc.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\valmemheap_realloc.c : $(VALMEMHEAP_DIR)\valmemheap_realloc.c
+ $(CMD_CP) $(VALMEMHEAP_DIR)\valmemheap_realloc.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\valmemheap_free.c : $(VALMEMHEAP_DIR)\valmemheap_free.c
+ $(CMD_CP) $(VALMEMHEAP_DIR)\valmemheap_free.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\valmemheap_getalign.c : $(VALMEMHEAP_DIR)\valmemheap_getalign.c
+ $(CMD_CP) $(VALMEMHEAP_DIR)\valmemheap_getalign.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\valmemheap_getsize.c : $(VALMEMHEAP_DIR)\valmemheap_getsize.c
+ $(CMD_CP) $(VALMEMHEAP_DIR)\valmemheap_getsize.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\valmemheap_alignsize.c : $(VALMEMHEAP_DIR)\valmemheap_alignsize.c
+ $(CMD_CP) $(VALMEMHEAP_DIR)\valmemheap_alignsize.c $(OBJS_DIR)\
+
+
+$(OBJS_DIR)\fixmemheap.h : $(FIXMEMHEAP_DIR)\fixmemheap.h
+ $(CMD_CP) $(FIXMEMHEAP_DIR)\fixmemheap.h $(OBJS_DIR)\
+
+$(OBJS_DIR)\fixmemheap_local.h : $(FIXMEMHEAP_DIR)\fixmemheap_local.h
+ $(CMD_CP) $(FIXMEMHEAP_DIR)\fixmemheap_local.h $(OBJS_DIR)\
+
+$(OBJS_DIR)\fixmemheap_create.c : $(FIXMEMHEAP_DIR)\fixmemheap_create.c
+ $(CMD_CP) $(FIXMEMHEAP_DIR)\fixmemheap_create.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\fixmemheap_delete.c : $(FIXMEMHEAP_DIR)\fixmemheap_delete.c
+ $(CMD_CP) $(FIXMEMHEAP_DIR)\fixmemheap_delete.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\fixmemheap_constructor.c : $(FIXMEMHEAP_DIR)\fixmemheap_constructor.c
+ $(CMD_CP) $(FIXMEMHEAP_DIR)\fixmemheap_constructor.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\fixmemheap_alloc.c : $(FIXMEMHEAP_DIR)\fixmemheap_alloc.c
+ $(CMD_CP) $(FIXMEMHEAP_DIR)\fixmemheap_alloc.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\fixmemheap_realloc.c : $(FIXMEMHEAP_DIR)\fixmemheap_realloc.c
+ $(CMD_CP) $(FIXMEMHEAP_DIR)\fixmemheap_realloc.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\fixmemheap_free.c : $(FIXMEMHEAP_DIR)\fixmemheap_free.c
+ $(CMD_CP) $(FIXMEMHEAP_DIR)\fixmemheap_free.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\fixmemheap_getalign.c : $(FIXMEMHEAP_DIR)\fixmemheap_getalign.c
+ $(CMD_CP) $(FIXMEMHEAP_DIR)\fixmemheap_getalign.c $(OBJS_DIR)\
+
+$(OBJS_DIR)\fixmemheap_getsize.c : $(FIXMEMHEAP_DIR)\fixmemheap_getsize.c
+ $(CMD_CP) $(FIXMEMHEAP_DIR)\fixmemheap_getsize.c $(OBJS_DIR)\
-$(OBJS_DIR)\mempol.c : $(MEMPOL_DIR)\mempol.c
- $(CMD_CP) $(MEMPOL_DIR)\mempol.c $(OBJS_DIR)\
+$(OBJS_DIR)\fixmemheap_alignsize.c : $(FIXMEMHEAP_DIR)\fixmemheap_alignsize.c
+ $(CMD_CP) $(FIXMEMHEAP_DIR)\fixmemheap_alignsize.c $(OBJS_DIR)\
$(OBJS_DIR)\assoc.h : $(ASSOC_DIR)\assoc.h
$(OBJS_DIR)\system_requestproc.$(EXT_OBJ): $(OBJS_DIR)\system_requestproc.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\system_process.$(EXT_OBJ): $(OBJS_DIR)\system_process.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\system_getnextprocess.$(EXT_OBJ): $(OBJS_DIR)\system_getnextprocess.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
+$(OBJS_DIR)\system_getsystemprocess.$(EXT_OBJ): $(OBJS_DIR)\system_getsystemprocess.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\sysapi_initialize.$(EXT_OBJ): $(OBJS_DIR)\sysapi_initialize.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\sysctx_isisr.$(EXT_OBJ): $(OBJS_DIR)\sysctx_isisr.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\sysisr_delete.$(EXT_OBJ): $(OBJS_DIR)\sysisr_delete.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\sysmem_alloc.$(EXT_OBJ): $(OBJS_DIR)\sysmem_alloc.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\sysmem_free.$(EXT_OBJ): $(OBJS_DIR)\sysmem_free.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
-$(OBJS_DIR)\sysmem_getmemif.$(EXT_OBJ): $(OBJS_DIR)\sysmem_getmemif.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
+$(OBJS_DIR)\sysmem_getmemheap.$(EXT_OBJ): $(OBJS_DIR)\sysmem_getmemheap.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\sysmem_getsize.$(EXT_OBJ): $(OBJS_DIR)\sysmem_getsize.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\sysmem_realloc.$(EXT_OBJ): $(OBJS_DIR)\sysmem_realloc.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
-$(OBJS_DIR)\sysmem_allociomem.$(EXT_OBJ): $(OBJS_DIR)\sysmem_allociomem.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
-$(OBJS_DIR)\sysmem_freeiomem.$(EXT_OBJ): $(OBJS_DIR)\sysmem_freeiomem.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\sysmtx_create.$(EXT_OBJ): $(OBJS_DIR)\sysmtx_create.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\sysmtx_delete.$(EXT_OBJ): $(OBJS_DIR)\sysmtx_delete.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\sysmtx_lock.$(EXT_OBJ): $(OBJS_DIR)\sysmtx_lock.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\systim_getcputime.$(EXT_OBJ): $(OBJS_DIR)\systim_getcputime.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\systim_cputimetosecond.$(EXT_OBJ): $(OBJS_DIR)\systim_cputimetosecond.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\systim_cputimetonanosecond.$(EXT_OBJ): $(OBJS_DIR)\systim_cputimetonanosecond.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
+$(OBJS_DIR)\sysio_allociomem.$(EXT_OBJ): $(OBJS_DIR)\sysio_allociomem.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
+$(OBJS_DIR)\sysio_freeiomem.$(EXT_OBJ): $(OBJS_DIR)\sysio_freeiomem.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\syshos_hook.$(EXT_OBJ): $(OBJS_DIR)\syshos_hook.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\handle_close.$(EXT_OBJ): $(OBJS_DIR)\handle_close.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
$(OBJS_DIR)\command.$(EXT_OBJ): $(OBJS_DIR)\command.c $(COMMON_HEADERS) $(SYSTEM_HEADERS)
-$(OBJS_DIR)\mempol.$(EXT_OBJ): $(OBJS_DIR)\mempol.c $(COMMON_HEADERS)
+$(OBJS_DIR)\valmemheap_constructor.$(EXT_OBJ): $(OBJS_DIR)\valmemheap_constructor.c $(COMMON_HEADERS)
+$(OBJS_DIR)\valmemheap_alloc.$(EXT_OBJ): $(OBJS_DIR)\valmemheap_alloc.c $(COMMON_HEADERS)
+$(OBJS_DIR)\valmemheap_realloc.$(EXT_OBJ): $(OBJS_DIR)\valmemheap_realloc.c $(COMMON_HEADERS)
+$(OBJS_DIR)\valmemheap_free.$(EXT_OBJ): $(OBJS_DIR)\valmemheap_free.c $(COMMON_HEADERS)
+$(OBJS_DIR)\valmemheap_getalign.$(EXT_OBJ): $(OBJS_DIR)\valmemheap_getalign.c $(COMMON_HEADERS)
+$(OBJS_DIR)\valmemheap_getsize.$(EXT_OBJ): $(OBJS_DIR)\valmemheap_getsize.c $(COMMON_HEADERS)
+$(OBJS_DIR)\valmemheap_alignsize.$(EXT_OBJ): $(OBJS_DIR)\valmemheap_alignsize.c $(COMMON_HEADERS)
+
+$(OBJS_DIR)\fixmemheap_create.$(EXT_OBJ): $(OBJS_DIR)\fixmemheap_create.c $(COMMON_HEADERS)
+$(OBJS_DIR)\fixmemheap_delete.$(EXT_OBJ): $(OBJS_DIR)\fixmemheap_delete.c $(COMMON_HEADERS)
+$(OBJS_DIR)\fixmemheap_constructor.$(EXT_OBJ): $(OBJS_DIR)\fixmemheap_constructor.c $(COMMON_HEADERS)
+$(OBJS_DIR)\fixmemheap_alloc.$(EXT_OBJ): $(OBJS_DIR)\fixmemheap_alloc.c $(COMMON_HEADERS)
+$(OBJS_DIR)\fixmemheap_realloc.$(EXT_OBJ): $(OBJS_DIR)\fixmemheap_realloc.c $(COMMON_HEADERS)
+$(OBJS_DIR)\fixmemheap_free.$(EXT_OBJ): $(OBJS_DIR)\fixmemheap_free.c $(COMMON_HEADERS)
+$(OBJS_DIR)\fixmemheap_getalign.$(EXT_OBJ): $(OBJS_DIR)\fixmemheap_getalign.c $(COMMON_HEADERS)
+$(OBJS_DIR)\fixmemheap_getsize.$(EXT_OBJ): $(OBJS_DIR)\fixmemheap_getsize.c $(COMMON_HEADERS)
+$(OBJS_DIR)\fixmemheap_alignsize.$(EXT_OBJ): $(OBJS_DIR)\fixmemheap_alignsize.c $(COMMON_HEADERS)
$(OBJS_DIR)\assoc.$(EXT_OBJ): $(OBJS_DIR)\assoc.c $(COMMON_HEADERS)
!endif
# Librarys
-!ifndef LINK_MEMPOL
-LINK_MEMPOL = Yes
+!ifndef LINK_VALMEMHEAP
+LINK_VALMEMHEAP = Yes
+!endif
+!ifndef LINK_FIXMEMHEAP
+LINK_FIXMEMHEAP = Yes
!endif
!ifndef LINK_ASSOC
LINK_ASSOC = Yes
OBJS = $(OBJS) $(OBJS_DIR)\system_process.$(EXT_OBJ)
CSRCS = $(CSRCS) $(SYSTEM_DIR)\system_getnextprocess.c
OBJS = $(OBJS) $(OBJS_DIR)\system_getnextprocess.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(SYSTEM_DIR)\system_getsystemprocess.c
+OBJS = $(OBJS) $(OBJS_DIR)\system_getsystemprocess.$(EXT_OBJ)
!endif
OBJS = $(OBJS) $(OBJS_DIR)\sysmem_alloc.$(EXT_OBJ)
CSRCS = $(CSRCS) $(SYSAPI_DIR)\sysmem_free.c
OBJS = $(OBJS) $(OBJS_DIR)\sysmem_free.$(EXT_OBJ)
-CSRCS = $(CSRCS) $(SYSAPI_DIR)\sysmem_getmemif.c
-OBJS = $(OBJS) $(OBJS_DIR)\sysmem_getmemif.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(SYSAPI_DIR)\sysmem_getmemheap.c
+OBJS = $(OBJS) $(OBJS_DIR)\sysmem_getmemheap.$(EXT_OBJ)
CSRCS = $(CSRCS) $(SYSAPI_DIR)\sysmem_getsize.c
OBJS = $(OBJS) $(OBJS_DIR)\sysmem_getsize.$(EXT_OBJ)
CSRCS = $(CSRCS) $(SYSAPI_DIR)\sysmem_realloc.c
OBJS = $(OBJS) $(OBJS_DIR)\sysmem_realloc.$(EXT_OBJ)
-CSRCS = $(CSRCS) $(SYSAPI_DIR)\sysmem_allociomem.c
-OBJS = $(OBJS) $(OBJS_DIR)\sysmem_allociomem.$(EXT_OBJ)
-CSRCS = $(CSRCS) $(SYSAPI_DIR)\sysmem_freeiomem.c
-OBJS = $(OBJS) $(OBJS_DIR)\sysmem_freeiomem.$(EXT_OBJ)
CSRCS = $(CSRCS) $(SYSAPI_DIR)\sysmtx_create.c
OBJS = $(OBJS) $(OBJS_DIR)\sysmtx_create.$(EXT_OBJ)
CSRCS = $(CSRCS) $(SYSAPI_DIR)\sysmtx_delete.c
OBJS = $(OBJS) $(OBJS_DIR)\systim_cputimetosecond.$(EXT_OBJ)
CSRCS = $(CSRCS) $(SYSAPI_DIR)\systim_cputimetonanosecond.c
OBJS = $(OBJS) $(OBJS_DIR)\systim_cputimetonanosecond.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(SYSAPI_DIR)\sysio_allociomem.c
+OBJS = $(OBJS) $(OBJS_DIR)\sysio_allociomem.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(SYSAPI_DIR)\sysio_freeiomem.c
+OBJS = $(OBJS) $(OBJS_DIR)\sysio_freeiomem.$(EXT_OBJ)
CSRCS = $(CSRCS) $(SYSAPI_DIR)\syshos_hook.c
OBJS = $(OBJS) $(OBJS_DIR)\syshos_hook.$(EXT_OBJ)
!endif
# Librarys
# --------------------------------------------------
-# Memory Pool
-!if "$(LINK_MEMPOL)" == "Yes"
-MEMPOL_DIR = $(HOSAPLFW_DIR)\library\container\mempol
-HEADERS = $(HEADERS) $(OBJS_DIR)\mempol.h
-CSRCS = $(CSRCS) $(MEMPOL_DIR)\mempol.c
-OBJS = $(OBJS) $(OBJS_DIR)\mempol.$(EXT_OBJ)
+# Valiable size memory heap
+!if "$(LINK_VALMEMHEAP)" == "Yes"
+VALMEMHEAP_DIR = $(HOSAPLFW_DIR)\library\container\valmemheap
+HEADERS = $(HEADERS) $(OBJS_DIR)\valmemheap.h
+HEADERS = $(HEADERS) $(OBJS_DIR)\valmemheap_local.h
+CSRCS = $(CSRCS) $(VALMEMHEAP_DIR)\valmemheap_constructor.c
+OBJS = $(OBJS) $(OBJS_DIR)\valmemheap_constructor.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(VALMEMHEAP_DIR)\valmemheap_alloc.c
+OBJS = $(OBJS) $(OBJS_DIR)\valmemheap_alloc.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(VALMEMHEAP_DIR)\valmemheap_realloc.c
+OBJS = $(OBJS) $(OBJS_DIR)\valmemheap_realloc.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(VALMEMHEAP_DIR)\valmemheap_free.c
+OBJS = $(OBJS) $(OBJS_DIR)\valmemheap_free.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(VALMEMHEAP_DIR)\valmemheap_getalign.c
+OBJS = $(OBJS) $(OBJS_DIR)\valmemheap_getalign.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(VALMEMHEAP_DIR)\valmemheap_getsize.c
+OBJS = $(OBJS) $(OBJS_DIR)\valmemheap_getsize.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(VALMEMHEAP_DIR)\valmemheap_alignsize.c
+OBJS = $(OBJS) $(OBJS_DIR)\valmemheap_alignsize.$(EXT_OBJ)
+!endif
+
+
+# Fixed size memory heap
+!if "$(LINK_FIXMEMHEAP)" == "Yes"
+FIXMEMHEAP_DIR = $(HOSAPLFW_DIR)\library\container\fixmemheap
+HEADERS = $(HEADERS) $(OBJS_DIR)\fixmemheap.h
+HEADERS = $(HEADERS) $(OBJS_DIR)\fixmemheap_local.h
+CSRCS = $(CSRCS) $(FIXMEMHEAP_DIR)\fixmemheap_create.c
+OBJS = $(OBJS) $(OBJS_DIR)\fixmemheap_create.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(FIXMEMHEAP_DIR)\fixmemheap_delete.c
+OBJS = $(OBJS) $(OBJS_DIR)\fixmemheap_delete.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(FIXMEMHEAP_DIR)\fixmemheap_constructor.c
+OBJS = $(OBJS) $(OBJS_DIR)\fixmemheap_constructor.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(FIXMEMHEAP_DIR)\fixmemheap_alloc.c
+OBJS = $(OBJS) $(OBJS_DIR)\fixmemheap_alloc.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(FIXMEMHEAP_DIR)\fixmemheap_realloc.c
+OBJS = $(OBJS) $(OBJS_DIR)\fixmemheap_realloc.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(FIXMEMHEAP_DIR)\fixmemheap_free.c
+OBJS = $(OBJS) $(OBJS_DIR)\fixmemheap_free.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(FIXMEMHEAP_DIR)\fixmemheap_getalign.c
+OBJS = $(OBJS) $(OBJS_DIR)\fixmemheap_getalign.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(FIXMEMHEAP_DIR)\fixmemheap_getsize.c
+OBJS = $(OBJS) $(OBJS_DIR)\fixmemheap_getsize.$(EXT_OBJ)
+CSRCS = $(CSRCS) $(FIXMEMHEAP_DIR)\fixmemheap_alignsize.c
+OBJS = $(OBJS) $(OBJS_DIR)\fixmemheap_alignsize.$(EXT_OBJ)
!endif
"system_requestproc.c",
"system_process.c",
"system_getnextprocess.c",
+ "system_getsystemprocess.c",
],
],
[
"sysisr_delete.c",
"sysmem_alloc.c",
"sysmem_free.c",
- "sysmem_getmemif.c",
+ "sysmem_getmemheap.c",
"sysmem_getsize.c",
"sysmem_realloc.c",
- "sysmem_allociomem.c",
- "sysmem_freeiomem.c",
"sysmtx_create.c",
"sysmtx_delete.c",
"sysmtx_lock.c",
"systim_getcputime.c",
"systim_cputimetosecond.c",
"systim_cputimetonanosecond.c",
+ "sysio_allociomem.c",
+ "sysio_freeiomem.c",
"syshos_hook.c",
],
],
[
"Librarys",
[
- "Memory Pool",
+ "Valiable size memory heap",
"\$(COMMON_HEADERS)",
- "\$(HOSAPLFW_DIR)/library/container/mempol",
- "MEMPOL",
+ "\$(HOSAPLFW_DIR)/library/container/valmemheap",
+ "VALMEMHEAP",
"Yes",
[
- "mempol.h",
+ "valmemheap.h",
+ "valmemheap_local.h",
],
[
- "mempol.c",
+ "valmemheap_constructor.c",
+ "valmemheap_alloc.c",
+ "valmemheap_realloc.c",
+ "valmemheap_free.c",
+ "valmemheap_getalign.c",
+ "valmemheap_getsize.c",
+ "valmemheap_alignsize.c",
+ ]
+ ],
+ [
+ "Fixed size memory heap",
+ "\$(COMMON_HEADERS)",
+ "\$(HOSAPLFW_DIR)/library/container/fixmemheap",
+ "FIXMEMHEAP",
+ "Yes",
+ [
+ "fixmemheap.h",
+ "fixmemheap_local.h",
+ ],
+ [
+ "fixmemheap_create.c",
+ "fixmemheap_delete.c",
+ "fixmemheap_constructor.c",
+ "fixmemheap_alloc.c",
+ "fixmemheap_realloc.c",
+ "fixmemheap_free.c",
+ "fixmemheap_getalign.c",
+ "fixmemheap_getsize.c",
+ "fixmemheap_alignsize.c",
]
],
[
int i;
/* 一時バッファ確保 */
- if ( (pubBuf = SysMem_Alloc(512)) == NULL )
+ if ( (pubBuf = SysIo_AllocIoMem(512)) == NULL )
{
return FATVOL_ERR_NG;
}
self->hBlockFile = File_Open(pszPath, FILE_OPEN_READ | FILE_OPEN_WRITE);
if ( self->hBlockFile == HANDLE_NULL )
{
- SysMem_Free(pubBuf);
+ SysIo_FreeIoMem(pubBuf);
return FATVOL_ERR_NG;
}
self->RootDirCluster = 0xf0000000;
/* FATバッファ準備 */
- self->pubFatBuf = (unsigned char *)SysMem_Alloc(self->SectorPerFat * self->BytesPerSector);
+ self->pubFatBuf = (unsigned char *)SysIo_AllocIoMem(self->SectorPerFat * self->BytesPerSector);
self->pubFatDirty = (unsigned char *)SysMem_Alloc(self->SectorPerFat);
if ( self->pubFatBuf == NULL || self->pubFatDirty == NULL )
{
- SysMem_Free(self->pubFatBuf);
+ SysIo_FreeIoMem(self->pubFatBuf);
SysMem_Free(self->pubFatDirty);
File_Close(self->hBlockFile);
- SysMem_Free(pubBuf);
+ SysIo_FreeIoMem(pubBuf);
return FATVOL_ERR_NG;
}
break;
+
case FATVOL_TYPE_FAT32:
self->BytesPerSector = pubBuf[0x0b] + (pubBuf[0x0c] << 8); /**< セクタサイズ */
self->SectorsPerCluster = pubBuf[0x0d]; /**< 1クラスタのセクタ数 */
self->RootDirCluster = pubBuf[0x2c] + (pubBuf[0x2d] << 8) + (pubBuf[0x2e] << 16) + (pubBuf[0x2f] << 24);
/* FATバッファ準備 */
- self->pubFatBuf = (unsigned char *)SysMem_Alloc(self->SectorPerFat * self->BytesPerSector);
+ self->pubFatBuf = (unsigned char *)SysIo_AllocIoMem(self->SectorPerFat * self->BytesPerSector);
self->pubFatDirty = (unsigned char *)SysMem_Alloc(self->SectorPerFat);
if ( self->pubFatBuf == NULL || self->pubFatDirty == NULL )
{
- SysMem_Free(self->pubFatBuf);
+ SysIo_FreeIoMem(self->pubFatBuf);
SysMem_Free(self->pubFatDirty);
File_Close(self->hBlockFile);
- SysMem_Free(pubBuf);
+ SysIo_FreeIoMem(pubBuf);
return FATVOL_ERR_NG;
}
default:
File_Close(self->hBlockFile);
- SysMem_Free(pubBuf);
+ SysIo_FreeIoMem(pubBuf);
return FATVOL_ERR_NG;
}
{
self->pClusterBuf[i].uiClusterNum = FATVOL_CLUSTER_ENDMARKER;
self->pClusterBuf[i].iDirty = 0;
- self->pClusterBuf[i].pubBuf = SysMem_Alloc(self->BytesPerCluster);
+ self->pClusterBuf[i].pubBuf = SysIo_AllocIoMem(self->BytesPerCluster);
}
-
/* 親クラスコンストラクタ呼び出し */
VolumeObj_Constructor(&self->VolumeObj, pMethods);
self->hMtx = SysMtx_Create(SYSMTX_ATTR_NORMAL);
/* 一時バッファ開放 */
- SysMem_Free(pubBuf);
+ SysIo_FreeIoMem(pubBuf);
return FATVOL_ERR_OK;
}
/* クラスタバッファ開放 */
for ( i = 0; i < self->iClusterBufNum; i++ )
{
- SysMem_Free(self->pClusterBuf[i].pubBuf);
+ SysIo_FreeIoMem(self->pClusterBuf[i].pubBuf);
}
SysMem_Free(self->pClusterBuf[i].pubBuf);
#define __HOS__array_h__
-#include "library/container/memif/memif.h"
+#include "library/container/memheap/memheap.h"
/* エラーコード */
#define ARRAY_ERR_OK 0
/* ストリームバッファクラス */
typedef struct c_array
{
- C_MEMIF *pMemIf; /* 利用するメモリI/F */
+ C_MEMHEAP *pMemHeap; /* 利用するメモリI/F */
void **ppArray; /* データ配列 */
ARRAY_INDEX ArraySize; /* 配列サイズ */
ARRAY_INDEX Size; /* 配列要素のサイズ */
/* 生成／削除 */
void Array_Create(C_ARRAY *self); /* 配列クラスの生成 */
-void Array_CreateEx(C_ARRAY *self, C_MEMIF *pMemIf); /* 配列クラスの生成 */
+void Array_CreateEx(C_ARRAY *self, C_MEMHEAP *pMemHeap); /* 配列クラスの生成 */
void Array_Delete(C_ARRAY *self); /* 配列クラスの削除 */
/* 操作 */
ARRAY_ERR err;
/* メモリ確保 */
- if ( (pMem = (void *)MemIf_Alloc(self->pMemIf, lSize)) == NULL )
+ if ( (pMem = (void *)MemHeap_Alloc(self->pMemHeap, lSize)) == NULL )
{
return ARRAY_ERR_NG;
}
/* サイズ拡張 */
if ( (err = Array_SetSize(self, self->Size + 1)) != ARRAY_ERR_OK )
{
- MemIf_Free(self->pMemIf, pMem);
+ MemHeap_Free(self->pMemHeap, pMem);
return err;
}
{
if ( self->ppArray[i] != NULL )
{
- MemIf_Free(self->pMemIf, self->ppArray[i]);
+ MemHeap_Free(self->pMemHeap, self->ppArray[i]);
}
}
self->Size = Size;
NewSize = Size + ARRAY_SIZE_UNIT;
NewSize -= NewSize % ARRAY_SIZE_UNIT;
- ppNewArray = (void **)MemIf_ReAlloc(self->pMemIf, self->ppArray, NewSize);
+ ppNewArray = (void **)MemHeap_ReAlloc(self->pMemHeap, self->ppArray, NewSize);
if ( ppNewArray == NULL )
{
return ARRAY_ERR_NG;
}
/* 連想バッファの生成 */
-void Assoc_CreateEx(C_ASSOC *self, C_MEMIF *pMemIf)
+void Assoc_CreateEx(C_ASSOC *self, C_MEMHEAP *pMemHeap)
{
- self->pMemIf = pMemIf;
- List_CreateEx(&self->List, pMemIf);
+ self->pMemHeap = pMemHeap;
+ List_CreateEx(&self->List, pMemHeap);
}
/* 連想バッファの削除 */
int iKeyLen;
void *pMem;
- iKeyLen = MEMIF_ALIGNSIZE(strlen(pszKey) + 1);
- if ( (pMem = MemIf_Alloc(self->pMemIf, iKeyLen + lSize)) == NULL )
+ iKeyLen = MemHeap_AlignSize(self->pMemHeap, strlen(pszKey) + 1);
+ if ( (pMem = MemHeap_Alloc(self->pMemHeap, iKeyLen + lSize)) == NULL )
{
return ASSOC_ERR_NG;
}
memcpy((char *)pMem + iKeyLen, pData, lSize);
err = List_AddTail(&self->List, pMem, iKeyLen + lSize);
- MemIf_Free(self->pMemIf, pMem);
+ MemHeap_Free(self->pMemHeap, pMem);
return err;
}
pDataKey = List_GetAt(&self->List, Pos);
if ( strcmp(pDataKey, pszKey) == 0 )
{
- return (void *)(pDataKey + MEMIF_ALIGNSIZE(strlen(pszKey) + 1));
+ return (void *)(pDataKey + MemHeap_AlignSize(self->pMemHeap, strlen(pszKey) + 1));
}
Pos = List_GetNextPos(&self->List, Pos);
}
pDataKey = List_GetAt(&self->List, Pos);
*ppszKey = pDataKey;
- return (void *)(pDataKey + MEMIF_ALIGNSIZE(strlen(pDataKey) + 1));
+ return (void *)(pDataKey + MemHeap_AlignSize(self->pMemHeap, strlen(pDataKey) + 1));
}
/* ストリームバッファクラス */
typedef struct c_assocbuf
{
- C_LIST List; /* とりあえず手抜き(そのうちB-Treeとかに....) */
- C_MEMIF *pMemIf;
+ C_LIST List; /* とりあえず手抜き(そのうちB-Treeとかに....) */
+ C_MEMHEAP *pMemHeap;
} C_ASSOC;
/* 生成／削除 */
void Assoc_Create(C_ASSOC *self); /* 連想バッファの生成 */
-void Assoc_CreateEx(C_ASSOC *self, C_MEMIF *pMemIf); /* 連想バッファの生成 */
+void Assoc_CreateEx(C_ASSOC *self, C_MEMHEAP *pMemHeap); /* 連想バッファの生成 */
void Assoc_Delete(C_ASSOC *self); /* 連想バッファの削除 */
/* 操作 */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file fixmemheap.h
+ * @brief %jp{固定サイズメモリヒープクラス}%en{fixed size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+
+#ifndef __HOS__fixmemheap_h__
+#define __HOS__fixmemheap_h__
+
+
+#include "library/container/memheap/memheap_local.h"
+
+
+typedef struct c_fixmemheap C_FIXMEMHEAP;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+C_FIXMEMHEAP *FixMemHeap_Create(void *pMemBase, MEMSIZE BlkSize, MEMSIZE BlkNum);
+void FixMemHeap_Delete(C_FIXMEMHEAP *self);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif /* __HOS__memheap_h__ */
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file fixmemheap_free.c
+ * @brief %jp{固定サイズメモリヒープクラス}%en{fixed size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "fixmemheap_local.h"
+
+
+
+/** サイズをアライメント単位に拡張 */
+MEMSIZE FixMemHeap_AlignSize(void *pMemHeap, MEMSIZE Size)
+{
+ C_FIXMEMHEAP *self;
+
+ /* upper cast */
+ self = (C_FIXMEMHEAP *)pMemHeap;
+
+ return self->BlkSize;
+}
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file fixmemheap_alloc.c
+ * @brief %jp{固定サイズメモリヒープクラス}%en{fixed size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "fixmemheap_local.h"
+
+
+
+/** %jp{メモリの割り当て} */
+void *FixMemHeap_Alloc(void *pMemHeap, MEMSIZE Size)
+{
+ C_FIXMEMHEAP *self;
+ void *pMem;
+
+ /* upper cast */
+ self = (C_FIXMEMHEAP *)pMemHeap;
+
+ /* %jp{ヒープの存在チェック} */
+ if ( self->pMemBase == NULL )
+ {
+ return NULL;
+ }
+
+ /* サイズチェック */
+ if ( Size > self->BlkSize)
+ {
+ return NULL;
+ }
+
+ /* %jp{空きチェック} */
+ if ( self->ppFree == NULL )
+ {
+ return NULL;
+ }
+
+ /* リスト繋ぎ変え */
+ pMem = self->ppFree;
+ self->ppFree = *self->ppFree;
+
+ return pMem;
+}
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file fixmemheap_alloc.c
+ * @brief %jp{固定サイズメモリヒープクラス}%en{fixed size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "fixmemheap_local.h"
+
+
+
+/** %jp{MemHeapクラス 仮想関数テーブル}%en{MemHeap class virtual function table} */
+const static T_MEMHEAP_METHODS FixMemHeap_Methods =
+ {
+ FixMemHeap_Alloc, /**< メモリの割り当て */
+ FixMemHeap_ReAlloc, /**< メモリの再割り当て */
+ FixMemHeap_Free, /**< メモリの開放 */
+ FixMemHeap_GetSize, /**< メモリのサイズ取得 */
+ FixMemHeap_GetAlign, /**< メモリアライメントの取得 */
+ FixMemHeap_AlignSize, /**< サイズをアライメント単位に拡張 */
+ };
+
+
+
+/** %jp{コンストラクタ} */
+void FixMemHeap_Constructor(C_FIXMEMHEAP *self, void *pMemBase, MEMSIZE BlkSize, MEMSIZE BlkNum)
+{
+ void **ppBlk;
+ void **ppBlkNext;
+ MEMSIZE i;
+
+ /* %jp{親クラスコンストラクタ} */
+ MemHeap_Constructor(&self->MemHeap, &FixMemHeap_Methods);
+
+ /* メンバ変数設定 */
+ self->pMemBase = pMemBase; /**< %jp{メモリ先頭ブロックのアドレス} */
+ self->BlkSize = BlkSize; /**< %jp{ブロックサイズ} */
+ self->BlkNum = BlkNum; /**< %jp{ブロック個数} */
+
+ /* メモリ初期化 */
+ ppBlk = (void **)self->pMemBase;
+ for ( i = 0; i < BlkSize - 1; i++ )
+ {
+ ppBlkNext = (void **)((char *)ppBlk + BlkSize);
+ *ppBlk = (void *)ppBlkNext;
+ ppBlk = ppBlkNext;
+ }
+ *ppBlk = NULL;
+
+ self->ppFree = (void **)self->pMemBase;
+}
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file fixmemheap_alloc.c
+ * @brief %jp{固定サイズメモリヒープクラス}%en{fixed size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "hosaplfw.h"
+#include "fixmemheap_local.h"
+
+
+
+/** 生成 */
+C_FIXMEMHEAP *FixMemHeap_Create(void *pMemBase, MEMSIZE BlkSize, MEMSIZE BlkNum)
+{
+ C_FIXMEMHEAP *self;
+
+ /* メモリ確保 */
+ if ( (self = (C_FIXMEMHEAP *)Memory_Alloc(sizeof(C_FIXMEMHEAP))) == NULL )
+ {
+ return NULL;
+ }
+
+ /* コンストラクタ呼び出し */
+ FixMemHeap_Constructor(self, pMemBase, BlkSize, BlkNum);
+
+ return (HANDLE)self;
+}
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file fixmemheap_alloc.c
+ * @brief %jp{固定サイズメモリヒープクラス}%en{fixed size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "hosaplfw.h"
+#include "fixmemheap_local.h"
+
+
+
+/** 削除 */
+void FixMemHeap_Delete(C_FIXMEMHEAP *self)
+{
+ /* デストラクタ呼び出し */
+ FixMemHeap_Destructor(self);
+
+ /* メモリ削除 */
+ Memory_Free(self);
+}
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file fixmemheap_free.c
+ * @brief %jp{固定サイズメモリヒープクラス}%en{fixed size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "fixmemheap_local.h"
+
+
+
+/** %jp{メモリの解放} */
+void FixMemHeap_Free(void *pMemHeap, void *pMem)
+{
+ C_FIXMEMHEAP *self;
+
+ /* upper cast */
+ self = (C_FIXMEMHEAP *)pMemHeap;
+
+ /* %jp{ポインタ範囲チェック} */
+ if ( pMem < (void *)self->pMemBase || pMem >= (void *)((char *)self->pMemBase + (self->BlkSize * self->BlkNum)) )
+ {
+ return;
+ }
+
+ /* リスト繋ぎ変え */
+ *(void **)pMem = (void *)self->ppFree;
+ self->ppFree = (void **)pMem;
+}
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file fixmemheap_free.c
+ * @brief %jp{固定サイズメモリヒープクラス}%en{fixed size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "fixmemheap_local.h"
+
+
+/** メモリアライメントの取得 */
+MEMSIZE FixMemHeap_GetAlign(void *pMemHeap)
+{
+ C_FIXMEMHEAP *self;
+
+ /* upper cast */
+ self = (C_FIXMEMHEAP *)pMemHeap;
+
+ return self->BlkSize;
+}
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file fixmemheap_free.c
+ * @brief %jp{固定サイズメモリヒープクラス}%en{fixed size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "fixmemheap_local.h"
+
+
+
+/** メモリのサイズ取得 */
+MEMSIZE FixMemHeap_GetSize(void *pMemHeap, void *pMem)
+{
+ C_FIXMEMHEAP *self;
+
+ /* upper cast */
+ self = (C_FIXMEMHEAP *)pMemHeap;
+
+ return self->BlkSize;
+}
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file fixmemheap_local.h
+ * @brief %jp{固定サイズメモリヒープクラス}%en{fixed size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+
+#ifndef __HOS__fixmemheap_local_h__
+#define __HOS__fixmemheap_local_h__
+
+
+#include "library/container/memheap/memheap_local.h"
+
+
+
+/** %jp{FixMemHeapクラス}%en{FixMemHeap class} */
+typedef struct c_fixmemheap
+{
+ C_MEMHEAP MemHeap; /* 継承 */
+
+ void *pMemBase; /**< %jp{メモリ先頭ブロックのアドレス} */
+ void **ppFree; /**< %jp{空きブロックアドレス} */
+
+ MEMSIZE BlkSize; /**< %jp{ブロックサイズ} */
+ MEMSIZE BlkNum; /**< %jp{ブロック個数} */
+} C_FIXMEMHEAP;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void FixMemHeap_Constructor(C_FIXMEMHEAP *self, void *pMemBase, MEMSIZE BlkSize, MEMSIZE BlkNum);
+#define FixMemHeap_Destructor(self) do { } while (0)
+
+void *FixMemHeap_Alloc(void *pMemHeap, MEMSIZE Size); /**< メモリの割り当て */
+void *FixMemHeap_ReAlloc(void *pMemHeap, void *pMem, MEMSIZE Size); /**< メモリの再割り当て */
+void FixMemHeap_Free(void *pMemHeap, void *pMem); /**< メモリの開放 */
+MEMSIZE FixMemHeap_GetSize(void *pMemHeap, void *pMem); /**< メモリのサイズ取得 */
+MEMSIZE FixMemHeap_GetAlign(void *pMemHeap); /**< メモリアライメントの取得 */
+MEMSIZE FixMemHeap_AlignSize(void *pMemHeap, MEMSIZE Size); /**< サイズをアライメント単位に拡張 */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif /* __HOS__fixmemheap_local_h__ */
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file fixmemheap_alloc.c
+ * @brief %jp{固定サイズメモリヒープクラス}%en{fixed size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include <string.h>
+#include "fixmemheap_local.h"
+
+
+
+/** %jp{メモリの再割り当て} */
+void *FixMemHeap_ReAlloc(void *pMemHeap, void *pMem, MEMSIZE Size)
+{
+ return NULL;
+}
+
+
+/* end of file */
#define __HOS__list_h__
-#include "library/container/memif/memif.h"
+#include "library/container/memheap/memheap.h"
#define LIST_ERR_OK 0
/* ストリームバッファクラス */
typedef struct c_list
{
- C_MEMIF *pMemIf; /* 利用するメモリI/F */
+ C_MEMHEAP *pMemHeap; /* 利用するメモリI/F */
void *pHead; /* 先頭要素へのポインタ */
} C_LIST;
/* 生成／削除 */
void List_Create(C_LIST *self); /* リストの生成 */
-void List_CreateEx(C_LIST *self, C_MEMIF *pMemIf); /* リストの生成 */
+void List_CreateEx(C_LIST *self, C_MEMHEAP *pMemHeap); /* リストの生成 */
void List_Delete(C_LIST *self); /* リストの削除 */
/* 操作 */
long lObjSize;
/* メモリ確保 */
- lObjSize = MemIf_AlignSize(self->pMemIf, sizeof(T_LIST_OBJ));
- pListObj = MemIf_Alloc(self->pMemIf, lObjSize + lSize);
+ lObjSize = MemHeap_AlignSize(self->pMemHeap, sizeof(T_LIST_OBJ));
+ pListObj = MemHeap_Alloc(self->pMemHeap, lObjSize + lSize);
if ( pListObj == NULL )
{
return LIST_ERR_OK;
/* コンストラクタ */
void List_Create(C_LIST *self)
{
- self->pMemIf = Memory_GetMemIf();
- self->pHead = NULL;
+ self->pMemHeap = Memory_GetMemHeap();
+ self->pHead = NULL;
}
/* コンストラクタ */
-void List_CreateEx(C_LIST *self, C_MEMIF *pMemIf)
+void List_CreateEx(C_LIST *self, C_MEMHEAP *pMemHeap)
{
- self->pMemIf = pMemIf;
- self->pHead = NULL;
+ self->pMemHeap = pMemHeap;
+ self->pHead = NULL;
}
long lObjSize;
pListObj = (T_LIST_OBJ *)Pos;
- lObjSize = MemIf_AlignSize(self->pMemIf, sizeof(T_LIST_OBJ));
+ lObjSize = MemHeap_AlignSize(self->pMemHeap, sizeof(T_LIST_OBJ));
return (void *)((char *)pListObj + lObjSize);
}
self->pHead = pListObj->pNext;
}
}
- MemIf_Free(self->pMemIf, pListObj);
+ MemHeap_Free(self->pMemHeap, pListObj);
return LIST_ERR_OK;
}
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file memheap.h
+ * @brief %jp{メモリヒープクラス(抽象クラス)}%en{memory heap class(abstract class)}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+
+#ifndef __HOS__memheap_h__
+#define __HOS__memheap_h__
+
+
+#include "system/type/type.h"
+
+
+
+/** %jp{MemHeapクラス 仮想関数テーブル}%en{MemHeap class virtual function table} */
+typedef struct t_memheap_methods
+{
+ void *(*pfncAlloc)(void *pMemHeap, MEMSIZE Size); /**< メモリの割り当て */
+ void *(*pfncReAlloc)(void *pMemHeap, void *pMem, MEMSIZE Size); /**< メモリの再割り当て */
+ void (*pfncFree)(void *pMemHeap, void *pMem); /**< メモリの開放 */
+ MEMSIZE (*pfncGetSize)(void *pMemHeap, void *pMem); /**< メモリのサイズ取得 */
+ MEMSIZE (*pfncGetAlign)(void *pMemHeap); /**< メモリアライメントの取得 */
+ MEMSIZE (*pfncAlignSize)(void *pMemHeap, MEMSIZE Size); /**< サイズをアライメント単位に拡張 */
+
+} T_MEMHEAP_METHODS;
+
+
+/** %jp{MemHeapクラス}%en{MemHeap class} */
+typedef struct c_memheap
+{
+ const T_MEMHEAP_METHODS *pMethods;
+} C_MEMHEAP;
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MemHeap_Alloc(self, Size) ((self)->pMethods->pfncAlloc((self), (Size)))
+#define MemHeap_ReAlloc(self, pMem, Size) ((self)->pMethods->pfncReAlloc((self), (pMem), (Size)))
+#define MemHeap_Free(self, pMem) ((self)->pMethods->pfncFree((self), (pMem)))
+#define MemHeap_GetSize(self, pMem) ((self)->pMethods->pfncGetSize((self), (pMem)))
+#define MemHeap_GetAlign(self) ((self)->pMethods->pfncGetAlign((self)))
+#define MemHeap_AlignSize(self, Size) ((self)->pMethods->pfncAlignSize((self), (Size)))
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif /* __HOS__memheap_h__ */
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file memheap_local.h
+ * @brief %jp{メモリヒープクラス(抽象クラス)}%en{memory heap class(abstract class)}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+
+#ifndef __HOS__memheap_local_h__
+#define __HOS__memheap_local_h__
+
+
+#include "memheap.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MemHeap_Constructor(self, methods) do { (self)->pMethods = (methods); } while (0)
+#define MemHeap_Destructor(self) do { } while (0)
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif /* __HOS_memheap_local_h__ */
+
+
+
+/* end of file */
+++ /dev/null
-
-
-#ifndef __HOS__memif_h__
-#define __HOS__memif_h__
-
-
-#include "system/type/type.h"
-
-
-#define MEMIF_MEMALIGN MEMALIGN
-#define MEMIF_ALIGNSIZE(x) (((x) + MEMIF_MEMALIGN - 1) & ~(MEMIF_MEMALIGN - 1))
-
-
-/* メモリインターフェースクラス */
-typedef struct c_memif
-{
- void *(*pfncAlloc)(MEMSIZE Size); /* メモリの割り当て */
- void *(*pfncReAlloc)(void *pMem, MEMSIZE Size); /* メモリの再割り当て */
- void (*pfncFree)(void *pMem); /* メモリの開放 */
- MEMSIZE (*pfncGetSize)(void *pMem); /* メモリのサイズ取得 */
-} C_MEMIF;
-
-
-#define MemIf_Alloc(pMemIf, Size) ((pMemIf)->pfncAlloc((Size)))
-#define MemIf_ReAlloc(pMemIf, pMem, Size) ((pMemIf)->pfncReAlloc((pMem), (Size)))
-#define MemIf_Free(pMemIf, pMem) ((pMemIf)->pfncFree((pMem)))
-#define MemIf_GetSize(pMemIf, pMem) ((pMemIf)->pfncGetSize((pMem)))
-#define MemIf_GetAlign(pMemIf) MEMIF_MEMALIGN
-#define MemIf_AlignSize(pMemIf, Size) MEMIF_ALIGNSIZE(Size)
-
-
-#endif /* __HOS__memif_h__ */
-
+++ /dev/null
-#include <stdio.h>
-#include <string.h>
-#include "mempol.h"
-
-
-/** %jp{コンストラクタ} */
-void MemPol_Create(C_MEMPOL *self, void *p_base, MEMPOL_MEMSIZE Size)
-{
- T_MEMPOL_MEMBLK *blk_last;
-
- /* %jp{サイズのアライメントを調整} */
- Size &= ~(MEMPOL_MEMALIGN - 1);
-
- /* %jp{サイズチェック} */
- if ( Size <= sizeof(T_MEMPOL_MEMBLK) )
- {
- self->pBase = NULL;
- return;
- }
-
- /* %jp{設定保存} */
- self->pBase = (T_MEMPOL_MEMBLK *)p_base;
- self->MemSize = Size;
-
- /* %jp{終端位置に番人を設定} */
- blk_last = (T_MEMPOL_MEMBLK *)((char *)p_base + Size - MEMPOL_MEMBLK_SIZE);
-
- /* %jp{全体を空き領域に設定} */
- self->pBase->pPrev = NULL;
- self->pBase->Size = Size - (MEMPOL_MEMBLK_SIZE * 2);
- self->pBase->iFlag = MEMPOL_FREE;
-
- /* %jp{終端の番人を利用中に設定} */
- blk_last->pPrev = NULL;
- blk_last->Size = 0;
- blk_last->iFlag = MEMPOL_USING;
-}
-
-
-/** %jp{メモリの割り当て} */
-void *MemPol_Alloc(C_MEMPOL *self, MEMPOL_MEMSIZE Size)
-{
- T_MEMPOL_MEMBLK *mblk;
- T_MEMPOL_MEMBLK *mblk_next;
- T_MEMPOL_MEMBLK *mblk_next2;
-
- /* %jp{ヒープの存在チェック} */
- if ( self->pBase == NULL )
- {
- return NULL;
- }
-
- /* %jp{サイズのアライメントを調整} */
- Size = MEMPOL_ALIGNED(Size);
-
- /* %jp{空き領域を検索} */
- mblk = self->pBase;
- while ( mblk->Size != 0 )
- {
- if ( mblk->iFlag == MEMPOL_FREE && mblk->Size >= Size )
- {
- /* 十分な容量があったら */
- if ( mblk->Size - Size > MEMPOL_MEMBLK_SIZE + MEMPOL_MEMALIGN )
- {
- /* ブロックを分割する */
- mblk_next = (T_MEMPOL_MEMBLK *)((char *)mblk + MEMPOL_MEMBLK_SIZE + Size);
- mblk_next2 = (T_MEMPOL_MEMBLK *)((char *)mblk + MEMPOL_MEMBLK_SIZE + mblk->Size);
- mblk_next->pPrev = mblk;
- mblk_next->Size = mblk->Size - Size - MEMPOL_MEMBLK_SIZE;
- mblk_next->iFlag = MEMPOL_FREE;
- mblk_next2->pPrev = mblk_next;
- mblk->Size = Size;
- }
- mblk->iFlag = MEMPOL_USING;
-
- return (void *)((char *)mblk + MEMPOL_MEMBLK_SIZE);
- }
-
- /* 次のブロックへ進む */
- mblk = (T_MEMPOL_MEMBLK *)((char *)mblk + mblk->Size + MEMPOL_MEMBLK_SIZE);
- }
-
- return NULL; /* 空きが無い */
-}
-
-
-/** %jp{メモリの再割り当て} */
-void *MemPol_ReAlloc(C_MEMPOL *self, void *pPtr, MEMPOL_MEMSIZE Size)
-{
- void *pNewPtr;
-
- /* とりあえず手抜き */
- if ( (pNewPtr = MemPol_Alloc(self, Size)) != NULL )
- {
- memcpy(pNewPtr, pPtr, MemPol_GetSize(self, pPtr));
- MemPol_Free(self, pPtr);
- }
-
- return pNewPtr;
-}
-
-
-/** %jp{メモリの解放} */
-void MemPol_Free(C_MEMPOL *self, void *pPtr)
-{
- T_MEMPOL_MEMBLK *mblk;
- T_MEMPOL_MEMBLK *mblktmp;
- T_MEMPOL_MEMBLK *mblknext;
-
- /* %jp{ポインタ範囲チェック} */
- if ( pPtr < (void *)self->pBase || pPtr >= (void *)((char *)self->pBase + self->MemSize) )
- {
- return;
- }
-
- /* %jp{メモリブロック位置を取得} */
- mblk = (T_MEMPOL_MEMBLK *)((char *)pPtr - MEMPOL_MEMBLK_SIZE);
-
- /* %jp{パラメーターチェック} */
- if ( mblk->iFlag != MEMPOL_USING ) /* %jp{使用中で無ければ} */
- {
- return;
- }
-
- /* %jp{フラグを未使用に設定} */
- mblk->iFlag = MEMPOL_FREE;
-
- /* %jp{次のブロックをチェック} */
- mblktmp = (T_MEMPOL_MEMBLK *)((char *)pPtr + mblk->Size);
- if ( mblktmp->iFlag == MEMPOL_FREE )
- {
- /* %jp{次のブロックが未使用なら結合する} */
- mblknext = (T_MEMPOL_MEMBLK *)((char *)mblktmp + mblktmp->Size + MEMPOL_MEMBLK_SIZE);
- mblknext->pPrev = mblk;
- mblk->Size += mblktmp->Size + MEMPOL_MEMBLK_SIZE;
- }
-
- /* %jp{前のブロックをチェック} */
- if ( mblk->pPrev != NULL )
- {
- mblktmp = mblk->pPrev;
- if ( mblktmp->iFlag == MEMPOL_FREE )
- {
- /* %jp{前のブロックが未使用なら結合する} */
- mblknext = (T_MEMPOL_MEMBLK *)((char *)mblk + mblk->Size + MEMPOL_MEMBLK_SIZE);
- mblknext->pPrev = mblktmp;
- mblktmp->Size += mblk->Size + MEMPOL_MEMBLK_SIZE;
- }
- }
-}
-
-
-/** %jp{メモリサイズの取得} */
-MEMPOL_MEMSIZE MemPol_GetSize(C_MEMPOL *self, void *pPtr)
-{
- T_MEMPOL_MEMBLK *mblk;
-
- /* %jp{ポインタ範囲チェック} */
- if ( pPtr < (void *)self->pBase || pPtr >= (void *)((char *)self->pBase + self->MemSize) )
- {
- return 0; /* %jp{このメモリプールの所属でない} */
- }
-
- /* %jp{メモリブロック位置を取得} */
- mblk = (T_MEMPOL_MEMBLK *)((char *)pPtr - MEMPOL_MEMBLK_SIZE);
-
- /* %jp{パラメーターチェック} */
- if ( mblk->iFlag != MEMPOL_USING ) /* %jp{使用中で無ければ} */
- {
- return 0; /* %jp{割り当ていない} */
- }
-
- /* %jp{サイズを返す} */
- return mblk->Size;
-}
-
+++ /dev/null
-
-
-#ifndef __HOS__mempol_h__
-#define __HOS__mempol_h__
-
-
-#define MEMPOL_MEMALIGN sizeof(void *) /**< %jp{メモリアライメント} */
-#define MEMPOL_USING 0x1234 /**< %jp{使用中} */
-#define MEMPOL_FREE 0xabcd /**< %jp{未使用} */
-
-typedef long MEMPOL_MEMSIZE;
-
-
-/** %jp{サイズアライメント} */
-#define MEMPOL_ALIGNED(size) (((size) + MEMPOL_MEMALIGN - 1) & ~(MEMPOL_MEMALIGN - 1))
-
-
-/** %jp{ヒープメモリブロック} */
-typedef struct t_mempol_memblk
-{
- struct t_mempol_memblk* pPrev; /**< %jp{前のブロック} */
- MEMPOL_MEMSIZE Size; /**< %jp{ブロックのサイズ} */
- int iFlag; /**< %jp{使用中フラグ} */
-} T_MEMPOL_MEMBLK;
-
-
-/** %jp{ヒープ制御ブロック} */
-typedef struct c_mempol
-{
- T_MEMPOL_MEMBLK *pBase; /**< %jp{カーネル用メモリ先頭ブロックのアドレス} */
- MEMPOL_MEMSIZE MemSize; /**< %jp{カーネル用メモリサイズ} */
-} C_MEMPOL;
-
-
-/** %jp{カーネルメモリ管理ブロックサイズ} */
-#define MEMPOL_MEMBLK_SIZE MEMPOL_ALIGNED(sizeof(T_MEMPOL_MEMBLK))
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void MemPol_Create(C_MEMPOL *self, void *p_base, MEMPOL_MEMSIZE Size); /**< %jp{コンストラクタ} */
-#define MemPol_Delete(self) do {} while(0) /**< %jp{デストラクタ} */
-void *MemPol_Alloc(C_MEMPOL *self, MEMPOL_MEMSIZE Size); /**< %jp{メモリの割り当て} */
-void *MemPol_ReAlloc(C_MEMPOL *self, void *pPtr, MEMPOL_MEMSIZE Size); /**< %jp{メモリの再割り当て} */
-void MemPol_Free(C_MEMPOL *self, void *pPtr); /**< %jp{メモリの解放} */
-MEMPOL_MEMSIZE MemPol_GetSize(C_MEMPOL *self, void *pPtr); /**< %jp{メモリサイズの取得} */
-#define MemPol_GetAlign() MEMPOL_MEMALIGN /**< %jp{アライメント取得} */
-#define MemPol_SizeAlign(Size) MEMPOL_ALIGNED(size) /**< %jp{メモリサイズのアライメントを合わせる} */
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif /* __HOS__mempol_h__ */
-
-
-/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file valmemheap.h
+ * @brief %jp{可変サイズメモリヒープクラス}%en{variable size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+
+#ifndef __HOS__valmemheap_h__
+#define __HOS__valmemheap_h__
+
+
+#include "library/container/memheap/memheap_local.h"
+
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif /* __HOS__memheap_h__ */
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file valmemheap_free.c
+ * @brief %jp{可変サイズメモリヒープクラス}%en{variable size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "valmemheap_local.h"
+
+
+
+/** サイズをアライメント単位に拡張 */
+MEMSIZE ValMemHeap_AlignSize(void *pMemHeap, MEMSIZE Size)
+{
+ C_VALMEMHEAP *self;
+
+ /* upper cast */
+ self = (C_VALMEMHEAP *)pMemHeap;
+
+ return (Size + self->AlignMask) & ~self->AlignMask;
+}
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file valmemheap_alloc.c
+ * @brief %jp{可変サイズメモリヒープクラス}%en{variable size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "valmemheap_local.h"
+
+
+
+/** %jp{メモリの割り当て} */
+void *ValMemHeap_Alloc(void *pMemHeap, MEMSIZE Size)
+{
+ C_VALMEMHEAP *self;
+ T_VALMEMHEAP_MEMBLK *mblk;
+ T_VALMEMHEAP_MEMBLK *mblk_next;
+ T_VALMEMHEAP_MEMBLK *mblk_next2;
+ MEMSIZE MemBlockSize;
+
+
+ /* upper cast */
+ self = (C_VALMEMHEAP *)pMemHeap;
+
+ /* %jp{ヒープの存在チェック} */
+ if ( self->pMemBase == NULL )
+ {
+ return NULL;
+ }
+
+ /* %jp{サイズのアライメントを調整} */
+ Size = ValMemHeap_AlignSize(self, Size);
+
+ /* %jp{メモリブロックのサイズを調整} */
+ MemBlockSize = ValMemHeap_GetMemBlockSize(self);
+
+ /* %jp{空き領域を検索} */
+ mblk = self->pMemBase;
+ while ( mblk->Size != 0 )
+ {
+ if ( mblk->iFlag == VALMEMHEAP_FREE && mblk->Size >= Size )
+ {
+ /* 十分な容量があったら */
+ if ( mblk->Size - Size > MemBlockSize + (self->AlignMask + 1) )
+ {
+ /* ブロックを分割する */
+ mblk_next = (T_VALMEMHEAP_MEMBLK *)((char *)mblk + MemBlockSize + Size);
+ mblk_next2 = (T_VALMEMHEAP_MEMBLK *)((char *)mblk + MemBlockSize + mblk->Size);
+ mblk_next->pPrev = mblk;
+ mblk_next->Size = mblk->Size - Size - MemBlockSize;
+ mblk_next->iFlag = VALMEMHEAP_FREE;
+ mblk_next2->pPrev = mblk_next;
+ mblk->Size = Size;
+ }
+ mblk->iFlag = VALMEMHEAP_USING;
+
+ return (void *)((char *)mblk + MemBlockSize);
+ }
+
+ /* 次のブロックへ進む */
+ mblk = (T_VALMEMHEAP_MEMBLK *)((char *)mblk + mblk->Size + MemBlockSize);
+ }
+
+ return NULL; /* 空きが無い */
+}
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file valmemheap_alloc.c
+ * @brief %jp{可変サイズメモリヒープクラス}%en{variable size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "valmemheap_local.h"
+
+
+
+/** %jp{MemHeapクラス 仮想関数テーブル}%en{MemHeap class virtual function table} */
+const static T_MEMHEAP_METHODS ValMemHeap_Methods =
+ {
+ ValMemHeap_Alloc, /**< メモリの割り当て */
+ ValMemHeap_ReAlloc, /**< メモリの再割り当て */
+ ValMemHeap_Free, /**< メモリの開放 */
+ ValMemHeap_GetSize, /**< メモリのサイズ取得 */
+ ValMemHeap_GetAlign, /**< メモリアライメントの取得 */
+ ValMemHeap_AlignSize, /**< サイズをアライメント単位に拡張 */
+ };
+
+
+
+/** %jp{コンストラクタ} */
+void ValMemHeap_Constructor(C_VALMEMHEAP *self, void *pMemBase, MEMSIZE MemSize, int AlignSize)
+{
+ T_VALMEMHEAP_MEMBLK *pBlkLast;
+ MEMSIZE MemBlockSize;
+
+
+ /* %jp{親クラスコンストラクタ} */
+ MemHeap_Constructor(&self->MemHeap, &ValMemHeap_Methods);
+
+ /* %jp{サイズのアライメントを調整} */
+ MemSize = MemSize & ~(AlignSize - 1);
+
+ /* メンバ変数設定 */
+ self->pMemBase = (T_VALMEMHEAP_MEMBLK *)pMemBase; /**< %jp{メモリ先頭ブロックのアドレス} */
+ self->MemSize = MemSize; /**< %jp{メモリサイズ} */
+ self->AlignMask = AlignSize - 1; /**< %jp{メモリアライメントサイズ} */
+
+ /* %jp{メモリブロックのサイズを調整} */
+ MemBlockSize = ValMemHeap_GetMemBlockSize(self);
+
+ /* %jp{サイズチェック} */
+ if ( MemSize <= MemBlockSize * 2 )
+ {
+ self->pMemBase = NULL;
+ return;
+ }
+
+ /* %jp{終端位置に番人を設定} */
+ pBlkLast = (T_VALMEMHEAP_MEMBLK *)((char *)self->pMemBase + MemSize - MemBlockSize);
+
+ /* %jp{全体を空き領域に設定} */
+ self->pMemBase->pPrev = NULL;
+ self->pMemBase->Size = MemSize - (MemBlockSize * 2);
+ self->pMemBase->iFlag = VALMEMHEAP_FREE;
+
+ /* %jp{終端の番人を利用中に設定} */
+ pBlkLast->pPrev = NULL;
+ pBlkLast->Size = 0;
+ pBlkLast->iFlag = VALMEMHEAP_USING;
+}
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file valmemheap_free.c
+ * @brief %jp{可変サイズメモリヒープクラス}%en{variable size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "valmemheap_local.h"
+
+
+
+/** %jp{メモリの解放} */
+void ValMemHeap_Free(void *pMemHeap, void *pMem)
+{
+ C_VALMEMHEAP *self;
+ T_VALMEMHEAP_MEMBLK *mblk;
+ T_VALMEMHEAP_MEMBLK *mblktmp;
+ T_VALMEMHEAP_MEMBLK *mblknext;
+ MEMSIZE MemBlockSize;
+
+
+ /* upper cast */
+ self = (C_VALMEMHEAP *)pMemHeap;
+
+ /* %jp{ポインタ範囲チェック} */
+ if ( pMem < (void *)self->pMemBase || pMem >= (void *)((char *)self->pMemBase + self->MemSize) )
+ {
+ return;
+ }
+
+ /* %jp{メモリブロックのサイズを調整} */
+ MemBlockSize = ValMemHeap_GetMemBlockSize(self);
+
+ /* %jp{メモリブロック位置を取得} */
+ mblk = (T_VALMEMHEAP_MEMBLK *)((char *)pMem - MemBlockSize);
+
+ /* %jp{パラメーターチェック} */
+ if ( mblk->iFlag != VALMEMHEAP_USING ) /* %jp{使用中で無ければ} */
+ {
+ return;
+ }
+
+ /* %jp{フラグを未使用に設定} */
+ mblk->iFlag = VALMEMHEAP_FREE;
+
+ /* %jp{次のブロックをチェック} */
+ mblktmp = (T_VALMEMHEAP_MEMBLK *)((char *)pMem + mblk->Size);
+ if ( mblktmp->iFlag == VALMEMHEAP_FREE )
+ {
+ /* %jp{次のブロックが未使用なら結合する} */
+ mblknext = (T_VALMEMHEAP_MEMBLK *)((char *)mblktmp + mblktmp->Size + MemBlockSize);
+ mblknext->pPrev = mblk;
+ mblk->Size += mblktmp->Size + MemBlockSize;
+ }
+
+ /* %jp{前のブロックをチェック} */
+ if ( mblk->pPrev != NULL )
+ {
+ mblktmp = mblk->pPrev;
+ if ( mblktmp->iFlag == VALMEMHEAP_FREE )
+ {
+ /* %jp{前のブロックが未使用なら結合する} */
+ mblknext = (T_VALMEMHEAP_MEMBLK *)((char *)mblk + mblk->Size + MemBlockSize);
+ mblknext->pPrev = mblktmp;
+ mblktmp->Size += mblk->Size + MemBlockSize;
+ }
+ }
+}
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file valmemheap_free.c
+ * @brief %jp{可変サイズメモリヒープクラス}%en{variable size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "valmemheap_local.h"
+
+
+/** メモリアライメントの取得 */
+MEMSIZE ValMemHeap_GetAlign(void *pMemHeap)
+{
+ C_VALMEMHEAP *self;
+
+ /* upper cast */
+ self = (C_VALMEMHEAP *)pMemHeap;
+
+ return self->AlignMask + 1;
+}
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file valmemheap_free.c
+ * @brief %jp{可変サイズメモリヒープクラス}%en{variable size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "valmemheap_local.h"
+
+
+
+/** メモリのサイズ取得 */
+MEMSIZE ValMemHeap_GetSize(void *pMemHeap, void *pMem)
+{
+ C_VALMEMHEAP *self;
+ T_VALMEMHEAP_MEMBLK *mblk;
+ MEMSIZE MemBlockSize;
+
+ /* upper cast */
+ self = (C_VALMEMHEAP *)pMemHeap;
+
+ /* %jp{メモリブロックのサイズを調整} */
+ MemBlockSize = ValMemHeap_GetMemBlockSize(self);
+
+ /* %jp{ポインタ範囲チェック} */
+ if ( pMem < (void *)self->pMemBase || pMem >= (void *)((char *)self->pMemBase + self->MemSize) )
+ {
+ return 0; /* %jp{このメモリプールの所属でない} */
+ }
+
+ /* %jp{メモリブロック位置を取得} */
+ mblk = (T_VALMEMHEAP_MEMBLK *)((char *)pMem - MemBlockSize);
+
+ /* %jp{パラメーターチェック} */
+ if ( mblk->iFlag != VALMEMHEAP_USING ) /* %jp{使用中で無ければ} */
+ {
+ return 0; /* %jp{割り当ていない} */
+ }
+
+ /* %jp{サイズを返す} */
+ return mblk->Size;
+}
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file valmemheap_local.h
+ * @brief %jp{可変サイズメモリヒープクラス}%en{variable size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+
+#ifndef __HOS__valmemheap_local_h__
+#define __HOS__valmemheap_local_h__
+
+
+#include "library/container/memheap/memheap_local.h"
+
+
+#define VALMEMHEAP_USING 0x1234 /**< %jp{使用中} */
+#define VALMEMHEAP_FREE 0xabcd /**< %jp{未使用} */
+
+
+/** %jp{ヒープメモリブロック} */
+typedef struct t_valmemheap_memblk
+{
+ struct t_valmemheap_memblk* pPrev; /**< %jp{前のブロック} */
+ MEMSIZE Size; /**< %jp{ブロックのサイズ} */
+ int iFlag; /**< %jp{使用中フラグ} */
+} T_VALMEMHEAP_MEMBLK;
+
+
+/** %jp{ValMemHeapクラス}%en{ValMemHeap class} */
+typedef struct c_valmemheap
+{
+ C_MEMHEAP MemHeap; /* 継承 */
+
+ T_VALMEMHEAP_MEMBLK *pMemBase; /**< %jp{メモリ先頭ブロックのアドレス} */
+ MEMSIZE MemSize; /**< %jp{メモリサイズ} */
+ int AlignMask; /**< %jp{メモリアライメントサイズ} */
+} C_VALMEMHEAP;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void ValMemHeap_Constructor(C_VALMEMHEAP *self, void *pMemBase, MEMSIZE MemSize, int AlignSize);
+#define ValMemHeap_Destructor(self) do { } while (0)
+
+void *ValMemHeap_Alloc(void *pMemHeap, MEMSIZE Size); /**< メモリの割り当て */
+void *ValMemHeap_ReAlloc(void *pMemHeap, void *pMem, MEMSIZE Size); /**< メモリの再割り当て */
+void ValMemHeap_Free(void *pMemHeap, void *pMem); /**< メモリの開放 */
+MEMSIZE ValMemHeap_GetSize(void *pMemHeap, void *pMem); /**< メモリのサイズ取得 */
+MEMSIZE ValMemHeap_GetAlign(void *pMemHeap); /**< メモリアライメントの取得 */
+MEMSIZE ValMemHeap_AlignSize(void *pMemHeap, MEMSIZE Size); /**< サイズをアライメント単位に拡張 */
+
+#define ValMemHeap_GetMemBlockSize(self) (ValMemHeap_AlignSize((self), sizeof(T_VALMEMHEAP_MEMBLK)))
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif /* __HOS__valmemheap_local_h__ */
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file valmemheap_alloc.c
+ * @brief %jp{可変サイズメモリヒープクラス}%en{variable size memory heap class}
+ *
+ * Copyright (C) 2006-2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include <string.h>
+#include "valmemheap_local.h"
+
+
+
+/** %jp{メモリの再割り当て} */
+void *ValMemHeap_ReAlloc(void *pMemHeap, void *pMem, MEMSIZE Size)
+{
+ C_VALMEMHEAP *self;
+ void *pNewMem;
+
+ /* upper cast */
+ self = (C_VALMEMHEAP *)pMemHeap;
+
+ /* とりあえず手抜き */
+ if ( (pNewMem = ValMemHeap_Alloc(self, Size)) != NULL )
+ {
+ memcpy(pNewMem, pMem, ValMemHeap_GetSize(self, pMem));
+ ValMemHeap_Free(self, pMem);
+ }
+
+ return pNewMem;
+}
+
+
+/* end of file */
/*************************/
/* システム初期化 */
- SysInf.pHeapMem = g_SystemHeap;
- SysInf.HeapSize = sizeof(g_SystemHeap);
+ memset(&SysInf, 0, sizeof(SysInf));
+ SysInf.pSysMemBase = g_SystemHeap;
+ SysInf.SysMemSize = sizeof(g_SystemHeap);
+ SysInf.SysMemAlign = 8;
+ SysInf.pIoMemBase = NULL;
SysInf.SystemStackSize = 1024;
SysInf.pfncBoot = Boot_Process;
SysInf.BootParam = (VPARAM)0;
/*************************/
/* システム初期化 */
- SysInf.pHeapMem = g_SystemHeap;
- SysInf.HeapSize = sizeof(g_SystemHeap);
+ memset(&SysInf, 0, sizeof(SysInf));
+ SysInf.pSysMemBase = g_SystemHeap;
+ SysInf.SysMemSize = sizeof(g_SystemHeap);
+ SysInf.SysMemAlign = 4;
+ SysInf.pIoMemBase = NULL;
SysInf.SystemStackSize = 1024;
SysInf.pfncBoot = Boot_Process;
SysInf.BootParam = (VPARAM)0;
/*************************/
Process_SetTerminal(HANDLE_NULL, hTty);
- Process_SetConsole(HANDLE_NULL, hCon);
+ Process_SetConIn(HANDLE_NULL, hCon);
+ Process_SetConOut(HANDLE_NULL, hCon);
Process_SetStdIn(HANDLE_NULL, hCon);
Process_SetStdOut(HANDLE_NULL, hCon);
Process_SetStdErr(HANDLE_NULL, hCon);
/*************************/
/* システム初期化 */
- SysInf.pHeapMem = g_SystemHeap;
- SysInf.HeapSize = sizeof(g_SystemHeap);
+ SysInf.pSysMemBase = g_SystemHeap;
+ SysInf.SysMemSize = sizeof(g_SystemHeap);
+ SysInf.SysMemAlign = 32;
+ SysInf.pIoMemBase = NULL;
SysInf.SystemStackSize = 2048;
SysInf.pfncBoot = Boot_Process;
SysInf.BootParam = (VPARAM)0;
/*************************/
/* システム初期化 */
- SysInf.pHeapMem = (void *)g_uwSystemHeap;
- SysInf.HeapSize = sizeof(g_uwSystemHeap);
+ SysInf.pSysMemBase = (void *)g_uwSystemHeap;
+ SysInf.SysMemSize = sizeof(g_uwSystemHeap);
+ SysInf.SysMemAlign = 4;
+ SysInf.pIoMemBase = NULL;
SysInf.SystemStackSize = 256;
SysInf.pfncBoot = Boot_Process;
SysInf.BootParam = (VPARAM)0;
/*************************/
Process_SetTerminal(HANDLE_NULL, hTty);
- Process_SetConsole(HANDLE_NULL, hCon);
+ Process_SetConIn(HANDLE_NULL, hCon);
+ Process_SetConOut(HANDLE_NULL, hCon);
Process_SetStdIn(HANDLE_NULL, hCon);
Process_SetStdOut(HANDLE_NULL, hCon);
Process_SetStdErr(HANDLE_NULL, hCon);
return 0;
}
-/*
-int putc(int c, FILE *stream)
-{
- return c;
-}
-*/
/* end of file */
/*************************/
/* システム初期化 */
- SysInf.pHeapMem = (void *)0x00440000;
- SysInf.HeapSize = 0x40000;
+ memset(&SysInf, 0, sizeof(SysInf));
+ SysInf.pSysMemBase = (void *)0x00440000;
+ SysInf.SysMemSize = 0x40000;
+ SysInf.SysMemAlign = 4;
+ SysInf.pIoMemBase = NULL;
SysInf.SystemStackSize = 1024;
SysInf.pfncBoot = Boot_Process;
SysInf.BootParam = (VPARAM)0;
/*************************/
Process_SetTerminal(HANDLE_NULL, hTty);
- Process_SetConsole(HANDLE_NULL, hCon);
+ Process_SetConIn(HANDLE_NULL, hCon);
+ Process_SetConOut(HANDLE_NULL, hCon);
Process_SetStdIn(HANDLE_NULL, hCon);
Process_SetStdOut(HANDLE_NULL, hCon);
Process_SetStdErr(HANDLE_NULL, hCon);
void Command_Initialize(void)
{
/* システムメモリを使う連想配列を生成 */
- Assoc_CreateEx(&Command_Assoc, SysMem_GetMemIf());
+ Assoc_CreateEx(&Command_Assoc, SysMem_GetMemHeap());
}
/* コマンドを登録する */
SysMem_Free(pMem);
}
+
+/* メモリヒープクラスの取得(ユーザー用) */
+C_MEMHEAP *Memory_GetMemHeap(void)
+{
+ return SysMem_GetMemHeap();
+}
+
#ifndef __HOS__memory_h__
#define __HOS__memory_h__
-#include "library/container/memif/memif.h"
+
+#include "library/container/memheap/memheap.h"
#ifdef __cplusplus
extern "C" {
#endif
-void *Memory_Alloc(long lSize); /* メモリの割り当て */
-void Memory_Free(void *pMem); /* メモリの割り当て */
-C_MEMIF *Memory_GetMemIf(void); /* メモリインターフェースの取得 */
+void *Memory_Alloc(long lSize); /* メモリの割り当て */
+void Memory_Free(void *pMem); /* メモリの割り当て */
+C_MEMHEAP *Memory_GetMemHeap(void); /* メモリインターフェースの取得 */
#ifdef __cplusplus
#include "system/type/type.h"
-#include "library/container/memif/memif.h"
+#include "library/container/memheap/memheap.h"
/* プロセスハンドル(システム用) */
#endif
/* 初期化 */
-void SysApi_Initialize(void *pMem, MEMSIZE lSize); /**< システムの初期化処理 */
+void SysApi_Initialize(void *pMem, MEMSIZE MemSize, MEMSIZE MemAlign, void *pIoMem, MEMSIZE IoMemSize, MEMSIZE IoMemAlign);
+ /**< システムの初期化処理 */
/* システム状態取得 */
int SysCtx_IsIsr(void); /**< ISRコンテキストかどうか調べる(システム用) */
void *SysMem_ReAlloc(void *pMem, MEMSIZE Size); /**< メモリの再割り当て(システム用) */
void SysMem_Free(void *pMem); /**< メモリの返却(システム用) */
MEMSIZE SysMem_GetSize(void *pMem); /**< メモリのサイズ取得(システム用) */
-C_MEMIF *SysMem_GetMemIf(void); /**< メモリインターフェースの取得(システム用) */
-
-/* システムによっては特定アドレス範囲にしかDMAが使えなかったり、非キャッシュ領域が必要なので別途設ける */
-void *SysMem_AllocIoMem(MEMSIZE Size); /**< I/O操作に適したメモリの割り当て(システム用) */
-void SysMem_FreeIoMem(void *pMem); /**< I/O操作に適したメモリの返却(システム用) */
+C_MEMHEAP *SysMem_GetMemHeap(void); /**< メモリインターフェースの取得(システム用) */
/* システム用割り込み制御API */
#define SysIo_XorPortW(Port, Data) (*(volatile unsigned long *)(Port) ^= (unsigned long)(Data))
#endif
+/* システムによっては特定アドレス範囲にしかDMAが使えなかったり、非キャッシュ領域が必要なので別途設ける */
+void *SysIo_AllocIoMem(MEMSIZE Size); /**< I/O操作に適したメモリの割り当て(システム用) */
+void SysIo_FreeIoMem(void *pMem); /**< I/O操作に適したメモリの返却(システム用) */
+
#ifdef __cplusplus
}
#include "kernel.h"
-SYSMTX_HANDLE SysMem_hMtx; /* システムメモリ管理用ミューテックス */
-C_MEMPOL SysMem_MemPol; /* システムヒープメモリ */
-T_SYSPRC_INF *SysPrc_InfTbl; /* プロセス管理用テーブル */
-T_SYSISR_INF *SysIsr_InfTbl; /* ISR管理用テーブル */
+SYSMTX_HANDLE SysMem_hMtx; /* システムメモリ管理用ミューテックス */
+C_VALMEMHEAP SysMem_ValMemHeap; /* システムヒープメモリ */
+
+SYSMTX_HANDLE SysIo_hMtx; /* I/O用ヒープメモリ管理用ミューテックス */
+C_VALMEMHEAP *SysIo_pValMemHeap = NULL; /* I/O用ヒープメモリ */
+
+T_SYSPRC_INF *SysPrc_InfTbl; /* プロセス管理用テーブル */
+T_SYSISR_INF *SysIsr_InfTbl; /* ISR管理用テーブル */
+
/* システムの初期化 */
-void SysApi_Initialize(void *pMem, MEMSIZE Size)
+void SysApi_Initialize(void *pMem, MEMSIZE MemSize, MEMSIZE MemAlign, void *pIoMem, MEMSIZE IoMemSize, MEMSIZE IoMemAlign)
{
/* メモリ管理の初期化 */
- SysMem_hMtx = SysMtx_Create(SYSMTX_ATTR_NORMAL); /* メモリ管理用排他制御用ミューテックス生成 */
- MemPol_Create(&SysMem_MemPol, pMem, Size); /* メモリプール生成 */
+ SysMem_hMtx = SysMtx_Create(SYSMTX_ATTR_NORMAL); /* メモリ管理用排他制御用ミューテックス生成 */
+ ValMemHeap_Constructor(&SysMem_ValMemHeap, pMem, MemSize, MemAlign); /* メモリヒープ生成 */
/* プロセス管理テーブルメモリ確保 */
SysPrc_InfTbl = (T_SYSPRC_INF *)SysMem_Alloc(sizeof(T_SYSPRC_INF) * (_kernel_max_tskid + 1));
/* ISR管理テーブルメモリ確保 */
SysIsr_InfTbl = (T_SYSISR_INF *)SysMem_Alloc(sizeof(T_SYSPRC_INF) * (_kernel_max_intno - _kernel_min_intno + 1));
memset(SysIsr_InfTbl, 0, sizeof(T_SYSPRC_INF) * (_kernel_max_intno - _kernel_min_intno + 1));
+
+ /* I/O用メモリ管理 */
+ if ( pIoMem != NULL )
+ {
+ SysIo_hMtx = SysMtx_Create(SYSMTX_ATTR_NORMAL); /* メモリ管理用排他制御用ミューテックス生成 */
+ SysIo_pValMemHeap = SysMem_Alloc(sizeof(C_VALMEMHEAP));
+ ValMemHeap_Constructor(SysIo_pValMemHeap, pIoMem, IoMemSize, IoMemAlign); /* メモリヒープ生成 */
+ }
}
#include "kernel.h"
#include "sysapi.h"
-#include "library/container/mempol/mempol.h"
+#include "library/container/valmemheap/valmemheap_local.h"
/* HOS-V4a 内部変数の参照(インチキ) */
} T_SYSISR_INF;
extern SYSMTX_HANDLE SysMem_hMtx; /* システムメモリ管理用ミューテックス */
-extern C_MEMPOL SysMem_MemPol; /* システムヒープメモリ */
+extern C_VALMEMHEAP SysMem_ValMemHeap; /* システムヒープメモリ */
+extern SYSMTX_HANDLE SysIo_hMtx; /* I/O用ヒープメモリ管理用ミューテックス */
+extern C_VALMEMHEAP *SysIo_pValMemHeap; /* I/O用ヒープメモリ */
extern T_SYSPRC_INF *SysPrc_InfTbl; /* プロセス管理用テーブル */
extern T_SYSISR_INF *SysIsr_InfTbl; /* ISR管理用テーブル */
extern SYSTIM_CPUTIME SysTim_TimeCounter; /* デフォルトのタイマカウンタ */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file system.h
+ * @brief %jp{システム用API定義}
+ *
+ * Copyright (C) 2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include <stdio.h>
+#include "sysapi_local.h"
+
+
+/* I/O用メモリのの割り当て */
+void *SysIo_AllocIoMem(MEMSIZE Size)
+{
+ void *pMem;
+
+ /* 通常メモリと兼用 */
+ if ( SysIo_pValMemHeap == NULL )
+ {
+ return SysMem_Alloc(Size);
+ }
+
+ /* I/O専用領域から割り当て */
+ SysMtx_Lock(SysIo_hMtx);
+ pMem = ValMemHeap_Alloc(SysIo_pValMemHeap, Size);
+ SysMtx_Unlock(SysIo_hMtx);
+
+ return pMem;
+}
+
+
+/* end of file */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file system.h
+ * @brief %jp{システム用API定義}
+ *
+ * Copyright (C) 2008 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include "sysapi_local.h"
+
+
+/* I/O用メモリの返却 */
+void SysIo_FreeIoMem(void *pMem)
+{
+ /* 通常メモリと兼用 */
+ if ( SysIo_pValMemHeap == NULL )
+ {
+ SysMem_Free(pMem);
+ return;
+ }
+
+ /* I/O専用領域を返却 */
+ SysMtx_Lock(SysIo_hMtx);
+ ValMemHeap_Free(SysIo_pValMemHeap, pMem);
+ SysMtx_Unlock(SysIo_hMtx);
+}
+
+
+
+/* end of file */
void *pMem;
SysMtx_Lock(SysMem_hMtx);
- pMem = MemPol_Alloc(&SysMem_MemPol, Size);
+ pMem = ValMemHeap_Alloc(&SysMem_ValMemHeap, Size);
SysMtx_Unlock(SysMem_hMtx);
return pMem;
+++ /dev/null
-/**
- * Hyper Operating System Application Framework
- *
- * @file system.h
- * @brief %jp{システム用API定義}
- *
- * Copyright (C) 2006 by Project HOS
- * http://sourceforge.jp/projects/hos/
- */
-
-
-#include "sysapi_local.h"
-
-
-/* I/O用メモリのの割り当て(必要に応じてオーバーライドすること) */
-void *SysMem_AllocIoMem(MEMSIZE Size)
-{
- return SysMem_Alloc(Size);
-}
-
-
-/* end of file */
void SysMem_Free(void *pMem)
{
SysMtx_Lock(SysMem_hMtx);
- MemPol_Free(&SysMem_MemPol, pMem);
+ ValMemHeap_Free(&SysMem_ValMemHeap, pMem);
SysMtx_Unlock(SysMem_hMtx);
}
#include "sysapi_local.h"
-/* I/O用メモリの返却(必要に応じてオーバーライドすること) */
-void SysMem_FreeIoMem(void *pMem)
+
+/* %jp{メモリインターフェースの取得} */
+C_MEMHEAP *SysMem_GetMemHeap(void)
{
- SysMem_Free(pMem);
+ return (C_MEMHEAP *)&SysMem_ValMemHeap;
}
-
/* end of file */
+++ /dev/null
-/**
- * Hyper Operating System Application Framework
- *
- * @file system.h
- * @brief %jp{システム用API定義}
- *
- * Copyright (C) 2006 by Project HOS
- * http://sourceforge.jp/projects/hos/
- */
-
-
-#include "sysapi_local.h"
-
-
-static const C_MEMIF SysMem_MemIf =
-{
- SysMem_Alloc,
- SysMem_ReAlloc,
- SysMem_Free,
- SysMem_GetSize,
-};
-
-
-/* %jp{メモリインターフェースの取得} */
-C_MEMIF *SysMem_GetMemIf(void)
-{
- return (C_MEMIF *)&SysMem_MemIf;
-}
-
-
-/* end of file */
{
MEMSIZE Size;
SysMtx_Lock(SysMem_hMtx);
- Size = MemPol_GetSize(&SysMem_MemPol, pMem);
+ Size = ValMemHeap_GetSize(&SysMem_ValMemHeap, pMem);
SysMtx_Unlock(SysMem_hMtx);
return Size;
void *SysMem_ReAlloc(void *pMem, MEMSIZE Size)
{
SysMtx_Lock(SysMem_hMtx);
- pMem = MemPol_ReAlloc(&SysMem_MemPol, pMem, Size);
+ pMem = ValMemHeap_ReAlloc(&SysMem_ValMemHeap, pMem, Size);
SysMtx_Unlock(SysMem_hMtx);
return pMem;
/* システム初期化情報 */
typedef struct t_system_initialize_inf
{
- void *pHeapMem; /**< システムヒープメモリに割り当てる領域の先頭アドレス */
- MEMSIZE HeapSize; /**< システムヒープメモリのサイズ */
+ void *pSysMemBase; /**< システムヒープメモリに割り当てる領域の先頭アドレス */
+ MEMSIZE SysMemSize; /**< システムヒープメモリのサイズ */
+ MEMSIZE SysMemAlign; /**< システムヒープメモリのアライメント単位 */
+
+ void *pIoMemBase; /**< I/O用のヒープメモリ領域 */
+ MEMSIZE IoMemSize; /**< I/O用のヒープメモリ領域サイズ */
+ MEMSIZE IoMemAlign; /**< I/O用のヒープメモリのアライメント単位 */
MEMSIZE SystemStackSize; /**< システムプロセスに割り当てるスタックサイズ */
--- /dev/null
+/**
+ * Hyper Operating System Application Framework
+ *
+ * @file system.h
+ * @brief %jp{システム用API定義}
+ *
+ * Copyright (C) 2006-2007 by Project HOS
+ * http://sourceforge.jp/projects/hos/
+ */
+
+
+#include "system/system/system_local.h"
+
+
+
+/* システムプロセスを得る */
+HANDLE System_GetSystemProcess(void)
+{
+ return (HANDLE)&g_System.Process;
+}
+
+
+
+/* end of file */
self = &g_System;
/* システムAPIの初期化 */
- SysApi_Initialize(pInf->pHeapMem, pInf->HeapSize);
-
+ SysApi_Initialize(pInf->pSysMemBase, pInf->SysMemSize, pInf->SysMemAlign,
+ pInf->pIoMemBase, pInf->IoMemSize, pInf->IoMemAlign);
+
/* ファイルシステム初期化 */
File_Initialize();
}
-/* システムプロセスを得る */
-HANDLE System_GetSystemProcess(void)
-{
- return (HANDLE)&g_System.Process;
-}
-
-
/* end of file */
OSDN Git Service
