Changeset 3df5b10 in git for omalloc

Timestamp:

Aug 14, 2000, 2:08:48 PM (24 years ago)

Author:

Olaf Bachmann <obachman@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

9d605984360cf5d30bdf13e295d63c41ae1bc952

Parents:

ecf4ca6ad75f235385946daeae249f3bc6fd13c8

Message:

* update


git-svn-id: file:///usr/local/Singular/svn/trunk@4516 2c84dea3-7e68-4137-9b89-c4e89433aadc

Location:

omalloc

Files:

• Makefile.in (modified) (17 diffs)
• configure.in (modified) (11 diffs)
• makeheader.pl (modified) (7 diffs)
• omAlloc.c (modified) (8 diffs)
• omAlloc.h (modified) (2 diffs)
• omConfig.h.in (modified) (6 diffs)
• omDebug.c (modified) (7 diffs)
• omDebug.h (modified) (1 diff)
• omFindExec.c (modified) (9 diffs)
• omFindExec.h (modified) (1 diff)
• omList.c (modified) (2 diffs)
• omList.h (modified) (6 diffs)
• omMemOps.h (modified) (10 diffs)
• omPage.h (modified) (2 diffs)
• omTables.c (modified) (8 diffs)
• omtTest.c (added)
• omtTest.h (added)
• omtTestAlloc.c (added)
• omtTestDebug.c (added)
• omtTestError.c (added)
• omtTestReal.c (added)

omalloc/Makefile.in

@@ -4 +4 @@
 ### Author:  obachman@mathematik.uni-kl.de (Olaf Bachmann)
 ### Created: 11/99
-### Version: $Id: Makefile.in,v 1.3 2000-05-31 13:34:28 obachman Exp $
+### Version: $Id: Makefile.in,v 1.4 2000-08-14 12:08:40 obachman Exp $
 #################################################################
 
 SHELL           = /bin/sh
+VERSION         = @VERSION@
 
 ##
 ## various paths
 ##
+prefix          = @prefix@
+exec_prefix     = @exec_prefix@
+
 # header file is installed here
 includedir      = @includedir@
@@ -26 +30 @@
 PERL            = @PERL@
 LN_S            = @LN_S@
-INSTALL         = ../install-sh -c
-INSTALL_PROGRAM = ${INSTALL}
-INSTALL_DATA    = ${INSTALL} -m 644
-MKINSTALLDIRS   = ../mkinstalldirs
+INSTALL         = @INSTALL@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@ 
+INSTALL_DATA    = @INSTALL_DATA@
+MKINSTALLDIRS   = ./mkinstalldirs
 ##
 ## compiler and linker options
 ##
 CFLAGS          = @CFLAGS@ 
-# CFLAGS                = @CFLAGS@  -Wno-unused
-CPPFLAGS        = @CPPFLAGS@
-DEFS            = -DNDEBUG @DEFS@
+CPPFLAGS        = -I. @CPPFLAGS@
+DEFS            = @DEFS@
 
 ##
 ## external config and and malloc files
 ##
-
+EXTERNAL_CONFIG_SOURCE = @EXTERNAL_CONFIG_SOURCE@
 EXTERNAL_CONFIG_HEADER = @EXTERNAL_CONFIG_HEADER@
-EXTERNAL_CONFIG_SOURCE = @EXTERNAL_CONFIG_SOURCE@
 
 OM_MALLOC_HEADER = @OM_MALLOC_HEADER@
@@ -56 +58 @@
 ###
 
-
 # normal C source files
-CSOURCES=                                                       \
-omBinPage.c      omList.c         omAllocEmulate.c              \
-omAlloc.c        omCheck.c        omOpts.c         omTrack.c    \
-omAllocSystem.c  omError.c        omStats.c                     \
-omBin.c          omFindExec.c     omDebug.c
+CSOURCES=                                                          \
+omBinPage.c      omList.c         omAllocEmulate.c omDebug.c       \
+omAlloc.c        omDebugCheck.c   omOpts.c         omGetBackTrace.c\
+omAllocSystem.c  omError.c        omStats.c        omRet2Info.c   \
+omBin.c          omFindExec.c     omDebugTrack.c                   \
+omalloc_provide.c         
 
 ifdef EXTERNAL_CONFIG_SOURCE
@@ -75 +77 @@
 
 HEADERS=                                                        \
-omAlloc.h              omCheck.h              omList.h          \
+omAlloc.h              omList.h               omDerivedConfig.h \
 omAllocDecl.h          omConfig.h             omMemOps.h        \
-omDebug.h              omOpts.h                                 \
+omDebug.h              omOpts.h               omInlineDecl.h    \
 omAllocPrivate.h       omError.h              omPage.h          \
 omAllocSystem.h        omFindExec.h           omStats.h         \
 omBin.h                omDefaultConfig.h      omStructs.h       \
-omBinPage.h            omInline.h             omTrack.h         \
-
-OBJS := $(CSOURCES:.c=.o)  $(GSOURCES:.c=.o)
-
+omBinPage.h            omInline.h             omGetBackTrace.h  \
+omReturn.h             omRet2Info.h             
+
+OBJS := $(CSOURCES:.c=.o)  $(GSOURCES:.c=.o) 
+OBJS_NDEBUG := $(CSOURCES:.c=.o_ndebug) $(GSOURCES:.c=.o_ndebug) 
 
 SOURCES=${CSOURCES} omGetPageSize.h omMallocSystem.h gmalloc.c dlmalloc.h dlmalloc.c \
-        omMmap.c gmalloc.c omTables.c ommalloc.c pmalloc.h pmalloc.c
+        omMmap.c gmalloc.c omTables.c pmalloc.h pmalloc.c omalloc.c omalloc_debug.c  \
+        $(TESTSOURCES) omtTestAlloc.c 
 
 ASO_OBJS := $(ASO_SOURCES:.aso.cc=.aso) 
 
-DISTFILES=$(SOURCES) $(HEADERS) makeheader.pl Makefile.in \
-           omConfig.h.in
+DISTFILES=$(SOURCES) $(HEADERS) omtTest.h makeheader.pl Makefile.in \
+           omConfig.h.in configure.in mkinstalldirs install-sh configure 
+
 ##
 ## Build Targets
 ##
-
-%.o: %.c omConfig.h omTables.inc
+%.o: %.c omConfig.h omTables.h omalloc.h omTables.inc
         ${CC} ${CFLAGS} ${CPPFLAGS} ${DEFS} -c $<
+
+%.o_ndebug: %.c omConfig.h omTables.h omalloc.h omTables.inc
+        ${CC} ${CFLAGS} ${CPPFLAGS} ${DEFS} -DOM_NDEBUG -c $< -o $@
 
 %.aso.o: %.aso.cc mmtables.inc 
@@ -107 +114 @@
         ./$< > $@
 
-all:    lib libomalloc.h libg
+all:    libomalloc.a libomalloc_ndebug.a omalloc.h omalloc.o omalloc_debug.o
 
 lib: libomalloc.a
@@ -116 +123 @@
         $(RANLIB) $@
 
-libomalloc.h: $(HEADERS) 
-        $(PERL) makeheader.pl omAlloc.h $@
+libomalloc_ndebug.a: $(OBJS_NDEBUG) Makefile omConfig.h
+        rm -f $@
+        $(AR) cr $@ $(OBJS_NDEBUG) 
+        $(RANLIB) $@
+
+omalloc.h: $(HEADERS) 
+        $(PERL) makeheader.pl -a omAlloc.h $@
+
+omalloc.o: omalloc.c
+        ${CC} ${CFLAGS} ${CPPFLAGS} ${DEFS} -DOM_NDEBUG -c $< -o $@
+
+omalloc_debug.o: omalloc_debug.c 
+        ${CC} ${CFLAGS} ${CPPFLAGS} ${DEFS} -c $< -o $@
 
 omTables.inc: omTables
         ./omTables > $@
 
-omTables: omAlloc.h omMalloc.h omConfig.h omTables.c
+omTables.h: omTables
+        ./omTables 1 >$@
+
+omTables: omAllocPrivate.h omConfig.h omTables.c
         ${CC} ${CFLAGS} ${CPPFLAGS} ${DEFS} -DOM_GENERATE_INC omTables.c -o omTables
 
@@ -138 +159 @@
         cp $(EXTERNAL_CONFIG_SOURCE) omExternalConfig.c
 endif
+
 ifdef EXTERNAL_CONFIG_HEADER
-omExternalConfig.h: ${EXTERNAL_CONFIG_HEADER}
-        rm -f omExternalConfig.h
-        cp ${EXTERNAL_CONFIG_HEADER} omExternalConfig.h
+omExternalConfig.h: $(EXTERNAL_CONFIG_HEADER)
+        cp $(EXTERNAL_CONFIG_HEADER) omExternalConfig.h
+omDerivedConfig.h: omExternalConfig.h
 endif
 
@@ -166 +188 @@
 ## install targets
 ##
-install: all
+install: all libomalloc_p.a
         $(MKINSTALLDIRS) $(libdir)
         $(MKINSTALLDIRS) $(includedir)
         $(INSTALL_DATA) libomalloc.a $(libdir)
         $(RANLIB) $(libdir)/libomalloc.a
-        $(INSTALL_DATA) libmalloc.h $(includedir)/omAlloc.h
+        $(INSTALL_DATA) libomalloc_ndebug.a $(libdir)
+        $(RANLIB) $(libdir)/libomalloc_ndebug.a
+        $(INSTALL_DATA) libomalloc_p.a $(libdir)
+        $(RANLIB) $(libdir)/libomalloc_p.a
+        $(INSTALL_DATA) omalloc.o omalloc_debug.o $(libdir)
+        $(INSTALL_DATA) omalloc.h omalloc.c $(includedir)
+
 
 uninstall: 
-        rm -f $(includedir)/omAlloc.h $(libdir)/libomalloc.a
+        rm -f $(includedir)/omalloc.h $(includedir)/omalloc.c
+        rm -f $(libdir)/libomalloc.a $(libdir)/libomalloc_ndebug.a $(libdir)/libomalloc_p.a $(libdir)/omalloc.o $(libdir)/omalloc_debug.o
+
+##
+## dist targets
+##
+dist: omalloc-$(VERSION).tgz
+omalloc-$(VERSION).tgz: $(DISTFILES)
+        rm -rf omalloc-$(VERSION)
+        mkdir omalloc-$(VERSION)
+        cp $(DISTFILES) omalloc-$(VERSION)
+        tar czf omalloc-$(VERSION).tgz omalloc-$(VERSION)
 
 ##
@@ -180 +219 @@
 ##
 mostlyclean: 
-        -rm -f core *.d *.o *.og *.op *_d.c *.ob *.a depend *.out *.tgz omTables
-        -rm -f omTest omTest_* libomalloc*
-        -rm -f omMalloc.c omMalloc.h omExternalConfig.h omExternalConfig.c
+        -rm -f core *.d *.o *.og *.op *_d.c *.ob *.a depend *.out *.tgz omTables *.o_ndebug *.gp *.gprof
+        -rm -f omtTest omtTest_* libomalloc* *.bprof omtTest omtTest_*
+        -rm -f omMalloc.c omExternalConfig.h omExternalConfig.c
 
 clean: mostlyclean
 
 distclean: clean
-        -rm -f  *~ .\#*  stamp-h configure
+        -rm -f  *~ .\#*  stamp-h configure omMalloc.h
+        rm -rf omalloc-$(VERSION)
         -rm -f omConfig.h Makefile TAGS* tags config.status config.cache config.log
 
@@ -201 +241 @@
 
 ##
+## check
+##
+
+check: omtTest omtTest_ndebug
+        ./omtTest
+        ./omtTest_ndebug
+
+##
 ## Below here is stuff for developpers
 #################################################################
@@ -211 +259 @@
 CCM             = gcc -MM -DGENERATE_DEPEND
 
-CFLAGSG         = -g -O -Wall -pipe
+CFLAGSG         = -g -O -fno-inline-functions -Wall -pipe
 DEFSG           =  @DEFS@
 
 OBJG := $(CSOURCES:.c=.og) $(GSOURCES:.c=.og)
 
-%.og: %.c
+%.og: %.c omConfig.h omTables.h omalloc.h
         $(CCG) ${CFLAGSG} ${CPPFLAGS} ${DEFSG} -c $< -o $@
 
@@ -228 +276 @@
 
 ##
-## expnaded macros
-##
-OBJD := $(CSOURCES:%.c=%_d.og) 
-
-%_d.c : %.c omConfig.h
+## expanded macros
+##
+OBJD := $(CSOURCES:%.c=%_d.og) $(GSOURCES:%.c=%_d.og)
+
+%_d.c : %.c omConfig.h omTables.h omalloc.h
         $(CCG) -E -P $< | $(PERL) -p -e 's/;/;\n/g' | $(PERL) -p -e 's/\{/\n\{/g' | $(PERL) -p -e 's/\}/\n\}/g' > $@
 .PRECIOUS: %_d.c
@@ -249 +297 @@
 CCP             = gcc
 
-CFLAGSP         = -g -pg -O3 -a -pipe
+CFLAGSP         = -g -pg -O3 -a -pipe 
 DEFSP           =  @DEFS@
 
@@ -258 +306 @@
 ## Profile Targets
 ##
-%.op: %.c
+%.op: %.c omConfig.h omTables.h omalloc.h
         $(CCP) ${CFLAGSP} ${CPPFLAGS} ${DEFSP} -c $< -o $@
 
@@ -274 +322 @@
 CCB             = gcc
 
-CFLAGSB         = -g -O3 -pipe
+CFLAGSB         = -g -O3 -pipe 
 DEFSB           =  @DEFS@
 
@@ -286 +334 @@
 ## Profile Targets
 ##
-%.ob: %.c
+%.ob: %.c omConfig.h omTables.h omalloc.h
         $(CCB) ${CFLAGSB} ${CPPFLAGS} ${DEFSB} -c $< -o $@
 
@@ -299 +347 @@
 ## Test program
 ##
-
-omTest_d: libd omTest_d.c omTest.d
-        $(CCG) ${CFLAGSG} ${CPPFLAGS} ${DEFSG} omTest_d.c -L. -lomalloc_d -o omTest_d
-
-omTest_g: libg omTest.c omTest.d
-        $(CCG) ${CFLAGSG} ${CPPFLAGS} ${DEFSG} omTest.c -L. -lomalloc_g -o omTest_g
-
-
-omTest_p: libp omTest.c omTest.d
-        $(CCP) ${CFLAGSP} ${CPPFLAGS} ${DEFSP} omTest.c -L. -lomalloc_p -o omTest_p
-
-omTest_b: libb omTest.c omTest.d
-        $(CCB) ${CFLAGSB} ${CPPFLAGS} ${DEFSB} omTest.c /usr/lib/bmon.o -L. -lomalloc_b -o omTest_b
-
-omTest: lib omTest.c omTest.d
-        $(CC) ${CFLAGS} ${CPPFLAGS} ${DEFS} omTest.c -L. -lomalloc -o omTest
-
-omTest_m: lib omTest.c omTest.d
-        $(CC) ${CFLAGS} ${CPPFLAGS} ${DEFS} -DOM_TEST_MALLOC omTest.c -L. -lomalloc -o omTest_m
-
-##
-## tar and backup
-##
-
-tar:
-        tar czvf omalloc.tgz $(DISTFILES)
-
-backup: tar
-        mcopy omalloc.tgz a:
+TESTSOURCES     = omtTest.c omtTestReal.c omtTestDebug.c omtTestError.c
+
+TEST_D := $(TESTSOURCES:.c=_d.og) 
+omtTest_d: libd $(TEST_D) 
+        $(CCG) ${CFLAGSG} ${CPPFLAGS} ${DEFSG} $(TEST_D) -L. -lomalloc_d -o omtTest_d
+
+TEST_G := $(TESTSOURCES:.c=.og) 
+omtTest_g: libg $(TEST_G)
+        $(CCG) ${CFLAGSG} ${CPPFLAGS} ${DEFSG} $(TEST_G) -L. -lomalloc_g -o omtTest_g
+
+TEST_P := $(TESTSOURCES:.c=.op) 
+omtTest_p: libp $(TEST_P)
+        $(CCG) ${CFLAGSP} ${CPPFLAGS} ${DEFSP} $(TEST_P) -L. -lomalloc_p -o omtTest_p
+
+TEST_B := $(TESTSOURCES:.c=.ob) 
+omtTest_b: libb $(TEST_B)
+        $(CCG) ${CFLAGSB} ${CPPFLAGS} ${DEFSB} $(TEST_B) -L. -lomalloc_b  /usr/lib/bmon.o -o omtTest_b
+
+TEST_O := $(TESTSOURCES:.c=.o) 
+omtTest: lib  $(TEST_O)
+        $(CC) ${CFLAGS} ${CPPFLAGS} ${DEFS} $(TEST_O) -L. -lomalloc -o omtTest
+
+TEST_NDEBUG_O := $(TESTSOURCES:.c=.o_ndebug)
+omtTest_ndebug: libomalloc_ndebug.a $(TEST_NDEBUG_O)
+        $(CC) ${CFLAGS} ${CPPFLAGS} ${DEFS} $(TEST_NDEBUG_O) -DOM_NDEBUG -L. -lomalloc_ndebug -o omtTest_ndebug
+
+%.om : %.c omalloc.h
+        $(CC) ${CFLAGS} ${CPPFLAGS} ${DEFS} -DOM_TEST_MALLOC -c $< -o $@
+TEST_M := $(TESTSOURCES:.c=.om)
+omtTest_m: lib $(TEST_M) 
+        $(CC) ${CFLAGS} ${CPPFLAGS} ${DEFS} -DOM_TEST_MALLOC $(TEST_M) -L. -lomalloc -o omtTest_m
+
+##
+## backup
+##
+
+backup: omalloc-$(VERSION).tgz
+        mcopy -o omalloc-$(VERSION).tgz a:
 
 ##
 ## Dependencies 
 ## 
