8 files changed, 10 insertions, 48 deletions
diff --git a/src/bytecode.c b/src/bytecode.c
index 3ac94055f33..7d5f85de140 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -891,7 +891,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	    if (sys_setjmp (c->jmp))
 	      {
 		struct handler *c = handlerlist;
-		int desc;
+		int dest;
 		top = c->bytecode_top;
 		dest = c->bytecode_dest;
 		handlerlist = c->next;
diff --git a/src/eval.c b/src/eval.c
index 4405b8bb738..9657f51aadc 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1440,7 +1440,7 @@ push_handler_nosignal (Lisp_Object tag_ch_val, enum handlertype handlertype)
   c->tag_or_ch = tag_ch_val;
   c->val = Qnil;
   c->next = handlerlist;
-  c->lisp_eval_depth = lisp_eval_depth;
+  c->f_lisp_eval_depth = lisp_eval_depth;
   c->pdlcount = SPECPDL_INDEX ();
   c->poll_suppress_count = poll_suppress_count;
   c->interrupt_input_blocked = interrupt_input_blocked;
@@ -3157,7 +3157,7 @@ let_shadows_global_binding_p (Lisp_Object symbol)
   return 0;
 }
 
-void
+static void
 do_specbind (struct Lisp_Symbol *sym, union specbinding *bind,
 	     Lisp_Object value)
 {
@@ -3332,7 +3332,7 @@ rebind_for_thread_switch (void)
 	  if (was_trapped)
 	    XSYMBOL (sym)->trapped_write = SYMBOL_UNTRAPPED_WRITE;
 	  bind->let.saved_value = Qnil;
-	  do_specbind (XSYMBOL (sym, bind, value, true);
+	  do_specbind (XSYMBOL (sym), bind, value);
 	  if (was_trapped)
 	    XSYMBOL (sym)->trapped_write = SYMBOL_TRAPPED_WRITE;
 	}
@@ -3363,7 +3363,7 @@ do_one_unbind (union specbinding *this_binding, bool unwinding)
       { /* If variable has a trivial value (no forwarding), and isn't
 	   trapped we can just set it.  No need to check for constant
 	   symbols here, since that was already done by specbind.  */
-	struct Lisp_Symbol sym = specpdl_symbol (this_binding);
+	Lisp_Object sym = specpdl_symbol (this_binding);
 	if (SYMBOLP (sym) && XSYMBOL (sym)->redirect == SYMBOL_PLAINVAL)
 	  {
 	    if (XSYMBOL (sym)->trapped_write == SYMBOL_UNTRAPPED_WRITE)
@@ -3399,7 +3399,7 @@ do_one_unbind (union specbinding *this_binding, bool unwinding)
     }
 }
 
-void
+static void
 do_nothing (void)
 {}
 
diff --git a/src/lisp.h b/src/lisp.h
index d4da32e3ebf..72ea50d5f27 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -4328,7 +4328,6 @@ extern int read_bytecode_char (bool);
 /* Defined in bytecode.c.  */
 extern void syms_of_bytecode (void);
 extern void relocate_byte_stack (struct byte_stack *);
-extern struct byte_stack *byte_stack_list;
 extern Lisp_Object exec_byte_code (Lisp_Object, Lisp_Object, Lisp_Object,
 				   Lisp_Object, ptrdiff_t, Lisp_Object *);
 extern Lisp_Object get_byte_code_arity (Lisp_Object);
diff --git a/src/process.c b/src/process.c
index 7f2a071e67b..e800bf278bc 100644
--- a/src/process.c
+++ b/src/process.c
@@ -526,8 +526,6 @@ recompute_max_desc (void)
 void
 delete_write_fd (int fd)
 {
-  int lim = max_desc;
-
   if ((fd_callback_info[fd].flags & NON_BLOCKING_CONNECT_FD) != 0)
     {
       if (--num_pending_connects < 0)
@@ -1232,7 +1230,7 @@ set_process_filter_masks (struct Lisp_Process *p)
   else if (EQ (p->filter, Qt)
 	   /* Network or serial process not stopped:  */
 	   && !EQ (p->command, Qt))
-    add_read_fd (p->infd);
+    add_non_keyboard_read_fd (p->infd);
 }
 
 DEFUN ("set-process-filter", Fset_process_filter, Sset_process_filter,
@@ -3281,7 +3279,7 @@ finish_after_tls_connection (Lisp_Object proc)
       pset_status (p, Qfailed);
       deactivate_process (proc);
     }
-  else if (! FD_ISSET (p->outfd, &connect_wait_mask))
+  else if ((fd_callback_info[p->outfd].flags & NON_BLOCKING_CONNECT_FD) == 0)
     {
       /* If we cleared the connection wait mask before we did the TLS
 	 setup, then we have to say that the process is finally "open"
@@ -5730,7 +5728,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
 
 		  if (0 <= p->infd && !EQ (p->filter, Qt)
 		      && !EQ (p->command, Qt))
-		    add_read_fd (p->infd);
+		    add_non_keyboard_read_fd (p->infd);
 		}
 	    }
 	}			/* End for each file descriptor.  */
@@ -7675,9 +7673,6 @@ void
 delete_keyboard_wait_descriptor (int desc)
 {
 #ifdef subprocesses
-  int fd;
-  int lim = max_desc;
-
   eassert (desc >= 0 && desc < FD_SETSIZE);
 
   fd_callback_info[desc].flags &= ~(FOR_READ | KEYBOARD_FD | PROCESS_FD);
diff --git a/src/regex.c b/src/regex.c
index bb046858dfe..e7231d3882b 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -1146,7 +1146,6 @@ print_double_string (re_char *where, re_char *string1, ssize_t size1,
 /* This has no initializer because initialized variables in Emacs
    become read-only after dumping.  */
 reg_syntax_t re_syntax_options;
-#endif
 
 
 /* Specify the precise syntax of regexps for compilation.  This provides
@@ -1166,20 +1165,7 @@ re_set_syntax (reg_syntax_t syntax)
 }
 WEAK_ALIAS (__re_set_syntax, re_set_syntax)
 
-#ifndef emacs
-/* Regexp to use to replace spaces, or NULL meaning don't.  */
-static const_re_char *whitespace_regexp;
-#else
-/* whitespace_regexp is a macro defined in thread.h.  */
 #endif
-
-void
-re_set_whitespace_regexp (const char *regexp)
-{
-  whitespace_regexp = (const_re_char *) regexp;
-}
-WEAK_ALIAS (__re_set_syntax, re_set_syntax)
->>>>>>> concurrency
 
 /* This table gives an error message for each of the error codes listed
    in regex.h.  Obviously the order here has to be same as there.
diff --git a/src/thread.c b/src/thread.c
index f5b04e4b231..11d55a5caef 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -143,8 +143,6 @@ lisp_mutex_lock (lisp_mutex_t *mutex, int new_count)
 static int
 lisp_mutex_unlock (lisp_mutex_t *mutex)
 {
-  struct thread_state *self = current_thread;
-
   if (mutex->owner != current_thread)
     error ("blah");
 
@@ -160,7 +158,6 @@ lisp_mutex_unlock (lisp_mutex_t *mutex)
 static unsigned int
 lisp_mutex_unlock_for_wait (lisp_mutex_t *mutex)
 {
-  struct thread_state *self = current_thread;
   unsigned int result = mutex->count;
 
   /* Ensured by condvar code.  */
@@ -601,9 +598,6 @@ DEFUN ("thread-yield", Fthread_yield, Sthread_yield, 0, 0, 0,
 static Lisp_Object
 invoke_thread_function (void)
 {
-  Lisp_Object iter;
-  volatile struct thread_state *self = current_thread;
-
   int count = SPECPDL_INDEX ();
 
   Ffuncall (1, &current_thread->function);
diff --git a/src/thread.h b/src/thread.h
index a089c7de573..d4cae360f68 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -142,18 +142,6 @@ struct thread_state
   Lisp_Object m_re_match_object;
 #define re_match_object (current_thread->m_re_match_object)
 
-  /* Set by `re_set_syntax' to the current regexp syntax to recognize.  Can
-     also be assigned to arbitrarily: each pattern buffer stores its own
-     syntax, so it can be changed between regex compilations.  */
-  reg_syntax_t m_re_syntax_options;
-#define re_syntax_options (current_thread->m_re_syntax_options)
-
-  /* Regexp to use to replace spaces, or NULL meaning don't.  */
-  /* This ought to be a "const re_char *" but that is not available
-     outside regex.h.  */
-  const void *m_whitespace_regexp;
-#define whitespace_regexp (current_thread->m_whitespace_regexp)
-
   /* This variable is different from waiting_for_input in keyboard.c.
      It is used to communicate to a lisp process-filter/sentinel (via the
      function Fwaiting_for_user_input_p) whether Emacs was waiting
diff --git a/src/w32proc.c b/src/w32proc.c
index 2d2d948bfea..c4f1f693741 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -72,7 +72,7 @@ extern BOOL g_b_init_compare_string_w;
 extern BOOL g_b_init_debug_break_process;
 
 int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
-		struct timespec *, void *);
+		struct timespec *, sigset_t *);
 
 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly.  */
 static signal_handler sig_handlers[NSIG];