Changeset 372

Timestamp:

04/22/15 04:14:59 (10 years ago)

Author:

sz

Message:

Renamed some classes and functions to make their purpose more obvious:

• FramMessage?, FMprintf, etc. become Hmessage, Hprintf, etc... (H for handled message).
• ErrorManager? (and its family) becomes MessageHandler?. Handler names reflect their function better, e.g. MessageHandlerToStdout?.

All MessageHandlers? must now be given the explicit "Enable" argument if you want them to automatically become active. This makes side effects clearly visible.

Location:

cpp

Files:

• common/hmessage.cpp (moved) (moved from cpp/common/framsg.cpp) (3 diffs)
• common/hmessage.h (moved) (moved from cpp/common/framsg.h) (1 diff)
• common/nonstd_math.cpp (modified) (4 diffs)
• common/nonstd_stdio.cpp (modified) (3 diffs)
• common/stl-util.cpp (modified) (3 diffs)
• frams/Makefile-SDK-files (modified) (5 diffs)
• frams/Makefile-maintain (copied) (copied from cpp/frams/Makefile-maintain) (1 diff)
• frams/_demos/f0_variants_test.cpp (modified) (2 diffs)
• frams/_demos/full_props.cpp (modified) (3 diffs)
• frams/_demos/geno_test.cpp (modified) (2 diffs)
• frams/_demos/genoconv_test.cpp (modified) (2 diffs)
• frams/_demos/genomanipulation.cpp (modified) (2 diffs)
• frams/_demos/genooper_test.cpp (modified) (2 diffs)
• frams/_demos/loader_test_param.cpp (modified) (2 diffs)
• frams/_demos/multiline_f0_test.cpp (modified) (1 diff)
• frams/_demos/neuro_layout_test.cpp (modified) (2 diffs)
• frams/_demos/neuro_test.cpp (modified) (2 diffs)
• frams/_demos/shapeconvert.cpp (modified) (5 diffs)
• frams/_demos/simil_test.cpp (modified) (2 diffs)
• frams/genetics/f1/conv_f1.cpp (modified) (3 diffs)
• frams/genetics/f4/conv_f4.cpp (modified) (3 diffs)
• frams/genetics/f4/f4_general.cpp (modified) (2 diffs)
• frams/genetics/f4/oper_f4.cpp (modified) (2 diffs)
• frams/genetics/genman.cpp (modified) (9 diffs)
• frams/genetics/geno.cpp (modified) (1 diff)
• frams/genetics/oper_fx.cpp (modified) (3 diffs)
• frams/mhandlers (moved) (moved from cpp/frams/errmgr)
• frams/mhandlers/errmanager.cpp (deleted)
• frams/mhandlers/errmanager.h (deleted)
• frams/mhandlers/mhandlers.cpp (copied) (copied from cpp/frams/errmgr/errmanager.cpp) (9 diffs)
• frams/mhandlers/mhandlers.h (copied) (copied from cpp/frams/errmgr/errmanager.h) (8 diffs)
• frams/mhandlers/stderrors.cpp (modified) (3 diffs)
• frams/mhandlers/stdouterr.cpp (deleted)
• frams/mhandlers/stdouterr.h (deleted)
• frams/mhandlers/stdouthandler.cpp (copied) (copied from cpp/frams/errmgr/stdouterr.cpp) (2 diffs)
• frams/mhandlers/stdouthandler.h (copied) (copied from cpp/frams/errmgr/stdouterr.h) (1 diff)
• frams/model/geometry/geometryutils.cpp (modified) (2 diffs)
• frams/model/geometry/meshbuilder.cpp (modified) (2 diffs)
• frams/model/geometry/modelgeometryinfo.cpp (modified) (2 diffs)
• frams/model/model.cpp (modified) (19 diffs)
• frams/neuro/neurofactory.cpp (modified) (1 diff)
• frams/neuro/neuroimpl.cpp (modified) (2 diffs)
• frams/neuro/neuroimpl.h (modified) (1 diff)
• frams/param/multiparamload.cpp (modified) (5 diffs)
• frams/param/param.cpp (modified) (12 diffs)
• frams/param/param.h (modified) (2 diffs)
• frams/util/3d.cpp (modified) (5 diffs)
• frams/util/extvalue.cpp (modified) (26 diffs)
• frams/util/sstringutils.cpp (modified) (2 diffs)
• frams/virtfile/stdiofile.cpp (modified) (5 diffs)
• frams/vm/classes/collectionobj.cpp (modified) (2 diffs)

cpp/common/hmessage.cpp

@@ -3 +3 @@
 // See LICENSE.txt for details.
 
-#include "framsg.h"
+#include "hmessage.h"
 #include <common/nonstd_stdio.h>
 #include "stl-util.h"
 #include "Convert.h"
 
-const char* MSG_LEVEL[]={"[DEBUG] ","","[WARN] ","[ERROR] ","[CRITICAL] "};
+const char* HMSG_LEVEL[]={"[DEBUG] ","","[WARN] ","[ERROR] ","[CRITICAL] "};
 
