move threads out of system

lib/core/locks.nim

@@ -18,8 +18,7 @@ when not compileOption("threads") and not defined(nimdoc):
   when false: # fix #12330
     {.error: "Locks requires --threads:on option.".}
 
-const insideRLocksModule = false
-include "system/syslocks"
+import std/private/syslocks
 
 type
   Lock* = SysLock ## Nim lock; whether this is re-entrant

lib/core/rlocks.nim

@@ -16,8 +16,7 @@ when not compileOption("threads") and not defined(nimdoc):
     # so they can replace each other seamlessly.
     {.error: "Rlocks requires --threads:on option.".}
 
-const insideRLocksModule = true
-include "system/syslocks"
+import std/private/syslocks
 
 type
   RLock* = SysLock ## Nim lock, re-entrant

lib/genode/alloc.nim

@@ -15,7 +15,7 @@ when not defined(genode):
   {.error: "Genode only module".}
 
 when not declared(GenodeEnv):
-  include genode/env
+  import genode/env
 
 type RamDataspaceCapability {.
   importcpp: "Genode::Ram_dataspace_capability", pure.} = object

lib/genode/env.nim

@@ -20,10 +20,10 @@ when not defined(genode):
   {.error: "Genode only include".}
 
 type
-  GenodeEnvObj {.importcpp: "Genode::Env", header: "<base/env.h>", pure.} = object
-  GenodeEnvPtr = ptr GenodeEnvObj
+  GenodeEnvObj* {.importcpp: "Genode::Env", header: "<base/env.h>", pure.} = object
+  GenodeEnvPtr* = ptr GenodeEnvObj
 
-const runtimeEnvSym = "nim_runtime_env"
+const runtimeEnvSym* = "nim_runtime_env"
 
 when not defined(nimscript):
-  var runtimeEnv {.importcpp: runtimeEnvSym.}: GenodeEnvPtr
+  var runtimeEnv* {.importcpp: runtimeEnvSym.}: GenodeEnvPtr

lib/pure/concurrency/cpuinfo.nim

@@ -40,7 +40,7 @@ when defined(macosx) or defined(bsd):
               importc: "sysctl", nodecl.}
 
 when defined(genode):
-  include genode/env
+  import genode/env
 
   proc affinitySpaceTotal(env: GenodeEnvPtr): cuint {.
     importcpp: "@->cpu().affinity_space().total()".}

lib/system/syslocks.nim → lib/std/private/syslocks.nim

@@ -15,7 +15,7 @@ when defined(windows):
   type
     Handle = int
 
