Mutex object initial implementation.

diff --git a/src/alloc.c b/src/alloc.c
index 2704b680263797f5f82530cbafa4235710417703..cea0bacca3d86b8794f94ad69b31999c109edcb3 100644 (file)
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -3011,6 +3011,12 @@ allocate_process ()
   return ALLOCATE_PSEUDOVECTOR (struct Lisp_Process, pid, PVEC_PROCESS);
 }
 
+struct Lisp_Mutex *
+allocate_mutex ()
+{
+  return ALLOCATE_PSEUDOVECTOR (struct Lisp_Mutex, owner, PVEC_MUTEX);
+}
+
 
 DEFUN ("make-vector", Fmake_vector, Smake_vector, 2, 2, 0,
        doc: /* Return a newly created vector of length LENGTH, with each element being INIT.

diff --git a/src/lisp.h b/src/lisp.h
index 1670c859b0e50a190ac48f22f4d4740b34413fe4..d4392bc7eabfbdbc0c94fe1b1d6cc74e283aab2d 100644 (file)
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -353,6 +353,7 @@ enum pvec_type
   PVEC_FONT = 0x200000,
   PVEC_OTHER = 0x400000,
   PVEC_THREAD = 0x800000,
+  PVEC_MUTEX = 0x1000000,
   PVEC_TYPE_MASK = 0xfffe00
 
 #if 0 /* This is used to make the value of PSEUDOVECTOR_FLAG available to
@@ -592,6 +593,7 @@ extern size_t pure_size;
 #define XCHAR_TABLE(a) (eassert (CHAR_TABLE_P (a)), (struct Lisp_Char_Table *) XPNTR(a))
 #define XSUB_CHAR_TABLE(a) (eassert (SUB_CHAR_TABLE_P (a)), (struct Lisp_Sub_Char_Table *) XPNTR(a))
 #define XBOOL_VECTOR(a) (eassert (BOOL_VECTOR_P (a)), (struct Lisp_Bool_Vector *) XPNTR(a))
+#define XMUTEX(a) (eassert (MUTEXP(a)),(struct Lisp_Mutex *) XPNTR(a))
 
 /* Construct a Lisp_Object from a value or address.  */
 
@@ -628,6 +630,7 @@ extern size_t pure_size;
 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
 #define XSETSUB_CHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUB_CHAR_TABLE))
 #define XSETTHREAD(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_THREAD))
+#define XSETMUTEX(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_MUTEX))
 
 /* Convenience macros for dealing with Lisp arrays.  */
 
@@ -1639,6 +1642,7 @@ typedef struct {
 #define BOOL_VECTOR_P(x) PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
 #define FRAMEP(x) PSEUDOVECTORP (x, PVEC_FRAME)
 #define THREADP(x) PSEUDOVECTORP (x, PVEC_THREAD)
+#define MUTEXP(x) PSEUDOVECTORP (x, PVEC_MUTEX)
 
 /* Test for image (image . spec)  */
 #define IMAGEP(x) (CONSP (x) && EQ (XCAR (x), Qimage))
@@ -2732,6 +2736,7 @@ extern struct Lisp_Hash_Table *allocate_hash_table P_ ((void));
 extern struct window *allocate_window P_ ((void));
 extern struct frame *allocate_frame P_ ((void));
 extern struct Lisp_Process *allocate_process P_ ((void));
+extern struct Lisp_Mutex *allocate_mutex P_ ((void));
 extern struct terminal *allocate_terminal P_ ((void));
 extern int gc_in_progress;
 extern int abort_on_gc;

diff --git a/src/print.c b/src/print.c
index 5c9bd8bfa2b50a859c7ca3a2090bbfbec9d6123c..79020012c08fd40bed7c075ee3b3eca8867fb8e9 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -2172,6 +2172,10 @@ print_object (obj, printcharfun, escapeflag)
            }
          PRINTCHAR ('>');
        }
+      else if (MUTEXP (obj))
+        {
+             strout ("#<mutex>", -1, -1, printcharfun, 0);
+        }
       else
        {
          EMACS_INT size = XVECTOR (obj)->size;

diff --git a/src/thread.c b/src/thread.c
index 3c3322e94555606182b1568399fdedde6b45a1cd..32d5f3fb49fb172b78d0f325d018b17f00c920c3 100644 (file)
--- a/src/thread.c
+++ b/src/thread.c
@@ -365,6 +365,47 @@ DEFUN ("inhibit-yield", Finhibit_yield, Sinhibit_yield, 1, 1, 0,
   return Qnil;
 }
 
+DEFUN ("make-mutex", Fmake_mutex, Smake_mutex, 0, 0, 0,
+       doc: /* Make a mutex.  */)
+     ()
+{
+  Lisp_Object ret;
+  struct Lisp_Mutex *mutex = allocate_mutex ();
+  mutex->owner = 0;
+  XSETMUTEX (ret, mutex);
+  return ret;
+}
+
+DEFUN ("mutex-lock", Fmutex_lock, Smutex_lock, 1, 1, 0,
+       doc: /* Lock a mutex.  */)
+     (val)
+     Lisp_Object val;
+{
+  struct Lisp_Mutex *mutex = XMUTEX (val);
+  while (1)
+    {
+      if (mutex->owner == 0 || mutex->owner == pthread_self ())
+        {
+          mutex->owner = pthread_self ();
+          return Qt;
+        }
+
+      thread_yield ();
+    }
+
+  return Qt;
+}
+
+DEFUN ("mutex-unlock", Fmutex_unlock, Smutex_unlock, 1, 1, 0,
+       doc: /* Unlock a mutex.  */)
+     (val)
+     Lisp_Object val;
+{
+  struct Lisp_Mutex *mutex = XMUTEX (val);
+  mutex->owner = 0;
+  return Qt;
+}
+
 int
 thread_select (n, rfd, wfd, xfd, tmo)
   int n;
@@ -447,4 +488,7 @@ syms_of_threads (void)
   defsubr (&Srun_in_thread);
   defsubr (&Syield);
   defsubr (&Sinhibit_yield);
+  defsubr (&Smake_mutex);
+  defsubr (&Smutex_lock);
+  defsubr (&Smutex_unlock);
 }

diff --git a/src/thread.h b/src/thread.h
index e58d2bebfdef7d12917da88d6c470cffc49caa0a..41157d03dc3cb19c1ea77da6c8d1aab90afa5b8f 100644 (file)
--- a/src/thread.h
+++ b/src/thread.h
@@ -1,5 +1,15 @@
 #include "regex.h"
 
+struct Lisp_Mutex
+{
+  EMACS_UINT size;
+
+  struct Lisp_Vector *v_next;
+
+  /* Thread that owns the mutex.  */
+  pthread_t owner;
+};
+
 struct thread_state
 {
   EMACS_UINT size;