-void FramMessage(const char *o, const char *m, const char *txt, int w)
+void Hmessage(const char *o, const char *m, const char *txt, int w)
 {
         int line = 0; //all lines except the first one get the "..." prefix
@@ -24 +24 @@
                 {
                         if (*nextsep == 0) //there was only one line! no need to modify it in any way.
-                                _FramMessageSingleLine(o, m, txt, w);
+                                _HmessageSingleLine(o, m, txt, w);
                         else //first line from multi-line
-                                _FramMessageSingleLine(o, m, string(txt, nextsep - txt).c_str(), w);
+                                _HmessageSingleLine(o, m, string(txt, nextsep - txt).c_str(), w);
                 }
                 else //consecutive lines from multi-line
-                        _FramMessageSingleLine(o, m, (FRAMSG_MULTILINE_CONTINUATION + string(txt, nextsep - txt)).c_str(), w); //could also add line numbers like ...(3)... but let's keep the prefix short and simple
+                        _HmessageSingleLine(o, m, (HMSG_MULTILINE_CONTINUATION + string(txt, nextsep - txt)).c_str(), w); //could also add line numbers like ...(3)... but let's keep the prefix short and simple
                 line++;
                 if ((nextsep[0] == '\r') && (nextsep[1] == '\n'))
@@ -39 +39 @@
 
 
-void FMprintf_va(const char *o,const char *m,int w,const char *bl,va_list va)
+void Hprintf_va(const char *o,const char *m,int w,const char *bl,va_list va)
 {
         string buf=ssprintf_va(bl,va);
-        FramMessage(o,m,buf.c_str(),w);
+        Hmessage(o,m,buf.c_str(),w);
 }
 
-void FMprintf(const char *o,const char *m,int w,const char *bl, ...)
+void Hprintf(const char *o,const char *m,int w,const char *bl, ...)
 {
         va_list argptr;
         va_start(argptr,bl);
-        FMprintf_va(o,m,w,bl,argptr);
+        Hprintf_va(o,m,w,bl,argptr);
         va_end(argptr);
 }
 
-void printFM(const char *bl,...)
+void printH(const char *bl,...)
 {
         va_list argptr;
         va_start(argptr,bl);
-        FMprintf_va("Message","printf",FMLV_INFO,bl,argptr);
+        Hprintf_va("Message","printf",HMLV_INFO,bl,argptr);
         va_end(argptr);
 }

cpp/common/hmessage.h

@@ -3 +3 @@
 // See LICENSE.txt for details.
 
-#ifndef _FRAMSG_H_
-#define _FRAMSG_H_
+#ifndef _HMESSAGE_H_
+#define _HMESSAGE_H_
 
 #include <stdarg.h>
 
-extern const char* MSG_LEVEL[];
-#define FRAMSG_FORMAT "%s%s.%s: %s"
-#define FRAMSG_MULTILINE_CONTINUATION "..."
+extern const char* HMSG_LEVEL[];
+#define HMSG_FORMAT "%s%s.%s: %s"
+#define HMSG_MULTILINE_CONTINUATION "..."
 
-void FMprintf(const char *o,const char *m,int w,const char *bl, ...);
-void FMprintf_va(const char *o,const char *m,int w,const char *bl,va_list va); //a different name than FMprintf - otherwise the compiler could confuse the "string" parameter with va_list and could call the wrong function
-void printFM(const char *bl,...); //a shorthand for printf (a different name again to avoid the risk of confusion with the two functions above. This would be unlikely but possible when the argument types would match)
-void FramMessage(const char *o,const char *m,const char *txt,int w);
+void Hprintf(const char *o,const char *m,int w,const char *bl, ...);
+void Hprintf_va(const char *o,const char *m,int w,const char *bl,va_list va); //a different name than Hprintf - otherwise the compiler could confuse the "string" parameter with va_list and could call the wrong function
+void printH(const char *bl,...); //a shorthand for printf (a different name again to avoid the risk of confusion with the two functions above. This would be unlikely but possible when the argument types would match)
+void Hmessage(const char *o,const char *m,const char *txt,int w);
 
-void _FramMessageSingleLine(const char *o,const char *m,const char *txt,int w); //don't call this directly - it is used internally
+void _HmessageSingleLine(const char *o,const char *m,const char *txt,int w); //don't call this directly - it is used internally
 
-#define FMLV_DEBUG -1
-#define FMLV_INFO 0
-#define FMLV_WARN 1
-#define FMLV_ERROR 2
-#define FMLV_CRITICAL 3
+#define HMLV_DEBUG -1
+#define HMLV_INFO 0
+#define HMLV_WARN 1
+#define HMLV_ERROR 2
+#define HMLV_CRITICAL 3
 
 /*

cpp/common/nonstd_math.cpp

@@ -81 +81 @@
 // But it was resolved by restarting windows and cleaning all intermediate compilation files :o (restarting windows was the key element! restarting BC++Builder and deleting files would not help)
 
-#include "framsg.h"
+#include "hmessage.h"
 
 unsigned int fp_control_word_std;
@@ -89 +89 @@
 {
         //unsigned int was=_clear87();
-        //FMprintf("","fpExceptInit",FMLV_INFO,"control87 status before clear was %08x", was);
+        //Hprintf("","fpExceptInit",HMLV_INFO,"control87 status before clear was %08x", was);
         fp_control_word_std=_control87(0, 0);             //4978 = 1001101110010
         // Make the new fp env same as the old one, except for the changes we're going to make
@@ -98 +98 @@
 {
         unsigned int was=_clear87(); //trzeba czyscic zeby nie bylo exception...
-        //FMprintf("","fpExceptEnable ",FMLV_INFO,"control87 status before clear was %08x", was);
+        //Hprintf("","fpExceptEnable ",HMLV_INFO,"control87 status before clear was %08x", was);
         _control87(fp_control_word_std, 0xffffffff);
-        //FMprintf("","fpExceptEnable ",FMLV_INFO,"control87 flags are %08x", _control87(0, 0)); //kontrola co sie ustawilo
+        //Hprintf("","fpExceptEnable ",HMLV_INFO,"control87 flags are %08x", _control87(0, 0)); //kontrola co sie ustawilo
 }
 
@@ -106 +106 @@
 {
         unsigned int was=_clear87(); //trzeba czyscic zeby nie bylo exception...
-        //FMprintf("","fpExceptDisable",FMLV_INFO,"control87 status before clear was %08x", was);
+        //Hprintf("","fpExceptDisable",HMLV_INFO,"control87 status before clear was %08x", was);
         _control87(fp_control_word_muted, 0xffffffff);
-        //FMprintf("","fpExceptDisable",FMLV_INFO,"control87 flags are %08x", _control87(0, 0)); //kontrola co sie ustawilo
+        //Hprintf("","fpExceptDisable",HMLV_INFO,"control87 flags are %08x", _control87(0, 0)); //kontrola co sie ustawilo
 }
 

cpp/common/nonstd_stdio.cpp

@@ -241 +241 @@
 
 #ifdef __ANDROID__
-#include "framsg.h"
+#include "hmessage.h"
 #include "nonstd.h"
 #include "nonstd_stl.h"
@@ -247 +247 @@
 {
         string respath=getAppResourcesDir();
-        //printFM("Opening '%s', mode='%s'",path,mode);
-        //printFM("getAppResourcesDir()='%s'",respath.c_str());
+        //printH("Opening '%s', mode='%s'",path,mode);
+        //printH("getAppResourcesDir()='%s'",respath.c_str());
         NvFile *rfile=NULL; //can only read
         FILE *rwfile=NULL;
@@ -255 +255 @@
                 path+=respath.length(); //strip the prefix, we need a relative path in assets
                 if (strstr(mode,"w"))
-                        printFM("Warning: attempt to open a read-only resource '%s' in writable mode '%s'",path,mode);
+                        printH("Warning: attempt to open a read-only resource '%s' in writable mode '%s'",path,mode);
                 rfile=NvFOpen(path); //"mode" not supported! can only read
-                //printFM("Opened RES file as %p",rfile);
+                //printH("Opened RES file as %p",rfile);
                 if (rfile==NULL) return NULL;
         } else //a "normal" access (HOME)
         {
                 rwfile=fopen(path,mode);
-                //printFM("Opened HOME file as %p",rwfile);
+                //printH("Opened HOME file as %p",rwfile);
                 if (rwfile==NULL) return NULL;
         }

cpp/common/stl-util.cpp

@@ -9 +9 @@
 #include "Convert.h"
 #include "nonstd.h"
-#include "framsg.h"
+#include "hmessage.h"
 #include <assert.h>
 #ifdef USE_VIRTFILE
@@ -107 +107 @@
         }
         if (warn_on_missing_file && !ok)
-                FMprintf("stl-util", "readCompleteFile", FMLV_WARN, "Couldn't open file '%s'", filename);
+                Hprintf("stl-util", "readCompleteFile", HMLV_WARN, "Couldn't open file '%s'", filename);
         return ok;
 }
@@ -137 +137 @@
         }
         if (warn_on_fail && !ok)
-                FMprintf("stl-util", "writeCompleteFile", FMLV_WARN, "couldn't write file '%s'", filename);
+                Hprintf("stl-util", "writeCompleteFile", HMLV_WARN, "couldn't write file '%s'", filename);
         return ok;
 }

cpp/frams/Makefile-SDK-files

@@ -2 +2 @@
 
 # ALL_DIRS is later expanded by the shell, no spaces/newlines allowed, or it breaks
-ALL_DIRS={common,frams,frams/canvas,frams/config,frams/errmgr,frams/genetics,frams/genetics/f0,frams/genetics/f1,frams/genetics/f2,frams/genetics/f3,frams/genetics/f4,frams/genetics/f5,frams/genetics/f6,frams/genetics/f7,frams/genetics/f8,frams/genetics/f9,frams/genetics/fF,frams/genetics/fT,frams/model,frams/neuro,frams/neuro/impl,frams/param,frams/test,frams/util,frams/vm/classes,frams/virtfile,frams/_demos,frams/model/geometry,frams/_demos/geometry,frams/model/similarity,frams/model/similarity/SVD}
+ALL_DIRS={common,frams,frams/canvas,frams/config,frams/mhandlers,frams/genetics,frams/genetics/f0,frams/genetics/f1,frams/genetics/f2,frams/genetics/f3,frams/genetics/f4,frams/genetics/f5,frams/genetics/f6,frams/genetics/f7,frams/genetics/f8,frams/genetics/f9,frams/genetics/fF,frams/genetics/fT,frams/model,frams/neuro,frams/neuro/impl,frams/param,frams/test,frams/util,frams/vm/classes,frams/virtfile,frams/_demos,frams/model/geometry,frams/_demos/geometry,frams/model/similarity,frams/model/similarity/SVD}
 
 GENMANF4=frams/genetics/f4/oper_f4.o
@@ -19 +19 @@
 GENMAN_COMMON_OBJS=frams/genetics/genman.o frams/param/mutableparam.o frams/param/mutparamlist.o frams/neuro/geneticneuroparam.o frams/neuro/neurolibparam.o
 
-SDK_OBJS=frams/util/list.o frams/util/advlist.o frams/param/param.o frams/util/sstring.o frams/util/sstringutils.o frams/util/3d.o frams/vm/classes/3dobject.o frams/model/model.o frams/model/modelparts.o frams/neuro/neurolibrary.o frams/genetics/geno.o frams/genetics/genoconv.o frams/util/extvalue.o frams/vm/classes/collectionobj.o frams/util/hashtable.o common/framsg.o common/stl-util.o common/nonstd_stdio.o frams/util/callbacks.o frams/param/syntparam.o frams/util/multirange.o frams/util/multimap.o frams/param/paramtabobj.o frams/errmgr/errmanager.o frams/param/paramobj.o frams/genetics/oper_fx.o common/nonstd_math.o frams/errmgr/stderrors.o common/Convert.o frams/util/rndutil.o
+SDK_OBJS=frams/util/list.o frams/util/advlist.o frams/param/param.o frams/util/sstring.o frams/util/sstringutils.o frams/util/3d.o frams/vm/classes/3dobject.o frams/model/model.o frams/model/modelparts.o frams/neuro/neurolibrary.o frams/genetics/geno.o frams/genetics/genoconv.o frams/util/extvalue.o frams/vm/classes/collectionobj.o frams/util/hashtable.o common/hmessage.o common/stl-util.o common/nonstd_stdio.o frams/util/callbacks.o frams/param/syntparam.o frams/util/multirange.o frams/util/multimap.o frams/param/paramtabobj.o frams/mhandlers/mhandlers.o frams/param/paramobj.o frams/genetics/oper_fx.o common/nonstd_math.o frams/mhandlers/stderrors.o common/Convert.o frams/util/rndutil.o
 
 GEOMETRY_OBJS=frams/model/geometry/meshbuilder.o frams/model/geometry/modelgeometryinfo.o frams/model/geometry/geometryutils.o
@@ -25 +25 @@
 #### sdk_tests
 
-GENOMANIPULATION_OBJS= frams/_demos/genomanipulation.o frams/errmgr/stdouterr.o frams/virtfile/virtfile.o  $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
+GENOMANIPULATION_OBJS= frams/_demos/genomanipulation.o frams/mhandlers/stdouthandler.o frams/virtfile/virtfile.o  $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
 
-MULTILINE_F0_OBJS=frams/_demos/multiline_f0_test.o frams/virtfile/stringfile.o frams/virtfile/virtfile.o frams/errmgr/stdouterr.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
+MULTILINE_F0_OBJS=frams/_demos/multiline_f0_test.o frams/virtfile/stringfile.o frams/virtfile/virtfile.o frams/mhandlers/stdouthandler.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
 
-F0_VARIANTS_OBJS=frams/_demos/f0_variants_test.o frams/virtfile/stringfile.o frams/virtfile/virtfile.o frams/errmgr/stdouterr.o   $(SDK_OBJS) $(GENOCONV_SDK_OBJS)
+F0_VARIANTS_OBJS=frams/_demos/f0_variants_test.o frams/virtfile/stringfile.o frams/virtfile/virtfile.o frams/mhandlers/stdouthandler.o   $(SDK_OBJS) $(GENOCONV_SDK_OBJS)
 
 LOADER_TEST_OBJS=frams/_demos/genotypeloader.o frams/_demos/loader_test.o frams/virtfile/virtfile.o frams/param/multiparamload.o frams/virtfile/stdiofile.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS)
 
-LOADER_TEST_PARAM_OBJS=frams/_demos/loader_test_param.o frams/virtfile/virtfile.o frams/param/multiparamload.o frams/virtfile/stdiofile.o frams/errmgr/stdouterr.o $(SDK_OBJS)
+LOADER_TEST_PARAM_OBJS=frams/_demos/loader_test_param.o frams/virtfile/virtfile.o frams/param/multiparamload.o frams/virtfile/stdiofile.o frams/mhandlers/stdouthandler.o $(SDK_OBJS)
 
-GENOCONV_TEST_OBJS= frams/_demos/genoconv_test.o frams/_demos/printconvmap.o frams/errmgr/stdouterr.o frams/virtfile/virtfile.o  $(SDK_OBJS) $(GENOCONV_SDK_OBJS)
+GENOCONV_TEST_OBJS= frams/_demos/genoconv_test.o frams/_demos/printconvmap.o frams/mhandlers/stdouthandler.o frams/virtfile/virtfile.o  $(SDK_OBJS) $(GENOCONV_SDK_OBJS)
 
-GENO_TEST_OBJS= frams/_demos/geno_test.o frams/virtfile/virtfile.o frams/errmgr/stdouterr.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
+GENO_TEST_OBJS= frams/_demos/geno_test.o frams/virtfile/virtfile.o frams/mhandlers/stdouthandler.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
 
-GENOOPER_TEST_OBJS=frams/_demos/genooper_test.o frams/virtfile/virtfile.o frams/errmgr/stdouterr.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
+GENOOPER_TEST_OBJS=frams/_demos/genooper_test.o frams/virtfile/virtfile.o frams/mhandlers/stdouthandler.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
 
 GENOOPER_TEST_FTEST_OBJS=frams/_demos/genooper_test_fTest.o frams/virtfile/virtfile.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS) $(GENMAN_FT)
 
-NEURO_TEST_OBJS= frams/_demos/neuro_test.o frams/errmgr/stdouterr.o frams/virtfile/virtfile.o \
+NEURO_TEST_OBJS= frams/_demos/neuro_test.o frams/mhandlers/stdouthandler.o frams/virtfile/virtfile.o \
         frams/neuro/neuroimpl.o frams/neuro/neurofactory.o frams/neuro/impl/neuroimpl-simple.o frams/neuro/impl/neuroimpl-channels.o \
         frams/neuro/impl/neuroimpl-fuzzy.o frams/neuro/impl/neuroimpl-fuzzy-f0.o  $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
 
-FULL_PROPS_OBJS= frams/_demos/full_props.o frams/errmgr/stdouterr.o frams/virtfile/virtfile.o  frams/virtfile/stdiofile.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
+FULL_PROPS_OBJS= frams/_demos/full_props.o frams/mhandlers/stdouthandler.o frams/virtfile/virtfile.o  frams/virtfile/stdiofile.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
 
-SHAPECONVERT_OBJS= frams/_demos/shapeconvert.o frams/errmgr/stdouterr.o frams/virtfile/virtfile.o  frams/virtfile/stdiofile.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
+SHAPECONVERT_OBJS= frams/_demos/shapeconvert.o frams/mhandlers/stdouthandler.o frams/virtfile/virtfile.o  frams/virtfile/stdiofile.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
 
 SERIAL_TEST_OBJS= frams/_demos/serial_test.o frams/virtfile/virtfile.o  $(SDK_OBJS) $(GENOCONV_SDK_OBJS)
@@ -55 +55 @@
 PART_SHAPES_OBJS= frams/_demos/part_shapes.o frams/virtfile/virtfile.o  $(SDK_OBJS) $(GENOCONV_SDK_OBJS)
 
-NEURO_LAYOUT_TEST_OBJS= frams/_demos/neuro_layout_test.o frams/virtfile/virtfile.o frams/errmgr/stdouterr.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS) frams/canvas/nn_layout_model.o frams/canvas/nn_simple_layout.o frams/canvas/nn_smart_layout.o
+NEURO_LAYOUT_TEST_OBJS= frams/_demos/neuro_layout_test.o frams/virtfile/virtfile.o frams/mhandlers/stdouthandler.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS) frams/canvas/nn_layout_model.o frams/canvas/nn_simple_layout.o frams/canvas/nn_smart_layout.o
 
 GEOMETRY_INFO_TEST_OBJS=frams/_demos/geometry/info_test.o frams/_demos/geometry/geometrytestutils.o frams/_demos/genotypeloader.o frams/virtfile/virtfile.o frams/param/multiparamload.o frams/virtfile/stdiofile.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GEOMETRY_OBJS)
@@ -66 +66 @@
 
 SIMIL_TEST_OBJS=frams/_demos/simil_test.o frams/model/similarity/SVD/lapack.o frams/model/similarity/SVD/matrix_tools.o frams/model/similarity/simil_match.o frams/model/similarity/simil_model.o  \
-     frams/_demos/genotypeloader.o frams/virtfile/virtfile.o frams/param/multiparamload.o frams/virtfile/stdiofile.o frams/errmgr/stdouterr.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
+     frams/_demos/genotypeloader.o frams/virtfile/virtfile.o frams/param/multiparamload.o frams/virtfile/stdiofile.o frams/mhandlers/stdouthandler.o $(SDK_OBJS) $(GENOCONV_SDK_OBJS) $(GENMAN_SDK_OBJS)
 
 SIMIL_UNITTESTS_OBJS=frams/_demos/simil_unittests.o frams/model/similarity/simil_match.o

cpp/frams/Makefile-maintain

@@ -4 +4 @@
 endif
 
+MISSING_ALL_DIRS=$(strip $(foreach DIR,$(shell echo $(ALL_DIRS)), $(if $(wildcard $(DIR)),,$(DIR))))
+
 clean:
 ifeq "$(ALL_DIRS)$(ALL_DIRS)" ""
         @echo "Makefile-maintain clean: ALL_DIRS and/or EXTRA_CLEAN_FILES must be defined"
 else
+        @echo -e -n $(if $(MISSING_ALL_DIRS),\\nMissing ALL_DIRS paths:\\n$(MISSING_ALL_DIRS)\\n\\n)
         rm -f $(EXTRA_CLEAN_FILES) $(ALL_DIRS)/*.{a,o,d}
 endif

cpp/frams/_demos/f0_variants_test.cpp

@@ -10 +10 @@
 #include <frams/genetics/defgenoconv.h>
 #include <frams/model/model.h>
-#include <frams/errmgr/stdouterr.h>
+#include <frams/mhandlers/stdouthandler.h>
 
 void save_as_f0(SString &gen,Model &m,bool omit_default_values)
@@ -74 +74 @@
 int main(int argc,char*argv[])
 {
-StdoutErrorHandler err;//the default ErrorHandler constructor automatically registers this object to receive framsg messages (and in this case, redirect them to standard output)
+MessageHandlerToStdout messages_to_stdout(MessageHandlerBase::Enable);
 
 //without converters the application would only handle "format 0" genotypes

cpp/frams/_demos/full_props.cpp

@@ -9 +9 @@
 
 #include <frams/model/model.h>
-#include <frams/errmgr/stdouterr.h>
+#include <frams/mhandlers/stdouthandler.h>
 #include <frams/genetics/preconfigured.h>
 
@@ -50 +50 @@
 {
 StdioFILE::setStdio();//setup VirtFILE::Vstdin/out/err
-StdoutErrorHandler err(ErrorHandlerBase::DontBlock,VirtFILE::Vstderr); //errors -> stderr, don't interfere with stdout
+MessageHandlerToStdout messages_to_stderr(MessageHandlerBase::Enable | MessageHandlerBase::DontBlock,VirtFILE::Vstderr); //errors -> stderr, don't interfere with stdout
 
 PreconfiguredGenetics genetics;
@@ -79 +79 @@
 if (!m.isValid())
         {
-        FMprintf("","full_props",FMLV_ERROR,"Cannot build Model from the supplied genotype\n");
+        Hprintf("","full_props",HMLV_ERROR,"Cannot build Model from the supplied genotype\n");
         return 2;       
         }

cpp/frams/_demos/geno_test.cpp

@@ -6 +6 @@
 #include <frams/util/sstringutils.h>
 #include <frams/genetics/preconfigured.h>
-#include <frams/errmgr/stdouterr.h>
+#include <frams/mhandlers/stdouthandler.h>
 
 /**
@@ -18 +18 @@
 {
         PreconfiguredGenetics genetics;
-        StdoutErrorHandler stdouterr; //comment this object out to mute error/warning messages
+        MessageHandlerToStdout messages_to_stdout(MessageHandlerBase::Enable); //comment this object out to mute error/warning messages
 
         if (argc <= 1)

cpp/frams/_demos/genoconv_test.cpp

@@ -9 +9 @@
 
 #include "printconvmap.h"
-#include <frams/errmgr/stdouterr.h>
+#include <frams/mhandlers/stdouthandler.h>
 
 /**
@@ -117 +117 @@
 int main(int argc,char *argv[])
 {
-StdoutErrorHandler err;//the default ErrorHandler constructor automatically registers this object to receive framsg messages (and in this case, redirect them to standard output)
+MessageHandlerToStdout messages_to_stdout(MessageHandlerBase::Enable);
 
 DefaultGenoConvManager gcm;

cpp/frams/_demos/genomanipulation.cpp

@@ -10 +10 @@
 #include <frams/model/model.h>
 #include <frams/genetics/preconfigured.h>
-#include <frams/errmgr/stdouterr.h>
+#include <frams/mhandlers/stdouthandler.h>
 
 /**
@@ -266 +266 @@
 int main(int argc,char*argv[])
 {
-StdoutErrorHandler err; //redirect model-related errors to stdout
+MessageHandlerToStdout messages_to_stdout(MessageHandlerBase::Enable); //redirect model-related errors to stdout
 
 srand(time(0));

cpp/frams/_demos/genooper_test.cpp

@@ -3 +3 @@
 // See LICENSE.txt for details.
 
-#include <frams/errmgr/stdouterr.h>
+#include <frams/mhandlers/stdouthandler.h>
 #include <frams/genetics/preconfigured.h>
 
@@ -21 +21 @@
 int main(int argc, char *argv[])
 {
-        StdoutErrorHandler err;//the default ErrorHandler constructor automatically registers this object to receive framsg messages (and in this case, redirect them to standard output)
+        MessageHandlerToStdout messages_to_stdout(MessageHandlerBase::Enable);
         PreconfiguredGenetics genetics;
 

cpp/frams/_demos/loader_test_param.cpp

@@ -5 +5 @@
 #include <frams/param/multiparamload.h>
 #include <frams/virtfile/stdiofile.h>
-#include <frams/errmgr/stdouterr.h>
+#include <frams/mhandlers/stdouthandler.h>
 
 /**
@@ -66 +66 @@
         StdioFILEDontClose virt_stderr(stderr);
         StdioFILEDontClose virt_stdout(stdout);
-        StdoutErrorHandler error_handler(0, &virt_stderr);
+        MessageHandlerToStdout messages_to_stderr(MessageHandlerBase::Enable, &virt_stderr);
         StdioFileSystem_autoselect stdiofilesys;
         MultiParamLoader loader(argv[1]);

cpp/frams/_demos/multiline_f0_test.cpp

@@ -10 +10 @@
 #include <frams/genetics/preconfigured.h>
 #include <frams/model/model.h>
-#include <frams/errmgr/stdouterr.h>
+#include <frams/mhandlers/stdouthandler.h>
 #include <frams/virtfile/stringfile.h>
 
 int main(int argc,char*argv[])
 {
-StdoutErrorHandler err;//the default ErrorHandler constructor automatically registers this object to receive framsg messages (and in this case, redirect them to standard output)
+MessageHandlerToStdout messages_to_stdout(MessageHandlerBase::Enable);
 PreconfiguredGenetics genetics;
 

cpp/frams/_demos/neuro_layout_test.cpp

@@ -7 +7 @@
 #include <frams/genetics/preconfigured.h>
 #include <frams/model/model.h>
-#include <frams/errmgr/stdouterr.h>
+#include <frams/mhandlers/stdouthandler.h>
 #include <frams/canvas/nn_layout_model.h>
 
@@ -83 +83 @@
 int main(int argc,char*argv[])
 {
-StdoutErrorHandler err;//the default ErrorHandler constructor automatically registers this object to receive framsg messages (and in this case, redirect them to standard output)
+MessageHandlerToStdout messages_to_stdout(MessageHandlerBase::Enable);
 PreconfiguredGenetics genetics;
 

cpp/frams/_demos/neuro_test.cpp

@@ -9 +9 @@
 #include <frams/neuro/neuroimpl.h>
 #include <frams/neuro/neurofactory.h>
-#include <frams/errmgr/stdouterr.h>
+#include <frams/mhandlers/stdouthandler.h>
 
 /**
@@ -60 +60 @@
 int main(int argc,char*argv[])
 {
-StdoutErrorHandler err;//the default ErrorHandler constructor automatically registers this object to receive framsg messages (and in this case, redirect them to standard output)
+MessageHandlerToStdout messages_to_stdout(MessageHandlerBase::Enable);
 PreconfiguredGenetics genetics;
 

cpp/frams/_demos/shapeconvert.cpp

@@ -9 +9 @@
 
 #include <frams/model/model.h>
-#include <frams/errmgr/stdouterr.h>
+#include <frams/mhandlers/stdouthandler.h>
 #include <frams/genetics/preconfigured.h>
 
@@ -34 +34 @@
 {
         StdioFILE::setStdio();//setup VirtFILE::Vstdin/out/err
-        StdoutErrorHandler err(ErrorHandlerBase::DontBlock, VirtFILE::Vstderr); //errors -> stderr, don't interfere with stdout
+        MessageHandlerToStdout messages_to_stderr(MessageHandlerBase::Enable | MessageHandlerBase::DontBlock, VirtFILE::Vstderr); //errors -> stderr, don't interfere with stdout
 
         PreconfiguredGenetics genetics;
@@ -50 +50 @@
                                 if ((shape != Part::SHAPE_ELLIPSOID) && (shape != Part::SHAPE_CUBOID) && (shape != Part::SHAPE_CYLINDER))
                                 {
-                                        FMprintf("", "shapeconvert", FMLV_ERROR, "Invalid shape");
+                                        Hprintf("", "shapeconvert", HMLV_ERROR, "Invalid shape");
                                         return 4;
                                 }
@@ -71 +71 @@
         if (!m.isValid())
         {
-                FMprintf("", "shapeconvert", FMLV_ERROR, "Cannot build Model from the supplied genotype");
+                Hprintf("", "shapeconvert", HMLV_ERROR, "Cannot build Model from the supplied genotype");
                 return 2;
         }
@@ -77 +77 @@
         if (m.getShape() != Model::SHAPE_OLD)
         {
-                FMprintf("", "shapeconvert", FMLV_ERROR, "Only old style shapes can be converted");
+                Hprintf("", "shapeconvert", HMLV_ERROR, "Only old style shapes can be converted");
                 return 3;
         }

cpp/frams/_demos/simil_test.cpp

@@ -5 +5 @@
 
 #include <vector>
-#include "frams/errmgr/stdouterr.h"
+#include "frams/mhandlers/stdouthandler.h"
 #include "frams/_demos/genotypeloader.h"
 #include "frams/genetics/preconfigured.h"
@@ -39 +39 @@
 int main(int argc, char *argv[])
 {
-    StdoutErrorHandler stdouterr; //comment this object out to mute error/warning messages 
+    MessageHandlerToStdout messages_to_stdout(MessageHandlerBase::Enable);
     typedef double *pDouble;
     int iCurrParam = 0; // index of the currently processed parameter

cpp/frams/genetics/f1/conv_f1.cpp

@@ -5 +5 @@
 #include "conv_f1.h"
 #include <common/nonstd_stl.h>
-#include <common/framsg.h>
+#include <common/hmessage.h>
 #include <frams/util/multirange.h>
 #include <frams/util/multimap.h>
@@ -63 +63 @@
                 if ((n1<0) || (n2<0) || (n1>=neuro_f1_to_f0.size()) || (n2>=neuro_f1_to_f0.size()))
                         {
-                        if (final) FMprintf("GenoConvF1","addInput",FMLV_WARN,
+                        if (final) Hprintf("GenoConvF1","addInput",HMLV_WARN,
                                             "illegal neuron connection %d <- %d (ignored)",n1,n2);
                         return 0;
@@ -178 +178 @@
                 else
                         {
-                        FramMessage("GenoConv_F1","grow","Illegal neuron position (ignored)",1);
+                        Hmessage("GenoConv_F1","grow","Illegal neuron position (ignored)",1);
                         g=skipNeuro(g+1);
                         }

cpp/frams/genetics/f4/conv_f4.cpp

@@ -6 +6 @@
 
 #include "conv_f4.h"
-#include <common/framsg.h>
+#include <common/hmessage.h>
 #include "../oper_fx.h" //for GENOPER_OK constant
 
@@ -110 +110 @@
                 if (res)
                 {
-                        FramMessage("f4_Model", "buildModelRec", "Error in building Model", 2);
+                        Hmessage("f4_Model", "buildModelRec", "Error in building Model", 2);
                         error = res;
                         break;
@@ -134 +134 @@
                         return cells->C[i];
         // none!
-        FramMessage("f4_Model", "getStick", "Not a single stick", 2);
+        Hmessage("f4_Model", "getStick", "Not a single stick", 2);
         return NULL;
 }

cpp/frams/genetics/f4/f4_general.cpp

@@ -7 +7 @@
 #include "f4_general.h"
 #include <common/nonstd_stl.h>
-#include <common/framsg.h>
+#include <common/hmessage.h>
 #include <frams/model/model.h> // for min and max attributes
 #include "../oper_fx.h" //for GENOPER_ constants
@@ -581 +581 @@
                         char buf[40];
                         sprintf(buf, "unknown code '%c'", gcur->name);
-                        FramMessage("f4_Cell", "onestep", buf, 2);
+                        Hmessage("f4_Cell", "onestep", buf, 2);
                         // fix: delete it
                         org->setRepairRemove(gcur->pos, gcur);

cpp/frams/genetics/f4/oper_f4.cpp

@@ -8 +8 @@
 #include "oper_f4.h"
 #include <frams/util/sstring.h>
-#include <common/framsg.h>
+#include <common/hmessage.h>
 
 #include <stdio.h>
@@ -51 +51 @@
         mutation_method_names[index++] = "deleted a node";
         mutation_method_names[index++] = "modified a node";
-        if (index != F4_COUNT + F4_ADD_COUNT - 1) FramMessage("Geno_f4", "Constructor", "Mutation names init error", 3);
+        if (index != F4_COUNT + F4_ADD_COUNT - 1) Hmessage("Geno_f4", "Constructor", "Mutation names init error", 3);
 }
 

cpp/frams/genetics/genman.cpp

@@ -6 +6 @@
 #include <frams/vm/classes/genoobj.h>
 #include GEN_CONFIG_FILE //configuration of active genetic operators
-#include "common/framsg.h"
+#include "common/hmessage.h"
 #include "common/nonstd_math.h"
 #include "common/stl-util.h"
-#include <frams/errmgr/errmanager.h>
+#include <frams/mhandlers/mhandlers.h>
 
 
@@ -267 +267 @@
                 if (gf->mutate(gn, chg, method) == GENOPER_OK)
                 {
-                        ErrorHandler eh(ErrorHandler::StoreFirstMessage); //mute testValidity()
+                        MessageHandlerToMemory eh(MessageHandlerBase::Enable | MessageHandlerToMemory::StoreFirstMessage); //mute testValidity()
                         Geno G(gn, gv.getFormat(), "", "");
                         canvalidate = true;
@@ -284 +284 @@
                 if (!ok && (count - pcount > 100))
                 {
-                        FMprintf("GenMan", "Mutate", 2, "Tried 100x and failed: %s", g.getGene().c_str());
+                        Hprintf("GenMan", "Mutate", 2, "Tried 100x and failed: %s", g.getGene().c_str());
                         return Geno("", -1, "", "GENOPER_OPFAIL: Mutate() tried 100x and failed");
                 }
@@ -308 +308 @@
 
         {
-                ErrorHandler eh(ErrorHandler::StoreFirstMessage); //mute testValidity()
+                MessageHandlerToMemory eh(MessageHandlerBase::Enable | MessageHandlerToMemory::StoreFirstMessage); //mute testValidity()
                 bool canvalidate = true;
                 if (testValidity(g1v, canvalidate) > 0 && canvalidate == false)
@@ -333 +333 @@
                         if (g1n[0]) { gn = g1n; chg = chg1; }
                         else { gn = g2n; chg = chg2; }
-                        ErrorHandler eh(ErrorHandler::StoreFirstMessage); //mute testValidity()
+                        MessageHandlerToMemory eh(MessageHandlerBase::Enable | MessageHandlerToMemory::StoreFirstMessage); //mute testValidity()
                         Geno G(gn, g1v.getFormat(), "", "");
                         bool canvalidate = true;
@@ -351 +351 @@
                 if (!ok && (count - pcount > 100))
                 {
-                        FMprintf("GenMan", "CrossOver", 2, "Tried 100x and failed: %s and %s", g1.getGene().c_str(), g2.getGene().c_str());
+                        Hprintf("GenMan", "CrossOver", 2, "Tried 100x and failed: %s and %s", g1.getGene().c_str(), g2.getGene().c_str());
                         return Geno("", -1, "", "GENOPER_OPFAIL: CrossOver() tried 100x and failed");
                 }
@@ -500 +500 @@
         l.chg = chg;
         l.fit = 0; //temporarily. Will be set when the genotype dies
-        //FMprintf("GenMan","saveLink",0,"#%d: [%d] '%s' + '%s' -> '%s'",GenoLinkList.size(),count,parent1.c_str(),parent2.c_str(),child.c_str());
+        //Hprintf("GenMan","saveLink",0,"#%d: [%d] '%s' + '%s' -> '%s'",GenoLinkList.size(),count,parent1.c_str(),parent2.c_str(),child.c_str());
         GenoLinkList.push_back(l);
 }
@@ -533 +533 @@
         float f1, f2;
         int m;
-        FramMessage("GenMan", "Report", "The following genetic operators are available:", 0);
+        Hmessage("GenMan", "Report", "The following genetic operators are available:", 0);
         for (unsigned int i = 0; i < oper_fx_list.size(); i++)
         {
@@ -549 +549 @@
                 }
                 //      if (oper_fx_list[i]->similarity("","")!=GENOPER_NOOPER) l+=" similarity";
-                FMprintf("GenMan", "Report", 0, "format f%c (%s):%s",
+                Hprintf("GenMan", "Report", 0, "format f%c (%s):%s",
                         oper_fx_list[i]->supported_format, oper_fx_list[i]->name.c_str(), l.c_str());
         }

cpp/frams/genetics/geno.cpp

@@ -250 +250 @@
                 }
         isvalid = 0;
-        FMprintf("Geno", "validate", FMLV_WARN, "Wrong configuration? No genotype validators defined for genetic format f%c.", format);
+        Hprintf("Geno", "validate", HMLV_WARN, "Wrong configuration? No genotype validators defined for genetic format f%c.", format);
 }
 

cpp/frams/genetics/oper_fx.cpp

@@ -5 +5 @@
 #include <ctype.h>  //isupper()
 #include "oper_fx.h"
-#include <common/framsg.h>
+#include <common/hmessage.h>
 #include <common/nonstd_math.h>
 #include <frams/util/rndutil.h>
@@ -173 +173 @@
                 }
                 else
-                        FMprintf("GenoOperators", "linearMix", FMLV_WARN, "Cannot mix values of types '%c' and '%c'", type1, type2);
+                        Hprintf("GenoOperators", "linearMix", HMLV_WARN, "Cannot mix values of types '%c' and '%c'", type1, type2);
 }
 
@@ -250 +250 @@
 {
         if (s == NULL)
-                FramMessage("GenoOperators", "skipWS", "NULL reference!", FMLV_WARN);
+                Hmessage("GenoOperators", "skipWS", "NULL reference!", HMLV_WARN);
         else
         while (isWS(*s)) s++;

cpp/frams/mhandlers/mhandlers.cpp

@@ -3 +3 @@
 // See LICENSE.txt for details.
 
-#include "errmanager.h"
+#include "mhandlers.h"
 #include <common/stl-util.h>
 
-void _FramMessageSingleLine(const char *o, const char *m, const char *txt, int w)
+void _HmessageSingleLine(const char *o, const char *m, const char *txt, int w)
 {
-        tlsGetRef(errmgr_instance).send(o, m, txt, w);
+        tlsGetRef(message_handler_manager_instance).send(o, m, txt, w);
 }
 
-THREAD_LOCAL_DEF(ErrorManager, errmgr_instance);
+THREAD_LOCAL_DEF(MessageHandlerManager, message_handler_manager_instance);
 
-void ErrorManager::send(int level, const char *o, const char *m, const char *bl, int w)
+void MessageHandlerManager::send(int level, const char *o, const char *m, const char *bl, int w)
 {
         if (level >= handlers.size()) level = handlers.size() - 1;
@@ -19 +19 @@
         for (int i = level; i >= 0; i--)
         {
-                ErrorHandlerBase *r = handlers(i);
-                if ((!(r->options & ErrorHandlerBase::Paused)) &&
-                        ((!blocked) || (r->options & ErrorHandlerBase::CannotBeBlocked)))
+                MessageHandlerBase *r = handlers(i);
+                if ((!(r->options & MessageHandlerBase::Paused)) &&
+                        ((!blocked) || (r->options & MessageHandlerBase::CannotBeBlocked)))
                 {
                         r->handle(o, m, bl, w);
-                        if (!(r->options & ErrorHandlerBase::DontBlock)) blocked = 1;
+                        if (!(r->options & MessageHandlerBase::DontBlock)) blocked = 1;
                 }
         }
 }
 
-int ErrorManager::add(ErrorHandlerBase *h)
+int MessageHandlerManager::add(MessageHandlerBase *h)
 {
         h->mgr = this;
@@ -36 +36 @@
 }
 
-void ErrorManager::remove(int i)
+void MessageHandlerManager::remove(int i)
 {
-        ErrorHandlerBase *h = handlers(i);
+        MessageHandlerBase *h = handlers(i);
         h->mgr = 0;
         handlers.remove(i);
 }
 
-void ErrorManager::remove(ErrorHandlerBase *h)
+void MessageHandlerManager::remove(MessageHandlerBase *h)
 {
         int i;
@@ -50 +50 @@
 }
 
-void ErrorManager::removeAll()
+void MessageHandlerManager::removeAll()
 {
         while (handlers.size() > 0)
@@ -58 +58 @@
 //////////////////////////////////
 
-void ErrorHandlerBase::send(const char *o, const char *m, const char *bl, int w)
+void MessageHandlerBase::send(const char *o, const char *m, const char *bl, int w)
 {
         if (!isEnabled()) return;
@@ -65 +65 @@
 }
 
-void ErrorHandlerBase::FMprintf(const char *o, const char *m, int w, const char *bl, ...)
+void MessageHandlerBase::Hprintf(const char *o, const char *m, int w, const char *bl, ...)
 {
         if (!isEnabled()) return;
@@ -77 +77 @@
 
 
-void ErrorHandlerBase::enable()
+void MessageHandlerBase::enable()
 {
         if (isEnabled()) return;
-        tlsGetRef(errmgr_instance).add(this);
+        tlsGetRef(message_handler_manager_instance).add(this);
 }
 
-void ErrorHandlerBase::disable()
+void MessageHandlerBase::disable()
 {
         if (!isEnabled()) return;
-        tlsGetRef(errmgr_instance).remove(this);
+        tlsGetRef(message_handler_manager_instance).remove(this);
 }
 
-void ErrorHandlerBase::pause()
+void MessageHandlerBase::pause()
 {
         if (isPaused()) return;
@@ -95 +95 @@
 }
 
-void ErrorHandlerBase::resume()
+void MessageHandlerBase::resume()
 {
         if (!isPaused()) return;
@@ -103 +103 @@
 /////////////////////////////////
 
-void ErrorHandler::handle(const char *o, const char *m, const char *bl, int w)
+void MessageHandlerToMemory::handle(const char *o, const char *m, const char *bl, int w)
 {
         if (w > maxlevel) maxlevel = w;
-        if (w >= FMLV_INFO) infocount++;
-        if (w >= FMLV_WARN) warncount++;
-        if (w >= FMLV_ERROR) errcount++;
+        if (w >= HMLV_INFO) infocount++;
+        if (w >= HMLV_WARN) warncount++;
+        if (w >= HMLV_ERROR) errcount++;
 
         if (w >= storlevel)

cpp/frams/mhandlers/mhandlers.h

@@ -3 +3 @@
 // See LICENSE.txt for details.
 
-#ifndef _ERRMANAGER_H_
-#define _ERRMANAGER_H_
+#ifndef _MHANDLERS_H_
+#define _MHANDLERS_H_
 
 #include <frams/util/list.h>
 #include <frams/util/sstring.h>
-#include <common/framsg.h>
+#include <common/hmessage.h>
 #include <common/threads.h>
 
-class ErrorHandlerBase;
+class MessageHandlerBase;
 
-class ErrorManager
+class MessageHandlerManager
 {
-        friend class ErrorHandlerBase;
-        SListTempl<ErrorHandlerBase*> handlers;
+        friend class MessageHandlerBase;
+        SListTempl<MessageHandlerBase*> handlers;
         void send(int level, const char *o, const char *m, const char *bl, int w);
 public:
-        int find(ErrorHandlerBase *r) { return handlers.find(r); }
-        int add(ErrorHandlerBase *r);
+        int find(MessageHandlerBase *r) { return handlers.find(r); }
+        int add(MessageHandlerBase *r);
         void remove(int i);
-        void remove(ErrorHandlerBase *r);
+        void remove(MessageHandlerBase *r);
         void removeAll();
         void send(const char *o, const char *m, const char *bl, int w)
@@ -28 +28 @@
                 send(handlers.size() - 1, o, m, bl, w);
         }
-        ~ErrorManager() { removeAll(); }
+        ~MessageHandlerManager() { removeAll(); }
 };
 
-extern THREAD_LOCAL_DECL(ErrorManager, errmgr_instance);
+extern THREAD_LOCAL_DECL(MessageHandlerManager, message_handler_manager_instance);
 
 ////////////////////////////////////////
 
-class ErrorHandlerBase
+class MessageHandlerBase
 {
-        friend class ErrorManager;
+        friend class MessageHandlerManager;
 protected:
-        ErrorManager* mgr;
+        MessageHandlerManager* mgr;
         int options;
 
@@ -46 +46 @@
         enum HandlerOptions
         {
-                DontBlock = 1, CannotBeBlocked = 2, DontEnable = 4, Paused = 8
+                DontBlock = 1, CannotBeBlocked = 2, Enable = 4, Paused = 8
         };
 
-        void FMprintf(const char *o, const char *m, int w, const char *bl, ...);
+        void Hprintf(const char *o, const char *m, int w, const char *bl, ...);
         void send(const char *o, const char *m, const char *bl, int w);
 
@@ -59 +59 @@
         void resume();
 
-        ErrorHandlerBase(int opts = 0) :mgr(0), options(opts)
+        MessageHandlerBase(int opts = 0) :mgr(0), options(opts)
         {
-                if (!(options&DontEnable)) enable();
+                if (options&Enable) enable();
         }
-        virtual ~ErrorHandlerBase()
+        virtual ~MessageHandlerBase()
         {
                 disable();
@@ -73 +73 @@
 ///////////////////////////////////////////
 
-class ErrorHandler : public ErrorHandlerBase
+class MessageHandlerToMemory : public MessageHandlerBase
 {
 protected:
@@ -81 +81 @@
 public:
 
-        void reset() { maxlevel = FMLV_INFO - 1; errcount = warncount = storcount = infocount = 0; msgs = 0; }
+        void reset() { maxlevel = HMLV_INFO - 1; errcount = warncount = storcount = infocount = 0; msgs = 0; }
 
         enum Options2
@@ -95 +95 @@
         const SString& getMessages() { return msgs; }
 
-        ErrorHandler(int opts = 0, int store = FMLV_ERROR) :ErrorHandlerBase(opts), storlevel(store)
+        MessageHandlerToMemory(int opts = 0, int minimal_level_to_store = HMLV_ERROR) :MessageHandlerBase(opts), storlevel(minimal_level_to_store)
         {
                 reset();
@@ -103 +103 @@
 };
 
-class ErrorRedirector : public ErrorHandlerBase
+class RedirectingMessageHandler : public MessageHandlerBase
 {
-        ErrorManager *other_mgr;
+        MessageHandlerManager *other_mgr;
 public:
-        ErrorRedirector(ErrorManager *om)
-                :ErrorHandlerBase(), other_mgr(om) {}
+        RedirectingMessageHandler(MessageHandlerManager *om,int opts=0)
+                :MessageHandlerBase(opts), other_mgr(om) {}
 
         void handle(const char *o, const char *m, const char *bl, int w)

cpp/frams/mhandlers/stderrors.cpp

@@ -5 +5 @@
 #include "stderrors.h"
 #include <frams/util/sstringutils.h>
-#include <common/framsg.h>
+#include <common/hmessage.h>
 
 bool listIndexCheck(SList* list,int index,const char* msgobj,const char* msgfun)
@@ -13 +13 @@
         {
         if (size>0) 
-                FMprintf(msgobj,msgfun,FMLV_ERROR,"Invalid index %d (allowed range is 0..%d)",index,size-1);
+                Hprintf(msgobj,msgfun,HMLV_ERROR,"Invalid index %d (allowed range is 0..%d)",index,size-1);
         else
-                FMprintf(msgobj,msgfun,FMLV_ERROR,"Invalid index %d (this list is empty)",index);
+                Hprintf(msgobj,msgfun,HMLV_ERROR,"Invalid index %d (this list is empty)",index);
         return 0;
         }
@@ -29 +29 @@
         {
         SString msg2=SString(msg)+": \"%s\" (adjusted to \"%s\")";
-        FMprintf(msgobj,msgfun,FMLV_WARN,msg2.c_str(),in.c_str(),corrected.c_str());
+        Hprintf(msgobj,msgfun,HMLV_WARN,msg2.c_str(),in.c_str(),corrected.c_str());
         }
 return corrected;

cpp/frams/mhandlers/stdouthandler.cpp

@@ -3 +3 @@
 // See LICENSE.txt for details.
 
-#include "stdouterr.h"
+#include "stdouthandler.h"
 #ifdef SHP
 #include <FBaseSys.h> //AppLog
@@ -10 +10 @@
 #endif
 
-void StdoutErrorHandler::handle(const char *o, const char *m, const char *bl, int w)
+void MessageHandlerToStdout::handle(const char *o, const char *m, const char *bl, int w)
 {
         if (w < -1) w = -1; else if (w>3) w = 3;
 #ifdef SHP
-        AppLog(FRAMSG_FORMAT "\n",MSG_LEVEL[w+1],o,m,bl);
+        AppLog(HMSG_FORMAT "\n",HMSG_LEVEL[w+1],o,m,bl);
 #else
         if (file)
-                file->printf(FRAMSG_FORMAT "\n", MSG_LEVEL[w + 1], o, m, bl);
+                file->printf(HMSG_FORMAT "\n", HMSG_LEVEL[w + 1], o, m, bl);
         else
-                printf(FRAMSG_FORMAT "\n", MSG_LEVEL[w + 1], o, m, bl);
+                printf(HMSG_FORMAT "\n", HMSG_LEVEL[w + 1], o, m, bl);
 #endif
 }

cpp/frams/mhandlers/stdouthandler.h

@@ -3 +3 @@
 // See LICENSE.txt for details.
 
-#ifndef _STDOUTERRORHANDLER_H_
-#define _STDOUTERRORHANDLER_H_
+#ifndef _STDOUTHANDLER_H_
+#define _STDOUTHANDLER_H_
 
-#include "errmanager.h"
+#include "mhandlers.h"
 #include <frams/virtfile/virtfile.h>
 
-class StdoutErrorHandler : public ErrorHandlerBase
+class MessageHandlerToStdout : public MessageHandlerBase
 {
         VirtFILE *file;
 public:
-        StdoutErrorHandler(int opts = DontBlock, VirtFILE *_file = NULL) :ErrorHandlerBase(opts), file(_file) {}
+        MessageHandlerToStdout(int opts = 0, VirtFILE *_file = NULL) :MessageHandlerBase(opts), file(_file) {}
         void handle(const char *o, const char *m, const char *bl, int w);
 };

cpp/frams/model/geometry/geometryutils.cpp

@@ -82 +82 @@
                         break;
         }
-        FMprintf("GeometryUtils", "isPointInsidePart", FMLV_ERROR, "Part shape=%d not supported", part->shape);
+        Hprintf("GeometryUtils", "isPointInsidePart", HMLV_ERROR, "Part shape=%d not supported", part->shape);
         return false;
 }
@@ -102 +102 @@
                         break;
         }
-        FMprintf("GeometryUtils", "isPointStrictlyInsidePart", FMLV_ERROR, "Part shape=%d not supported", part->shape);
+        Hprintf("GeometryUtils", "isPointStrictlyInsidePart", HMLV_ERROR, "Part shape=%d not supported", part->shape);
         return false;
 }

cpp/frams/model/geometry/meshbuilder.cpp

@@ -639 +639 @@
 
                 default:
-                        FMprintf("MeshBuilder::PartSurface", "initialize", FMLV_WARN, "Part shape=%d not supported, skipping...", part->shape);
+                        Hprintf("MeshBuilder::PartSurface", "initialize", HMLV_WARN, "Part shape=%d not supported, skipping...", part->shape);
         }
 }
@@ -725 +725 @@
 
                 default:
-                        FMprintf("MeshBuilder::PartApices", "initialize", FMLV_WARN, "Part shape=%d not supported, skipping...", part->shape);
+                        Hprintf("MeshBuilder::PartApices", "initialize", HMLV_WARN, "Part shape=%d not supported, skipping...", part->shape);
         }
 }

cpp/frams/model/geometry/modelgeometryinfo.cpp

@@ -16 +16 @@
         if (points.size() < 1) //maybe 1 or 2 points are also not enough for findSizesAndAxesOfPointsGroup() to work...
         {
-                FMprintf("ModelGeometryInfo", "findSizesAndAxesOfModel", FMLV_ERROR, "Empty points sample for model with %d part(s)", model.getPartCount());
+                Hprintf("ModelGeometryInfo", "findSizesAndAxesOfModel", HMLV_ERROR, "Empty points sample for model with %d part(s)", model.getPartCount());
                 sizes = Pt3D_0;
                 axes = Orient_1;
@@ -116 +116 @@
                         return externalAreaOfCylinder(model, partIndex, density);
         }
-        FMprintf("ModelGeometryInfo", "externalAreaOfPart", FMLV_ERROR, "Part shape=%d not supported", part->shape);
+        Hprintf("ModelGeometryInfo", "externalAreaOfPart", HMLV_ERROR, "Part shape=%d not supported", part->shape);
         return 0;
 }

cpp/frams/model/model.cpp

@@ -5 +5 @@
 #include <common/nonstd_math.h>
 #include "model.h"
-#include <common/framsg.h>
+#include <common/hmessage.h>
 #include <frams/util/multimap.h>
-#include <frams/errmgr/errmanager.h>
+#include <frams/mhandlers/mhandlers.h>
 
 Model::Model()
@@ -317 +317 @@
 SString line;
 MultiRange frommap;
-ErrorHandler err(ErrorHandler::DontBlock);
+MessageHandlerToMemory mh(MessageHandlerBase::Enable | MessageHandlerBase::DontBlock);
 for (;f0txt.getNextToken(pos,line,'\n');lnum++)
         {
@@ -325 +325 @@
                 frommap.add(lastpos,pos-1);
                 }
-        err.reset();
+        mh.reset();
         if (singleStepBuild(line,autobuildmaps ? (&frommap) : 0)==-1)
                 {
                 buildstatus=invalid;
-                FMprintf("Model","build",FMLV_ERROR,
+                Hprintf("Model","build",HMLV_ERROR,
                          geno.getName().len()?"illegal f0 code at line %d (%s)":"illegal f0 code at line %d",
                          lnum,geno.getName().c_str());
@@ -336 +336 @@
                 return;
                 }
-        if (err.getWarningCount())
+        if (mh.getWarningCount())
                 {if (f0warnposition<0) f0warnposition=lastpos;}
         lastpos=pos;
         }
-err.disable();
+mh.disable();
 close();
 if (convmap)
@@ -513 +513 @@
 {
 if (buildstatus!=building)
-        FMprintf("Model","close",FMLV_WARN,"unexpected close() - no open()");
+        Hprintf("Model","close",HMLV_WARN,"unexpected close() - no open()");
 if (internalcheck(1)>0)
         {
@@ -609 +609 @@
                 {
                 delete j;
-                FMprintf("Model","build",FMLV_ERROR,
+                Hprintf("Model","build",HMLV_ERROR,
                          "invalid part reference for joint #%d",getJointCount()-1);
                 return -1;
@@ -694 +694 @@
                 return 0;
                 }
-        FMprintf("Model","build",FMLV_ERROR,
+        Hprintf("Model","build",HMLV_ERROR,
                  "invalid neuron connection #%d <- #%d",c.n1_refno,c.n2_refno);
         return -1;
@@ -782 +782 @@
                         else
                                 {
-                                FMprintf("Model","internalCheck",FMLV_ERROR,
+                                Hprintf("Model","internalCheck",HMLV_ERROR,
                                          "illegal N-N connection #%d (reference to #%d) (%s)",
                                          i,n->conn_refno,(const char*)geno.getName());
@@ -853 +853 @@
 if (var -> field < getMin ## template () . field) \
         { var->field= getMin ## template () . field; \
-        FMprintf("Model","internalCheck",FMLV_WARN,# field " too small in " # template "#%d (adjusted)",i);} \
+        Hprintf("Model","internalCheck",HMLV_WARN,# field " too small in " # template "#%d (adjusted)",i);} \
 else if (var -> field > getMax ## template () . field) \
         { var->field= getMax ## template ()  . field; \
-        FMprintf("Model","internalCheck",FMLV_WARN,# field " too big in " # template "#%d (adjusted)",i);}
+        Hprintf("Model","internalCheck",HMLV_WARN,# field " too big in " # template "#%d (adjusted)",i);}
 
 #define LINKFLAG 0x8000000
@@ -912 +912 @@
                         {
                         shape=SHAPE_ILLEGAL;
-                        FMprintf("Model","internalCheck",FMLV_WARN,"Inconsistent part shapes (mixed old and new shapes)");
+                        Hprintf("Model","internalCheck",HMLV_WARN,"Inconsistent part shapes (mixed old and new shapes)");
                         }
                 }
@@ -941 +941 @@
                                 {
                                 ret=0;
-                                FMprintf("Model","internalCheck",FMLV_ERROR,
+                                Hprintf("Model","internalCheck",HMLV_ERROR,
                                          "delta joint cycle detected at joint#%d (%s)",
                                          i,geno.getName().c_str());
@@ -978 +978 @@
                         {
                         ret=0;
-                        FMprintf("Model","internalCheck",FMLV_ERROR,"delta too big in joint #%d (%s)",
+                        Hprintf("Model","internalCheck",HMLV_ERROR,"delta too big in joint #%d (%s)",
                                  i,geno.getName().c_str());
                         }
@@ -984 +984 @@
                         {
                         ret=0;
-                        FMprintf("Model","internalCheck",FMLV_ERROR,"delta too small in joint #%d (%s)",
+                        Hprintf("Model","internalCheck",HMLV_ERROR,"delta too small in joint #%d (%s)",
                                  i,geno.getName().c_str());
                         }
@@ -992 +992 @@
         else
                 {
-                FMprintf("Model","internalCheck",FMLV_ERROR,"illegal part references in joint #%d (%s)",
+                Hprintf("Model","internalCheck",HMLV_ERROR,"illegal part references in joint #%d (%s)",
                          i,geno.getName().c_str());
                 ret=0;
@@ -1001 +1001 @@
                         {
                         shape=SHAPE_ILLEGAL;
-                        FMprintf("Model","internalCheck",FMLV_WARN,"Inconsistent joint shapes (mixed old and new shapes)");
+                        Hprintf("Model","internalCheck",HMLV_WARN,"Inconsistent joint shapes (mixed old and new shapes)");
                         }
                 }
@@ -1071 +1071 @@
                 if (!(p->flags&LINKFLAG))
                         {
-                        FMprintf("Model","internalCheck",FMLV_ERROR,"not all parts connected (eg.#0-#%d) (%s)",
+                        Hprintf("Model","internalCheck",HMLV_ERROR,"not all parts connected (eg.#0-#%d) (%s)",
                                  i,geno.getName().c_str());
                         ret=0;
@@ -1084 +1084 @@
         if (j->p1_refno==j->p2_refno)
                 {
-                FMprintf("Model","internalCheck",FMLV_ERROR,"illegal self connection, joint #%d (%s)",
+                Hprintf("Model","internalCheck",HMLV_ERROR,"illegal self connection, joint #%d (%s)",
                          i,geno.getName().c_str());
                 ret=0;
@@ -1095 +1095 @@
                     || ((j->p1_refno==j2->p2_refno)&&(j->p2_refno==j2->p1_refno)))
                         {
-                        FMprintf("Model","internalCheck",FMLV_ERROR,"illegal duplicate joints #%d and #%d (%s)",
+                        Hprintf("Model","internalCheck",HMLV_ERROR,"illegal duplicate joints #%d and #%d (%s)",
                                  i,k,geno.getName().c_str());
                         ret=0;
@@ -1125 +1125 @@
 {
 if (buildstatus==building)
-        FMprintf("Model","getGeno",FMLV_WARN,"model was not completed - missing close()");
+        Hprintf("Model","getGeno",HMLV_WARN,"model was not completed - missing close()");
 if (buildstatus!=valid)
         return Geno("",'0',"","invalid");

cpp/frams/neuro/neurofactory.cpp

@@ -98 +98 @@
         }
 if (removed.len())
-        FMprintf("NeuroFactory","removeUninmplemented",FMLV_INFO,
+        Hprintf("NeuroFactory","removeUninmplemented",HMLV_INFO,
          "Removed Neuro classes: %s",removed.c_str());
 }

cpp/frams/neuro/neuroimpl.cpp

@@ -72 +72 @@
         n->userdata[mytags_id]=ni;
         if (!ni) { errorcount++;
-                FMprintf("NeuroNetImpl","create",FMLV_WARN,"neuron #%d (%s) implementation not available",
+                Hprintf("NeuroNetImpl","create",HMLV_WARN,"neuron #%d (%s) implementation not available",
                          i,n->getClassName().c_str());
                 continue; } // implementation not available?!
@@ -87 +87 @@
         if (!ni->lateinit())
                 { ni->status=NeuroImpl::InitError; errorcount++;
-                FMprintf("NeuroNetImpl","create",FMLV_WARN,"neuron #%d (%s) initialization failed",
+                Hprintf("NeuroNetImpl","create",HMLV_WARN,"neuron #%d (%s) initialization failed",
                          i,n->getClassName().c_str());
                 continue; }

cpp/frams/neuro/neuroimpl.h

@@ -8 +8 @@
 #include <frams/model/model.h>
 #include <frams/param/param.h>
-#include <common/framsg.h>
+#include <common/hmessage.h>
 #ifdef NEURO_SIGNALS
 #include <frams/simul/signals.h>

cpp/frams/param/multiparamload.cpp

@@ -5 +5 @@
 #include "multiparamload.h"
 #include <frams/util/sstringutils.h>
-#include "common/framsg.h"
+#include "common/hmessage.h"
 #include <ctype.h>
 
@@ -107 +107 @@
         else if (status==BeforeUnknown)
                 {
-                FMprintf("MultiParamLoader","go",FMLV_WARN,"Skipping object '%s'",lastunknown.c_str());
+                Hprintf("MultiParamLoader","go",HMLV_WARN,"Skipping object '%s'",lastunknown.c_str());
                 loadObjectNow(&emptyparam,false);
                 continue;
@@ -137 +137 @@
                                 {
                                 const char* thisfilename=file->VgetPath();
-                                FMprintf("MultiParamLoader","go",FMLV_WARN,"invalid \"%s\"%s%s",buf.c_str(),
+                                Hprintf("MultiParamLoader","go",HMLV_WARN,"invalid \"%s\"%s%s",buf.c_str(),
                                          (thisfilename?" in ":""),(thisfilename?thisfilename:""));
                                 }
@@ -204 +204 @@
 if (alreadyIncluded(newfilename.c_str()))
         {
-        FMprintf("MultiParamLoader","include",FMLV_WARN,"circular reference ignored (\"%s\")",
+        Hprintf("MultiParamLoader","include",HMLV_WARN,"circular reference ignored (\"%s\")",
                     filename.c_str());
         return;
@@ -212 +212 @@
 if (!f)
         {
-        FMprintf("MultiParamLoader","include",FMLV_WARN,"\"%s\" not found",newfilename.c_str());
+        Hprintf("MultiParamLoader","include",HMLV_WARN,"\"%s\" not found",newfilename.c_str());
         }
 else

cpp/frams/param/param.cpp

@@ -8 +8 @@
 #include "param.h"
 #include <frams/util/extvalue.h>
-#include "common/framsg.h"
+#include "common/hmessage.h"
 #include <frams/util/sstringutils.h>
 
@@ -445 +445 @@
                 {
                         SString name(p0, p_len);
-                        FMprintf("ParamInterface", "load", FMLV_WARN, "Ignored unknown property '%s' while reading object '%s'", name.c_str(), getName());
+                        Hprintf("ParamInterface", "load", HMLV_WARN, "Ignored unknown property '%s' while reading object '%s'", name.c_str(), getName());
                 }
 
@@ -518 +518 @@
         case 'o':       ret.setObject(getObject(i)); break;
         case 'x':       ret = getExtValue(i); break;
-        default: FMprintf("ParamInterface", "get", FMLV_ERROR, "'%s.%s' is not a field", getName(), id(i));
+        default: Hprintf("ParamInterface", "get", HMLV_ERROR, "'%s.%s' is not a field", getName(), id(i));
         }
 }
@@ -562 +562 @@
                         if (v.type == TObj)
                         {
-                                FMprintf("ParamInterface", "set", FMLV_WARN, "Getting integer value from object reference (%s)", v.getString().c_str());
+                                Hprintf("ParamInterface", "set", HMLV_WARN, "Getting integer value from object reference (%s)", v.getString().c_str());
                                 return 0;
                         }
@@ -574 +574 @@
                         if (v.type == TObj)
                         {
-                                FMprintf("ParamInterface", "set", FMLV_WARN, "Getting floating point value from object reference (%s)", v.getString().c_str());
+                                Hprintf("ParamInterface", "set", HMLV_WARN, "Getting floating point value from object reference (%s)", v.getString().c_str());
                                 return 0;
                         }
@@ -583 +583 @@
         case 'o': return setObject(i, v.getObject());
         case 'x': return setExtValue(i, v);
-        default: FMprintf("ParamInterface", "set", FMLV_ERROR, "'%s.%s' is not a field", getName(), id(i));
+        default: Hprintf("ParamInterface", "set", HMLV_ERROR, "'%s.%s' is not a field", getName(), id(i));
         }
         return 0;
@@ -605 +605 @@
                         if ((after == NULL) || (*after))
                         {
-                                FMprintf("ParamInterface", "set", FMLV_WARN, "serialization format mismatch in %s.%s", (getName() ? getName() : "<Unknown>"), id(i));
+                                Hprintf("ParamInterface", "set", HMLV_WARN, "serialization format mismatch in %s.%s", (getName() ? getName() : "<Unknown>"), id(i));
                                 e.setEmpty();
                         }
@@ -690 +690 @@
         }
         if (err!=NULL)
-                FMprintf("SimpleAbstractParam","sanityCheck", FMLV_ERROR,
+                Hprintf("SimpleAbstractParam","sanityCheck", HMLV_ERROR,
                 "Invalid ParamEntry for %s.%s (%s)", getName(), pe->id, err);
 }       
@@ -961 +961 @@
         else
         {
-                FMprintf("SimpleAbstractParam", "call", FMLV_ERROR,
+                Hprintf("SimpleAbstractParam", "call", HMLV_ERROR,
                         (*pe->type != 'p') ? "'%s.%s' is not a function" : "Internal error - undefined function pointer for '%s.%s'", getName(), pe->id);
                 ret->setInvalid();
@@ -1060 +1060 @@
                         {
                                 SString name(t, (int)(equals_sign - t));
-                                FMprintf("Param", "load2", FMLV_WARN, "Unknown property '%s' while reading object '%s' (ignored)", name.c_str(), getName());
+                                Hprintf("Param", "load2", HMLV_WARN, "Unknown property '%s' while reading object '%s' (ignored)", name.c_str(), getName());
                         }
                         t = equals_sign + 1; // t=value
@@ -1070 +1070 @@
 #endif
                         {
-                        FMprintf("Param", "load2", FMLV_WARN, "Missing property name in '%s' (assuming '%s')",
+                        Hprintf("Param", "load2", HMLV_WARN, "Missing property name in '%s' (assuming '%s')",
                                 getName(), id(i) ? id(i) : "unknown property?");
                         }
@@ -1092 +1092 @@
                         fields_loaded++;
                         if (ret&(PSET_HITMAX | PSET_HITMIN))
-                                FMprintf("Param", "load2", FMLV_WARN, "Adjusted '%s' in '%s' (was too %s)",
+                                Hprintf("Param", "load2", HMLV_WARN, "Adjusted '%s' in '%s' (was too %s)",
                                 id(i), getName(), (ret&PSET_HITMAX) ? "big" : "small");
                         *(char*)valstop = remember;

cpp/frams/param/param.h

@@ -12 +12 @@
 #include <frams/util/statrick.h>
 #include <frams/virtfile/virtfile.h>
-#include <common/framsg.h>
+#include <common/hmessage.h>
 
 class ExtValue;
@@ -273 +273 @@
                         SString svaluetoset = SString::valueOf(valuetoset); //converts any type to SString
                         SString actual = get(i);
-                        FMprintf("Param", "set", FMLV_WARN, "Setting '%s.%s = %s' exceeded allowed range (too %s). Adjusted to %s.",
+                        Hprintf("Param", "set", HMLV_WARN, "Setting '%s.%s = %s' exceeded allowed range (too %s). Adjusted to %s.",
                                 getName(), id(i), svaluetoset.c_str(), (setflags&PSET_HITMAX) ? "big" : "small", actual.c_str());
                 }

cpp/frams/util/3d.cpp

@@ -4 +4 @@
 
 #include <common/nonstd_math.h>
-#include <common/framsg.h>
+#include <common/hmessage.h>
 #include "3d.h"
 
@@ -17 +17 @@
 {
         double q = x*x + y*y + z*z;
-        if (q < 0) { if (report_errors) FMprintf("Pt3D", "operator()", FMLV_ERROR, "sqrt(%g): domain error", q); return 0; }
+        if (q < 0) { if (report_errors) Hprintf("Pt3D", "operator()", HMLV_ERROR, "sqrt(%g): domain error", q); return 0; }
         return sqrt(q);
 }
@@ -24 +24 @@
 {
         double len = length();
-        if (fabs(len) < 1e-50) { if (report_errors) FMprintf("Pt3D", "normalize()", FMLV_WARN, "vector[%g,%g,%g] too small", x, y, z); x = 1; y = 0; z = 0; return false; }
+        if (fabs(len) < 1e-50) { if (report_errors) Hprintf("Pt3D", "normalize()", HMLV_WARN, "vector[%g,%g,%g] too small", x, y, z); x = 1; y = 0; z = 0; return false; }
         operator/=(len);
         return true;
@@ -64 +64 @@
         if (dx == 0 && dy == 0)
         {
-                if (report_errors) FMprintf("Pt3D", "getAngle()", FMLV_WARN, "atan2(%g,%g)", dy, dx);
+                if (report_errors) Hprintf("Pt3D", "getAngle()", HMLV_WARN, "atan2(%g,%g)", dy, dx);
                 return 0; // incorrect result, but there is no correct one
         }
@@ -147 +147 @@
 {
         double q = x*x + y*y;
-        if (q < 0) { if (Pt3D::report_errors) FMprintf("", "d2()", FMLV_ERROR, "sqrt(%g): domain error", q); return 0; }
+        if (q < 0) { if (Pt3D::report_errors) Hprintf("", "d2()", HMLV_ERROR, "sqrt(%g): domain error", q); return 0; }
         return sqrt(q);
 }

cpp/frams/util/extvalue.cpp

@@ -98 +98 @@
         if (warn)
         {
-                FMprintf("ExtValue", "getObjectTarget", FMLV_WARN, "%s object expected, %s found", classname, interfaceName());
+                Hprintf("ExtValue", "getObjectTarget", HMLV_WARN, "%s object expected, %s found", classname, interfaceName());
         }
 
@@ -269 +269 @@
                         if (tmp.len() > 30) tmp = tmp.substr(0, 30) + "...";
                         if (type == TString) tmp = SString("\"") + tmp + SString("\"");
-                        FMprintf("ExtValue", "getObjectTarget", FMLV_WARN, "%s object expected, %s found", classname, tmp.c_str());
+                        Hprintf("ExtValue", "getObjectTarget", HMLV_WARN, "%s object expected, %s found", classname, tmp.c_str());
                 }
                 return NULL;
@@ -419 +419 @@
                                 context->v2->typeAndValue().c_str());
                 }
-                FMprintf("ExtValue", "interpretCompare", FMLV_ERROR, "%s", msg.c_str());
+                Hprintf("ExtValue", "interpretCompare", HMLV_ERROR, "%s", msg.c_str());
                 ret = -1;
         }
@@ -448 +448 @@
                 {
                 case TDouble:
-                        FMprintf("ExtValue", "add", FMLV_WARN, "Adding %s to %s", src.typeAndValue().c_str(), typeAndValue().c_str());
+                        Hprintf("ExtValue", "add", HMLV_WARN, "Adding %s to %s", src.typeAndValue().c_str(), typeAndValue().c_str());
                         setDouble(double(getInt()) + src.getDouble());
                         return;
@@ -487 +487 @@
         default:;
         }
-        FMprintf("ExtValue", "add", FMLV_ERROR, "Can't add %s to %s", src.typeAndValue().c_str(), typeAndValue().c_str());
+        Hprintf("ExtValue", "add", HMLV_ERROR, "Can't add %s to %s", src.typeAndValue().c_str(), typeAndValue().c_str());
 }
 
@@ -502 +502 @@
                         return;
                 case TDouble:
-                        FMprintf("ExtValue", "subtract", FMLV_WARN, "Subtracting %s from %s", src.typeAndValue().c_str(), typeAndValue().c_str());
+                        Hprintf("ExtValue", "subtract", HMLV_WARN, "Subtracting %s from %s", src.typeAndValue().c_str(), typeAndValue().c_str());
                         setDouble(double(getInt()) - src.getDouble());
                         return;
@@ -520 +520 @@
         default:;
         }
-        FMprintf("ExtValue", "subtract", FMLV_ERROR, "Can't subtract %s from %s", src.typeAndValue().c_str(), typeAndValue().c_str());
+        Hprintf("ExtValue", "subtract", HMLV_ERROR, "Can't subtract %s from %s", src.typeAndValue().c_str(), typeAndValue().c_str());
 }
 
@@ -535 +535 @@
                         return;
                 case TDouble:
-                        FMprintf("ExtValue", "multiply", FMLV_WARN, "Multiplying %s by %s", typeAndValue().c_str(), src.typeAndValue().c_str());
+                        Hprintf("ExtValue", "multiply", HMLV_WARN, "Multiplying %s by %s", typeAndValue().c_str(), src.typeAndValue().c_str());
                         setDouble(double(getInt())*src.getDouble());
                         return;
@@ -591 +591 @@
         default:;
         }
-        FMprintf("ExtValue", "multiply", FMLV_WARN, "Can't multiply %s by %s", typeAndValue().c_str(), src.typeAndValue().c_str());
-}
-
-#include <common/framsg.h>
+        Hprintf("ExtValue", "multiply", HMLV_WARN, "Can't multiply %s by %s", typeAndValue().c_str(), src.typeAndValue().c_str());
+}
+
 /*#include "fpu_control.h"
 #include <signal.h>
@@ -612 +611 @@
         else
         {
-                FMprintf("ExtValue", "divide", FMLV_CRITICAL, "Division by zero: %d/0", idata());
+                Hprintf("ExtValue", "divide", HMLV_CRITICAL, "Division by zero: %d/0", idata());
                 setInvalid();
         }
@@ -621 +620 @@
         if (a == 0.0)
         {
-                FMprintf("ExtValue", "divide", FMLV_CRITICAL, "Division by zero: %s/0.0", getString().c_str());
+                Hprintf("ExtValue", "divide", HMLV_CRITICAL, "Division by zero: %s/0.0", getString().c_str());
                 setInvalid();
         }
@@ -630 +629 @@
                 if (!finite(tmp))
                 {
-                        FMprintf("ExtValue", "divide", FMLV_CRITICAL, "Overflow %s/%g", getString().c_str(), a); setInvalid();
+                        Hprintf("ExtValue", "divide", HMLV_CRITICAL, "Overflow %s/%g", getString().c_str(), a); setInvalid();
                 }
                 else
@@ -636 +635 @@
                 // niby dobrze ale lepiej byloby to robic bardziej systematycznie a nie tylko w dzieleniu?
                 //if (isnan(ddata())) //http://www.digitalmars.com/d/archives/c++/Traping_divide_by_zero_5728.html
-                //        { FMprintf("ExtValue","divide",FMLV_ERROR,"not-a-number",(const char*)getString()); setInvalid(); }
+                //        { Hprintf("ExtValue","divide",HMLV_ERROR,"not-a-number",(const char*)getString()); setInvalid(); }
                 fpExceptEnable();
         }
@@ -652 +651 @@
                         return;
                 case TDouble:
-                        FMprintf("ExtValue", "divide", FMLV_WARN, "Dividing %s by %s", typeAndValue().c_str(), src.typeAndValue().c_str());
+                        Hprintf("ExtValue", "divide", HMLV_WARN, "Dividing %s by %s", typeAndValue().c_str(), src.typeAndValue().c_str());
                         divDouble(src.ddata());
                         return;
@@ -674 +673 @@
         default:;
         }
-        FMprintf("ExtValue", "divide", FMLV_ERROR, "Can't divide %s by %s", typeAndValue().c_str(), src.typeAndValue().c_str());
+        Hprintf("ExtValue", "divide", HMLV_ERROR, "Can't divide %s by %s", typeAndValue().c_str(), src.typeAndValue().c_str());
 }
 
@@ -779 +778 @@
 
         case TObj: case TUnknown: case TInvalid:
-                FMprintf("ExtValue", "modulo", FMLV_WARN, "Can't apply modulo to %s", typeDescription().c_str());
+                Hprintf("ExtValue", "modulo", HMLV_WARN, "Can't apply modulo to %s", typeDescription().c_str());
 
         default:;
@@ -792 +791 @@
         {
                 if (error)
-                        FMprintf("ExtValue", "parseInt", FMLV_ERROR, "Could not parse '%s'%s", s, strict ? " (strict)" : "");
+                        Hprintf("ExtValue", "parseInt", HMLV_ERROR, "Could not parse '%s'%s", s, strict ? " (strict)" : "");
                 return false;
         }
@@ -806 +805 @@
         {
                 if (error)
-                        FMprintf("ExtValue", "parseDouble", FMLV_ERROR, "Could not parse '%s'", s);
+                        Hprintf("ExtValue", "parseDouble", HMLV_ERROR, "Could not parse '%s'", s);
                 return false;
         }
@@ -837 +836 @@
         case TString: return getInt(sdata().c_str());
         case TObj:
-                FMprintf("ExtValue", "getInt", FMLV_WARN, "Getting integer value from object reference (%s)", getString().c_str());
+                Hprintf("ExtValue", "getInt", HMLV_WARN, "Getting integer value from object reference (%s)", getString().c_str());
                 return (paInt)(intptr_t)odata().param;
         default:;
@@ -852 +851 @@
         case TString: return getDouble(sdata().c_str());
         case TObj:
-                FMprintf("ExtValue", "getDouble", FMLV_WARN, "Getting floating point value from object reference (%s)", getString().c_str());
+                Hprintf("ExtValue", "getDouble", HMLV_WARN, "Getting floating point value from object reference (%s)", getString().c_str());
                 return (double)(intptr_t)odata().param;
         default:;
@@ -990 +989 @@
                 else
                 {
-                        FMprintf("ExtValue", "deserialize", FMLV_ERROR, "Missing '\"' in string: '%s'", ret);
+                        Hprintf("ExtValue", "deserialize", HMLV_ERROR, "Missing '\"' in string: '%s'", ret);
                         return NULL;
                 }
@@ -1012 +1011 @@
                                 else if (*p != ']')
                                 {
-                                        FMprintf("ExtValue", "deserialize", FMLV_ERROR, "Missing ',' in Vector: '%s'", p);
+                                        Hprintf("ExtValue", "deserialize", HMLV_ERROR, "Missing ',' in Vector: '%s'", p);
                                         return NULL;
                                 }
@@ -1038 +1037 @@
                         if ((!ret) || (args[1].getType() != TString)) { p = NULL; break; }
                         p = ret;
-                        if (*p != ':') { FMprintf("ExtValue", "deserialize", FMLV_ERROR, "Missing ':' in Dictionary: '%s'", p); p = NULL; break; }
+                        if (*p != ':') { Hprintf("ExtValue", "deserialize", HMLV_ERROR, "Missing ':' in Dictionary: '%s'", p); p = NULL; break; }
                         p++;
                         ret = args[0].deserialize(p);
@@ -1047 +1046 @@
                         else if (*p != '}')
                         {
-                                FMprintf("ExtValue", "deserialize", FMLV_ERROR, "Missing ',' in Dictionary: '%s'", p);
+                                Hprintf("ExtValue", "deserialize", HMLV_ERROR, "Missing ',' in Dictionary: '%s'", p);
                                 return NULL;
                         }
@@ -1087 +1086 @@
                         }
                 }
-                FMprintf("ExtValue", "deserialize", FMLV_ERROR, "Invalid reference: '%s'", in - 1);
+                Hprintf("ExtValue", "deserialize", HMLV_ERROR, "Invalid reference: '%s'", in - 1);
                 return NULL;
         }
@@ -1134 +1133 @@
                 }
                 setEmpty();
-                FMprintf("ExtValue", "deserialize", FMLV_WARN, "object of class \"%s\" could not be deserialized", clsname.c_str());
+                Hprintf("ExtValue", "deserialize", HMLV_WARN, "object of class \"%s\" could not be deserialized", clsname.c_str());
                 return ret;
         }
-        FMprintf("ExtValue", "deserialize", FMLV_ERROR, "Bad syntax: '%s'", in);
+        Hprintf("ExtValue", "deserialize", HMLV_ERROR, "Bad syntax: '%s'", in);
         setEmpty();
         return NULL;

cpp/frams/util/sstringutils.cpp

@@ -5 +5 @@
 #include "sstringutils.h"
 #include <frams/virtfile/virtfile.h>
-#include <common/framsg.h>
+#include <common/hmessage.h>
 #include <common/nonstd.h>
 
@@ -19 +19 @@
         }
         else if (framsgmodule)
-                FMprintf(framsgmodule, "loadSString", FMLV_WARN, error ? error : "can't open file \"%s\"", filename);
+                Hprintf(framsgmodule, "loadSString", HMLV_WARN, error ? error : "can't open file \"%s\"", filename);
         return ret;
 }

cpp/frams/virtfile/stdiofile.cpp

@@ -6 +6 @@
 #include <common/nonstd_dir.h>
 #include <common/nonstd_stdio.h>
-#include <common/framsg.h>
+#include <common/hmessage.h>
 #include <common/Convert.h>
 
 VirtFILE* StdioFileSystem::Vfopen(const char *path, const char *mode)
 {
-        //printFM("Vfopen %s %s",path,mode);
+        //printH("Vfopen %s %s",path,mode);
 #ifdef _WIN32
         FILE *f = _wfopen(Convert::utf8ToUtf16(path).c_str(), Convert::strTOwstr(mode).c_str());
@@ -21 +21 @@
 #endif
 #endif
-        //printFM("%p",f);
+        //printH("%p",f);
         if (f) return new StdioFILE(f, path); else return NULL;
 }
@@ -27 +27 @@
 VirtDIR* StdioFileSystem::Vopendir(const char* path)
 {
-        //printFM("Vopendir %s",path);
+        //printH("Vopendir %s",path);
 #ifdef _WIN32
         DIRTYPE *d = wopendir(Convert::utf8ToUtf16(path).c_str());
@@ -33 +33 @@
         DIR *d = opendir(path);
 #endif
-        //printFM("%p",d);
+        //printH("%p",d);
         if (d) return new StdioDIR(d); else return NULL;
 }
@@ -56 +56 @@
 dirent* StdioDIR::Vreaddir()
 {
-        //printFM("Vreaddir %s",dir);
+        //printH("Vreaddir %s",dir);
 #ifdef _WIN32
         wdirent *wde=wreaddir(dir);

cpp/frams/vm/classes/collectionobj.cpp

@@ -5 +5 @@
 #include "collectionobj.h"
 #include <common/nonstd_math.h> //sqrt in borland
-#include <frams/errmgr/stderrors.h>
+#include <frams/mhandlers/stderrors.h>
 #include <common/nonstd_stl.h>
 #include <frams/util/sstringutils.h>
@@ -232 +232 @@
         {
         ret=false;
-        FMprintf("VectorElementComparator","",FMLV_ERROR,"Comparison function returned no value");
+        Hprintf("VectorElementComparator","",HMLV_ERROR,"Comparison function returned no value");
         }
 else