make the minibuffer mutex recursive.

Define the `mutexp' function.

Add support for non-recursive mutexes.

make-mutex accepts a new parameter, if the value is non nil then the
mutex is recursive; by default a non-recursive mutex is created.

Fix problems caused by the last rebase.

Handle exclusive access to the minibuffer using a mutex, remove inhibit-yield

Mutex object initial implementation.

Revert "Support more complex code blocks as argument to `run-in-thread"

This reverts commit a54548174153cb02b366fe6164cf3aa30597759c.

Remove blocal_getrealvalue

If a no-let-bound buffer-local symbol's value is modified, propagate it.

the thread_yield return value considers blocked threads too

xg_select uses thread_select

Fix gnus startup in a separate thread.

local_var_alist_ is shared by threads.

- buffer local values per-thread cleanup.
- any binding-testsuite.el test is completed successfully.

Cleanup

Fix some binding-testsuite.el test cases when threads are used.

This one still fails:

(defvar binding-test-some-local 'some)

(defvar binding-test-buffer-A (get-buffer-create "A"))

(with-current-buffer binding-test-buffer-A
 (set (make-variable-buffer-local 'binding-test-some-local) 'local))

(run-in-thread '(with-current-buffer binding-test-buffer-A
                 (message "local: %s" binding-test-some-local)))
(while (yield))

Use get_current_thread to retrieve the current thread object.

Fix a bug introduced by recent changes

Use the `realvalue' when the default binding is used.

Unbind thread-bound variables when the thread is terminated.

Propagate buffer-local-variables changes to other threads.

It is done in a quite expensive way, O(n^2) in the threads number.

Buffer local variables per-thread almost work now

A know problem is backward propagation.  A global buffer local
variable modified in a thread is not seen by other threads.

Use the global value as initial realvalue.

Handle default value

Fix gc segfault.

Use the buffer local value for symval forwarding

Avoid a double symval forwarding

Fix per-thread buffer-local variables

Fix make bootstrap

now realvalue is a Lisp_ThreadLocal

Initialize realvalue to sym->value.

Remove control, l->thread_data can't be nil at this point.

blocal_get_thread_data is not used before blocal_set_thread_data.

Move realvalue to thread_data.

Rename struct Lisp_Buffer_Local_Value `cdrs' member to `thread_data'.

Initial per-thread buffer local variables support.

Now this example works well:

(progn
 (make-variable-buffer-local 'va)

 (defun tha ()
   (dolist (va '("AA" "AB" "AC" "AD" "AE"))
     (message "thread a: %s" va)
     (yield)
     (message "thread a: %s" va)))

 (defun thb ()
   (dolist (va '("BF" "BG" "BH" "BI" "BL"))
     (message "thread b: %s" va)
     (yield)
     (message "thread b: %s" va)))

 (with-current-buffer (get-buffer-create "a")
   (run-in-thread '(tha)))
 (thb))

Change Lisp_Buffer_Local_Value representation.

This doesn't change semantics but prepares the way for per-thread
buffer-local bindings.

Define and use SET_PER_BUFFER_VALUE_RAW

Fix some elisp routines.

Set the buffer after the lock is acquired.

Remove desired_buffer from the thread_state struct.

Rename buffer_cond to thread_cond.

Remove the buffer-locking mechanism.

Handle the thread_notify_kill_buffer return code.

Notify threads when a buffer is killed.

Initialize threads properly.

Revert a few BUF_ changes to use direct field access.

Inhibit yield during a redisplay

`unbind_to' will restore the previous inhibit_yield status.

Use ALLOCATE_PSEUDOVECTOR.

Restore an initialization in search.c.
(Still doesn't build.)

Mark `last_thing_searched' and `saved_last_thing_searched' before free unused memory.

Allow to yield when buffer local variables are let-bound by a thread.

Make regular expression match data per-thread.

minor updates to buffer-objfwd patch

Make buffer-objfwd variables work per-thread.

See hack-buffer-objfwd.el to see how this was done.

Set the current_buffer properly.

Detach the thread when it is sleeping on `select'

Unlock the buffer on yields when buffer local variables are not bound by the thread.

Yield to another thread if the subprocess has no data available.

Move with-no-threads inside the let body block.

Define the `with-no-threads' macro and use it in the read-* functions.

Fix a problem with the garbage collector, storing the stack top every

time the running thread is blocked.

Rewrite the condition to wake-up the thread that locked the buffer. Also don't try to schedule a new thread when this is not possible.

Define with-new-thread macro.

Call error if thread creation failed.

Raise an error when the thread cannot be created correctly.

Implementation of a custom threads scheduler. Try to wake-up the thread with a lock on the desired buffer, if it can't be done then use round-robin.

Move all locking logic into thread.c.

When there are other active threads, yield returns t.

run-in-thread accepts a new optional argument: nolock.

When it is no-nil the thread does not try to get a lock on the current
buffer before work on it.

With this change, the following example works quite smoothly; while
loading imap folders, gnus yields to another thread:

(load-library "gnus")

;; Redefine to use yield
(defun imap-send-command-wait (command &optional buffer)
 (imap-wait-for-tag (prog1 (imap-send-command command buffer) (yield)) buffer))

(progn
 (run-in-thread '(gnus) t)
 (dotimes (i 20)
   ;; yield is called automatically during a buffer-switch
   (message (format "I got here %i" i))))

Protect from yield while waiting for keyboard input.

Fix a problem introduced with 9541917a66e9ef59a64bfe19c0d4a6146e3433d3

Block yield if garbage collecting can cause an abort.

A new thread maintain the parent's buffer when the thread starts not after it entered in `global_lock'.

Block yield when input is blocked.

When Finhibit_yield is not-nil, allow access to any buffer from the

current thread.  It is needed to avoid deadlocks or undesidered
threads switch.

This mechanism is implemented storing the previous buffer's owner and
restore it when the current thread releases the buffer.

Fix a bug introduced in ccdc353864000ec8f13cb64d95cd5774510fa302

Use `waitpid' to check if a process is still alive. The previous mechanism caused threads to hang.

Allow access to the minibuffer only to a thread at time.

Honor the function return type.

Avoid the access to NULL memory while gc marks.

Remove assertion that does not seem valid anymore.

Now it is possible to disable threading using "inhibit-yield".

It should be used in a similar way:

  (defmacro with-no-threading (&rest body)
    `(unwind-protect (inhibit-yield nil)
      (progn (inhibit-yield t)
               ,@body)))

Reflect last changes in the GDB script.

Signals can be captured by any thread.

Initialize a new buffer's owner to nil.

Support more complex code blocks as argument to `run-in-thread

It introduces this change:

 (defun tha ()
  ...)

 (run-in-thread 'tha)

becomes:
 (run-in-thread '(tha))

Free the thread specdl. Bug introduced with c466c557f39fc71c10b16e93b484a83187780228.

Revert to the previous code.

Check for `other_threads_p ()' in the inner loop too because this condition can change since the initial check.

Solve some problems with memory cleanup.

Remove explicit calls to `xfree' but leave `lisp_malloc'ed memory to
the garbage collector.

Check for `pthread_create' errors and restore the previous situation
in case something went wrong.

Fix a segfault when m_current_buffer is NULL

Initialize stack_top when a new thread is created.

Release the current buffer when a thread exits.

Fix boundp and a bug in store_symval_forwarding.

First working draft of thread-local binding.

At least 2 of the 9 kinds of variable bindings should work ok --
defvaralias variables and ordinary variables.
All other kinds will exhibit weird behavior.
A simple program that works:

   (defvar zz t)
   (defvar buffer-a (get-buffer-create "zardoz"))

   (defun tha ()
     (dolist (v '("A" "B" "C" "D"))
(message "thread a: %s" v)
(yield))
     (setq zz nil))

   (defun thb ()
     (dolist (v '("E" "F" "G" "H" "I"))
(message "thread b: %s" v)
(yield)
))

   (with-current-buffer buffer-a
     (run-in-thread 'tha))
   (thb)

   (while zz
     (yield))

Fix another oversight in thread.c.

Fix two bad bugs in thread.c.

Initial code for buffer locking.

Add some buffer locking; does not yet actually work.
Make current_buffer per-thread.
Turn thread_state into a vectorlike.
Arrange to populate initial specpdl; put condition-case around
thread body.

Introduce threads.

Add a new thread.c file.
Move selected globals to a thread-specific structure.
Add elisp functions run-in-thread and yield.
Update GC to work with threads.

Introduce thread-local object.

Add minimal support for it.

Rewrite globals to allow indirection in C.

The bulk of the patch was done by running rewrite-globals.el.
Then a couple minor fixes were applied by hand.