-    SysLock {.importc: "CRITICAL_SECTION",
+    SysLock* {.importc: "CRITICAL_SECTION",
               header: "<windows.h>", final, pure.} = object # CRITICAL_SECTION in WinApi
       DebugInfo: pointer
       LockCount: int32
@@ -24,29 +24,29 @@ when defined(windows):
       LockSemaphore: int
       SpinCount: int
 
-    SysCond {.importc: "RTL_CONDITION_VARIABLE", header: "<windows.h>".} = object
+    SysCond* {.importc: "RTL_CONDITION_VARIABLE", header: "<windows.h>".} = object
       thePtr {.importc: "ptr".} : Handle
 
-  proc initSysLock(L: var SysLock) {.importc: "InitializeCriticalSection",
+  proc initSysLock*(L: var SysLock) {.importc: "InitializeCriticalSection",
                                      header: "<windows.h>".}
     ## Initializes the lock `L`.
 
   proc tryAcquireSysAux(L: var SysLock): int32 {.importc: "TryEnterCriticalSection",
                                                  header: "<windows.h>".}
     ## Tries to acquire the lock `L`.
 
-  proc tryAcquireSys(L: var SysLock): bool {.inline.} =
+  proc tryAcquireSys*(L: var SysLock): bool {.inline.} =
     result = tryAcquireSysAux(L) != 0'i32
 
-  proc acquireSys(L: var SysLock) {.importc: "EnterCriticalSection",
+  proc acquireSys*(L: var SysLock) {.importc: "EnterCriticalSection",
                                     header: "<windows.h>".}
     ## Acquires the lock `L`.
 
-  proc releaseSys(L: var SysLock) {.importc: "LeaveCriticalSection",
+  proc releaseSys*(L: var SysLock) {.importc: "LeaveCriticalSection",
                                     header: "<windows.h>".}
     ## Releases the lock `L`.
 
-  proc deinitSys(L: var SysLock) {.importc: "DeleteCriticalSection",
+  proc deinitSys*(L: var SysLock) {.importc: "DeleteCriticalSection",
                                    header: "<windows.h>".}
 
   proc initializeConditionVariable(
@@ -60,41 +60,41 @@ when defined(windows):
   ): int32 {.stdcall, noSideEffect, dynlib: "kernel32", importc: "SleepConditionVariableCS".}
 
 
-  proc signalSysCond(hEvent: var SysCond) {.stdcall, noSideEffect,
+  proc signalSysCond*(hEvent: var SysCond) {.stdcall, noSideEffect,
     dynlib: "kernel32", importc: "WakeConditionVariable".}
 
-  proc broadcastSysCond(hEvent: var SysCond) {.stdcall, noSideEffect,
+  proc broadcastSysCond*(hEvent: var SysCond) {.stdcall, noSideEffect,
     dynlib: "kernel32", importc: "WakeAllConditionVariable".}
 
-  proc initSysCond(cond: var SysCond) {.inline.} =
+  proc initSysCond*(cond: var SysCond) {.inline.} =
     initializeConditionVariable(cond)
-  proc deinitSysCond(cond: var SysCond) {.inline.} =
+  proc deinitSysCond*(cond: var SysCond) {.inline.} =
     discard
-  proc waitSysCond(cond: var SysCond, lock: var SysLock) =
+  proc waitSysCond*(cond: var SysCond, lock: var SysLock) =
     discard sleepConditionVariableCS(cond, lock, -1'i32)
 
 elif defined(genode):
   const
     Header = "genode_cpp/syslocks.h"
   type
-    SysLock {.importcpp: "Nim::SysLock", pure, final,
+    SysLock* {.importcpp: "Nim::SysLock", pure, final,
               header: Header.} = object
-    SysCond {.importcpp: "Nim::SysCond", pure, final,
+    SysCond* {.importcpp: "Nim::SysCond", pure, final,
               header: Header.} = object
 
-  proc initSysLock(L: var SysLock) = discard
-  proc deinitSys(L: var SysLock) = discard
-  proc acquireSys(L: var SysLock) {.noSideEffect, importcpp.}
-  proc tryAcquireSys(L: var SysLock): bool {.noSideEffect, importcpp.}
-  proc releaseSys(L: var SysLock) {.noSideEffect, importcpp.}
+  proc initSysLock*(L: var SysLock) = discard
+  proc deinitSys*(L: var SysLock) = discard
+  proc acquireSys*(L: var SysLock) {.noSideEffect, importcpp.}
+  proc tryAcquireSys*(L: var SysLock): bool {.noSideEffect, importcpp.}
+  proc releaseSys*(L: var SysLock) {.noSideEffect, importcpp.}
 
-  proc initSysCond(L: var SysCond) = discard
-  proc deinitSysCond(L: var SysCond) = discard
-  proc waitSysCond(cond: var SysCond, lock: var SysLock) {.
+  proc initSysCond*(L: var SysCond) = discard
+  proc deinitSysCond*(L: var SysCond) = discard
+  proc waitSysCond*(cond: var SysCond, lock: var SysLock) {.
     noSideEffect, importcpp.}
-  proc signalSysCond(cond: var SysCond) {.
+  proc signalSysCond*(cond: var SysCond) {.
     noSideEffect, importcpp.}
-  proc broadcastSysCond(cond: var SysCond) {.
+  proc broadcastSysCond*(cond: var SysCond) {.
     noSideEffect, importcpp.}
 
 else:
@@ -105,7 +105,7 @@ else:
       when defined(linux) and defined(amd64):
         abi: array[40 div sizeof(clong), clong]
 
-    SysLockAttr {.importc: "pthread_mutexattr_t", pure, final
+    SysLockAttr* {.importc: "pthread_mutexattr_t", pure, final
                header: """#include <sys/types.h>
                           #include <pthread.h>""".} = object
       when defined(linux) and defined(amd64):
@@ -143,92 +143,92 @@ else:
     # to prevent this once and for all, we're doing an extra malloc when
     # initializing the primitive.
     type
-      SysLock = ptr SysLockObj
-      SysCond = ptr SysCondObj
+      SysLock* = ptr SysLockObj
+      SysCond* = ptr SysCondObj
 
     when not declared(c_malloc):
       proc c_malloc(size: csize_t): pointer {.
         importc: "malloc", header: "<stdlib.h>".}
       proc c_free(p: pointer) {.
         importc: "free", header: "<stdlib.h>".}
 
-    proc initSysLock(L: var SysLock, attr: ptr SysLockAttr = nil) =
+    proc initSysLock*(L: var SysLock, attr: ptr SysLockAttr = nil) =
       L = cast[SysLock](c_malloc(csize_t(sizeof(SysLockObj))))
       initSysLockAux(L[], attr)
 
-    proc deinitSys(L: var SysLock) =
+    proc deinitSys*(L: var SysLock) =
       deinitSysAux(L[])
       c_free(L)
 
-    template acquireSys(L: var SysLock) =
+    template acquireSys*(L: var SysLock) =
       acquireSysAux(L[])
-    template tryAcquireSys(L: var SysLock): bool =
+    template tryAcquireSys*(L: var SysLock): bool =
       tryAcquireSysAux(L[]) == 0'i32
-    template releaseSys(L: var SysLock) =
+    template releaseSys*(L: var SysLock) =
       releaseSysAux(L[])
   else:
     type
-      SysLock = SysLockObj
-      SysCond = SysCondObj
+      SysLock* = SysLockObj
+      SysCond* = SysCondObj
 
-    template initSysLock(L: var SysLock, attr: ptr SysLockAttr = nil) =
+    template initSysLock*(L: var SysLock, attr: ptr SysLockAttr = nil) =
       initSysLockAux(L, attr)
-    template deinitSys(L: var SysLock) =
+    template deinitSys*(L: var SysLock) =
       deinitSysAux(L)
-    template acquireSys(L: var SysLock) =
+    template acquireSys*(L: var SysLock) =
       acquireSysAux(L)
-    template tryAcquireSys(L: var SysLock): bool =
+    template tryAcquireSys*(L: var SysLock): bool =
       tryAcquireSysAux(L) == 0'i32
-    template releaseSys(L: var SysLock) =
+    template releaseSys*(L: var SysLock) =
       releaseSysAux(L)
 
-  when insideRLocksModule:
-    let SysLockType_Reentrant {.importc: "PTHREAD_MUTEX_RECURSIVE",
-      header: "<pthread.h>".}: SysLockType
-    proc initSysLockAttr(a: var SysLockAttr) {.
-      importc: "pthread_mutexattr_init", header: "<pthread.h>", noSideEffect.}
-    proc setSysLockType(a: var SysLockAttr, t: SysLockType) {.
-      importc: "pthread_mutexattr_settype", header: "<pthread.h>", noSideEffect.}
+  # rlocks
+  var SysLockType_Reentrant* {.importc: "PTHREAD_MUTEX_RECURSIVE",
+    header: "<pthread.h>".}: SysLockType
+  proc initSysLockAttr*(a: var SysLockAttr) {.
+    importc: "pthread_mutexattr_init", header: "<pthread.h>", noSideEffect.}
+  proc setSysLockType*(a: var SysLockAttr, t: SysLockType) {.
+    importc: "pthread_mutexattr_settype", header: "<pthread.h>", noSideEffect.}
+
+  # locks
+  proc initSysCondAux(cond: var SysCondObj, cond_attr: ptr SysCondAttr = nil) {.
+    importc: "pthread_cond_init", header: "<pthread.h>", noSideEffect.}
+  proc deinitSysCondAux(cond: var SysCondObj) {.noSideEffect,
+    importc: "pthread_cond_destroy", header: "<pthread.h>".}
+
+  proc waitSysCondAux(cond: var SysCondObj, lock: var SysLockObj): cint {.
+    importc: "pthread_cond_wait", header: "<pthread.h>", noSideEffect.}
+  proc signalSysCondAux(cond: var SysCondObj) {.
+    importc: "pthread_cond_signal", header: "<pthread.h>", noSideEffect.}
+  proc broadcastSysCondAux(cond: var SysCondObj) {.
+    importc: "pthread_cond_broadcast", header: "<pthread.h>", noSideEffect.}
 
+  when defined(ios):
+    proc initSysCond*(cond: var SysCond, cond_attr: ptr SysCondAttr = nil) =
+      cond = cast[SysCond](c_malloc(csize_t(sizeof(SysCondObj))))
+      initSysCondAux(cond[], cond_attr)
+
+    proc deinitSysCond*(cond: var SysCond) =
+      deinitSysCondAux(cond[])
+      c_free(cond)
+
+    template waitSysCond*(cond: var SysCond, lock: var SysLock) =
+      discard waitSysCondAux(cond[], lock[])
+    template signalSysCond*(cond: var SysCond) =
+      signalSysCondAux(cond[])
+    template broadcastSysCond*(cond: var SysCond) =
+      broadcastSysCondAux(cond[])
   else:
-    proc initSysCondAux(cond: var SysCondObj, cond_attr: ptr SysCondAttr = nil) {.
-      importc: "pthread_cond_init", header: "<pthread.h>", noSideEffect.}
-    proc deinitSysCondAux(cond: var SysCondObj) {.noSideEffect,
-      importc: "pthread_cond_destroy", header: "<pthread.h>".}
-
-    proc waitSysCondAux(cond: var SysCondObj, lock: var SysLockObj): cint {.
-      importc: "pthread_cond_wait", header: "<pthread.h>", noSideEffect.}
-    proc signalSysCondAux(cond: var SysCondObj) {.
-      importc: "pthread_cond_signal", header: "<pthread.h>", noSideEffect.}
-    proc broadcastSysCondAux(cond: var SysCondObj) {.
-      importc: "pthread_cond_broadcast", header: "<pthread.h>", noSideEffect.}
-
-    when defined(ios):
-      proc initSysCond(cond: var SysCond, cond_attr: ptr SysCondAttr = nil) =
-        cond = cast[SysCond](c_malloc(csize_t(sizeof(SysCondObj))))
-        initSysCondAux(cond[], cond_attr)
-
-      proc deinitSysCond(cond: var SysCond) =
-        deinitSysCondAux(cond[])
-        c_free(cond)
-
-      template waitSysCond(cond: var SysCond, lock: var SysLock) =
-        discard waitSysCondAux(cond[], lock[])
-      template signalSysCond(cond: var SysCond) =
-        signalSysCondAux(cond[])
-      template broadcastSysCond(cond: var SysCond) =
-        broadcastSysCondAux(cond[])
-    else:
-      template initSysCond(cond: var SysCond, cond_attr: ptr SysCondAttr = nil) =
-        initSysCondAux(cond, cond_attr)
-      template deinitSysCond(cond: var SysCond) =
-        deinitSysCondAux(cond)
-
-      template waitSysCond(cond: var SysCond, lock: var SysLock) =
-        discard waitSysCondAux(cond, lock)
-      template signalSysCond(cond: var SysCond) =
-        signalSysCondAux(cond)
-      template broadcastSysCond(cond: var SysCond) =
-        broadcastSysCondAux(cond)
+    template initSysCond*(cond: var SysCond, cond_attr: ptr SysCondAttr = nil) =
+      initSysCondAux(cond, cond_attr)
+    template deinitSysCond*(cond: var SysCond) =
+      deinitSysCondAux(cond)
+
+    template waitSysCond*(cond: var SysCond, lock: var SysLock) =
+      discard waitSysCondAux(cond, lock)
+    template signalSysCond*(cond: var SysCond) =
+      signalSysCondAux(cond)
+    template broadcastSysCond*(cond: var SysCond) =
+      broadcastSysCondAux(cond)
 
 {.pop.}