-%.d: %.c omConfig.h Makefile
-        echo $(@:.d=.og) $(@:.d=.od)  $(@:.d=.ob) $(@:.d=_d.c)" " \\ > $@
+%.d: %.c omConfig.h Makefile omTables.h omTables.inc omalloc.h
+        echo $(@:.d=.o_ndebug) $(@:.d=.og) $(@:.d=.od)  $(@:.d=.op) $(@:.d=.ob) $(@:.d=_d.c) $(@:.d=.om)" " \\ > $@
         $(CCM) ${CPPFLAGS} ${DEFSG} $< >> $@
 
-depend:   omTest.d $(CSOURCES:.c=.d) omConfig.h 
+depend:   $(CSOURCES:.c=.d) omConfig.h $(TESTSOURCES:.c=.d)
         cat *.d >depend
 

omalloc/configure.in

@@ -4 +4 @@
 dnl Author:  obachman@mathematik.uni-kl.de (Olaf Bachmann)
 dnl Created: 11/99
-dnl Version: $Id: configure.in,v 1.3 2000-05-31 13:34:29 obachman Exp $
+dnl Version: $Id: configure.in,v 1.4 2000-08-14 12:08:42 obachman Exp $
 dnl lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
 
 AC_INIT(omAlloc.c)
+
+VERSION=0.9.5
+AC_SUBST(VERSION)
 
 dnl lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
@@ -13 +16 @@
 dnl
 AC_ARG_WITH(
-  external_config_h,
+  external-config_h,
   [ --with-external-config_h=HEADER_FILE
                     use HEADER_FILE for external configuration])
 AC_ARG_WITH(
-  external_config_c,
+  external-config_c,
   [ --with-external-config_c=C_FILE
                     use C_FILE for external implementations])
@@ -25 +28 @@
                     which malloc to use, default: dlmalloc ])
 AC_ARG_WITH(
-  external_malloc_h,
+  external-malloc_h,
   [ --with-external-malloc-h=HEADER_FILE
                     use HEADER_FILE for external malloc declaration])
 AC_ARG_WITH(
-  external_malloc_c,
-  [ --with-external-malloc-h=C_FILE
+  external-malloc_c,
+  [ --with-external-malloc-c=C_FILE
                     use C_FILE for external malloc implementation])
 AC_ARG_WITH(
@@ -37 +40 @@
                     how to get page-aligned memory, default: use first possible])
 AC_ARG_WITH(
-  provide_malloc,
-  [ --with-provide-malloc  
-                    provide ANSI-C conforming malloc/calloc/realloc/free])
-AC_ARG_WITH(
-  emulate_omalloc,
+  provide-malloc,
+  [ --with-provide-malloc=yes|debug|malloc
+                    provide normal|debug|underlying malloc ANSI-C conforming 
+                    versions of malloc|calloc|realloc|free])
+AC_ARG_WITH(
+  emulate-omalloc,
   [ --with-emulate-omalloc
                     provide only omallocs interface, but do not use its features])
@@ -50 +54 @@
                     default: if possible sloppy, else strict])
 AC_ARG_WITH(
-  dense_bins,
+  dense-bins,
   [ --with-dense-bins  use dense bin distribution])
 AC_ARG_WITH(
   inline,
   [ --without-inline   do not inline])
+AC_ARG_WITH(
+  debug,
+  [ --without-debug    disable all debugging facilities])
+AC_ARG_WITH(
+  track,
+  [ --without-track    disable debug tracking functionality])
+AC_ARG_WITH(
+  track-fl,
+  [ --with-track-fl    track file and line numbers])
+AC_ARG_WITH(
+  track-return,
+  [ --with-track-return track return addresses])
+AC_ARG_WITH(
+  track-backtrace,
+  [ --with-track-backtrace track stack backtraces])
 AC_ARG_WITH(
   internal_debug,
   [ --with-internal-debug       
                        turn on internal debugging])
-AC_ARG_WITH(
-  mtrack,
-  [ --without-mtrack   disable backtrace and memory track])
-AC_ARG_WITH(
-  frame_addr_func,
-  [ --with_frame_addr_func=FUNC
-                    use FUNC as function for determening frame addr
-                    default: __bultin_frame_address])
-AC_ARG_WITH(
-  return_addr_func,
-  [ --with_return_addr_func=FUNC
-                    use FUNC as function for determening return addr
-                    default: __bultin_return_address])
-
-dnl lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
-dnl get singuname
-dnl
-AC_MSG_CHECKING(singuname)
-AC_CACHE_VAL(ac_cv_singuname,
-ac_cv_singuname="unknown"
-if test -r "singuname.sh"; then
-  if (/bin/sh singuname.sh >/dev/null 2>&1) then
-    ac_cv_singuname=`/bin/sh singuname.sh`
-  fi
-fi
-if test "$ac_cv_singuname" = unknown && test -r "../singuname.sh"; then
-  if (/bin/sh ../singuname.sh >/dev/null 2>&1) then
-    ac_cv_singuname=`/bin/sh ../singuname.sh`
-  fi
-fi
-)
-AC_MSG_RESULT($ac_cv_singuname)
-if test "$ac_cv_singuname" = unknown; then
-  AC_MSG_WARN(Unknown architecture: Check singuname.sh)
-  ac_cv_singuname="unknown"
-fi
-
 dnl lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
 dnl compiler/make  config
 dnl
-if test "${CFLAGS+set}" != set; then
-  CFLAGS="-O"
-  ac_cflags_set=no
-fi
+dnl I'm not sure why I did this
+dnl if test "${CFLAGS+set}" != set; then
+dnl  CFLAGS="-O"
+dnl  ac_cflags_set=no
+dnl fi
+
 AC_PROG_MAKE_SET
 AC_PROG_CC
 AC_PROG_CPP
+AC_PROG_RANLIB
+AC_PROG_LN_S
+AC_PROG_INSTALL
 AC_C_CONST
 AC_C_INLINE
-AC_PROG_RANLIB
-AC_PROG_LN_S
 
 dnl lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
@@ -229 +214 @@
     AC_DEFINE(OM_HAVE_EXTERNAL_CONFIG_H)
     EXTERNAL_CONFIG_HEADER=${with_external_config_h}
+    rm -f omExternalConfig.h
+    cp ${with_external_config_h} omExternalConfig.h
 fi
 if test "${with_external_config_c+set}" = set; then
@@ -248 +235 @@
 if test "${with_malloc}" = system; then
   OM_MALLOC_HEADER=omMallocSystem.h
-  if test "${with_provide_malloc}" = yes; then
-    AC_MSG_ERROR("can not provide malloc for --with_malloc=system")
+  if test "${with_provide_malloc}" = yes || test "${with_provide_malloc}" = debug; then
+    AC_MSG_ERROR("can not provide malloc for --with-malloc=system")
   fi
 elif test "${with_malloc}" = gmalloc; then
@@ -261 +248 @@
     AC_MSG_ERROR(need --with_external_malloc_h for external malloc)
   fi
-  if test "${with_provide_malloc}" = yes; then
+  if test "${with_provide_malloc}" = yes || test "${with_provide_malloc}" = debug; then
     AC_MSG_ERROR("can not provide malloc for --with_malloc=external")
   fi
@@ -307 +294 @@
 AC_DEFINE(OM_MALLOC_PROVIDES_SIZEOF_ADDR)
 fi
-
-if test "${with_provide_malloc}" = yes; then
-  AC_DEFINE(OM_PROVIDE_MALLOC)
+  
+if test "${with_provide_malloc}" = malloc; then
+   AC_DEFINE(OM_PROVIDE_MALLOC, 3)
+elif test "${with_provide_malloc}" = debug; then
+   AC_DEFINE(OM_PROVIDE_MALLOC, 2)
+elif test "${with_provide_malloc}" = yes; then
+  AC_DEFINE(OM_PROVIDE_MALLOC, 1)
+else
+  AC_DEFINE(OM_PROVIDE_MALLOC, 0)
 fi
 
@@ -406 +399 @@
 dnl debug and inline
 dnl
+AC_MSG_CHECKING(whether to disable debugging)
+if test "$with_debug" != no; then
+AC_MSG_RESULT(no)
+else
+AC_MSG_RESULT(yes)
+AC_DEFINE(OM_NDEBUG)
+with_track=no
+fi
+
+AC_MSG_CHECKING(whether to have tracking debug functionality)
+if test "$with_track" != no; then
+AC_MSG_RESULT(yes)
+AC_DEFINE(OM_HAVE_TRACK)
+else
+AC_MSG_RESULT(no)
+fi
+
 AC_MSG_CHECKING(whether to use internal debug)
 if test "$with_internal_debug" = yes; then
@@ -430 +440 @@
 
 dnl lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
-dnl mtrack business
-dnl
-if test "$with_mtrack" != no; then
-# get function for return address
-if test "${with_return_addr_func+set}" = set; then
-if test "${with_return_addr_func}" != no; then
-  ac_cv_return_addr_func=$with_return_addr_func
-fi
-else
-if test "${GCC}" = yes; then
-  ac_cv_return_addr_func="__builtin_return_address"
-fi
-fi
-
-# test this function
-if test "${ac_cv_return_addr_func+set}" = set; then
-AC_DEFINE_UNQUOTED(OM_RETURN_ADDR, $ac_cv_return_addr_func)
-# first, check whether return addr works
-AC_MSG_CHECKING(whether $ac_cv_return_addr_func works)
-AC_CACHE_VAL(ac_cv_return_addr_func_works,
+dnl backtrace business
+dnl
+AC_MSG_CHECKING(whether GET_RET_ADDR works)
+AC_CACHE_VAL(ac_cv_get_return_addr_works,
 AC_TRY_RUN([
+#include "omReturn.h"
 int test_return_addr()
 {
-   if (OM_RETURN_ADDR(1)  != 0 && OM_RETURN_ADDR(0) != 0 && 
-       OM_RETURN_ADDR(1) != OM_RETURN_ADDR(0)) return 0;
-   return 1;
-}
-
+  char* f;
+  GET_RET_ADDR(f);
+  return (int) f;
+}
 int main()
 {
-   return test_return_addr();
-}
-], ac_cv_return_addr_func_works=yes,  
-   ac_cv_return_addr_func_works=no,
-   ac_cv_return_addr_func_works=no))
-AC_MSG_RESULT($ac_cv_return_addr_func_works)
-
-if test "$ac_cv_return_addr_func_works" = yes; then
-AC_DEFINE(OM_RETURN_ADDR_WORKS)
-# check whether return addr works with rvalues
-AC_MSG_CHECKING(whether $ac_cv_return_addr_func takes rvalues)
-AC_CACHE_VAL(ac_cv_return_addr_func_rvalue,
+   exit(! test_return_addr());
+}
+], ac_cv_get_return_addr_works=yes,  
+   ac_cv_get_return_addr_works=no,
+   ac_cv_get_return_addr_works=no))
+AC_MSG_RESULT($ac_cv_get_return_addr_works)
+if test "$ac_cv_get_return_addr_works" = yes; then
+AC_DEFINE(OM_GET_RETURN_ADDR_WORKS)
+fi
+
+AC_MSG_CHECKING(whether omGetBackTrace works)
+AC_CACHE_VAL(ac_cv_get_backtrace_works,
 AC_TRY_RUN([
-int test_return_addr(int f1, int f2)
-{
-   if (OM_RETURN_ADDR(f1)  != 0 && OM_RETURN_ADDR(f0) != 0 &&
-       OM_RETURN_ADDR(f1) != OM_RETURN_ADDR(f0)) return 0;
-   return 1;
-}
-
+#include "omGetBackTrace.c"
+#include <stdio.h>
+int test_backtrace()
+{
+  void* bt;
+  int i = omGetBackTrace(&bt, 0, 10);
+  return i;
+}
 int main()
 {
-   return test_return_addr(1, 0);
-}
-], ac_cv_return_addr_func_rvalue=yes,  
-   ac_cv_return_addr_func_rvalue=no,
-   ac_cv_return_addr_func_rvalue=no))
-AC_MSG_RESULT($ac_cv_return_addr_func_rvalue)
-if test "$ac_cv_return_addr_func_rvalue" = yes; then
-  AC_DEFINE_UNQUOTED(OM_RETURN_ADDR_RVALUE)
-fi
-fi # "$ac_cv_return_addr_func_works" = yes;
-fi # "${ac_cv_return_addr_func+set}" = set;
-
-# get function for frame address
-if test "${with_frame_addr_func+set}" = set; then
-if test "${with_frame_addr_func}" != no; then
-  ac_cv_frame_addr_func=$with_frame_addr_func
-fi
-else
-if test "${GCC}" = yes; then
-  ac_cv_frame_addr_func="__builtin_frame_address"
-fi
-fi
-
-# test this function
-if test "${ac_cv_frame_addr_func+set}" = set; then
-AC_DEFINE_UNQUOTED(OM_FRAME_ADDR, $ac_cv_frame_addr_func)
-# first, check whether frame addr works
-AC_MSG_CHECKING(whether $ac_cv_frame_addr_func works)
-AC_CACHE_VAL(ac_cv_frame_addr_func_works,
-AC_TRY_RUN([
-int test_frame_addr()
-{
-   if (OM_FRAME_ADDR(1)  != 0 && OM_FRAME_ADDR(0) != 0 && 
-       OM_FRAME_ADDR(1) != OM_FRAME_ADDR(0)) return 0;
-   return 1;
-}
-
-int main()
-{
-   return test_frame_addr();
-}
-], ac_cv_frame_addr_func_works=yes,  
-   ac_cv_frame_addr_func_works=no,
-   ac_cv_frame_addr_func_works=no))
-AC_MSG_RESULT($ac_cv_frame_addr_func_works)
-
-if test "$ac_cv_frame_addr_func_works" = yes; then
-AC_DEFINE(OM_FRAME_ADDR_WORKS)
-# check whether frame addr works with rvalues
-AC_MSG_CHECKING(whether $ac_cv_frame_addr_func takes rvalues)
-AC_CACHE_VAL(ac_cv_frame_addr_func_rvalue,
-AC_TRY_RUN([
-int test_frame_addr(int f1, int f2)
-{
-   if (OM_FRAME_ADDR(f1)  != 0 && OM_FRAME_ADDR(f0) != 0 &&
-       OM_FRAME_ADDR(f1) != OM_FRAME_ADDR(f0)) return 0;
-   return 1;
-}
-
-int main()
-{
-   return test_frame_addr(1, 0);
-}
-], ac_cv_frame_addr_func_rvalue=yes,  
-   ac_cv_frame_addr_func_rvalue=no,
-   ac_cv_frame_addr_func_rvalue=no))
-AC_MSG_RESULT($ac_cv_frame_addr_func_rvalue)
-if test "$ac_cv_frame_addr_func_rvalue" = yes; then
-  AC_DEFINE_UNQUOTED(OM_FRAME_ADDR_RVALUE)
-fi
-fi # "$ac_cv_frame_addr_func_works" = yes;
-fi # "${ac_cv_frame_addr_func+set}" = set;
-
-fi  # "$with_mtrack" != no;
-
-
-dnl lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
-dnl last but not least, let's be smart about CFLAGS
-dnl
-if test "${GCC}" = yes && test "$ac_cflags_set" = no ; then
-  CFLAGS="-pipe -Wall -O3 -fomit-frame-pointer"
-fi
-
+   int i;       
+   omInitGetBackTrace();
+   i = test_backtrace();
+   if (i == 1) exit(0);
+   else exit(i+1);
+}
+], ac_cv_get_backtrace_works=yes,  
+   ac_cv_get_backtrace_works=no,
+   ac_cv_get_backtrace_works=no))
+AC_MSG_RESULT($ac_cv_get_backtrace_works)
+if test "$ac_cv_get_backtrace_works" = yes; then
+AC_DEFINE(OM_GET_BACKTRACE_WORKS)
+fi
+
+AC_MSG_CHECKING(whether to track return addresses)
+if test "$with_track_return" = no || test "$ac_cv_get_return_addr_works" = no; then
+  with_track_return=no
+else
+  AC_DEFINE(OM_TRACK_RETURN)
+  with_track_return=yes
+fi
+AC_MSG_RESULT($with_track_return)
+
+AC_MSG_CHECKING(whether to track files and line numbers)
+if test "$with_track_fl" = no && test "$with_track_return" = no; then
+  with_track_fl=yes
+fi
+if test "${with_track_fl+set}" != set; then 
+  if test "$with_track_return" = yes; then
+    with_track_fl=no
+  else
+    with_track_fl=yes
+  fi
+fi
+AC_MSG_RESULT($with_track_fl)
+if test "$with_track_fl" = yes; then 
+  AC_DEFINE(OM_TRACK_FILE_LINE)
+fi
+
+AC_MSG_CHECKING(whether to track stack backtraces)
+if test "$with_track" != no && test "$ac_cv_get_backtrace_works" = yes && test "$with_track_backtrace" != no; then
+  with_track_backtrace=yes
+  AC_DEFINE(OM_TRACK_BACKTRACE)
+else
+  with_track_backtrace=no
+fi
+AC_MSG_RESULT($with_track_backtrace)
+  
+dnl lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
+dnl wrap it up
+dnl
 AC_CONFIG_HEADER(omConfig.h omMalloc.h:${OM_MALLOC_HEADER})
