Remove pthread.h from janet.h

Should make janet a bit easier to use. Also changes the
header to not expose the size of native mutexes and rwlocks, except
with janet_os_mutex_size and janet_os_rwlock_size.

src/boot/boot.janet

@@ -45,6 +45,7 @@
 (defn defmacro :macro
   "Define a macro."
   [name & more]
+  (setdyn name @{}) # override old macro definitions in the case of a recursive macro
   (apply defn name :macro more))
 
 (defmacro as-macro

src/core/abstract.c

@@ -23,6 +23,7 @@
 #ifndef JANET_AMALG
 #include "features.h"
 #include <janet.h>
+#include "util.h"
 #include "gc.h"
 #include "state.h"
 #ifdef JANET_EV
@@ -85,6 +86,14 @@ void *janet_abstract_threaded(const JanetAbstractType *atype, size_t size) {
 
 #ifdef JANET_WINDOWS
 
+void janet_os_mutex_size(void) {
+    return sizeof(CRITICAL_SECTION);
+}
+
+void janet_os_rwlock_size(void) {
+    return sizeof(SRWLock);
+}
+
 static int32_t janet_incref(JanetAbstractHead *ab) {
     return InterlockedIncrement(&ab->gc.data.refcount);
 }
@@ -137,6 +146,14 @@ void janet_os_rwlock_wunlock(JanetOSRWLock *rwlock) {
 
 #else
 
+size_t janet_os_mutex_size(void) {
+    return sizeof(pthread_mutex_t);
+}
+
+size_t janet_os_rwlock_size(void) {
+    return sizeof(pthread_rwlock_t);
+}
+
 static int32_t janet_incref(JanetAbstractHead *ab) {
     return __atomic_add_fetch(&ab->gc.data.refcount, 1, __ATOMIC_RELAXED);
 }
@@ -149,44 +166,44 @@ void janet_os_mutex_init(JanetOSMutex *mutex) {
     pthread_mutexattr_t attr;
     pthread_mutexattr_init(&attr);
     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-    pthread_mutex_init(mutex, &attr);
+    pthread_mutex_init((pthread_mutex_t *) mutex, &attr);
 }
 
 void janet_os_mutex_deinit(JanetOSMutex *mutex) {
-    pthread_mutex_destroy(mutex);
+    pthread_mutex_destroy((pthread_mutex_t *) mutex);
 }
 
 void janet_os_mutex_lock(JanetOSMutex *mutex) {
-    pthread_mutex_lock(mutex);
+    pthread_mutex_lock((pthread_mutex_t *) mutex);
 }
 
 void janet_os_mutex_unlock(JanetOSMutex *mutex) {
-    int ret = pthread_mutex_unlock(mutex);
+    int ret = pthread_mutex_unlock((pthread_mutex_t *) mutex);
     if (ret) janet_panic("cannot release lock");
 }
 
 void janet_os_rwlock_init(JanetOSRWLock *rwlock) {
-    pthread_rwlock_init(rwlock, NULL);
+    pthread_rwlock_init((pthread_rwlock_t *) rwlock, NULL);
 }
 
 void janet_os_rwlock_deinit(JanetOSRWLock *rwlock) {
-    pthread_rwlock_destroy(rwlock);
+    pthread_rwlock_destroy((pthread_rwlock_t *) rwlock);
 }
 
 void janet_os_rwlock_rlock(JanetOSRWLock *rwlock) {
-    pthread_rwlock_rdlock(rwlock);
+    pthread_rwlock_rdlock((pthread_rwlock_t *) rwlock);
 }
 
 void janet_os_rwlock_wlock(JanetOSRWLock *rwlock) {
-    pthread_rwlock_wrlock(rwlock);
+    pthread_rwlock_wrlock((pthread_rwlock_t *) rwlock);
 }
 
 void janet_os_rwlock_runlock(JanetOSRWLock *rwlock) {
-    pthread_rwlock_unlock(rwlock);
+    pthread_rwlock_unlock((pthread_rwlock_t *) rwlock);
 }
 
 void janet_os_rwlock_wunlock(JanetOSRWLock *rwlock) {
-    pthread_rwlock_unlock(rwlock);
+    pthread_rwlock_unlock((pthread_rwlock_t *) rwlock);
 }
 
 #endif

src/core/ev.c

@@ -79,7 +79,11 @@ typedef struct {
     int32_t limit;
     int closed;
     int is_threaded;
-    JanetOSMutex lock;
+#ifdef JANET_WINDOWS
+    CRITICAL_SECTION lock;
+#else
+    pthread_mutex_t lock;
+#endif
 } JanetChannel;
 
 typedef struct {
@@ -643,7 +647,7 @@ static void janet_chan_init(JanetChannel *chan, int32_t limit, int threaded) {
     janet_q_init(&chan->items);
     janet_q_init(&chan->read_pending);
     janet_q_init(&chan->write_pending);
-    janet_os_mutex_init(&chan->lock);
+    janet_os_mutex_init((JanetOSMutex *) &chan->lock);
 }
 
 static void janet_chan_deinit(JanetChannel *chan) {
@@ -656,17 +660,17 @@ static void janet_chan_deinit(JanetChannel *chan) {
         }
     }
     janet_q_deinit(&chan->items);
-    janet_os_mutex_deinit(&chan->lock);
+    janet_os_mutex_deinit((JanetOSMutex *) &chan->lock);
 }
 
 static void janet_chan_lock(JanetChannel *chan) {
     if (!janet_chan_is_threaded(chan)) return;
-    janet_os_mutex_lock(&chan->lock);
+    janet_os_mutex_lock((JanetOSMutex *) &chan->lock);
 }
 
 static void janet_chan_unlock(JanetChannel *chan) {
     if (!janet_chan_is_threaded(chan)) return;
-    janet_os_mutex_unlock(&chan->lock);
+    janet_os_mutex_unlock((JanetOSMutex *) &chan->lock);
 }
 
 /*
@@ -3013,14 +3017,9 @@ JANET_CORE_FN(janet_cfun_stream_write,
     janet_await();
 }
 
-typedef struct {
-    JanetOSMutex mutex;
-} JanetAbstractMutex;
-
 static int mutexgc(void *p, size_t size) {
-    JanetAbstractMutex *mutex = (JanetAbstractMutex *) p;
     (void) size;
-    janet_os_mutex_deinit(&mutex->mutex);
+    janet_os_mutex_deinit(p);
     return 0;
 }
 
@@ -3035,8 +3034,8 @@ JANET_CORE_FN(janet_cfun_mutex,
               "Create a new lock to coordinate threads.") {
     janet_fixarity(argc, 0);
     (void) argv;
-    JanetAbstractMutex *mutex = janet_abstract_threaded(&janet_mutex_type, sizeof(JanetAbstractMutex));
+    void *mutex = janet_abstract_threaded(&janet_mutex_type, janet_os_mutex_size());
-    janet_os_mutex_init(&mutex->mutex);
+    janet_os_mutex_init(mutex);
     return janet_wrap_abstract(mutex);
 }
 
@@ -3046,8 +3045,8 @@ JANET_CORE_FN(janet_cfun_mutex_acquire,
               " This will block this entire thread until the lock becomes available, and will not yield to other fibers "
               "on this system thread.") {
     janet_fixarity(argc, 1);
-    JanetAbstractMutex *mutex = janet_getabstract(argv, 0, &janet_mutex_type);
+    void *mutex = janet_getabstract(argv, 0, &janet_mutex_type);
-    janet_os_mutex_lock(&mutex->mutex);
+    janet_os_mutex_lock(mutex);
     return argv[0];
 }
 
@@ -3055,19 +3054,14 @@ JANET_CORE_FN(janet_cfun_mutex_release,
               "(ev/release-lock lock)",
               "Release a lock such that other threads may acquire it.") {
     janet_fixarity(argc, 1);
-    JanetAbstractMutex *mutex = janet_getabstract(argv, 0, &janet_mutex_type);
+    void *mutex = janet_getabstract(argv, 0, &janet_mutex_type);
-    janet_os_mutex_unlock(&mutex->mutex);
+    janet_os_mutex_unlock(mutex);
     return argv[0];
 }
 
-typedef struct {
-    JanetOSRWLock rwlock;
-} JanetAbstractRWLock;
-
 static int rwlockgc(void *p, size_t size) {
-    JanetAbstractRWLock *rwlock = (JanetAbstractRWLock *) p;
     (void) size;
-    janet_os_rwlock_deinit(&rwlock->rwlock);
+    janet_os_rwlock_deinit(p);
     return 0;
 }
 
@@ -3082,8 +3076,8 @@ JANET_CORE_FN(janet_cfun_rwlock,
               "Create a new read-write lock to coordinate threads.") {
     janet_fixarity(argc, 0);
     (void) argv;
-    JanetAbstractRWLock *rwlock = janet_abstract_threaded(&janet_rwlock_type, sizeof(JanetAbstractRWLock));
+    void *rwlock = janet_abstract_threaded(&janet_rwlock_type, janet_os_rwlock_size());
-    janet_os_rwlock_init(&rwlock->rwlock);
+    janet_os_rwlock_init(rwlock);
     return janet_wrap_abstract(rwlock);
 }
 
@@ -3091,8 +3085,8 @@ JANET_CORE_FN(janet_cfun_rwlock_read_lock,
               "(ev/acquire-rlock rwlock)",
               "Acquire a read lock an a read-write lock.") {
     janet_fixarity(argc, 1);
-    JanetAbstractRWLock *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type);
+    void *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type);
-    janet_os_rwlock_rlock(&rwlock->rwlock);
+    janet_os_rwlock_rlock(rwlock);
     return argv[0];
 }
 
@@ -3100,8 +3094,8 @@ JANET_CORE_FN(janet_cfun_rwlock_write_lock,
               "(ev/acquire-wlock rwlock)",
               "Acquire a write lock on a read-write lock.") {
     janet_fixarity(argc, 1);
-    JanetAbstractRWLock *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type);
+    void *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type);
-    janet_os_rwlock_wlock(&rwlock->rwlock);
+    janet_os_rwlock_wlock(rwlock);
     return argv[0];
 }
 
@@ -3109,8 +3103,8 @@ JANET_CORE_FN(janet_cfun_rwlock_read_release,
               "(ev/release-rlock rwlock)",
               "Release a read lock on a read-write lock") {
     janet_fixarity(argc, 1);
-    JanetAbstractRWLock *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type);
+    void *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type);
-    janet_os_rwlock_runlock(&rwlock->rwlock);
+    janet_os_rwlock_runlock(rwlock);
     return argv[0];
 }
 
@@ -3118,8 +3112,8 @@ JANET_CORE_FN(janet_cfun_rwlock_write_release,
               "(ev/release-wlock rwlock)",
               "Release a write lock on a read-write lock") {
     janet_fixarity(argc, 1);
-    JanetAbstractRWLock *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type);
+    void *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type);
-    janet_os_rwlock_wunlock(&rwlock->rwlock);
+    janet_os_rwlock_wunlock(rwlock);
     return argv[0];
 }
 

src/core/pp.c

@@ -983,8 +983,9 @@ void janet_buffer_format(
                     break;
                 }
                 case 's': {
-                    const uint8_t *s = janet_getstring(argv, arg);
+                    JanetByteView bytes = janet_getbytes(argv, arg);
-                    int32_t l = janet_string_length(s);
+                    const uint8_t *s = bytes.bytes;
+                    int32_t l = bytes.len;
                     if (form[2] == '\0')
                         janet_buffer_push_bytes(b, s, l);
                     else {

src/core/util.h

@@ -34,6 +34,10 @@
 #include <stddef.h>
 #include <stdbool.h>
 
+#ifdef JANET_EV
+#include <pthread.h>
+#endif
+
 #ifndef _MSC_VER
 #include <alloca.h>
 #endif

src/include/janet.h

@@ -307,22 +307,10 @@ typedef struct {
     JANET_CURRENT_CONFIG_BITS })
 #endif
 
-/* Feature include for pthreads. Most feature detection code should go in
+/* Some extra includes if EV is enabled */
- * features.h instead. */
+#ifdef JANET_EV
-#ifndef JANET_WINDOWS
+typedef struct JanetOSMutex JanetOSMutex;
-#ifndef _XOPEN_SOURCE
+typedef struct JanetOSRWLock JanetOSRWLock;
-#define _XOPEN_SOURCE 600
-#endif
-#if _XOPEN_SOURCE < 600
-#undef _XOPEN_SOURCE
-#define _XOPEN_SOURCE 600
-#endif
-#endif
-
-/* What to do when out of memory */
-#ifndef JANET_OUT_OF_MEMORY
-#include <stdio.h>
-#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "janet out of memory\n"); exit(1); } while (0)
 #endif
 
 /***** END SECTION CONFIG *****/
@@ -342,27 +330,10 @@ typedef struct {
 #include <stddef.h>
 #include <stdio.h>
 
-/* Some extra includes if EV is enabled */
+
-#ifdef JANET_EV
+/* What to do when out of memory */
-#ifdef JANET_WINDOWS
+#ifndef JANET_OUT_OF_MEMORY
-typedef struct JanetDudCriticalSection {
+#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "janet out of memory\n"); exit(1); } while (0)
-    /* Avoid including windows.h here - instead, create a structure of the same size */
-    /* Needs to be same size as crtical section see WinNT.h for CRITCIAL_SECTION definition */
-    void *debug_info;
-    long lock_count;
-    long recursion_count;
-    void *owning_thread;
-    void *lock_semaphore;
-    unsigned long spin_count;
-} JanetOSMutex;
-typedef struct JanetDudRWLock {
-    void *ptr;
-} JanetOSRWLock;
-#else
-#include <pthread.h>
-typedef pthread_mutex_t JanetOSMutex;
-typedef pthread_rwlock_t JanetOSRWLock;
-#endif
 #endif
 
 #ifdef JANET_BSD
@@ -1394,6 +1365,8 @@ JANET_API int32_t janet_abstract_incref(void *abst);
 JANET_API int32_t janet_abstract_decref(void *abst);
 
 /* Expose some OS sync primitives */
+JANET_API size_t janet_os_mutex_size(void);
+JANET_API size_t janet_os_rwlock_size(void);
 JANET_API void janet_os_mutex_init(JanetOSMutex *mutex);
 JANET_API void janet_os_mutex_deinit(JanetOSMutex *mutex);
 JANET_API void janet_os_mutex_lock(JanetOSMutex *mutex);