Cleanup

include/clasp/asttooling/clangTooling.h

@@ -110,7 +110,7 @@ class DerivableSyntaxOnlyAction : public clbind::Derivable<clang::SyntaxOnlyActi
   virtual void ExecuteAction() {
     clang::CompilerInstance &CI = this->getCompilerInstance();
     CI.getFrontendOpts().DisableFree = true;
-    this->ExecuteAction();
+    this->Base::ExecuteAction();
   }
 };
 

include/clasp/clbind/constructor.h

@@ -201,8 +201,7 @@ class WRAPPER_Constructor_O < constructor<ARGS...>, Policies, Pointer, Construct
 
   static inline LCC_RETURN wrapper_entry_point_n(const BytecodeWrapper& dummy, core::T_O* lcc_closure, size_t lcc_nargs, core::T_O** lcc_args )
   {
-    MyType* closure = gctools::untag_general<MyType*>((MyType*)lcc_closure);
-    INCREMENT_FUNCTION_CALL_COUNTER(closure);
+    INCREMENT_FUNCTION_CALL_COUNTER(gctools::untag_general<MyType*>((MyType*)lcc_closure));
     DO_DRAG_CXX_CALLS();
     if (lcc_nargs!=NumParams) cc_wrong_number_of_arguments(lcc_closure,lcc_nargs,NumParams,NumParams);
     std::tuple<translate::from_object<ARGS>...> all_args = arg_tuple<0,policies<>,ARGS...>::goFrame(lcc_args);

include/clasp/clbind/function.h

@@ -107,7 +107,7 @@ class WRAPPER_VariadicFunction<RT (*)(ARGS...), Policies, clbind::pureOutsPack<P
   enum { NumParams = sizeof...(ARGS) };
 
   WRAPPER_VariadicFunction(FuncType ptr, core::FunctionDescription_sp fdesc, core::T_sp code)
-      : fptr(ptr), GlobalSimpleFunBase_O(fdesc, core::ClaspXepFunction::make<MyType>(), code) {
+    : GlobalSimpleFunBase_O(fdesc, core::ClaspXepFunction::make<MyType>(), code), fptr(ptr) {
     this->validateCodePointer((void **)&this->fptr, sizeof(this->fptr));
   };
 

include/clasp/clbind/getterTop.h

@@ -12,7 +12,7 @@ class WRAPPER_Getter
 
 public:
   WRAPPER_Getter(VariablePtrType ptr, core::FunctionDescription_sp fdesc, core::T_sp code)
-      : mptr(ptr), GlobalSimpleFunBase_O(fdesc,core::ClaspXepFunction::make<MyType>(),code) {
+    : GlobalSimpleFunBase_O(fdesc,core::ClaspXepFunction::make<MyType>(),code), mptr(ptr) {
     trapGetterMethoid();
   };
 

include/clasp/clbind/memberFunction.h

@@ -50,7 +50,7 @@ class WRAPPER_AlienVariadicMethod < RT(OT::*)(ARGS...), Policies, ArgumentWrappe
   enum { NumParams = sizeof...(ARGS)+1 };
 
   WRAPPER_AlienVariadicMethod(MethodType ptr, core::FunctionDescription_sp fdesc, core::T_sp code)
-      : mptr(ptr), GlobalSimpleFunBase_O(fdesc,core::ClaspXepFunction::make<MyType>(),code)  {
+    : GlobalSimpleFunBase_O(fdesc,core::ClaspXepFunction::make<MyType>(),code), mptr(ptr)  {
     this->validateCodePointer((void**)&this->mptr,sizeof(this->mptr));
   };
 
@@ -120,7 +120,7 @@ class WRAPPER_AlienVariadicMethod < RT(OT::*)(ARGS...) const, Policies, Argument
   enum { NumParams = sizeof...(ARGS)+1 };
 
   WRAPPER_AlienVariadicMethod(MethodType ptr, core::FunctionDescription_sp fdesc, core::T_sp code)
-      : mptr(ptr), GlobalSimpleFunBase_O(fdesc,core::ClaspXepFunction::make<MyType>(),code)  {
+    : GlobalSimpleFunBase_O(fdesc,core::ClaspXepFunction::make<MyType>(),code), mptr(ptr) {
     this->validateCodePointer((void**)&this->mptr,sizeof(this->mptr));
   };
 

include/clasp/core/backtrace.h

@@ -32,10 +32,10 @@ DebuggerFrame_O : public General_O {
   DebuggerFrame_O(T_sp a_fname, T_sp a_return_address, T_sp a_sp, T_sp a_fd,
                   T_sp a_closure, T_sp a_args, bool a_av, T_sp a_lang,
                   bool a_is_xep)
-      : fname(a_fname), return_address(a_return_address),
+    : fname(a_fname), return_address(a_return_address),
       source_position(a_sp), function_description(a_fd),
-      closure(a_closure), args(a_args), args_available(a_av), is_xep(a_is_xep),
-      lang(a_lang), up(nil<T_O>()), down(nil<T_O>())
+      closure(a_closure), args(a_args), args_available(a_av),
+      lang(a_lang), up(nil<T_O>()), down(nil<T_O>()), is_xep(a_is_xep)
   {}
   static DebuggerFrame_sp make(T_sp fname, T_sp ra,
                                T_sp sp, T_sp fd,

include/clasp/core/debugger.h

@@ -70,19 +70,17 @@ struct OpenDynamicLibraryInfo {
   bool           _IsExecutable;
   std::string    _Filename;
   void*          _Handle;
-  SymbolTable    _SymbolTable;
   gctools::clasp_ptr_t      _LibraryStart;
   gctools::clasp_ptr_t      _TextStart;
   gctools::clasp_ptr_t      _TextEnd;
   bool                      _HasVtableSection;
   gctools::clasp_ptr_t      _VtableSectionStart;
   gctools::clasp_ptr_t      _VtableSectionEnd;
-  OpenDynamicLibraryInfo(bool is_executable, const std::string& f, void* h, const SymbolTable& symbol_table, gctools::clasp_ptr_t libstart, gctools::clasp_ptr_t textStart, gctools::clasp_ptr_t textEnd,
+  OpenDynamicLibraryInfo(bool is_executable, const std::string& f, void* h, gctools::clasp_ptr_t libstart, gctools::clasp_ptr_t textStart, gctools::clasp_ptr_t textEnd,
                          bool hasVtableSection, gctools::clasp_ptr_t vtableSectionStart, gctools::clasp_ptr_t vtableSectionEnd ) :
     _IsExecutable(is_executable),
     _Filename(f),
     _Handle(h),
-    _SymbolTable(symbol_table),
     _LibraryStart(libstart),
     _TextStart(textStart),
     _TextEnd(textEnd),

include/clasp/core/exceptions.h

@@ -293,7 +293,6 @@ struct CxxFunctionInvocationLogger {
 #define IMPLEMENT_MEF(msg) SIMPLE_ERROR("Implement function %s:%d %s %s", __FILE__ , __LINE__ , __FUNCTION__ , msg)
 
 #define WARN_IMPLEMENT_ME() printf("%s:%d:%s Implement function\n", __FILE__, __LINE__, __FUNCTION__ );
-#define WARN_IMPLEMENT_MEF(msg) printf("%s\n", (BF("Implement function %s:%d %s %s") % __FILE__ % __LINE__ % __FUNCTION__ % (msg).str().c_str()).str().c_str());
 
 #define NOT_SUPPORTED() SIMPLE_ERROR("Subclass(%s) does not support the function(%s) file(%s) lineNumber(%d)", this->className() , __FUNCTION__ , __FILE__ , __LINE__);
 
@@ -305,9 +304,6 @@ struct CxxFunctionInvocationLogger {
 #define DEPRECATED() SIMPLE_ERROR(("Depreciated!!! function(%s) file(%s) lineNumber(%d)") , __FUNCTION__ , __FILE__ , __LINE__);
 #define STUB() printf("%s:%d>%s  stub\n", __FILE__, __LINE__, __FUNCTION__ )
 
-#define MAY_BE_DEPRECATED() printf("%s\n", (BF("May be depreciated!!! function(%s) file(%s) lineNumber(%d)") % __FUNCTION__ % __FILE__ % __LINE__).str().c_str());
-#define DEPRECATEDP(s) SIMPLE_ERROR(("Depreciated!!! function(%s) file(%s) lineNumber(%d) %s") , __FUNCTION__ , __FILE__ , __LINE__ , (s));
-
 FORWARD(Cons);
 
 #ifdef DEBUG_ASSERT
@@ -495,10 +491,6 @@ void assert_failure_bounds_error_lt(const char* file, size_t line, const char* f
     SIMPLE_ERROR(("Assertion [%s>%s] failed values are (%s) and (%s)") , #x , #y , (x) , (y)); \
   }
 #define ASSERT_gt(x, y) ASSERT_greaterThan(x, y)
-#define FATAL_ASSERTP(x, e)                                                                             \
-  if (!(x)) {                                                                                           \
-    SIMPLE_ERROR(_lisp, core::LispError_O::create(BF("Assertion [%s] failed - %s") % #x % (e), _lisp)); \
-  };
 
 #if DEBUG_TRAP_NULLS == 1
 #define ASSERTNOTNULLP(x, e)                                                      \
@@ -535,8 +527,6 @@ void assert_failure_bounds_error_lt(const char* file, size_t line, const char* f
   {}
 #define ASSERT_gt(x, y) \
   {}
-#define FATAL_ASSERTP(x, e) \
-  {}
 #define ASSERTNOTNULLP(x, e) \
   {}
 #define ASSERTNOTNULL(x) \

include/clasp/core/external_wrappers.h

@@ -54,7 +54,7 @@ class WRAPPER_IndirectMethod < RT(OT::ExternalType::*)(ARGS...), Policies, OT, A
   enum { NumParams = sizeof...(ARGS)+1 };
 
   WRAPPER_IndirectMethod(MethodType ptr, core::FunctionDescription_sp fdesc, core::T_sp code)
-      : mptr(ptr), GlobalSimpleFunBase_O(fdesc,core::ClaspXepFunction::make<MyType>(),code)  {
+    : GlobalSimpleFunBase_O(fdesc,core::ClaspXepFunction::make<MyType>(),code), mptr(ptr)  {
     this->validateCodePointer((void**)&this->mptr,sizeof(this->mptr));
   };
 
@@ -118,7 +118,7 @@ class WRAPPER_IndirectMethod < RT(OT::ExternalType::*)(ARGS...) const, Policies,
   enum { NumParams = sizeof...(ARGS)+1 };
 
   WRAPPER_IndirectMethod(MethodType ptr, core::FunctionDescription_sp fdesc, core::T_sp code)
-      : mptr(ptr), GlobalSimpleFunBase_O(fdesc,core::ClaspXepFunction::make<MyType>(),code)  {
+    : GlobalSimpleFunBase_O(fdesc,core::ClaspXepFunction::make<MyType>(),code), mptr(ptr)  {
     this->validateCodePointer((void**)&this->mptr,sizeof(this->mptr));
   };
 
@@ -185,7 +185,7 @@ class WRAPPER_Getter : public GlobalSimpleFunBase_O {
 public:
 
   WRAPPER_Getter(MemPtr ptr, core::FunctionDescription_sp fdesc, core::T_sp code)
-      : mptr(ptr), GlobalSimpleFunBase_O(fdesc,core::ClaspXepFunction::make<MyType>(),code) {
+    : GlobalSimpleFunBase_O(fdesc,core::ClaspXepFunction::make<MyType>(),code), mptr(ptr) {
     this->validateCodePointer((void**)&this->mptr,sizeof(this->mptr));
   }
 

include/clasp/core/funcallableInstance.h

@@ -63,7 +63,7 @@ class FuncallableInstance_O : public Function_O {
   explicit FuncallableInstance_O(GlobalSimpleFun_sp fdesc, Instance_sp metaClass, size_t slots)
       : Base(fdesc), _Class(metaClass), _RealFunction(nil<Function_O>()){};
   FuncallableInstance_O(GlobalSimpleFun_sp fdesc, Instance_sp cl, Rack_sp rack)
-      : Base(fdesc), _Class(cl), _Rack(rack), _RealFunction(nil<Function_O>()){};
+    : Base(fdesc), _Rack(rack), _Class(cl), _RealFunction(nil<Function_O>()){};
   virtual ~FuncallableInstance_O(){};
 
 public:

include/clasp/core/lisp.h

@@ -257,29 +257,29 @@ struct globals_t {
   // ------------------------------------------------------------
   // ------------------------------------------------------------
   // ------------------------------------------------------------
-  globals_t() : _MakePackageCallback(NULL),
-                _ExportSymbolCallback(NULL),
-                _PathMax(CLASP_MAXPATHLEN),
-                _ActiveThreadsMutex(ACTVTHRD_NAMEWORD),
+  globals_t() : _ActiveThreadsMutex(ACTVTHRD_NAMEWORD),
                 _DefaultSpecialBindingsMutex(SPCLBIND_NAMEWORD),
                 _FinalizersMutex(MPSMESSG_NAMEWORD),
                 _SourceFilesMutex(SRCFILES_NAMEWORD),
                 _PackagesMutex(PKGSMUTX_NAMEWORD),
-#ifdef DEBUG_MONITOR_SUPPORT
-                _MonitorMutex(LOGMUTEX_NAMEWORD),
-#endif
                 _ThePathnameTranslationsMutex(PNTRANSL_NAMEWORD),
                 _JITLogMutex(JITLOG___NAMEWORD),
                 _UnixSignalHandlersMutex(UNIXSIGN_NAMEWORD),
-                _CodeBlocksMutex(CODEBLOK_NAMEWORD),
+                _CodeBlocksMutex(CODEBLOK_NAMEWORD),              
+#ifdef DEBUG_MONITOR_SUPPORT
+                _MonitorMutex(LOGMUTEX_NAMEWORD),
+#endif
                 _StackWarnSize(gctools::_global_stack_max_size * 0.9), // 6MB default stack size before warnings
                 _StackSampleCount(0),
                 _StackSampleSize(0),
                 _StackSampleMax(0),
                 _ReplCounter(1),
                 _Bundle(NULL),
                 _DebugStream(NULL),
-                _SingleStepLevel(UndefinedUnsignedInt)
+                _SingleStepLevel(UndefinedUnsignedInt),
+                _MakePackageCallback(NULL),
+                _ExportSymbolCallback(NULL),
+                _PathMax(CLASP_MAXPATHLEN)
   {
     this->_GlobalInitializationCallbacks.clear();
     this->_TraceLevel = 0;
@@ -385,8 +385,6 @@ class Lisp {
 public:
   static void initializeGlobals(LispPtr lisp);
 
-public:
-  static void lisp_initSymbols(LispPtr lisp);
 public:
   static const int MaxFunctionArguments; //<! See ecl/src/c/main.d:163 ecl_make_cache(64,4096)
 public:

include/clasp/core/lispStream.h

@@ -233,8 +233,6 @@ struct FileOps {
 // Define types of streams
 // See ecl object.h:600
 
-#define C_STREAM 1
-
 typedef enum { clasp_stream_mode_input, clasp_stream_mode_output, clasp_stream_mode_io } ClaspStreamModeEnum;
 
 class StreamCursor {

include/clasp/core/mpPackage.fwd.h

@@ -141,7 +141,7 @@ class contention_free_shared_mutex {
 
 public:
   contention_free_shared_mutex() :
-      shared_locks_array_ptr(std::make_shared<array_slock_t>()), shared_locks_array(*shared_locks_array_ptr), want_x_lock(false), recursive_xlock_count(0),
+    want_x_lock(false), shared_locks_array_ptr(std::make_shared<array_slock_t>()), shared_locks_array(*shared_locks_array_ptr), recursive_xlock_count(0),
       owner_thread_id(thread_id_t()) {}
 
   ~contention_free_shared_mutex() {

include/clasp/core/mpPackage.h

@@ -149,9 +149,12 @@ class Process_O : public core::CxxObject_O {
 public:
   Process_O(core::T_sp name, core::T_sp function, core::List_sp arguments, core::List_sp initialSpecialBindings = nil<core::T_O>(),
             size_t stack_size = 8 * 1024 * 1024)
-      : _Parent(nil<core::T_O>()), _UniqueID(global_process_UniqueID++), _Name(name), _Function(function), _Arguments(arguments),
-        _InitialSpecialBindings(initialSpecialBindings), _ThreadInfo(NULL), _ReturnValuesList(nil<core::T_O>()), _Aborted(false),
-        _AbortCondition(nil<core::T_O>()), _StackSize(stack_size), _Phase(Nascent), _SuspensionMutex(SUSPBARR_NAMEWORD) {
+    : _UniqueID(global_process_UniqueID++), _Parent(nil<core::T_O>()), _Name(name), _Function(function), _Arguments(arguments),
+      _InitialSpecialBindings(initialSpecialBindings),
+      _ReturnValuesList(nil<core::T_O>()), _Aborted(false),
+      _AbortCondition(nil<core::T_O>()), _ThreadInfo(NULL),
+      _Phase(Nascent), _SuspensionMutex(SUSPBARR_NAMEWORD),
+      _StackSize(stack_size) {
     if (!function) {
       printf("%s:%d Trying to create a process and the function is NULL\n", __FILE__, __LINE__);
     }

include/clasp/core/newhash.h

@@ -103,52 +103,51 @@ hash_string(int initval, const unsigned char *k, int length) {
   /*------------------------------------- handle the last 11 bytes */
   c += length;
   switch (len) {
-  /* all the case statements fall through */
   case 23:
-    c += ((uintptr_t)k[22] << 52);
+      c += ((uintptr_t)k[22] << 52); [[fallthrough]];
   case 22:
-    c += ((uintptr_t)k[21] << 48);
+    c += ((uintptr_t)k[21] << 48); [[fallthrough]];
   case 21:
-    c += ((uintptr_t)k[20] << 40);
+    c += ((uintptr_t)k[20] << 40); [[fallthrough]];
   case 20:
-    c += ((uintptr_t)k[19] << 32);
+    c += ((uintptr_t)k[19] << 32); [[fallthrough]];
   case 19:
-    c += ((uintptr_t)k[18] << 24);
+    c += ((uintptr_t)k[18] << 24); [[fallthrough]];
   case 18:
-    c += ((uintptr_t)k[17] << 16);
+    c += ((uintptr_t)k[17] << 16); [[fallthrough]];
   case 17:
-    c += ((uintptr_t)k[16] << 8);
+    c += ((uintptr_t)k[16] << 8); [[fallthrough]];
   /* the first byte of c is reserved for the length */
   case 16:
-    b += ((uintptr_t)k[15] << 52);
+    b += ((uintptr_t)k[15] << 52); [[fallthrough]];
   case 15:
-    b += ((uintptr_t)k[14] << 48);
+    b += ((uintptr_t)k[14] << 48); [[fallthrough]];
   case 14:
-    b += ((uintptr_t)k[13] << 40);
+    b += ((uintptr_t)k[13] << 40); [[fallthrough]];
   case 13:
-    b += ((uintptr_t)k[12] << 32);
+    b += ((uintptr_t)k[12] << 32); [[fallthrough]];
   case 12:
-    b += ((uintptr_t)k[11] << 24);
+    b += ((uintptr_t)k[11] << 24); [[fallthrough]];
   case 11:
-    b += ((uintptr_t)k[10] << 16);
+    b += ((uintptr_t)k[10] << 16); [[fallthrough]];
   case 10:
-    b += ((uintptr_t)k[9] << 8);
+    b += ((uintptr_t)k[9] << 8); [[fallthrough]];
   case 9:
-    b += k[8];
+    b += k[8]; [[fallthrough]];
   case 8:
-    a += ((uintptr_t)k[7] << 52);
+    a += ((uintptr_t)k[7] << 52); [[fallthrough]];
   case 7:
-    a += ((uintptr_t)k[6] << 48);
+    a += ((uintptr_t)k[6] << 48); [[fallthrough]];
   case 6:
-    a += ((uintptr_t)k[5] << 40);
+    a += ((uintptr_t)k[5] << 40); [[fallthrough]];
   case 5:
-    a += ((uintptr_t)k[4] << 32);
+    a += ((uintptr_t)k[4] << 32); [[fallthrough]];
   case 4:
-    a += ((uintptr_t)k[3] << 24);
+    a += ((uintptr_t)k[3] << 24); [[fallthrough]];
   case 3:
-    a += ((uintptr_t)k[2] << 16);
+    a += ((uintptr_t)k[2] << 16); [[fallthrough]];
   case 2:
-    a += ((uintptr_t)k[1] << 8);
+    a += ((uintptr_t)k[1] << 8); [[fallthrough]];
   case 1:
     a += k[0];
     /* case 0: nothing left to add */

include/clasp/core/numbers.h

@@ -150,7 +150,7 @@ namespace core
   SingleFloat_sp clasp_make_single_float(float d);
   DoubleFloat_sp clasp_make_double_float(double d);
   Number_sp clasp_log1_complex_inner(Number_sp r, Number_sp i);
-  void clasp_report_divide_by_zero(Number_sp x);
+  [[noreturn]] void clasp_report_divide_by_zero(Number_sp x);
 };
 
 namespace core {

include/clasp/core/package.h

@@ -224,8 +224,9 @@ class Package_O : public General_O {
 
  public:
   // Not default constructable
- Package_O() : _Nicknames(nil<T_O>()), _LocalNicknames(nil<T_O>()),
-                                   _Documentation(nil<T_O>()), _Lock(PACKAGE__NAMEWORD), _ActsLikeKeywordPackage(false)
+  Package_O() :  _ActsLikeKeywordPackage(false),
+                 _Nicknames(nil<T_O>()), _LocalNicknames(nil<T_O>()),
+                 _Documentation(nil<T_O>()), _Lock(PACKAGE__NAMEWORD)
   {};
 
   virtual void fixupInternalsForSnapshotSaveLoad( snapshotSaveLoad::Fixup* fixup ) {

include/clasp/core/record.h

@@ -493,14 +493,14 @@ class Record_O : public General_O {
 
   template <typename SK, typename SV, typename CMP>
   void field(Symbol_sp name, gctools::SmallMultimap_uncopyable<gctools::smart_ptr<SK>,gctools::smart_ptr<SV>,CMP>& value ) {
-    RECORD_LOG(BF("field(Symbol_sp name, gctools::SmallMultimap<gctools::smart_ptr<SK>,gctools::smart_ptr<SV>> ) name: %s") % _rep_(name));
+    RECORD_LOG(("field(Symbol_sp name, gctools::SmallMultimap<gctools::smart_ptr<SK>,gctools::smart_ptr<SV>> ) name: %s") , _rep_(name));
     switch (this->stage()) {
     case saving: {
       Vector_sp vec_value = core__make_vector(cl::_sym_T_O, value.size());
       size_t idx(0);
       for (auto it : value)
         vec_value->rowMajorAset(idx++,Cons_O::create(it.first, it.second));
-      RECORD_LOG(BF("saving entry: %s") % _rep_(vec_value));
+      RECORD_LOG(("saving entry: %s") , _rep_(vec_value));
       Cons_sp apair = core::Cons_O::create(name, vec_value);
       this->_alist = core::Cons_O::create(apair, this->_alist);
     } break;
@@ -512,13 +512,13 @@ class Record_O : public General_O {
       if (!find.consp())
         SIMPLE_ERROR_SPRINTF("Could not find field %s",  _rep_(name).c_str());
       Cons_sp apair = gc::As_unsafe<Cons_sp>(find);
-      RECORD_LOG(BF("loading find: %s") % _rep_(apair));
+      RECORD_LOG(("loading find: %s") , _rep_(apair));
       Vector_sp vec_value = gc::As<Vector_sp>(CONS_CDR(apair));
-      RECORD_LOG(BF("vec_value: %s") % _rep_(vec_value));
+      RECORD_LOG(("vec_value: %s") , _rep_(vec_value));
       value.clear();
       for (size_t i(0), iEnd(cl__length(vec_value)); i < iEnd; ++i) {
         T_sp val = vec_value->rowMajorAref(i);
-        RECORD_LOG(BF("Loading vec0[%d] new@%p: %s\n") % i % (void *)(val.raw_()) % _rep_(val));
+        RECORD_LOG(("Loading vec0[%d] new@%p: %s\n") , i , (void *)(val.raw_()) , _rep_(val));
         value.push_back(std::make_pair<gctools::smart_ptr<SK>,
                         gctools::smart_ptr<SV>>(gc::As_unsafe<gctools::smart_ptr<SK>>(oCar(val)),
                                                 gc::As_unsafe<gctools::smart_ptr<SV>>(oCdr(val))));
@@ -527,7 +527,7 @@ class Record_O : public General_O {
         this->flagSeen(apair);
     } break;
     case patching: {
-      RECORD_LOG(BF("Patching"));
+      RECORD_LOG(("Patching"));
       for ( auto&& pairi : value ) {
         gc::smart_ptr<T_O> orig_key = pairi.first;
         gc::smart_ptr<T_O> orig_value = pairi.second;