+
 
 AC_OUTPUT(Makefile, \

omalloc/makeheader.pl

@@ -1 +1 @@
 #!/usr/bin/perl
-# $Id: makeheader.pl,v 1.1.1.1 1999-11-18 17:45:53 obachman Exp $
+# $Id: makeheader.pl,v 1.2 2000-08-14 12:08:43 obachman Exp $
 #
 # makeheader.pl - generate a header file out of several header file (ver 1.2).
@@ -20 +20 @@
 if ( ( $#ARGV == -1 ) || ( $ARGV[0] =~ /-help|-\?/ ) ) {
     die "
-usage: makeheader [-?] {-I<includedir>} <templatefile> <outfile>
+usage: makeheader [-?] [-a] {-I<includedir>} <templatefile> <outfile>
 
 This is makeheader, a header file generation tool.
@@ -32 +32 @@
 #include \"<includefile>\"
 
-in <templatefile>.
+in <templatefile>. If <includefile> contains sections marked with
+/*BEGINPRIVATE*/ and /*ENDPRIVATE*/ then these sections are excluded.
 
 If you use the alternate form
@@ -41 +42 @@
 only sections marked with /*BEGINPUBLIC*/ and /*ENDPUBLIC*/ are
 pasted from <includefile> into <outfile>.
+
+Option -a is equivalent to a /*MAKEHEADER*/ marking of all
+#include \"<includefile>\" of <templatefile>.
 
 <includefile> is looked up in all <includedir>s, then in the
@@ -54 +58 @@
         $includes .= ( $1 ? $1 : shift ) . ":";
     }
+    $all = 1 if /^-a/;
 }
 $includes .= ".:";
@@ -76 +81 @@
 
 while( <INFILE> ) {
-    if ( /^\/\*MAKEHEADER(.*)\*\/$/ ) {
-        # check whether we have to read public part only
-        if ( $1 eq " PUBLIC ONLY" ) {
+    if ( /^\/\*MAKEHEADER(.*)\*\/$/ || ($all && /^\#include \"(.*)\"$/)) {
+        if (/^\/\*MAKEHEADER(.*)\*\/$/)
+        {
+          # check whether we have to read public part only
+          if ( $1 eq " PUBLIC ONLY" ) {
             $public_only = 1;
-        } else {
+          } else {
             $public_only = 0;
+          }
+          $_ = <INFILE>; chop;
         }
 
         # get name of file to include
-        $_ = <INFILE>; chop;
         if ( /^\#include \"(.*)\"$/ ) {
             $inclfile = $1;
@@ -110 +118 @@
         } else {
             # just paste contents into output
-            while ( <INCLFILE> ) { print OUTFILE $_; }
+            while ( <INCLFILE> ) 
+            {
+              $exclude = 1, next if /^\/\*BEGINPRIVATE\*\/\s*$/;
+              $exclude = 0, next if /^\/\*ENDPRIVATE\*\/\s*$/;
+              print OUTFILE $_ unless $exclude;
+            }
         }
         close INCLFILE;

omalloc/omAlloc.c

@@ -4 +4 @@
  *  Author:  obachman@mathematik.uni-kl.de (Olaf Bachmann)
  *  Created: 11/99
- *  Version: $Id: omAlloc.c,v 1.5 2000-05-31 13:34:29 obachman Exp $
+ *  Version: $Id: omAlloc.c,v 1.6 2000-08-14 12:08:43 obachman Exp $
  *******************************************************************/
 #ifndef OM_ALLOC_C
@@ -10 +10 @@
 
 #include "omAlloc.h"
-
 /*******************************************************************
  *  
@@ -18 +17 @@
 
 omBinPage_t om_ZeroPage[] = {{0, NULL, NULL, NULL, NULL}};
-omBinPage_t om_CheckPage[] = {{0, NULL, NULL, NULL, NULL}};
-omBinPage_t om_LargePage[] = {{0, NULL, NULL, NULL, NULL}};
-omBin_t     om_LargeBin[] = {{om_LargePage, NULL, NULL, 0, 0, 0}};
-omBin_t     om_CheckBin[] = {{om_CheckPage, NULL, NULL, 0, 0, 0}};
 omSpecBin om_SpecBin = NULL;
 
-/*******************************************************************
- *  
- *  Definition of Func
- *  
- *******************************************************************/
-
-#define ALLOCBIN_FUNC_WRAPPER(func)             \
-void* omFunc##func (omBin bin)                  \
-{                                               \
-  void* addr;                                   \
-  __omType##func (void*, addr, bin);            \
-  return addr;                                  \
-}
-
-#define REALLOCBIN_FUNC_WRAPPER(func)                               \
-void* omFunc##func (void* old_addr, omBin old_bin, omBin new_bin)   \
-{                                                                   \
-  void* new_addr;                                                   \
-  __omType##func (old_addr, old_bin, void*, new_addr, new_bin);     \
-  return new_addr;                                                  \
-}
-
-#define ALLOCSIZE_FUNC_WRAPPER(func)            \
-void* omFunc##func (size_t size)                \
-{                                               \
-  void* addr;                                   \
-  __omType##func (void*, addr, size);           \
-  return addr;                                  \
-}
-
-#define REALLOCSIZE_FUNC_WRAPPER(func)                                  \
-void* omFunc##func (void* old_addr, size_t old_size, size_t new_size)   \
-{                                                                       \
-  void* new_addr;                                                       \
-  __omType##func (old_addr, old_size, void*, new_addr, new_size);       \
-  return new_addr;                                                      \
-}
-
-#define REALLOC_FUNC_WRAPPER(func)                      \
-void* omFunc##func (void* old_addr, size_t new_size)    \
-{                                                       \
-  void* new_addr;                                       \
-  __omType##func (old_addr, void*, new_addr, new_size); \
-  return new_addr;                                      \
-}
-
-#define FREESIZE_FUNC_WRAPPER(func)             \
-void omFunc##func (void* addr, size_t size)     \
-{                                               \
-  __om##func (addr, size);                      \
-}
-
-#define FREEBIN_FUNC_WRAPPER(func)             \
-void omFunc##func (void* addr, omBin bin)     \
-{                                               \
-  __om##func (addr, bin);                      \
-}
-
-#define FREE_FUNC_WRAPPER(func)                 \
-void omFunc##func (void* addr)                  \
-{                                               \
-  __om##func (addr);                            \
-}
-
-ALLOCBIN_FUNC_WRAPPER(AllocBin)
-ALLOCBIN_FUNC_WRAPPER(Alloc0Bin)
-REALLOCBIN_FUNC_WRAPPER(ReallocBin)
-REALLOCBIN_FUNC_WRAPPER(Realloc0Bin)
-FREEBIN_FUNC_WRAPPER(FreeBin)
-
-ALLOCSIZE_FUNC_WRAPPER(Alloc)
-ALLOCSIZE_FUNC_WRAPPER(Alloc0)
-REALLOCSIZE_FUNC_WRAPPER(ReallocSize)
-REALLOCSIZE_FUNC_WRAPPER(Realloc0Size)
-REALLOC_FUNC_WRAPPER(Realloc)
-REALLOC_FUNC_WRAPPER(Realloc0)
-FREESIZE_FUNC_WRAPPER(FreeSize)
-FREE_FUNC_WRAPPER(Free)
-
-#ifdef OM_ALIGNMENT_NEEDS_WORK
-ALLOCSIZE_FUNC_WRAPPER(AllocAligned)
-ALLOCSIZE_FUNC_WRAPPER(Alloc0Aligned)
-REALLOCSIZE_FUNC_WRAPPER(ReallocAlignedSize)
-REALLOCSIZE_FUNC_WRAPPER(Realloc0AlignedSize)
-REALLOC_FUNC_WRAPPER(ReallocAligned)
-REALLOC_FUNC_WRAPPER(Realloc0Aligned)
-#endif /* OM_ALIGNMENT_NEEDS_WORK */
+#include "omTables.inc"
+
 
 /*******************************************************************
@@ -215 +125 @@
   {
     omAssume(bin->last_page != NULL);
+    /* Set this to zero, but preserve the first bit,
+       so that tracking works */
+#ifdef OM_HAVE_TRACK
+    bin->current_page->used_blocks &= (1 << (BIT_SIZEOF_LONG -1));
+#else    
     bin->current_page->used_blocks = 0;
+#endif
   }
 
@@ -238 +154 @@
 
 
-/* page->used_blocks == 0, so, either free page or reallocate to 
+/* page->used_blocks <= 0, so, either free page or reallocate to 
    the right of current_page */
 /*
@@ -253 +169 @@
   omAssume(page->used_blocks <= 0);
 
-#ifdef OM_HAVE_DEBUG
-  if (page->used_blocks < 0) omDebugFree(addr, 0);
+#ifdef OM_HAVE_TRACK
+  if (page->used_blocks < 0) 
+  {
+    omFreeTrackAddr(addr);
+    return;
+  }
 #endif
     
@@ -267 +187 @@
     else
       omFreeBinPages(page, - bin->max_blocks);
-#ifdef OM_HAVE_DEBUG
+#ifdef OM_HAVE_TRACK
     om_JustFreedPage = page;
 #endif    
@@ -297 +217 @@
 /*******************************************************************
  *  
- *  ANSI-C malloc-conforming functions
- *  
- *******************************************************************/
-
-#include "ommalloc.c"
-
-#ifdef OM_PROVIDE_MALLOC
-#undef malloc
-#undef realloc
-#undef free
-#undef calloc
-#define ommallocFunc malloc
-#define omreallocFunc realloc
-#define omfreeFunc free
-#define omcallocFunc calloc
-#include "ommalloc.c"
-#endif
-
+ *  DoRealloc
+ *  
+ *******************************************************************/
+#ifdef OM_ALIGNMNET_NEEDS_WORK
+#define DO_ZERO(flag) (flag & 1)
+#else
+#define DO_ZERO(flag)    flag
+#endif
+
+void* omDoRealloc(void* old_addr, size_t new_size, int flag)
+{
+  void* new_addr;
+  
+  if (!omIsBinPageAddr(old_addr) && new_size > OM_MAX_BLOCK_SIZE)
+  {
+    if (DO_ZERO(flag))
+      return omRealloc0Large(old_addr, new_size);
+    else
+      return omReallocLarge(old_addr, new_size);
+  }
+  else
+  {
+    size_t old_size = omSizeOfAddr(old_addr);
+    size_t min_size;
+    
+    omAssume(OM_IS_ALIGNED(old_addr));
+    
+#ifdef OM_ALIGNMENT_NEEDS_WORK
+    if (flag & 2)
+      __omTypeAllocAligned(void*, new_addr, new_size);
+    else
+#endif
+      __omTypeAlloc(void*, new_addr, new_size);
+    
+    new_size = omSizeOfAddr(new_addr);
+    min_size = (old_size < new_size ? old_size : new_size);
+    omMemcpyW(new_addr, old_addr, min_size >> LOG_SIZEOF_LONG);
+    
+    if (DO_ZERO(flag) && (new_size > old_size))
+      omMemsetW((void*) new_addr + min_size, 0, (new_size - old_size) >> LOG_SIZEOF_LONG);
+  
+    __omFreeSize(old_addr, old_size);
+
+    return new_addr;
+  }
+}
 
 #endif /* OM_ALLOC_C */

omalloc/omAlloc.h

@@ -4 +4 @@
  *  Author:  obachman@mathematik.uni-kl.de (Olaf Bachmann)
  *  Created: 11/99
- *  Version: $Id: omAlloc.h,v 1.3 2000-05-31 13:34:30 obachman Exp $
+ *  Version: $Id: omAlloc.h,v 1.4 2000-08-14 12:08:44 obachman Exp $
  *******************************************************************/
 #ifndef OM_ALLOC_H
@@ -13 +13 @@
 #include <string.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "omConfig.h"
+#include "omDerivedConfig.h"
+#include "omError.h"
 #include "omStructs.h"
-#include "omError.h"
 #include "omAllocDecl.h"
+#include "omInlineDecl.h"
 #include "omBin.h"
-#include "omCheck.h"
 #include "omMemOps.h"
 #include "omList.h"
-#include "omTrack.h"
+#include "omFindExec.h"
+#include "omGetBackTrace.h"
+#include "omRet2Info.h"
 #include "omStats.h"
 #include "omOpts.h"
 #include "omBinPage.h"
 #include "omAllocSystem.h"
+#include "omTables.h"
 #include "omAllocPrivate.h"
+#include "omDebug.h"
 #include "omInline.h"
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* OM_ALLOC_H */

omalloc/omConfig.h.in

@@ -5 +5 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 11/99
- *  Version: $Id: omConfig.h.in,v 1.3 2000-05-31 13:34:31 obachman Exp $
+ *  Version: $Id: omConfig.h.in,v 1.4 2000-08-14 12:08:44 obachman Exp $
  *******************************************************************/
 #ifndef OM_CONFIG_H
@@ -13 +13 @@
  * Defines which are set by configure
  ******************************************************************/
+/* define if you provide an external config file to be included
+   by omDefaultConfig.h */
+#ifndef OM_HAVE_EXTERNAL_CONFIG_H
+#define OM_HAVE_EXTERNAL_CONFIG_H
+#endif
 /* define if you can inline */
 #ifndef OM_INLINE
@@ -28 +33 @@
 #ifndef OM_INLINE_LOCAL
 #define OM_INLINE_LOCAL static
+#endif
+/* defint to nothing if you do not understand const */
+#ifndef const
+#undef const
 #endif
 /* define to the name of addr2line program, undef otherwise */
@@ -77 +86 @@
 #define HAVE_SYS_MMAN_H
 #endif
-/* define to func which returns ith return addr */
-#ifndef OM_RETURN_ADDR
-#undef OM_RETURN_ADDR
+/* define if GET_RETURN_ADDR works */
+#ifndef OM_GET_RETURN_ADDR_WORK
+#undef OM_GET_RETURN_ADDR_WORKS
 #endif
-/* define to func which returns ith frame addr */
-#ifndef OM_FRAME_ADDR
-#undef OM_FRAME_ADDR
-#endif
-/* define if OM_RETURN_ADDR actually works */
-#ifndef OM_RETURN_ADDR_WORKS
-#undef OM_RETURN_ADDR_WORKS
-#endif
-/* define if OM_FRAME_ADDR actually works */
-#ifndef OM_FRAME_ADDR_WORKS
-#undef OM_FRAME_ADDR_WORKS
-#endif
-/* define if OM_RETURN_ADDR actually rvalue */
-#ifndef OM_RETURN_ADDR_RVALUE
-#undef OM_RETURN_ADDR_RVALUE
-#endif
-/* define if OM_FRAME_ADDR actually rvalue */
-#ifndef OM_FRAME_ADDR_RVALUE
-#undef OM_FRAME_ADDR_RVALUE
+/* define if GET_RETURN_ADDR works */
+#ifndef OM_GET_BACKTRACE_WORK
+#undef OM_GET_BACKTRACE_WORKS
 #endif
 /* Define sizeof(long) */
@@ -133 +126 @@
 #undef OM_MALLOC_PROVIDES_SIZEOF_ADDR
 #endif
-#ifndef OM_PROVIDE_MALLOC
-/* define if you want omalloc to provide ANSI-C conforming
-   malloc/calloc/realloc/free funcs */
-#undef OM_PROVIDE_MALLOC
-#endif
 #ifndef OM_EMULATE_OMALLOC
 /* define if you only want to emulate omalloc, but not actually use it */
@@ -154 +142 @@
 #undef OM_HAVE_DENSE_BIN_DISTRIBUTION
 #endif
+/* define to disable all debugging stuff */
+#ifndef OM_NDEBUG
+#undef OM_NDEBUG
+#endif
+/* define to enable debug tracking */
+#ifndef OM_HAVE_TRACK
+#undef OM_HAVE_TRACK
+#endif
+/* define to enable tracking of files/line numbers */
+#ifndef OM_TRACK_FILE_LINE
+#undef OM_TRACK_FILE_LINE
+#endif
+/* define to enable tracking of return addresses */
+#ifndef OM_TRACK_RETURN
+#undef OM_TRACK_RETURN
+#endif
+/* define to enable tracking of stack backtraces */
+#ifndef OM_TRACK_BACKTRACE
+#undef OM_TRACK_BACKTRACE
+#endif
 /* define to enable internal debugging */
 #ifndef OM_INTERNAL_DEBUG
 #undef OM_INTERNAL_DEBUG
 #endif
-
-/*******************************************************************
- * Defines which are not set by configure
- ******************************************************************/
-#ifndef SIZEOF_VOIDP
-/* configure makes sure that SIZEOF_VOIDP == SIZEOF_LONG */
-#define SIZEOF_VOIDP SIZEOF_LONG
+/* define to -1/0/1/2/3 if you want omalloc to provide 
+   "underlying malloc"/no/normal/debug ANSI-C conforming  
+   malloc/calloc/realloc/free funcs */
+#ifndef OM_PROVIDE_MALLOC
+#define OM_PROVIDE_MALLOC 0
 #endif
-
-/* SIZEOF_VOIDP == 8 || SIZEOF_VOIDP == 4 checked by configure */
-#if SIZEOF_VOIDP == 8
-#define LOG_SIZEOF_LONG  3
-#define LOG_SIZEOF_VOIDP 3
-#define LOG_BIT_SIZEOF_LONG 6
-#else
-#define LOG_SIZEOF_LONG  2
-#define LOG_SIZEOF_VOIDP 2
-#define LOG_BIT_SIZEOF_LONG 5
-#endif
-
-/* SIZEOF_SYSTEM_PAGE == 4096 || SIZEOF_SYSTEM_PAGE == 8192 checked by configure */
-#if SIZEOF_SYSTEM_PAGE == 8192
-#define LOG_BIT_SIZEOF_SYSTEM_PAGE 13
-#else
-#define LOG_BIT_SIZEOF_SYSTEM_PAGE 12
-#endif
-
-#ifndef CHAR_BIT
-#define CHAR_BIT 8
-#endif
-
-#define BIT_SIZEOF_LONG (CHAR_BIT << LOG_SIZEOF_LONG)
-
-#ifdef OM_ALIGN_8
-#define SIZEOF_OM_ALIGNMENT 8
-#define SIZEOF_OM_ALIGNMENT_1 7
-#define LOG_SIZEOF_OM_ALIGNMENT 3 
-#define SIZEOF_STRICT_ALIGNMENT 8
-#else
-#define SIZEOF_OM_ALIGNMENT 4
-#define SIZEOF_OM_ALIGNMENT_1 3
-#define LOG_SIZEOF_OM_ALIGNMENT 2
-#ifdef OM_ALIGNMENT_NEEDS_WORK
-#define SIZEOF_STRICT_ALIGNMENT 8
-#else
-#define SIZEOF_STRICT_ALIGNMENT 4
-#endif
-#endif
-
-#define OM_ALIGN_SIZE(size) \
-   (((size) + SIZEOF_OM_ALIGNMENT_1) & (~SIZEOF_OM_ALIGNMENT_1))
-
-#define OM_STRICT_ALIGN_SIZE(size)                                          \
-   (((size) + SIZEOF_STRICT_ALIGNMENT - 1) & (~ (SIZEOF_STRICT_ALIGNMENT - 1)))
-
-
-/* define to enable assume */
-#ifndef HAVE_OM_ASSUME
-#if !defined(NDEBUG) || defined(OM_INTERNAL_DEBUG)
-#define HAVE_OM_ASSUME
-#endif
-#endif
-
-/* set to 0 to disable aso memory mamagent */
-#ifndef HAVE_ASO
-#define HAVE_ASO 1
-#endif
-#if defined(HAVE_ASO) && HAVE_ASO == 1
-/* define to enable ASO debugging */
-#undef ASO_DEBUG
-#endif
-
-#ifndef NULL
-#define NULL ((void*)0)
-#endif
-
 #endif /* OM_CONFIG_H  */

omalloc/omDebug.c

@@ -1 +1 @@
 /*******************************************************************
- *  File:    omDebug.c
- *  Purpose: implementation of main omDebug functions
+ *  File:    omTest.c
+ *  Purpose: implementation of main omTest functions
  *  Author:  obachman@mathematik.uni-kl.de (Olaf Bachmann)
- *  Created: 11/99
- *  Version: $Id: omDebug.c,v 1.3 2000-05-31 13:34:31 obachman Exp $
+ *  Created: 7/00
+ *  Version: $Id: omDebug.c,v 1.4 2000-08-14 12:08:44 obachman Exp $
  *******************************************************************/
+#include <limits.h>
 #include "omConfig.h"
-
-#ifdef OM_HAVE_DEBUG
-
 #include "omAlloc.h"
-
+#include "omDebug.h"
+#include "omReturn.h"
+
+#ifndef OM_NDEBUG
 /*******************************************************************
  *  
@@ -17 +18 @@
  *  
  *******************************************************************/
-/* number of bytes for padding before addr: needs to > 0 and a multiple of OM_SIZEOF_STRICT_ALIGNMENT */
-#ifndef OM_SIZEOF_FRONT_PADDING
-#define OM_SIZEOF_FRONT_PADDING SIZEOF_STRICT_ALIGNMENT
-#endif
-/* number of bytes for padding after addr: needs to be a multiple of OM_SIZEOF_STRICT_ALIGNMENT */ 
-#ifndef OM_SIZEOF_BACK_PADDING
-#define OM_SIZEOF_BACK_PADDING SIZEOF_STRICT_ALIGNMENT
-#endif
-
-struct omDebugAddr_s;
-typedef struct omDebugAddr_s omDebugAddr_t;
-typedef omDebugAddr_t * omDebugAddr;
-
-struct omDebugAddr_s
-{
-  char              debug;
-  char              check;
-  short             alloc_line;
-  char*             alloc_file;
-  /* debug > 1 */
-  void*             alloc_frames[OM_MAX_FRAMES];
-  /* debug > 2 */
-  void*             size_bin;
-  omFlags_t         flags;
-  omDebugCount_t    debugs;
-  /* debug > 3 */
-  short             free_line;
-  char*             free_file;
-  /* debug > 4 */
-  void*             free_frames[OM_MAX_FRAMES];
-};
-
-/* this is only needed to determine SIZEOF_DEBUG_ADDR_i */
-static struct omDebugAddr_s debug_addr;
-#define OM_SIZEOF_DEBUG_ADDR_1  OM_STRICT_ALIGN_SIZE(((void*)&debug_addr.alloc_frames-(void*)&debug_addr))
-#define OM_SIZEOF_DEBUG_ADDR_2  OM_STRICT_ALIGN_SIZE(((void*)&debug_addr.size_bin-(void*)&debug_addr))
-#define OM_SIZEOF_DEBUG_ADDR_3  (OM_STRICT_ALIGN_SIZE(((void*)&debug_addr.free_line-(void*)&debug_addr))+SIZEOF_FRONT_PADDING)
-#define OM_SIZEOF_DEBUG_ADDR_4  (OM_STRICT_ALIGN_SIZE(((void*)&debug_addr.free_frames-(void*)&debug_addr))+SIZEOF_FRONT_PADDING)
-#define OM_SIZEOF_DEBUG_ADDR_5  OM_SIZEOF_DEBUG_ADDR
-#define OM_SIZEOF_DEBUG_ADDR    (OM_STRICT_ALIGN_SIZE(sizeof(struct omDebugAddr_s)) + SIZEOF_FRONT_PADDING)
-
-OM_INLINE_LOCAL omDebugAddr omAddr_2_DebugAddr(void* addr)
-{
-  void* page = omGetPageOfAddr(addr);
-  size_t size = omGetTopeBinOfPage((omBinPage) page)->sizeW << LOG_SIZEOF_LONG;
-  page += SIZEOF_OM_BIN_PAGE_HEADER;
-  return (omDebugAddr) (page + (void*) (((unsigned long)addr - (unsigned long)page) / size)*size);
-}
-
-#define OM_BIN_FLAG     1           /* size_bin is bin, if set, else size */
-#define OM_USED_FLAG    2           /* is in use, if set */
-#define OM_FREE_FLAG    4           /* had been freed, if set */
-#define OM_STATIC_FLAG  8           /* if set, considered to be static, i.e. never be freed */
-#define OM_MAX_FLAG             64  /* define, but never use it */
-#define SET_FLAG(var, flag)     (var |= (flag))
-#define CLEAR_FLAG(var, flag)   (var &= ~(flag))
-#define IS_FLAG_SET(var, flag)  (var & (flag))
-
-
-#define _omDebugAddr_2_OutAddr(d_addr)   (((void*) d_addr) + OM_SIZEOF_DEBUG_ADDR_HEADER)
-#define _omOutAddr_2_DebugAddr(addr)     ((omDebugAddr) ((void*) addr - OM_SIZEOF_DEBUG_ADDR_HEADER))
-#define _omOutSize_2_DebugSize(size)     (size + OM_SIZEOF_DEBUG_ADDR_HEADER + OM_SIZEOF_BACK_PADDING)
-#define _omDebugSize_2_OutSize(size)     (size - OM_SIZEOF_DEBUG_ADDR_HEADER - OM_SIZEOF_BACK_PADDING)
-
+
+static void* __omDebugAlloc(void* size_bin, omTrackFlags_t  flags, char track, OM_FLR_DECL);
+static void* __omDebugRealloc(void* old_addr, void* old_size_bin, void* new_size_bin,
+                              omError_t old_status, omTrackFlags_t  old_flags, 
+                              omTrackFlags_t  new_flags, 
+                              char track, OM_FLR_DECL);
+static void __omDebugFree(void* addr, void* size_bin, omTrackFlags_t  flags, OM_FLR_DECL);
+
+void* om_KeptAddr = NULL;
+static unsigned long om_NumberOfKeptAddrs = 0;
+static void* om_LastKeptAddr = NULL;
+
+/*******************************************************************
+ *  
+ * Test routines
+ *  
+ *******************************************************************/
+#define OM_CLFL check_level OM_FL_KOMMA OM_FL
+omError_t omTestAddrBin(void* addr, omBin bin, int check_level)
+{
+  return _omDebugAddr(addr,bin,OM_FBIN,OM_CLFL);
+}
+omError_t omTestAddrSize(void* addr, size_t size, int check_level)
+{
+  return _omDebugAddr(addr,(void*)(size),OM_FSIZE,OM_CLFL);
+}
+omError_t omTestAddr(void* addr, int check_level)
+{
+  return _omDebugAddr(addr,NULL, 0, OM_CLFL);
+}
+omError_t omtestAddrSize(void* addr, size_t size, int check_level)
+{
+  return _omDebugAddr(addr,(void*)(size),OM_FSIZE|OM_FSLOPPY,OM_CLFL);
+}
+omError_t omtestAddr(void* addr, int check_level)
+{
+  return _omDebugAddr(addr,NULL, OM_FSLOPPY, OM_CLFL);
+}
+
+omError_t omTestAddrAlignedBin(void* addr, omBin bin, int check_level)
+{
+  return _omDebugAddr(addr,bin,OM_FBIN|OM_FALIGN,OM_CLFL);
+}
+omError_t omTestAddrAlignedSize(void* addr, size_t size, int check_level)
+{
+  return _omDebugAddr(addr,(void*)(size),OM_FSIZE|OM_FALIGN,OM_CLFL);
+}
+omError_t omTestAddrAligned(void* addr, int check_level)
+{
+  return _omDebugAddr(addr,NULL, OM_FALIGN, OM_CLFL);
+}
+omError_t omtestAddrAlignedSize(void* addr, size_t size, int check_level)
+{
+  return _omDebugAddr(addr,(void*)(size),OM_FSIZE|OM_FSLOPPY|OM_FALIGN,OM_CLFL);
+}
+omError_t omtestAddrAligned(void* addr, int check_level)
+{
+  return _omDebugAddr(addr,NULL, OM_FSLOPPY|OM_FALIGN, OM_CLFL);
+}
+
+omError_t omTestBin(omBin bin, int check_level)
+{
+  return _omDebugBin(bin, OM_CLFL);
+}
+omError_t omTestMemory(int check_level)
+{
+  return _omDebugMemory(OM_CLFL);
+}
+
+#undef MAX
+#define MAX(a,b) (a > b ? a : b)
+/*******************************************************************
+ *  
+ * First level _omDebug alloc/free routines: call respective checks and dispatch
+ * to routines which do the actual work
+ *  
+ *******************************************************************/
+void* _omDebugAlloc(void* size_bin, omTrackFlags_t flags, OM_CTFL_DECL)
+{
+  void* addr;
+  OM_R_DEF;
+  check = MAX(check, om_Opts.MinCheck);
+  track = MAX(track, om_Opts.MinTrack);
+
+  if (check)
+  {
+    if (check > 1)
+    {
+      if (flags & OM_FBIN)
+        (void) _omCheckBin((omBin)size_bin, 1, check-1, omError_MemoryCorrupted, OM_FLR_VAL);
+      else if (check > 2)
+      {
+        omAssume(flags & OM_FSIZE);
+        (void) _omCheckMemory(check-2, omError_MemoryCorrupted, OM_FLR_VAL);
+      }
+    }
+    if (size_bin == NULL && ! (flags & OM_FSLOPPY))
+    {
+      omReportError(omError_NullSizeAlloc, omError_NoError, OM_FLR_VAL, "");
+    }
+  }
+
+  addr = __omDebugAlloc(size_bin, flags, track, OM_FLR_VAL);
+  
 #ifdef OM_INTERNAL_DEBUG
-static void* omDebugAddr_2_OutAddr(void* d_addr) {return _omDebugAddr_2_OutAddr(d_addr);}
-static void* omOutAddr_2_DebugAddr(void* addr)   {return _omOutAddr_2_DebugAddr(addr);}
-static size_t omOutSize_2_DebugSize(size_t size) {return _omOutSize_2_DebugSize(size);} 
-static size_t omDebugSize_2_OutSize(size_t size) {return _omOutSize_2_DebugSize(size);}
-#else
-#define omDebugAddr_2_OutAddr   _omDebugAddr_2_OutAddr
-#define omOutAddr_2_DebugAddr   _omOutAddr_2_DebugAddr
-#define omOutSize_2_DebugSize   _omOutSize_2_DebugSize
-#define omDebugSize_2_OutSize   _omDebugSize_2_OutSize
-#endif
-
-static void* om_Frames[OM_MAX_FRAMES];
-
+  (void) _omCheckAddr(addr, size_bin,flags|OM_FUSED,check, omError_InternalBug, OM_FLR);
+#endif
+
+  return addr;
+}
+
+
+void* _omDebugRealloc(void* old_addr, void* old_size_bin, void* new_size_bin,
+                      omTrackFlags_t old_flags, omTrackFlags_t new_flags, OM_CTFL_DECL)
+{
+  void* new_addr = NULL;
+  omError_t status = omError_NoError;
+  OM_R_DEF;
+  check = MAX(check, om_Opts.MinCheck);
+  track = MAX(track, om_Opts.MinTrack);
+  
+  if (check)
+  {
+    status = _omCheckAddr(old_addr, old_size_bin, old_flags|OM_FUSED, check, omError_NoError, OM_FLR_VAL);
+
+    if (status == omError_NoError && check > 1 && new_flags & OM_FBIN)
+      status = omDoCheckBin((omBin)new_size_bin, 1, check-1, omError_MemoryCorrupted, OM_FLR_VAL);
+    
+    if (new_size_bin == NULL && !(new_flags & OM_FSLOPPY))
+    {
+      omReportError(omError_NullSizeAlloc, omError_NoError, OM_FLR_VAL, "");
+      new_size_bin = (void*) 1;
+    }
+  }
+  
+  new_addr = __omDebugRealloc(old_addr, old_size_bin, new_size_bin,
+                              status, old_flags, new_flags, track, OM_FLR_VAL);
+#ifdef OM_INTERNAL_DEBUG
+  if (status == omError_NoError)
+    (void) _omCheckAddr(new_addr, new_size_bin,new_flags|OM_FUSED,check, omError_InternalBug, OM_FLR);
+#endif
+
+  return new_addr;
+}
+
+void _omDebugFree(void* addr, void* size_bin,
+                  omTrackFlags_t flags, OM_CFL_DECL)
+{
+  OM_R_DEF;
+  check = MAX(check, om_Opts.MinCheck);
+  if (check && _omCheckAddr(addr, size_bin, flags|OM_FUSED, check, omError_NoError, OM_FLR_VAL)) return;
+  
+  __omDebugFree(addr,size_bin,flags, OM_FLR_VAL);
+  
+#ifdef OM_INTERNAL_DEBUG
+  if (flags & OM_FBIN)
+    (void) _omCheckBin((omBin)size_bin, 1, check-1,omError_InternalBug, OM_FLR);
+  else 
+    (void) _omCheckMemory(check-2,omError_InternalBug,OM_FLR);
+#endif
+}
+
+void* _omDebugMemDup(void* addr, omTrackFlags_t flags, OM_CTFL_DECL)
+{
+  void* ret;
+  size_t sizeW;
+  OM_R_DEF;
+
+  check = MAX(check, om_Opts.MinCheck);
+  track = MAX(track, om_Opts.MinTrack);
+
+  if (check & _omCheckAddr(addr, 0, OM_FUSED, check, omError_NoError, OM_FLR_VAL))
+  {
+    return NULL;
+  }
+  else
+  {
+    sizeW = omSizeWOfAddr(addr);
+  }
+
+  ret = __omDebugAlloc((void*) (sizeW << LOG_SIZEOF_LONG), OM_FSIZE | flags, track, OM_FLR_VAL);
+  omMemcpyW(ret, addr, sizeW);
+
+#ifdef OM_INTERNAL_DEBUG
+  (void) _omCheckAddr(ret, (void*) (sizeW << LOG_SIZEOF_LONG),OM_FUSED|OM_FSIZE,
+                     check, omError_InternalBug, OM_FLR);
+#endif
+  return ret;
+}
+
+char* _omDebugStrDup(const char* addr, OM_TFL_DECL)
+{
+  unsigned long size, i=0;
+  char* ret;
+  OM_R_DEF;
+
+  if (addr == NULL)
+  {
+    omReportAddrError(omError_NotString, omError_NoError, addr, 0, 0, OM_FLR_VAL, "NULL String");
+    return NULL;
+  }
+  track = MAX(track, om_Opts.MinTrack);
+
+  if (omIsBinPageAddr(addr))
+  {
+    size = omSizeOfAddr(addr);
+  }
+  else
+  {
+    size = ULONG_MAX;
+  }
+
+  while (addr[i] != '\0' && i < size) i++;
+  if (i == size)
+  {
+    omReportAddrError(omError_NotString, omError_NoError, addr, 0, 0, OM_FLR_VAL, "Not 0 terminated");
+    i = size-1;
+  }
+  ret = __omDebugAlloc((void*)i+1, OM_FSIZE, track, OM_FLR_VAL);
+  memcpy(ret, addr, i);
+  ret[i] = '\0';
+
+#ifdef OM_INTERNAL_DEBUG
+  (void) _omCheckAddr(ret, i+1,OM_FUSED|OM_FSIZE,om_Opts.MinCheck, omError_InternalBug, OM_FLR);
+#endif
+  return ret;
+}
+
+omError_t _omDebugAddr(void* addr, void* bin_size, omTrackFlags_t flags, OM_CFL_DECL)
+{
+  OM_R_DEF;
+  return _omCheckAddr(addr, bin_size, 
+                      OM_FUSED|flags,MAX(check,om_Opts.MinCheck),omError_NoError,OM_FLR_VAL);
+}
+omError_t _omDebugMemory(OM_CFL_DECL)
+{
+  OM_R_DEF;
+  return _omCheckMemory(MAX(check, om_Opts.MinCheck), omError_NoError,OM_FLR_VAL);
+}
+omError_t _omDebugBin(omBin bin, OM_CFL_DECL)
+{
+  OM_R_DEF;
+  return _omCheckBin(bin, 1, MAX(check, om_Opts.MinCheck), omError_NoError,OM_FLR_VAL);
+}
+  
 /*******************************************************************
  *  
- * Public routines --they are just dispatcher to equivalent first-level,
- * i.e.,  _om*  routines
+ * Second level _omDebug alloc/free routines: do the actual work
  *  
  *******************************************************************/
-
-void* omTestAllocBin(omBin bin, char check, char debug, char* file, int line)
-{
-  return _omTestAlloc(bin,
-                      OM_BIN_FLAGS,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR);
-}
-void* omTestAlloc0Bin(omBin bin, char check, char debug, char* file, int line)
-{
-  return _omTestAlloc(bin, 
-                      OM_BIN_FLAG|OM_ZERO_FLAG,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR);
-}
-void* omTestReallocBin(void* old_addr, omBin old_bin, omBin new_bin, char check, char debug, char* file, int line)
-{
-  return _omTestRealloc(old_addr, old_bin, new_bin, 
-                        OM_BIN_FLAG,OM_BIN_FLAG,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR);
-}   
-void* omTestRealloc0Bin(void* old_addr, omBin old_bin, omBin new_bin, char check, char debug, char* file, int line)
-{
-  return _omTestRealloc(old_addr, old_bin, new_bin, 
-                        OM_BIN_FLAG,OM_BIN_FLAG|OM_ZERO_FLAG,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR);
-}
-void omTestFreeBin(void* addr, omBin bin, char check, char* file, int line)
-{
-  _omTestFree(addr, bin, 
-              OM_BIN_FLAG,MAX(check,om_Opts.MinCheck),f,l,OM_DEBUG_RETURN_ADDR);
-}
-
-void* omTestAlloc(size_t size, char check, char debug, char* file, int line)
-{
-  return _omTestAlloc(size, 
-                      OM_SIZE_FLAG,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR);
-}
-void* omTestAlloc0(size_t size, char check, char debug, char* file, int line)
-{
-  return _omTestAlloc(size, 
-                      OM_SIZE_FLAG|OM_ZERO_FLAG, MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR);
-}
-void* omTestAllocAligned(size_t size, char check, char debug, char* file, int line)
-{
-  return _omTestAlloc(size, 
-                      OM_SIZE_FLAG|OM_ALIGNED_FLAG,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR);
-}
-void* omTestAlloc0Aligned(size_t size, char check, char debug, char* file, int line)
-{
-  return _omTestAlloc(size, 
-                      OM_SIZE_FLAG|OM_ALIGNED_FLAG|OM_ZERO_FLAG,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR);
-}
-
-void* omTestRealloc(void* addr, size_t new_size, char check, char debug, char* file, int line)
-{
-  return _omTestRealloc(addr, NULL, new_size, 
-                        0,OM_SIZE_FLAG,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR);
-}
-void* omTestRealloc0(void* addr, size_t new_size, char check, char debug, char* file, int line)
-{
-  return _omTestRealloc(addr, NULL, new_size, 
-                        0, OM_SIZE_FLAG|OM_ZERO_FLAG, MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR);
-}
-void* omTestReallocAligned(void* addr, size_t new_size, char check, char debug, char* file, int line)
-{
-  return _omTestRealloc(addr, NULL, new_size, 
-                        0,OM_SIZE_FLAG|OM_ALIGNED_FLAG,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR);
-}
-void* omTestRealloc0Aligned(void* addr, size_t new_size, char check, char debug, char* file, int line)
-{
-  return _omTestRealloc(addr, NULL, new_size, 
-                        0,OM_SIZE_FLAG|OM_ZERO_FLAG|OM_ALIGNED_FLAG,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR,OM_REALLOC0_ALIGNED);
-}
-
-void* omTestReallocSize(void* addr, size_t old_size, size_t new_size, char check, char debug, char* file, int line)
-{
-  return _omTestRealloc(addr, old_size, new_size, 
-                        OM_SIZE_FLAG,OM_SIZE_FLAG,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR,OM_REALLOC_SIZE);
-}
-void* omTestRealloc0Size(void* addr, size_t old_size, size_t new_size, char check, char debug, char* file, int line)
-{
-  return _omTestRealloc(addr, old_size, new_size, 
-                        OM_SIZE_FLAG,OM_SIZE_FLAG|OM_ZERO_FLAG,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR,OM_REALLOC0_SIZE);
-}
-void* omTestReallocAlignedSize(void* addr, size_t old_size, size_t new_size, char check, char debug, char* file, int line)
-{
-  return _omTestRealloc(addr, old_size, new_size, 
-                        OM_SIZE_FLAG,OM_SIZE_FLAG|OM_ALIGNED_FLAG,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR,OM_REALLOC_ALIGNED_SIZE);
-}
-void* omTestRealloc0AlignedSize(void* addr, size_t old_size, size_t new_size, char check, char debug, char* file, int line)
-{
-  return _omTestRealloc(addr, old_size, new_size, 
-                        OM_SIZE_FLAG,OM_SIZE_FLAG|OM_ZERO_FLAG|OM_ALIGNED_FLAG,MAX(check,om_Opts.MinCheck),MAX(debug,om_Opts.MinDebug),f,l,OM_DEBUG_RETURN_ADDR,OM_REALLOC0_ALIGNED_SIZE);
-}
-
-void omTestFreeSize(void* addr, size_t size, char check, char* file, int line)
-{
-  _omTestFree(addr, size, 
-              OM_SIZE_FLAG, MAX(check,om_Opts.MinCheck),f,l,OM_DEBUG_RETURN_ADDR,OM_FREE_SIZE);
-}
-void omTestFree(void* addr, size_t size, char check, char* file, int line)
-{
-  _omTestFree(addr, NULL, 
-              0, MAX(check,om_Opts.MinCheck),f,l,OM_DEBUG_RETURN_ADDR,OM_FREE);
-}
-
-omError_t omTestAddrBin(void* addr, omBin bin, char check, char* file, int line)
-{
-  return _omTestAddr(addr, bin, 
-                     OM_USED_FLAG|OM_BIN_FLAG|OM_COUNT_FLAG, MAX(check,om_Opts.MinCheck),f,l,OM_DEBUG_RETURN_ADDR);
-}
-omError_t omTestAddrSize(void* addr, size_t size, char check, char* file, int line)
-{
-  return _omTestAddr(addr, size, 
-                     OM_USED_FLAG|OM_SIZE_FLAG|OM_COUNT_FLAG, MAX(check,om_Opts.MinCheck),f,l,OM_DEBUG_RETURN_ADDR);
-}
-omError_t omTestAddr(void* adr, char check, char* file, int line)
-{
-  return _omTestAddr(addr, NULL, 
-                     OM_USED_FLAG|OM_COUNT_FLAG,MAX(check,om_Opts.MinCheck),f,l,OM_DEBUG_RETURN_ADDR);
-}
-omError_t omTestAlignedAddrBin(void* addr, omBin bin, char check, char* file, int line)
-{
-  return _omTestAddr(addr, bin, 
-                     OM_USED_FLAG|OM_BIN_FLAG|OM_ALIGNED_FLAG|OM_COUNT_FLAG, MAX(check,om_Opts.MinCheck),f,l,OM_DEBUG_RETURN_ADDR);
-}
-omError_t omTestAlignedAddr(void* adr, char check, char* file, int line)
-{
-  return _omTestAddr(addr,  bin, 
-                     OM_USED_FLAG|OM_BIN_FLAG|OM_ALIGNED_FLAG|OM_COUNT_FLAG,MAX(check,om_Opts.MinCheck),f,l,OM_DEBUG_RETURN_ADDR);
-}
-omError_t omTestAlignedAddrSize(void* addr, size_t size, char check, char* file, int line)
-{
-  return _omTestAddr(addr, bin,    
-                     OM_USED_FLAG|OM_BIN_FLAG|OM_ALIGNED_FLAG|OM_COUNT_FLAG, MAX(check,om_Opts.MinCheck),f,l,OM_DEBUG_RETURN_ADDR);
-}
-
-/* TBC */
-omError_t omTestBin(omBin bin, char check, char* file, int line)
-{
-  return omError_NoError;
-}
-omError_t omTestMemory(char check, char debug)
-{
-  return omError_NoError;
-}
-
-/*******************************************************************
- *  
- * First level _om* routines: call respective checks and dispatch
- * to second level, i.e., __om routines
- *  
- *******************************************************************/
-static void* _omTestAlloc(void* bin_size, 
-                          int flags, char check, char debug,char* f,const int l,void* r)
-{
-  void* addr;
-  
-  om_ReportError = omError_MemoryCorrupted;
-  if (flags & BIN_FLAG)
-    (void) _omTestBin((omBin)bin_size,check-1,f,l,r);
-  else 
-    (void) _omTestMemory(check-2,f,l,r);
-
-  addr = __omTestAlloc(bin_size, flags, debug, f, l, r);
-  
-#ifdef OM_INTERNAL_DEBUG
-  om_ReportError = omError_InternalBug;
-  (void) _omTestAddr(addr, bin_size,flags|OM_USED_FLAGS,check, __FILE__,__LINE__,0);
-#endif
-
-  om_ReportError = omError_NoError;
-  return new_addr;
-}
-
-
-static void* _omTestRealloc(void* old_addr, void* old_bin_size, void* new_bin_size,
-                            int old_flags, int new_flags, char check, char debug, char* f, const int l, void* r)
-{
-  void* new_addr = NULL;
-  
-  (void*) _omTestAddr(old_addr, old_flags|OM_USED_FLAG, old_bin_size, check, f, l, r);
-
-  new_addr = __omTestRealloc(old_addr, old_bin_size, new_bin_size,
-                             old_flags, new_flags, debug, f, l, r);
-#ifdef OM_INTERNAL_DEBUG
-  om_ReportError = omError_InternalBug;
-  (void) _omTestAddr(new_addr, bin_size,flags|OM_USED_FLAGS,check, __FILE__,__LINE__,0);
-  om_ReportError = omError_NoError;
-#endif
-
-  return new_addr;
-}
-
-
-static void _omTestFree(void* addr, void* size_bin,
-                        int flags, char check, char* f, const int l, void* r)
-{
-  if (! _omTestAddr(addr, size_bin, flags, check, f, l, r))
-    __omTestFree(addr,size_bin,flags,f,l,r);
-  
-#ifdef OM_INTERNAL_DEBUG
-  om_ReportError = omError_InternalBug;
-  if (flags & BIN_FLAG)
-    (void) _omTestBin((omBin)bin_size,check-1,__FILE__,__LINE__,0);
-  else 
-    (void) _omTestMemory(check-2,__FILE__,__LINE__,0);
-  om_ReportError = omError_NoError;
-#endif
-}
-
-
-static omError_t _omTestAddr(void* addr, void* size_bin,
-                        int flags, char check, char* f, const int l, void* r)
-{
-  if (check <= 0) return omError_NoError;
-  
-  if (!__omPrimitiveTestAddr(addr, size_bin, flags, f, l, r) ||
-      !__omTestAddr(addr, size_bin, flags, f, l, r))
-    return om_ErrorStatus;
-  
-  if (check > 1) 
-  {
-    if (omIsDebugAddr(addr))
-    {
-      if (! _omTestBin(omGetBinOfAddr(addr), 1,check-1, f, l, r))
-        return om_ErrorStatus;
-      if (flags & OM_BIN_FLAG)
-        return _omTestBin((omBin) bin_size, 0, check - 1, f, l, r);
-    }
-    else
-    {
-      if (omIsBinAddr(addr))
-        return _omTestBin(omGetBinOfAddr(addr), 0, check-1, f, l, r);
-      else if (check > 2)
-        return _omTestMemory(check-2, f, l, r);
-    }
-  }
-
-  return om_ErrorStatus = omError_NoError;
-}
-
-
-static omError_t _omTestBin(omBin bin, char is_debug_bin, 
-                            char check, char* f, const int l, void* r)
-{
-  if (check <= 0) return omError_NoError;
-  
-  if (! __omPrimitiveTestBin(bin, f, l, r) ||
-      ! __omTestBin(bin, is_debug_bin, check - 1, f, l, r))
-    return om_ErrorStatus;
-  
-  if (check > 1) 
-    return _omTestMemory(check - 1, f, l, r);
-
-  return om_ErrorStatus = omError_NoError;
-}
-
-
-static omError_t _omTestMemory(char check, char* f, const int l, void* r)
-{
-  int i = 0;
-  omSpecBin s_bin;
-  void* addr;
-  
-  if (check <= 0) return omError_NoError;
-  
-  if (! omTestBinPagesReagions(check, f, l, r)) return om_ErrorStatus;
-  
-  for (i=0; i<= OM_MAX_BIN_INDEX; i++)
-  {
-    if (! __omTestBin(&om_StaticBin[i], 0, check - 1, f, l, r))
-      return om_ErrorStatus;
-  }
-
-  for (i=0; i<= OM_MAX_DEBUG_BIN_INDEX; i++)
-  {
-    if (! __omTestBin(&om_StaticDebugBin[i], 1, check -1, f, l, r))
-      return om_ErrorStatus;
-  }
-  
-  s_bin = om_SpecBin;
-  while (s_bin != NULL)
-  {
-    if (! __omTestBin(s_bin->bin, 0,check - 1, f, l, r)) 
-      return om_ErrorStatus;
-    s_bin = s_bin->next;
-  }
-  
-
-  addr = FirstKeptDebugAddr;
-  
-  while (addr != NULL)
-  {
-    if (! __omTestAddr(addr, NULL, OM_FREE_FLAG, f, l, r))
-      return om_ErrorStatus;
-    addr = *((void**) addr);
-  }
-    
-  return om_ErrorStatus = omError_NoError;
-}
-
-/*******************************************************************
- *  
- * Second level __om* routines: do the actual work, no checks, 
- * assume that everything is ok
- *  
- *******************************************************************/
-static void* __omTestAlloc(void* bin_size, 
-                           int flags, char check, char debug,char* f,const int l,void* r)
+static void* __omDebugAlloc(void* size_bin, omTrackFlags_t flags, char track, OM_FLR_DECL)
 {
   void* o_addr;
-  o_size = (flags & OM_BIN_FLAG ? ((omBin)bin)->sizeW << LOG_SIZEOF_LONG : (size_t) bin_size);
-  
-  if (debug > 0)
-  {
-    omDebugAddr d_addr;
-    size_t d_size, o_size;
-
-    d_size = omOutSize_2_DebugSize(o_size, debug);
-    
-    d_addr = omAllocDebugAddr(d_size);
-    
-    d_addr->next = (void*) -1;
-    d_addr->debug = debug;
-    d_addr->alloc_file = f;
-    d_addr->alloc_line = l;
-    
-    if (debug > 1)
-    {
-      memset(&d_addr->alloc_frames, 0, OM_MAX_FRAMES*SIZEOF_VOIDP);
-      omGetCurrentBackTrace(&d_addr->alloc_frames, OM_MAX_FRAMES, r);
-      
-      if (debug > 2)
-      {
-        char* pattern;
-        
-        d_addr->size_bin = size_bin;
-        d_addr->flags = flags | USED_FLAG;
-        d_addr->debugs = 0;
-
-        if (debug > 3)
-        {
-          d_addr->free_line = -1;
-          d_addr->free_file = (char*) -1;
-          
-          if (debug > 4)
-            memset(&d_addr->free_frames, 0, OM_MAX_FRAMES*SIZEOF_VOIDP);
-        }
-
-        memset(omDebugAddr_2_FrontPattern(d_addr), OM_FRONT_PATTER, OM_SIZEOF_FRONT_PATTERN);
-        memset(omDebugAddr_2_BackPattern(d_addr), OM_BACK_PATTER, omDebugAddr_2_BackPatternSize(d_addr));
-      }
-    }
-    o_addr = omDebugAddr_2_OutAddr(d_addr);
-    if (flags & OM_ZERO_FLAG) memset(o_addr, 0, o_size);
+  size_t o_size = (flags & OM_FBIN ? ((omBin)size_bin)->sizeW << LOG_SIZEOF_LONG : (size_bin != NULL ? (size_t) size_bin: 1));
+  
+#ifdef OM_HAVE_TRACK
+  if (track > 0)
+  {
+    o_addr = omAllocTrackAddr(size_bin, flags, track, OM_FLR_VAL);
   }
   else
-  {
-    if (flags & OM_BIN_FLAG)
-    {
-      omBin bin = (omBin) bin_size;
-
-      if (flags & ZERO_FLAG)
-        __omTypeAllo0cBin(void*, o_addr, bin);
+#endif
+  {
+    if (flags & OM_FBIN)
+    {
+      omBin bin = (omBin) size_bin;
+
+      if (flags & OM_FZERO)
+        __omTypeAlloc0Bin(void*, o_addr, bin);
       else
         __omTypeAllocBin(void*, o_addr, bin);
@@ -466 +292 @@
     else
     {
-      if (flags & ZERO_FLAG)
+      if (flags & OM_FZERO)
       {
-        if (flags & OM_ALIGNED_FLAG)
+#ifdef OM_ALIGNMENT_NEEDS_WORK
+        if (flags & OM_FALIGN)
           __omTypeAlloc0Aligned(void*, o_addr, o_size);
         else
+#endif
           __omTypeAlloc0(void*, o_addr, o_size);
       }
       else
       {
-        if (flags & OM_ALIGNED_FLAG)
+#ifdef OM_ALIGNMENT_NEEDS_WORK
+        if (flags & OM_FALIGN)
           __omTypeAllocAligned(void*, o_addr, o_size);
         else
+#endif
           __omTypeAlloc(void*, o_addr, o_size);
       }
@@ -483 +313 @@
   }
   
-  if (! (flags & OM_ZERO_FLAG)) memset(o_addr, OM_INIT_PATTERN, o_size);
-  
   return o_addr;
 }
-static omDebugAddr omAllocDebugAddr(size_t d_size)
-{
-  omDebugAddr d_addr;
-  omBin bin;
-  
-  if (d_size <= OM_MAX_DEBUG_BLOCK_SIZE)
-    bin = omSize2DebugBin(d_size);
+
+static void* __omDebugRealloc(void* old_addr, void* old_size_bin, void* new_size_bin,
+                              omError_t old_status, omTrackFlags_t  old_flags, omTrackFlags_t  new_flags, 
+                              char track, OM_FLR_DECL)
+{
+  void* new_addr;
+  size_t old_size = (old_flags & OM_FSIZE ? (size_t) old_size_bin :
+                     (omSizeOfAddr(old_addr)));
+  size_t new_size;
+                 
+  omAssume(new_flags & OM_FSIZE || new_flags & OM_FBIN);
+  
+  if (old_addr == NULL || ((old_flags & OM_FSIZE) && old_size_bin == NULL))
+  {
+    new_addr = __omDebugAlloc(new_size_bin, new_flags, track, OM_FLR_VAL);
+  }
+  else if (om_Opts.Keep > 0 || track > 0 || omIsTrackAddr(old_addr) || old_status != omError_NoError)
+  {
+    new_addr = __omDebugAlloc(new_size_bin, new_flags, track, OM_FLR_VAL);
+    new_size =  omSizeOfAddr(new_addr);
+    old_size = omSizeOfAddr(old_addr);
+    
+    memcpy(new_addr, old_addr, (old_size < new_size ? old_size : new_size));
+    
+    if ((new_flags & OM_FZERO) && new_size > old_size) 
+      memset(new_addr + old_size, 0, new_size - old_size);
+    if (old_status == omError_NoError) __omDebugFree(old_addr, old_size_bin, old_flags, OM_FLR_VAL);
+  }
   else
-    bin = omGetSpecBin(d_size);
-  
-  __omTypeAllocBin(omTestAddr, d_addr, bin);
-  
-  omAssume(bin->current_page == omGetPageOfAddr(d_addr));
-
-  omSetDebugOfUsedBlocks(bin->current_page->used_blocks);
-  
-  return d_addr;
-}
-
-
-static void* __omTestRealloc(void* old_addr, void* old_bin_size, void* new_bin_size,
-                             int old_flags, int new_flags, char debug, char* f,const int l,void* r)
-{
-  void* new_addr;
-  
-  if (om_Opts.Keep > 0 || debug > 0 || omIsDebugAddr(old_addr))
-  {
-    new_addr = __omTestAlloc(new_bin_size, new_flags, debug, f, l, r);
-    memcpy(new_addr, old_addr, omSizeOfAddr(old_addr));
-    __omTestFree(old_addr, old_bin_size, old_flags, f, l, r);
-  }
-  else
-  {
-    if (new_flags & OM_BIN_FLAG) 
-    {
-      omBin new_bin = (omBin) new_bin_size;
-      omBin old_bin = (omBin) old_bin_size;
+  {
+    if (new_flags & OM_FBIN) 
+    {
+      omBin new_bin = (omBin) new_size_bin;
+      omBin old_bin = (omBin) old_size_bin;
       
-      omAssume(old_flags & OM_BIN_FLAG);
-      if (new_flags & OM_ZERO_FLAG)
+      omAssume(old_flags & OM_FBIN);
+      if (new_flags & OM_FZERO)
         __omTypeRealloc0Bin(old_addr, old_bin, void*, new_addr, new_bin);
       else
@@ -533 +358 @@
     else
     {
-      size_t new_size = (size_t) new_bin_size;
-      omAssume(!(new_flags & OM_BIN_FLAG) && !(old_flags & OM_BIN_FLAG));
+      new_size = (size_t) new_size_bin;
+      if (new_size == 0) new_size = 1;
+      omAssume(!(new_flags & OM_FBIN) && !(old_flags & OM_FBIN));
       
-      if (flags & OM_SIZE_FLAG)
+      if (old_flags & OM_FSIZE)
       {
-        size_t old_size = (size_t) old_bin_size;
+        size_t old_size = (size_t) old_size_bin;
         
-        if (new_flags & OM_ZERO_FLAG)
+        if (new_flags & OM_FZERO)
         {
-          if (new_flags & OM_ALIGNED_FLAG)
-            __omTypeRealloc0AlignedSize(old_addr, old_size, (void*), new_addr, new_size);
+#ifdef OM_ALIGNMENT_NEEDS_WORK
+          if (new_flags & OM_FALIGN)
+            __omTypeRealloc0AlignedSize(old_addr, old_size, void*, new_addr, new_size);
           else
-            __omTypeRealloc0Size(old_addr, old_size, (void*), new_addr, new_size);
+#endif
+            __omTypeRealloc0Size(old_addr, old_size, void*, new_addr, new_size);
         }
         else
         {
-          if (new_flags & OM_ALIGNED_FLAG)
-            __omTypeReallocAlignedSize(old_addr, old_size, (void*), new_addr, new_size);
+#ifdef OM_ALIGNMENT_NEEDS_WORK
+          if (new_flags & OM_FALIGN)
+            __omTypeReallocAlignedSize(old_addr, old_size, void*, new_addr, new_size);
           else
-            __omTypeReallocSize(old_addr, old_size, (void*), new_addr, new_size);
+#endif
+            __omTypeReallocSize(old_addr, old_size, void*, new_addr, new_size);
         }
       }
       else
       {
-        if (new_flags & OM_ZERO_FLAG)
+        if (new_flags & OM_FZERO)
         {
-          if (new_flags & OM_ALIGNED_FLAG)
-            __omTypeRealloc0Aligned(old_addr, (void*), new_addr, new_size);
+#ifdef OM_ALIGNMENT_NEEDS_WORK
+          if (new_flags & OM_FALIGN)
+            __omTypeRealloc0Aligned(old_addr, void*, new_addr, new_size);
           else
-            __omTypeRealloc0(old_addr, (void*), new_addr, new_size);
+#endif
+            __omTypeRealloc0(old_addr, void*, new_addr, new_size);
         }
         else
         {
-          if (new_flags & OM_ALIGNED_FLAG)
-            __omTypeReallocAligned(old_addr, (void*), new_addr, new_size);
+#ifdef OM_ALIGNMENT_NEEDS_WORK
+          if (new_flags & OM_FALIGN)
+            __omTypeReallocAligned(old_addr, void*, new_addr, new_size);
           else
-            __omTypeRealloc(old_addr, (void*), new_addr, new_size);
+#endif
+            __omTypeRealloc(old_addr, void*, new_addr, new_size);
         }
       }
     }
   }
-
   return new_addr;
 }
 
-
-unsigned long om_NumberOfKeptAddrs = 0;
-omDebugAddr om_FirstKeptDebugAddr = NULL;
-omDebugAddr om_LastKeptDebugAddr = NULL;
-static void __omTestFree(void* addr, void* size_bin, int flags, char* f,const int l,void* r)
-{
-  if (omIsDebugAddr(addr))
-  {
-    omDebugAddr d_addr = omOutAddr_2_DebugAddr(addr);
-    
-    d_addr->next = NULL;
-    
-    if (d_addr->debug > 2)
-    {
-      d_addr->flags &= ~OM_USED_FLAG;
-      d_addr->flags |= OM_FREE_FLAG;
-      
-      if (d_addr->debug > 3)
-      {
-        d_addr->free_line = l;
-        d_addr->free_file = f;
-        
-        if (d_addr->debug > 4)
-          omGetCurrentBackTrace(&d_addr->free_frames, OM_MAX_FRAMES, r);
-      }
-    }
-  }
-  
+static omBin omGetOrigSpecBinOfAddr(void* addr)
+{
+  if (omIsBinPageAddr(addr))
+  {
+#ifdef OM_HAVE_TRACK
+    if (omIsBinAddrTrackAddr(addr)) return omGetOrigSpecBinOfTrackAddr(addr);
+    else
+#endif
+    {
+      omBin bin = omGetTopBinOfAddr(addr);
+      if (!omIsStaticNormalBin(bin)) return bin;
+    }
+  }
+  return NULL;
+}
+
+static void __omDebugFree(void* addr, void* size_bin, omTrackFlags_t flags, OM_FLR_DECL)
+{
+  omBin bin = NULL;
+  
+  if (addr == NULL || ((flags & OM_FSIZE) && size_bin == NULL)) return;
   if (om_Opts.Keep > 0)
   {
+#ifdef OM_HAVE_TRACK
+    if (omIsTrackAddr(addr))
+      addr = omMarkAsFreeTrackAddr(addr, 1, OM_FLR_VAL);
+#endif
+    bin = omGetOrigSpecBinOfAddr(addr);
+    if (bin != NULL) 
+    {
+      omSpecBin s_bin = omFindInGList(om_SpecBin, next, bin, (unsigned long) bin);
+      omAssume(s_bin != NULL);
+      (s_bin->ref)++;
+    }
+
     if (om_NumberOfKeptAddrs)
     {
-      omAssume(om_FirstKeptDebugAddr != NULL && om_LastKeptDebugAddr != NULL &&
-               ((om_NumberOfKeptAddr == 1 && om_LastKeptDebugAddr == om_FirstKeptDebugAddr) ||
-                (om_NumberOfKeptAddr != 1 && om_LastKeptDebugAddr != om_FirstKeptDebugAddr)));
+      omAssume(om_KeptAddr != NULL && om_LastKeptAddr != NULL &&
+               ((om_NumberOfKeptAddrs == 1 && om_LastKeptAddr == om_KeptAddr) ||
+                (om_NumberOfKeptAddrs != 1 && om_LastKeptAddr != om_KeptAddr)));
       om_NumberOfKeptAddrs++;
       *((void**) om_LastKeptAddr) = addr;
       om_LastKeptAddr = addr;
+      *((void**) addr) = NULL;
     }
     else
@@ -621 +460 @@
       om_NumberOfKeptAddrs = 1;
       om_LastKeptAddr = addr;
-      om_FirstKeptAddr = addr;
+      om_KeptAddr = addr;
       *((void**) om_LastKeptAddr) = NULL;
     }
@@ -627 +466 @@
     if (om_NumberOfKeptAddrs > om_Opts.Keep)
     {
-      addr = om_FirstKeptAddr;
-      om_FirstKeptAddr = *((void**) addr);
+      omError_t status = omDoCheckAddr(om_KeptAddr, NULL, OM_FKEPT, om_Opts.MinCheck,  
+                                       omError_MemoryCorrupted, OM_FLR_VAL);
+      addr = om_KeptAddr;
+      om_KeptAddr = *((void**) addr);
       om_NumberOfKeptAddrs--;
+      if (status != omError_NoError) return;
     }
     else
       return;
+
+    bin = omGetOrigSpecBinOfAddr(addr);
+  }
+
+#ifdef OM_HAVE_TRACK
+  if (omIsTrackAddr(addr))
+  {
+    omMarkAsFreeTrackAddr(addr, 0, OM_FLR_VAL);
+    omFreeTrackAddr(addr);
   }
   else
-  {
-    if (! omIsDebugAddr(addr))
-    {
-      if (flags & OM_BIN_FLAG) 
-        ___omFreeBin(addr);
-      else if (flags & OM_SIZE_FLAG)
-        __omFreeSize(addr, (size_t) bin_size);
-      else
-        __omFree(addr);
-
-      return;
-    }
-  }
-  
-  if (omIsDebugAddr(addr))
-    omFreeDebugAddr(addr);
-  else
-    __omFree(addr);
-}
-static void omFreeDebugAddr(void* d_addr)
-{
-  omBinPage page;
-  
-  omAssume(d_addr != NULL && omIsDebugAddr(d_addr));
-
-  page = (omBinPage) omGetPageOfAddr((void*) d_addr);
-  omAssume(omIsBinPage(page));
-
-  omUnsetDebugOfUsedBlocks(page->used_blocks);
-
-  om_JustFreedPage = NULL;
-
-  ___omFreeBin(d_addr);
-
-  if (page != om_JustFreedPage)
-    omSetDebugOfUsedBlocks(page->used_blocks);
-}
-
-/*******************************************************************
- *  
- * Second level omCheck routines: do the actual checks
- *  
- *******************************************************************/
-
-#define omIsAddrInValidRange(addr) 1
-
-omError_t omCheckAddr(void* addr, void* bin_size, int flags, char level, char* f, const int l, void* r)
-{
-  if (addr == NULL) 
-    return omReportAddrError(omError_NullAddr, addr, bin_size, flags, f, l, r, "");
-  
-  if (((long) addr  & (SIZEOF_OM_ALIGNMENT - 1)))
-    return omReportAddrError(omError_UnalignedAddr, addr, bin_size, flags, f, l, r,  "");
-
-  if ((flags & OM_ALIGN_FLAG) &&  ((long) addr  & (SIZEOF_OM_STRICT_ALIGNMENT - 1)))
-    return omReportAddrError(omError_UnalignedAddr, addr, bin_size, flags, f, l, r,  "");
-
-  if (! omIsAddrInValidRange(addr))
-    return omReportAddrError(omError_InvalidRange, addr, bin_size, flags, f, l, r,  "");
-
-  if (omIsBinPageAddr(addr))
-  {
-    if (! omCheckPageHeader(omGetPageOfAddr(addr))) 
-      return omReportAddrError(omError_MemoryCorrupted, addr, bin_size, flags, f, l, r,  
-                               "Page Header corrupted");
-
-    if (omIsDebugAddr(addr))
-    {
-      omDebugAddr d_addr = omAddr_2_DebugAddr(addr);
-      if (d_addr->debug < 0 || d_addr->debug > OM_DEBUG_MAX)
-        return omReportAddrError(omError_MemoryCorrupted, addr, bin_size, flags, f, l, r, 
-                                 "debug:%d out of range", d_addr->debug);
-      if (omDebugAddr_2_OutAddr(d_addr) != addr)
-        return omReportAddrError(omError_FalseAddr, addr, bin_size, flags, f, l, r, 
-                                 "omDebugAddr_2_OutAddr(d_addr):%d  != addr:%d",
-                                 omDebugAddr_2_OutAddr(d_addr), addr);
-      if (! omCheckDebugAddr(d_addr, bin_size, flags, level, f, l, r))
-        return om_ErrorStatus;
-      
-      if (level > 1 && 
-          !omCheckBinAddr(d_addr, NULL, (flags &~ OM_SIZE_FLAG) &~ OM_BIN_FLAG , level, f, l, r))
-        return om_ErrorStatus;
-      else
-        return om_ErrorStatus = omError_NoError;
-    }
-    else
-    {
-      return omCheckBinAddr(addr, bin_size, flags, level, f, l, r);
-    }
-  }
-  else
-  {
-    return omCheckLargeAddr(addr, bin_size, flags, level, f, l, r);
-  }
-}
-
-omError_t omCheckLargeAddr(void* addr, void* bin_size, int flags, char level, char* f, const int l, void* r)
-{
-  
-
-
-      
-#endif /* OM_HAVE_DEBUG */
+#endif   
+    if (om_Opts.Keep <= 0 && (flags & OM_FBIN))
+      ___omFreeBin(addr);
+    else if (om_Opts.Keep <= 0 && (flags & OM_FSIZE))
+      __omFreeSize(addr, (size_t) size_bin);
+    else
+      __omFree(addr);
+
+  if (bin != NULL) omUnGetSpecBin(&bin);
+}
+
+void omFreeKeptAddr()
+{
+  void* next;
+  omBin bin;
+  
+  while (om_KeptAddr != NULL)
+  {
+    next = *((void**)om_KeptAddr);
+    bin = omGetOrigSpecBinOfAddr(om_KeptAddr);
+
+#ifdef OM_HAVE_TRACK
+    if (omIsTrackAddr(om_KeptAddr)) 
+    {
+      omMarkAsFreeTrackAddr(om_KeptAddr, 0, OM_FLR);
+      omFreeTrackAddr(om_KeptAddr);
+    }
+    else
+#endif    
+      __omFree(om_KeptAddr);
+
+    if (bin != NULL) omUnGetSpecBin(&bin);
+    om_KeptAddr = next;
+  }
+  om_NumberOfKeptAddrs = 0;
+  om_LastKeptAddr = NULL;
+}
+
+#endif /* ! OM_NDEBUG */

omalloc/omDebug.h

@@ -1 +1 @@
 /*******************************************************************
  *  File:    omDebug.h
- *  Purpose: declaration of main omDebug functions
+ *  Purpose: declaration of common Debug/Check/Track stuff
  *  Author:  obachman@mathematik.uni-kl.de (Olaf Bachmann)
- *  Created: 11/99
- *  Version: $Id: omDebug.h,v 1.3 2000-05-31 13:34:31 obachman Exp $
+ *  Created: 7/00
+ *  Version: $Id: omDebug.h,v 1.4 2000-08-14 12:08:45 obachman Exp $
  *******************************************************************/
-#include "omError.h"
-
-/* Debugging addresses and Bins */
-omError_t omDebugAddrBin(void* addr, omBin bin, int level);
-omError_t omDebugAddr(void* adr, int level);
-omError_t omDebugAddrSize(void* addr, size_t size, int level);
-
-omError_t omDebugAlignedBinAddr(void* addr, int level);
-omError_t omDebugAlignedBinAddrBin(void* addr, omBin bin, int level);
-omError_t omDebugAlignedAddr(void* adr, int level);
-omError_t omDebugAlignedAddrSize(void* addr, size_t size, int level);
-
-omError_t omDebugBin(omBin bin, int level);
-omError_t omDebugBins(int level);
-
-/* combining check and alloc/free */
-void* omDebugAllocBin(omBin bin, int level);
-void* omDebugAlloc0Bin(omBin bin, int level);
-void* omDebugReallocBin(void* addr, omBin old_bin, omBin new_bin, int level);
-void* omDebugRealloc0Bin(void* addr, omBin old_bin, omBin new_bin, int level);
-void  omDebugFreeBin(void* addr, omBin bin, int level);
-
-void* omDebugAlloc(size_t Size, int level);
-void* omDebugAlloc0(size_t Size, int level);
-void* omDebugAllocAligned(size_t Size, int level);
-void* omDebugAlloc0Aligned(size_t Size, int level);
-
-void* omDebugRealloc(void* addr, size_t new_Size, int level);
-void* omDebugRealloc0(void* addr, size_t new_Size, int level);
-void* omDebugReallocAligned(void* addr, size_t new_Size, int level);
-void* omDebugRealloc0Aligned(void* addr, size_t new_Size, int level);
-
-void* omDebugReallocSize(void* addr, size_t old_Size, size_t new_Size, int level);
-void* omDebugRealloc0Size(void* addr, size_t old_Size, size_t new_Size, int level);
-void* omDebugReallocAlignedSize(void* addr, size_t old_Size, size_t new_Size, int level);
-void* omDebugRealloc0AlignedSize(void* addr, size_t old_Size, size_t new_Size, int level);
-
-void omDebugFreeSize(void* addr, size_t size, int level);
-void omDebugFree(void* addr, int level);
-
-void* omDebugAllocAlignedFunc(size_t size);
-void* omDebugReallocAlignedFunc(void* addr, size_t new_size);
-void  omDebugFreeFunc(void* addr);
+#ifndef OM_DEBUG_H
+#define OM_DEBUG_H
 
 
+#if defined(OM_NDEBUG) || ! defined(OM_HAVE_TRACK)
+#define omIsTrackAddr(addr)             0
+#define omIsTrackAddrPage(page)         0
+#define omIsNormalBinPageAddr(addr)     omIsBinPageAddr(addr)
+#define omIsBinAddrTrackAddr(addr)      0
+#else
+#define omIsTrackAddrBinPage(bin_page)  ((bin_page)->used_blocks < 0)
+#define omIsBinAddrTrackAddr(addr)      omIsTrackAddrBinPage(omGetBinPageOfAddr(addr))
+#define omIsTrackAddr(addr)             (omIsBinPageAddr(addr) && omIsBinAddrTrackAddr(addr))
+#define omIsNormalBinPageAddr(addr)     (omIsBinPageAddr(addr) && !omIsBinAddrTrackAddr(addr))
+#endif
+
+#if defined(OM_NDEBUG)
+#define omMarkAsStaticAddr(addr)    ((void)0)
+#define omMarkMemoryAsStatic()      ((void)0)
+#define omUnMarkAsStaticAddr()      ((void)0)
+#define omUnMarkMemoryAsStatic()    ((void)0)
+#define omFreeKeptAddr()            ((void)0)
+#define omPrintUsedAddrs(fd)        ((void)0)
+#define omPrintUsedTrackAddrs(fd)   ((void)0)
+#else
+#define OM_FBIN     1           /* size_bin is bin */
+#define OM_FSIZE    2           /* size_bin is size */
+#define OM_FUSED    4           /* is in use, if set */
+#define OM_FKEPT    8           /* had been freed, if set */
+#define OM_FSTATIC  16          /* if set, considered to be static, i.e. never be freed */
+#define OM_FZERO    32          /* for Alloc0 */
+#define OM_FALIGN   64          /* for AllocAligned */
+#define OM_FSLOPPY  128         /* be sloppy about arguments */
+#define OM_FMAX     250         /* maximal flag: OM_FBIN and OM_FSIZE can not be at the same time, 
+                                   and so can't OM_USED and OM_KEPT. Hence 255 - BIN - USED*/
+typedef unsigned char omTrackFlags_t;
+
+void* _omDebugAlloc(void* size_bin, omTrackFlags_t flags, OM_CTFL_DECL);
+void* _omDebugRealloc(void* old_addr, void* old_size_bin, void* new_size_bin,
+                      omTrackFlags_t old_flags, omTrackFlags_t new_flags, OM_CTFL_DECL);
+void  _omDebugFree(void* addr, void* size_bin, omTrackFlags_t flags, OM_CFL_DECL);
+void* _omDebugMemDup(void* addr, omTrackFlags_t flags, OM_CTFL_DECL);
+char* _omDebugStrDup(const char* addr, OM_TFL_DECL);
+
+omError_t _omDebugBin(omBin bin, OM_CFL_DECL);
+omError_t _omDebugMemory(OM_CFL_DECL);
+omError_t _omDebugAddr(void* addr, void* bin_size, omTrackFlags_t flags, OM_CFL_DECL);
+
+void omFreeKeptAddr();
+void omPrintUsedAddrs(FILE* fd);
+void omPrintUsedTrackAddrs(FILE* fd);
+
+void omMarkAsStaticAddr(void* addr);
+void omMarkMemoryAsStatic();
+void omUnMarkAsStaticAddr(void* addr);
+void omUnMarkMemoryAsStatic();
+#endif /* ! OM_NDEBUG */
+
+/*BEGINPRIVATE*/
+
+#if defined(OM_NDEBUG) || ! defined(OM_HAVE_TRACK)
+#define omGetUsedBlocksOfPage(page)     (page->used_blocks)
+#else
+#define omGetUsedBlocksOfPage(page)     (page->used_blocks & ~(1 << (BIT_SIZEOF_LONG -1)))
+#endif
+
+#ifndef OM_NDEBUG
 
 
+void* om_KeptAddr;
+unsigned long om_MaxAddr;
+unsigned long om_MinAddr;
+
+/***********************************************************************
+ *
+ * omDebugCheck.c
+ *
+ **********************************************************************/
+omError_t omCheckPtr(void* ptr, omError_t report, OM_FLR_DECL);
+omError_t _omCheckAddr(void* addr, void* size_bin, omTrackFlags_t flags, char check,  
+                       omError_t report, OM_FLR_DECL);
+omError_t omDoCheckBinAddr(void* addr, void* bin_size, omTrackFlags_t flags, char level, 
+                           omError_t report, OM_FLR_DECL);
+omError_t _omCheckBin(omBin bin, int normal_bin, char check,  omError_t report, OM_FLR_DECL);
+omError_t _omCheckMemory(char check,  omError_t report, OM_FLR_DECL);
+omError_t omReportAddrError(omError_t error, omError_t report, void* addr, void* bin_size, omTrackFlags_t flags, 
+                            OM_FLR_DECL, const char* fmt, ...);
+omError_t omDoCheckBin(omBin bin, int normal_bin, char level, 
+                       omError_t report, OM_FLR_DECL);
+int omIsKnownTopBin(omBin bin, int normal_bin);
+void omIterateTroughAddrs(int normal, int track, void (*CallBackUsed)(void*), void (*CallBackFree)(void*));
+void omIterateTroughBinAddrs(omBin bin, void (*CallBackUsed)(void*), void (*CallBackFree)(void*));
+omError_t omDoCheckAddr(void* addr, void* bin_size, omTrackFlags_t flags, char level, 
+                        omError_t report, OM_FLR_DECL);
 
 
+/***********************************************************************
+ *
+ * omDebugTrack.c
+ *
+ **********************************************************************/
+#ifdef OM_HAVE_TRACK
+extern omBin_t om_StaticTrackBin[];
+extern omBin om_Size2TrackBin[];
+#define omSmallSize2TrackBin(size)      om_Size2TrackBin[((size) -1)>>LOG_SIZEOF_OM_ALIGNMENT]
+extern omBinPage om_JustFreedPage;
+extern void omFreeTrackAddr(void* addr);
+extern size_t omOutSizeOfTrackAddr(void* addr);
+extern omSpecBin om_SpecTrackBin;
 
+void* omAllocTrackAddr(void* bin_size, omTrackFlags_t flags, char track, OM_FLR_DECL);
+void* omMarkAsFreeTrackAddr(void* addr, int keep, OM_FLR_DECL);
+omError_t omCheckTrackAddr(void* addr, void* bin_size, omTrackFlags_t flags, char level, 
+                           omError_t report_error, OM_FLR_DECL);
+void omPrintTrackAddrInfo(FILE* fd, void* addr);
+omBin omGetOrigSpecBinOfTrackAddr(void* addr);
+size_t omOutSizeOfTrackAddr(void* addr);
+extern int omIsStaticTrackAddr(void* addr);
+#define omSetTrackOfUsedBlocks(ub)      (ub |= (1 << (BIT_SIZEOF_LONG -1)))
+#define omUnsetTrackOfUsedBlocks(ub)    (ub &= ~(1 << (BIT_SIZEOF_LONG -1)))
+#define omIsSetTrackOfUsedBlocks(ub)    (ub & (1 << (BIT_SIZEOF_LONG -1)))
+#else
+#define omIsStaticTrackAddr(addr)   0
+#endif
+
+
+/***********************************************************************
+ *
+ * omBinPage.c
+ *
+ **********************************************************************/
+int omIsKnownMemoryRegion(omBinPageRegion region);
+omError_t omCheckBinPageRegion(omBinPageRegion region, int level, omError_t report, OM_FLR_DECL);
+omError_t omCheckBinPageRegions(int level, omError_t report, OM_FLR_DECL);
+omBinPageRegion omFindRegionOfAddr(void* addr);
+int omIsAddrOnFreeBinPage(void* addr);
+
+/***********************************************************************
+ *
+ * Some Handy Macros 
+ *
+ **********************************************************************/
+#define omCheckReturn(cond) \
+  do {omError_t _status = cond; if (_status) return _status;} while (0)
+#define omCheckReturnError(cond, error) \
+  do {void* _status = (void*) (cond); if (_status) return omReportError(error, report, OM_FLR_VAL, "");} while (0)
+#define omCheckReturnCorrupted(cond) \
+  omCheckReturnError(cond, omError_MemoryCorrupted)
+#define omAddrCheckReturn(cond)                                               \
+do                                                                            \
+{                                                                             \
+  omError_t _status = cond;                                                   \
+  if (_status && _status != omError_MaxError)                                 \
+  {                                                                           \
+    omPrintAddrInfo(stderr, _status, addr, bin_size, flags, "  occured for"); \
+    return _status;                                                           \
+  }                                                                           \
+} while (0)
+#define omAddrCheckReturnError(cond, error) \
+  do {void* _status = (void*) (cond); if (_status) return omReportAddrError(error, report, addr, bin_size, flags, OM_FLR_VAL, "");} while (0)
+#define omAddrCheckReturnCorrupted(cond) \
+  omAddrCheckReturnError(cond, omError_MemoryCorrupted)
+
+#endif /* ! OM_NDEBUG */
+/*ENDPRIVATE*/
+
+#endif /* OM_DEBUG_H */

omalloc/omFindExec.c

@@ -4 +4 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 11/99
- *  Version: $Id: omFindExec.c,v 1.2 2000-05-31 13:34:31 obachman Exp $
+ *  Version: $Id: omFindExec.c,v 1.3 2000-08-14 12:08:45 obachman Exp $
  *******************************************************************/
 
@@ -20 +20 @@
 #define MAXPATHLEN 1024
 #endif
-
 
 /* ABSOLUTE_FILENAME_P (fname): True if fname is an absolute filename */
@@ -36 +35 @@
 char * omFindExec (const char *name, char* executable)
 #else
-char * omFindExec_link (const char *name, char* executable)
+static char * omFindExec_link (const char *name, char* executable)
 #endif
 {
   char *search;
   char *p;
+#ifdef WINNT
+  char *extra = NULL;
+#endif
   char tbuf[MAXPATHLEN];
 
@@ -84 +86 @@
       char *extra = NULL;
       /* we are under msdos display */
-      FIX ME
-        extra = (char*) AllocL((search != NULL ? strlen(search) : 0) + 3);
+      extra = (char*) omAlloc((search != NULL ? strlen(search) : 0) + 3);
       strcpy(extra, ".:");
       if (search != NULL) strcat(extra, search);
@@ -125 +126 @@
 #ifdef WINNT
           if (extra != NULL)
-            FreeL(extra);
+            omFree(extra);
 #endif
           strcpy(executable, tbuf);
@@ -142 +143 @@
     }
   }
-    
-    return NULL;
-  }
+  return NULL;
+}
 
 #ifdef HAVE_READLINK
+/* similar to readlink, but dont' mess up absolute pathnames */
+static int my_readlink(const char* name, char* buf, size_t bufsize)
+{
+  char buf2[MAXPATHLEN];
+  int ret;
+  
+  if ((ret = readlink(name, buf2, bufsize)) > 0)
+  {
+    buf2[ret] = 0;
+    if (*name == '/' && *buf2 != '/')
+    {
+      char* last = strrchr(name, '/');
+      int i = 0;
+      while (&(name[i]) != last)
+      {
+        buf[i] = name[i];
+        i++;
+      }
+      buf[i] = '/';
+      i++;
+      strcpy(&(buf[i]), buf2);
+      return i + ret;
+    }
+    else
+    {
+      strcpy(buf, buf2);
+    }
+  }
+  return ret;
+}
 
 #define MAX_LINK_LEVEL 10
@@ -152 +182 @@
    followed up to MAX_LINK_LEVEL
 */
-int full_readlink(const char* name, char* buf, size_t bufsize)
+static int full_readlink(const char* name, char* buf, size_t bufsize)
 {
   int ret;
   
-  if ((ret=readlink(name, buf, bufsize)) > 0)
+  if ((ret=my_readlink(name, buf, bufsize)) > 0)
   {
     char buf2[MAXPATHLEN];
@@ -164 +194 @@
     {
       buf[ret] = '\0';
-      if ((ret2 = readlink(buf, buf2, MAXPATHLEN)) > 0)
+      if ((ret2 = my_readlink(buf, buf2, MAXPATHLEN)) > 0)
       {
         i++;
@@ -195 +225 @@
   if (link != NULL && (ret=full_readlink(link, buf, MAXPATHLEN)) > 0)
   {
+    char *p = strrchr(link, '/');
+
+
+    if(p!=NULL) *(p+1)='\0';
     buf[ret]='\0';
-    return omFindExec_link(buf, exec);
+
+    if (buf[0] != '/')
+    {
+      strcpy(exec, link);
+      strcat(exec, buf);
+    }
+    else
+    {
+      strcpy(exec, buf);
+    }
+
+    return exec;
   }
   return link;

omalloc/omFindExec.h

@@ -4 +4 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 11/99
- *  Version: $Id: omFindExec.h,v 1.1.1.1 1999-11-18 17:45:54 obachman Exp $
+ *  Version: $Id: omFindExec.h,v 1.2 2000-08-14 12:08:46 obachman Exp $
  *******************************************************************/
 #ifndef OM_FIND_EXEC_H
 #define OM_FIND_EXEC_H
 
-#include <stdio.h>
 /* determines absolute pathname of program prog, writes it into exec */
 /* returns exec on succes, NULL on failure */

omalloc/omList.c

@@ -4 +4 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 11/99
- *  Version: $Id: omList.c,v 1.2 1999-11-22 18:12:59 obachman Exp $
+ *  Version: $Id: omList.c,v 1.3 2000-08-14 12:08:46 obachman Exp $
  *******************************************************************/
+#include "omConfig.h"
+
 #ifndef NULL
 #define NULL ((void*) 0)
@@ -169 +171 @@
 
 
+#ifndef OM_NDEBUG
+#include "omAlloc.h"
+#include "omDebug.h"
+
+omError_t _omCheckList(void* list, int next, int level, omError_t report, OM_FLR_DECL)
+{
+  if (level <= 1) return omError_NoError;
+  
+  if (level == 1)
+  {
+    while (list != NULL)
+    {
+      omCheckReturn(omCheckPtr(list, report, OM_FLR_VAL));
+      ITER(list);
+    }
+  }
+  else
+  {
+    void* l1 = list;
+    void* l2;
+    int l = 0, i;
+
+    l1 = list;
+    while (l1 != NULL)
+    {
+      omCheckReturn(omCheckPtr(l1, report, OM_FLR_VAL));
+      i = 0;
+      l2 = list;
+      while (l1 != l2)
+      {
+        i++;
+        ITER(l2);
+      }
+      if (i != l) 
+        return omReportError(omError_ListCycleError, report, OM_FLR_VAL, "");
+      ITER(l1);
+      l++;
+    }
+  }
+  return omError_NoError;
+}
+
+omError_t _omCheckSortedList(void* list, int next, int long_field, int level, omError_t report, OM_FLR_DECL)
+{
+  void* prev = NULL;
+  
+  if (level <= 1) return omError_NoError;
+  
+  if (level == 1)
+  {
+    while (list != NULL)
+    {
+      omCheckReturn(omCheckPtr(list, report, OM_FLR_VAL));
+      if (prev != NULL && VALUE(prev, long_field) > VALUE(list, long_field))
+        return omReportError(omError_SortedListError, report, OM_FLR_VAL, 
+                             "%d > %d", VALUE(prev, long_field), VALUE(list, long_field));
+      prev = list;
+      ITER(list);
+    }
+  }
+  else
+  {
+    void* l1 = list;
+    void* l2;
+    int l = 0, i;
+
+    while (l1 != NULL)
+    {
+      omCheckReturn(omCheckPtr(l1, report, OM_FLR_VAL));
+      if (prev != NULL && VALUE(prev, long_field) > VALUE(l1, long_field))
+        return omReportError(omError_SortedListError, report, OM_FLR_VAL, 
+                             "%d > %d", VALUE(prev, long_field), VALUE(l1, long_field));
+      i = 0;
+      l2 = list;
+      while (l1 != l2)
+      {
+        i++;
+        ITER(l2);
+      }
+      omCheckReturnError(i != l, omError_ListCycleError);
+      prev = l1;
+      ITER(l1);
+      l++;
+    }
+  }
+  return omError_NoError;
+}
+#endif
+
+

omalloc/omList.h

@@ -4 +4 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 11/99
- *  Version: $Id: omList.h,v 1.1.1.1 1999-11-18 17:45:53 obachman Exp $
+ *  Version: $Id: omList.h,v 1.2 2000-08-14 12:08:46 obachman Exp $
  *******************************************************************/
 
 #ifndef OM_LIST_H
 #define OM_LIST_H
-
 
 #define OM_LIST_OFFSET(ptr, name_of_offset_field) \
@@ -50 +49 @@
 void* _omInsertInSortedList(void* list, int next, int long_field, 
                             void* addr);
-
+#ifndef OM_NDEBUG
+/* Check whether list is ok, i.e. whether addr of lists are aligned and in valid range */
+omError_t _omCheckList(void* list, int next, int level, omError_t report, OM_FLR_DECL);
+/* like above, but also check that sorting is ok */
+omError_t _omCheckSortedList(void* list, int next, int long_field, int level, omError_t report, OM_FLR_DECL);
+#endif
 
 /********************************************************************
@@ -68 +72 @@
   _omRemoveFromList(ptr, 0, addr)
 #define omFindInList(ptr, what, value) \
-  _omFindInList(ptr, 0, OM_LIST_OFFSET(ptr, what), value)
+  _omFindInList(ptr, 0, OM_LIST_OFFSET(ptr, what), (unsigned long) value)
 #define omInsertInSortedList(ptr, what, addr) \
   _omInsertInSortedList(ptr, 0, OM_LIST_OFFSET(ptr, what), addr)
@@ -75 +79 @@
 #define omRemoveFromSortedList(ptr, what, addr) \
   _omRemoveFromSortedList(ptr, 0, OM_LIST_OFFSET(ptr, what), addr)
-
+#ifndef OM_NDEBUG
+#define omCheckList(ptr, level, report, OM_FLR_VAL) \
+  _omCheckList(ptr, 0, level, report, OM_FLR_VAL)
+#define omCheckSortedList(ptr, what, level, report, OM_FLR_VAL) \
+  _omCheckSortedList(ptr, 0, OM_LIST_OFFSET(ptr, what), level, report, OM_FLR_VAL)
+#endif
 
 /********************************************************************
@@ -93 +102 @@
   _omRemoveFromList(ptr, OM_LIST_OFFSET(ptr, next), addr)
 #define omFindInGList(ptr, next, what, value) \
-  _omFindInList(ptr, OM_LIST_OFFSET(ptr, next), OM_LIST_OFFSET(ptr, what), value)
+  _omFindInList(ptr, OM_LIST_OFFSET(ptr, next), OM_LIST_OFFSET(ptr, what), (unsigned long) value)
 #define omInsertInSortedGList(ptr, next, what, addr) \
   _omInsertInSortedList(ptr, OM_LIST_OFFSET(ptr, next), OM_LIST_OFFSET(ptr, what), addr)
@@ -100 +109 @@
 #define omRemoveFromSortedGList(ptr, next, what, addr) \
   _omRemoveFromSortedList(ptr, OM_LIST_OFFSET(addr,next),OM_LIST_OFFSET(addr,what),addr)
+#ifndef OM_NDEBUG
+#define omCheckGList(ptr, next, level, report, OM_FLR_VAL) \
+ _omCheckList(ptr, OM_LIST_OFFSET(ptr,next), level, report, OM_FLR_VAL)
+#define omCheckSortedGList(ptr, next, what, level, report, OM_FLR_VAL) \
+ _omCheckSortedList(ptr, OM_LIST_OFFSET(ptr,next), OM_LIST_OFFSET(ptr,what), level, report, OM_FLR_VAL)
+#endif
 
 #endif /* OM_LIST_H */

omalloc/omMemOps.h

@@ -4 +4 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 11/99
- *  Version: $Id: omMemOps.h,v 1.1.1.1 1999-11-18 17:45:53 obachman Exp $
+ *  Version: $Id: omMemOps.h,v 1.2 2000-08-14 12:08:46 obachman Exp $
  *******************************************************************/
 
@@ -28 +28 @@
 #else /* ! DO_DEEP_PROFILE */
 
-#define omMemcpyW(p1, p2, l)                      \
+#define omMemcpyW(p1, p2, l)                    \
 do                                              \
 {                                               \
   long _i = l;                                  \
-  long* _s1 = (long*) p1;                       \
-  const long* _s2 = (long*) p2;                 \
+  long* _s1 = (long*) (p1);                       \
+  const long* _s2 = (long*) (p2);                 \
                                                 \
   for (;;)                                      \
@@ -46 +46 @@
 while(0)
 
-#define omMemcpy_nwODD(p1, p2, l)                 \
+#define omMemcpy_nwODD(p1, p2, l)               \
 do                                              \
 {                                               \
-  long _i = l - 1;                              \
-  long* _s1 = (long*) p1;                       \
-  const long* _s2 = (long*) p2;                 \
+  long _i = (l) - 1;                              \
+  long* _s1 = (long*) (p1);                       \
+  const long* _s2 = (long*) (p2);                 \
                                                 \
   *_s1++ = *_s2++;                              \
@@ -64 +64 @@
 while(0)
 
-#define omMemcpy_nwEVEN(p1, p2, l)                \
+#define omMemcpy_nwEVEN(p1, p2, l)              \
 do                                              \
 {                                               \
   long _i = l;                                  \
-  long* _s1 = (long*) p1;                       \
-  const long* _s2 = (long*) p2;                 \
+  long* _s1 = (long*) (p1);                       \
+  const long* _s2 = (long*) (p2);                 \
                                                 \
   for (;;)                                      \
@@ -81 +81 @@
 while(0)
 
-#define omMemaddW(P1, P2, P3, L)                  \
+#define omMemaddW(P1, P2, P3, L)                \
 do                                              \
 {                                               \
@@ -98 +98 @@
 while(0)
 
-#define omMemadd_nwODD(P1, P2, P3, L)             \
+#define omMemadd_nwODD(P1, P2, P3, L)           \
 do                                              \
 {                                               \
@@ -119 +119 @@
 while(0)
 
-#define omMemadd_nwEVEN(P1, P2, P3, L)            \
+#define omMemadd_nwEVEN(P1, P2, P3, L)          \
 do                                              \
 {                                               \
@@ -137 +137 @@
 while(0)
 
-#define omMemadd_nwONE(P1, P2, P3)                \
+#define omMemadd_nwONE(P1, P2, P3)              \
 do                                              \
 {                                               \
@@ -148 +148 @@
 while(0)
 
-#define omMemadd_nwTWO(P1, P2, P3)                \
+#define omMemadd_nwTWO(P1, P2, P3)              \
 do                                              \
 {                                               \
@@ -160 +160 @@
 while(0)
 
-#define omMemsetW(P1, W, L)                       \
+#define omMemsetW(P1, W, L)                     \
 do                                              \
 {                                               \
-  long* _p1 = (long*) P1;                               \
+  long* _p1 = (long*) (P1);                     \
   unsigned long _l = L;                         \
-                                                \
+  unsigned long _w = W;                         \
   while(_l)                                     \
   {                                             \
-    *_p1++ = W;                                 \
+    *_p1++ = _w;                                \
     _l--;                                       \
   }                                             \

omalloc/omPage.h

@@ -4 +4 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 11/99
- *  Version: $Id: omPage.h,v 1.3 2000-05-31 13:34:32 obachman Exp $
+ *  Version: $Id: omPage.h,v 1.4 2000-08-14 12:08:46 obachman Exp $
  *******************************************************************/
 #ifndef OM_PAGE_H
@@ -108 +108 @@
   ((void*) ((long) (addr) & ~(SIZEOF_SYSTEM_PAGE -1)))
 
+#define omGetBinPageOfAddr(addr) \
+  ((omBinPage) ((long) (addr) & ~(SIZEOF_SYSTEM_PAGE -1)))
+
 #define omIsAddrOnPage(addr, page) (omGetPageOfAddr(addr) == (void*) (page))
 

omalloc/omTables.c

@@ -4 +4 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 11/99
- *  Version: $Id: omTables.c,v 1.2 2000-05-31 13:34:32 obachman Exp $
+ *  Version: $Id: omTables.c,v 1.3 2000-08-14 12:08:47 obachman Exp $
  *******************************************************************/
 
@@ -16 +16 @@
 #include <string.h>
 #include "omConfig.h"
-#include "omAlloc.h"
+#include "omDerivedConfig.h"
+#include "omStructs.h"
+#include "omAllocPrivate.h"
 
 /* Specify the minimal number of blocks which should go into a bin */
@@ -62 +64 @@
 #endif /* OM_ALIGN_8 */
 
-void OutputSize2Bin(size_t *binSize, size_t max_block_size)
+void OutputSize2Bin(size_t *binSize, size_t max_block_size, int track)
 {
   int i, j;
-  printf("omBin om_Size2Bin[/*%d*/] = {\n",
-         max_block_size / SIZEOF_OM_ALIGNMENT);
+  printf("omBin om_Size2%sBin[/*%d*/] = {\n",
+         (track? "Track" : ""), max_block_size / SIZEOF_OM_ALIGNMENT);
   i=0;
   j=SIZEOF_OM_ALIGNMENT;
   while (j < max_block_size)
   {
-    printf("&om_StaticBin[%d], /* %d */ \n", i, j);
+    printf("&om_Static%sBin[%d], /* %d */ \n", (track? "Track" : ""), i, j);
     if (binSize[i] == j) i++;
     j += SIZEOF_OM_ALIGNMENT;
   }
-  printf("&om_StaticBin[%d] /* %d */};\n\n", i, j);
-}
-
-void OutputSize2AlignedBin(size_t *binSize, size_t max_block_size)
+  printf("&om_Static%sBin[%d] /* %d */};\n\n", (track? "Track" : ""), i, j);
+}
+
+void OutputSize2AlignedBin(size_t *binSize, size_t max_block_size, int track)
 {
   int i, j;
@@ -86 +88 @@
     _exit(1);
   }
-  printf("omBin om_Size2AlignedBin[/*%d*/] = {\n",
-         max_block_size / SIZEOF_OM_ALIGNMENT);
+  printf("omBin om_Size2%sBin[/*%d*/] = {\n",
+         (track ? "Track" : "Aligned"), max_block_size / SIZEOF_OM_ALIGNMENT);
   i=0;
   while (binSize[i] % SIZEOF_STRICT_ALIGNMENT != 0) i++;
@@ -93 +95 @@
   while (j < max_block_size)
   {
-    printf("&om_StaticBin[%d], /* %d */ \n", i, j);
+    printf("&om_Static%sBin[%d], /* %d */ \n", (track ? "Track" : ""), i, j);
     if (binSize[i] == j)
     {
@@ -101 +103 @@
     j += SIZEOF_OM_ALIGNMENT;
   }
-  printf("&om_StaticBin[%d] /* %d */};\n\n", i, j);
-}
-
-void OutputStaticBin(size_t *binSize, int max_bin_index)
+  printf("&om_Static%sBin[%d] /* %d */};\n\n", (track ? "Track" : ""), i, j);
+}
+
+void OutputStaticBin(size_t *binSize, int max_bin_index, int track)
 {
   int i;
-  printf("omBin_t om_StaticBin[/*%d*/] = {\n", max_bin_index+1);
+  printf("omBin_t om_Static%sBin[/*%d*/] = {\n", (track ? "Track" : ""), max_bin_index+1);
 
   for (i=0;  i< max_bin_index; i++)
@@ -162 +164 @@
 }
 
-int main()
+int main(int argc, char* argv[])
 {
   int max_bin_index = 0;
@@ -174 +176 @@
     if (om_BinSize[max_bin_index] == OM_MAX_BLOCK_SIZE) break;
   }
-  /* output what goes into omAllocPrivate.h */
+  if (argc > 1)
+  {
+    /* output what goes into omTables.h */
+  printf("
+#ifndef OM_TABLES_H
+#define OM_TABLES_H
+#define OM_MAX_BLOCK_SIZE %d
+#define OM_MAX_BIN_INDEX %d
+#define OM_SIZEOF_UNIQUE_MAX_BLOCK_THRESHOLD %d
+#endif /* OM_TABLES_H */
+",  OM_MAX_BLOCK_SIZE, max_bin_index, GetMaxBlockThreshold());
+  return 0;
+  }
+  
   printf("
 #ifndef OM_TABLES_INC
 #define OM_TABLES_INC
-
-#ifdef OM_ALLOC_PRIVATE_H
-#define OM_MAX_BLOCK_SIZE %d
-#define OM_MAX_BIN_INDEX %d
-#define OM_SIZEOF_UNIQUE_MAX_BLOCK_THRESHOLD %d
-#endif /* OM_ALLOC_PRIVATE_H */
-
-#ifdef OM_ALLOC_C
-extern omBinPage_t om_ZeroPage[];
-",  OM_MAX_BLOCK_SIZE, max_bin_index, GetMaxBlockThreshold());
+");
+  
   /* Output om_StaticBin */
-  OutputStaticBin(om_BinSize, max_bin_index);
+  OutputStaticBin(om_BinSize, max_bin_index, 0);
   /* Output om_Size2Bin */
-  OutputSize2Bin(om_BinSize, OM_MAX_BLOCK_SIZE);
-
-#ifdef OM_ALIGNMENT_NEEDS_WORK
-  OutputSize2AlignedBin(om_BinSize, OM_MAX_BLOCK_SIZE);
-#endif
-  
-  printf("
+  OutputSize2Bin(om_BinSize, OM_MAX_BLOCK_SIZE, 0);
+
+#ifdef OM_ALIGNMENT_NEEDS_WORK
+  OutputSize2AlignedBin(om_BinSize, OM_MAX_BLOCK_SIZE, 0);
+#endif
+  
+  printf("\n#ifdef OM_HAVE_TRACK\n");
+  /* Output om_StaticBin */
+  OutputStaticBin(om_BinSize, max_bin_index, 1);
+  /* Output om_Size2Bin */
+#ifdef OM_ALIGNMENT_NEEDS_WORK
+  OutputSize2AlignedBin(om_BinSize, OM_MAX_BLOCK_SIZE, 1);
 #else
-extern omBin_t om_StaticBin[];
-extern omBin om_Size2Bin[];
-extern omBin om_Size2AlignedBin[];
-#endif /* OM_ALLOC_C */
-#endif /* OM_TABLES_INC */
-");
+  OutputSize2Bin(om_BinSize, OM_MAX_BLOCK_SIZE, 1);
+#endif
+  printf("\n#endif /* OM_HAVE_TRACK */\n");
+
+  printf("\n#endif /* OM_TABLES_INC */\n");
   return 0;
 }