Replace QUIT with maybe_quit

There’s no longer need to have QUIT stand for a slug of C statements.
Use the more-obvious function-call syntax instead.
Also, use true and false when setting immediate_quit.
These changes should not affect the generated machine code.
* src/lisp.h (QUIT): Remove.  All uses replaced by maybe_quit.

37 files changed, 192 insertions, 197 deletions

diff --git a/src/alloc.c b/src/alloc.c
index f7da7e44f29..f7b6515f4e7 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -2880,7 +2880,7 @@ DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0,
   for (EMACS_INT size = XFASTINT (length); 0 < size; size--)
     {
       val = Fcons (init, val);
-      QUIT;
+      maybe_quit ();
     }
 
   return val;
diff --git a/src/buffer.c b/src/buffer.c
index fde23cace1a..c00cc40d6f2 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -415,19 +415,16 @@ followed by the rest of the buffers.  */)
 }
 
 /* Like Fassoc, but use Fstring_equal to compare
-   (which ignores text properties),
-   and don't ever QUIT.  */
+   (which ignores text properties), and don't ever quit.  */
 
 static Lisp_Object
-assoc_ignore_text_properties (register Lisp_Object key, Lisp_Object list)
+assoc_ignore_text_properties (Lisp_Object key, Lisp_Object list)
 {
-  register Lisp_Object tail;
+  Lisp_Object tail;
   for (tail = list; CONSP (tail); tail = XCDR (tail))
     {
-      register Lisp_Object elt, tem;
-      elt = XCAR (tail);
-      tem = Fstring_equal (Fcar (elt), key);
-      if (!NILP (tem))
+      Lisp_Object elt = XCAR (tail);
+      if (!NILP (Fstring_equal (Fcar (elt), key)))
 	return elt;
     }
   return Qnil;
diff --git a/src/bytecode.c b/src/bytecode.c
index a64bc171d14..499fb881e2e 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -679,7 +679,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	    {
 	      quitcounter = 1;
 	      maybe_gc ();
-	      QUIT;
+	      maybe_quit ();
 	    }
 	  pc += op;
 	  NEXT;
diff --git a/src/callint.c b/src/callint.c
index 565fac8a451..d96454883cf 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -794,7 +794,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
     }
   unbind_to (speccount, Qnil);
 
-  QUIT;
+  maybe_quit ();
 
   args[0] = Qfuncall_interactively;
   args[1] = function;
diff --git a/src/callproc.c b/src/callproc.c
index 90c15de2913..301ccf383b5 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -198,11 +198,11 @@ call_process_cleanup (Lisp_Object buffer)
     {
       kill (-synch_process_pid, SIGINT);
       message1 ("Waiting for process to die...(type C-g again to kill it instantly)");
-      immediate_quit = 1;
-      QUIT;
+      immediate_quit = true;
+      maybe_quit ();
       wait_for_termination (synch_process_pid, 0, 1);
       synch_process_pid = 0;
-      immediate_quit = 0;
+      immediate_quit = false;
       message1 ("Waiting for process to die...done");
     }
 #endif	/* !MSDOS */
@@ -726,8 +726,8 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
       process_coding.src_multibyte = 0;
     }
 
-  immediate_quit = 1;
-  QUIT;
+  immediate_quit = true;
+  maybe_quit ();
 
   if (0 <= fd0)
     {
@@ -769,7 +769,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
 	    }
 
 	  /* Now NREAD is the total amount of data in the buffer.  */
-	  immediate_quit = 0;
+	  immediate_quit = false;
 
 	  if (!nread)
 	    ;
@@ -843,7 +843,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
 	      display_on_the_fly = true;
 	    }
 	  immediate_quit = true;
-	  QUIT;
+	  maybe_quit ();
 	}
     give_up: ;
 
@@ -860,7 +860,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
   wait_for_termination (pid, &status, fd0 < 0);
 #endif
 
-  immediate_quit = 0;
+  immediate_quit = false;
 
   /* Don't kill any children that the subprocess may have left behind
      when exiting.  */
diff --git a/src/ccl.c b/src/ccl.c
index c172fc66811..90bd2f46794 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -1993,7 +1993,7 @@ programs.  */)
 		  : 0);
 
   ccl_driver (&ccl, NULL, NULL, 0, 0, Qnil);
-  QUIT;
+  maybe_quit ();
   if (ccl.status != CCL_STAT_SUCCESS)
     error ("Error in CCL program at %dth code", ccl.ic);
 
diff --git a/src/decompress.c b/src/decompress.c
index f6628d5ddd9..a53a66df187 100644
--- a/src/decompress.c
+++ b/src/decompress.c
@@ -186,7 +186,7 @@ This function can be called only in unibyte buffers.  */)
       decompressed = avail_out - stream.avail_out;
       insert_from_gap (decompressed, decompressed, 0);
       unwind_data.nbytes += decompressed;
-      QUIT;
+      maybe_quit ();
     }
   while (inflate_status == Z_OK);
 
diff --git a/src/dired.c b/src/dired.c
index bf10f1710ff..52e81fb380b 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -139,7 +139,7 @@ read_dirent (DIR *dir, Lisp_Object dirname)
 #endif
 	  report_file_error ("Reading directory", dirname);
 	}
-      QUIT;
+      maybe_quit ();
     }
 }
 
@@ -248,13 +248,13 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
 
       /* Now that we have unwind_protect in place, we might as well
 	 allow matching to be interrupted.  */
-      immediate_quit = 1;
-      QUIT;
+      immediate_quit = true;
+      maybe_quit ();
 
       bool wanted = (NILP (match)
 		     || re_search (bufp, SSDATA (name), len, 0, len, 0) >= 0);
 
-      immediate_quit = 0;
+      immediate_quit = false;
 
       if (wanted)
 	{
@@ -508,7 +508,7 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
       ptrdiff_t len = dirent_namelen (dp);
       bool canexclude = 0;
 
-      QUIT;
+      maybe_quit ();
       if (len < SCHARS (encoded_file)
 	  || (scmp (dp->d_name, SSDATA (encoded_file),
 		    SCHARS (encoded_file))
diff --git a/src/editfns.c b/src/editfns.c
index 634aa1f63b2..82c6abb9987 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -2695,7 +2695,7 @@ called interactively, INHERIT is t.  */)
     string[i] = str[i % len];
   while (n > stringlen)
     {
-      QUIT;
+      maybe_quit ();
       if (!NILP (inherit))
 	insert_and_inherit (string, stringlen);
       else
diff --git a/src/eval.c b/src/eval.c
index 734f01d81ae..62d4af15e27 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -858,7 +858,7 @@ usage: (let* VARLIST BODY...)  */)
 
   for (varlist = XCAR (args); CONSP (varlist); varlist = XCDR (varlist))
     {
-      QUIT;
+      maybe_quit ();
 
       elt = XCAR (varlist);
       if (SYMBOLP (elt))
@@ -925,7 +925,7 @@ usage: (let VARLIST BODY...)  */)
 
   for (argnum = 0; CONSP (varlist); varlist = XCDR (varlist))
     {
-      QUIT;
+      maybe_quit ();
       elt = XCAR (varlist);
       if (SYMBOLP (elt))
 	temps [argnum++] = Qnil;
@@ -978,7 +978,7 @@ usage: (while TEST BODY...)  */)
   body = XCDR (args);
   while (!NILP (eval_sub (test)))
     {
-      QUIT;
+      maybe_quit ();
       prog_ignore (body);
     }
 
@@ -1011,7 +1011,7 @@ definitions to shadow the loaded ones for use in file byte-compilation.  */)
 	 until we get a symbol that is not an alias.  */
       while (SYMBOLP (def))
 	{
-	  QUIT;
+	  maybe_quit ();
 	  sym = def;
 	  tem = Fassq (sym, environment);
 	  if (NILP (tem))
@@ -1131,7 +1131,7 @@ unwind_to_catch (struct handler *catch, Lisp_Object value)
   /* Restore certain special C variables.  */
   set_poll_suppress_count (catch->poll_suppress_count);
   unblock_input_to (catch->interrupt_input_blocked);
-  immediate_quit = 0;
+  immediate_quit = false;
 
   do
     {
@@ -1514,10 +1514,10 @@ signal_or_quit (Lisp_Object error_symbol, Lisp_Object data, bool keyboard_quit)
   Lisp_Object string;
   Lisp_Object real_error_symbol
     = (NILP (error_symbol) ? Fcar (data) : error_symbol);
-  register Lisp_Object clause = Qnil;
+  Lisp_Object clause = Qnil;
   struct handler *h;
 
-  immediate_quit = 0;
+  immediate_quit = false;
   if (gc_in_progress || waiting_for_input)
     emacs_abort ();
 
@@ -2135,7 +2135,7 @@ eval_sub (Lisp_Object form)
   if (!CONSP (form))
     return form;
 
-  QUIT;
+  maybe_quit ();
 
   maybe_gc ();
 
@@ -2721,7 +2721,7 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
   Lisp_Object val;
   ptrdiff_t count;
 
-  QUIT;
+  maybe_quit ();
 
   if (++lisp_eval_depth > max_lisp_eval_depth)
     {
@@ -2966,7 +2966,7 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
   bool previous_optional_or_rest = false;
   for (; CONSP (syms_left); syms_left = XCDR (syms_left))
     {
-      QUIT;
+      maybe_quit ();
 
       next = XCAR (syms_left);
       if (!SYMBOLP (next))
diff --git a/src/fileio.c b/src/fileio.c
index 8c8cba9e49c..ac6d7819411 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -316,7 +316,7 @@ use the standard functions without calling themselves recursively.  */)
 	    }
 	}
 
-      QUIT;
+      maybe_quit ();
     }
   return result;
 }
@@ -1960,9 +1960,9 @@ permissions.  */)
       report_file_error ("Copying permissions to", newname);
     }
 #else /* not WINDOWSNT */
-  immediate_quit = 1;
+  immediate_quit = true;
   ifd = emacs_open (SSDATA (encoded_file), O_RDONLY, 0);
-  immediate_quit = 0;
+  immediate_quit = false;
 
   if (ifd < 0)
     report_file_error ("Opening input file", file);
@@ -2024,8 +2024,8 @@ permissions.  */)
 	oldsize = out_st.st_size;
     }
 
-  immediate_quit = 1;
-  QUIT;
+  immediate_quit = true;
+  maybe_quit ();
 
   if (clone_file (ofd, ifd))
     newsize = st.st_size;
@@ -2047,7 +2047,7 @@ permissions.  */)
   if (newsize < oldsize && ftruncate (ofd, newsize) != 0)
     report_file_error ("Truncating output file", newname);
 
-  immediate_quit = 0;
+  immediate_quit = false;
 
 #ifndef MSDOS
   /* Preserve the original file permissions, and if requested, also its
@@ -3393,13 +3393,13 @@ read_non_regular (Lisp_Object state)
 {
   int nbytes;
 
-  immediate_quit = 1;
-  QUIT;
+  immediate_quit = true;
+  maybe_quit ();
   nbytes = emacs_read (XSAVE_INTEGER (state, 0),
 		       ((char *) BEG_ADDR + PT_BYTE - BEG_BYTE
 			+ XSAVE_INTEGER (state, 1)),
 		       XSAVE_INTEGER (state, 2));
-  immediate_quit = 0;
+  immediate_quit = false;
   /* Fast recycle this object for the likely next call.  */
   free_misc (state);
   return make_number (nbytes);
@@ -3858,8 +3858,8 @@ by calling `format-decode', which see.  */)
 	    report_file_error ("Setting file position", orig_filename);
 	}
 
-      immediate_quit = 1;
-      QUIT;
+      immediate_quit = true;
+      maybe_quit ();
       /* Count how many chars at the start of the file
 	 match the text at the beginning of the buffer.  */
       while (1)
@@ -3910,7 +3910,7 @@ by calling `format-decode', which see.  */)
 	  goto handled;
 	}
       immediate_quit = true;
-      QUIT;
+      maybe_quit ();
       /* Count how many chars at the end of the file
 	 match the text at the end of the buffer.  But, if we have
 	 already found that decoding is necessary, don't waste time.  */
@@ -3967,7 +3967,7 @@ by calling `format-decode', which see.  */)
 	  if (nread == 0)
 	    break;
 	}
-      immediate_quit = 0;
+      immediate_quit = false;
 
       if (! giveup_match_end)
 	{
@@ -4065,11 +4065,11 @@ by calling `format-decode', which see.  */)
 	     quitting while reading a huge file.  */
 
 	  /* Allow quitting out of the actual I/O.  */
-	  immediate_quit = 1;
-	  QUIT;
+	  immediate_quit = true;
+	  maybe_quit ();
 	  this = emacs_read (fd, read_buf + unprocessed,
 			     READ_BUF_SIZE - unprocessed);
-	  immediate_quit = 0;
+	  immediate_quit = false;
 
 	  if (this <= 0)
 	    break;
@@ -4284,13 +4284,13 @@ by calling `format-decode', which see.  */)
 	    /* Allow quitting out of the actual I/O.  We don't make text
 	       part of the buffer until all the reading is done, so a C-g
 	       here doesn't do any harm.  */
-	    immediate_quit = 1;
-	    QUIT;
+	    immediate_quit = true;
+	    maybe_quit ();
 	    this = emacs_read (fd,
 			       ((char *) BEG_ADDR + PT_BYTE - BEG_BYTE
 				+ inserted),
 			       trytry);
-	    immediate_quit = 0;
+	    immediate_quit = false;
 	  }
 
 	if (this <= 0)
@@ -4602,7 +4602,7 @@ by calling `format-decode', which see.  */)
 		}
 	    }
 
-	  QUIT;
+	  maybe_quit ();
 	  p = XCDR (p);
 	}
 
@@ -4992,7 +4992,7 @@ write_region (Lisp_Object start, Lisp_Object end, Lisp_Object filename,
 	}
     }
 
-  immediate_quit = 1;
+  immediate_quit = true;
 
   if (STRINGP (start))
     ok = a_write (desc, start, 0, SCHARS (start), &annotations, &coding);
@@ -5016,7 +5016,7 @@ write_region (Lisp_Object start, Lisp_Object end, Lisp_Object filename,
       save_errno = errno;
     }
 
-  immediate_quit = 0;
+  immediate_quit = false;
 
   /* fsync is not crucial for temporary files.  Nor for auto-save
      files, since they might lose some work anyway.  */
diff --git a/src/filelock.c b/src/filelock.c
index 886ab61c7aa..de65c52efa1 100644
--- a/src/filelock.c
+++ b/src/filelock.c
@@ -505,7 +505,7 @@ read_lock_data (char *lfname, char lfinfo[MAX_LFINFO + 1])
       /* readlinkat saw a non-symlink, but emacs_open saw a symlink.
 	 The former must have been removed and replaced by the latter.
 	 Try again.  */
-      QUIT;
+      maybe_quit ();
     }
 
   return nbytes;
diff --git a/src/fns.c b/src/fns.c
index c175dd935d3..b8ebfe5b2e7 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -96,7 +96,7 @@ static void
 rarely_quit (unsigned short int *quit_count)
 {
   if (! (++*quit_count & (QUIT_COUNT_HEURISTIC - 1)))
-    QUIT;
+    maybe_quit ();
 }
 
 /* Random data-structure functions.  */
@@ -132,7 +132,7 @@ To get the number of bytes, use `string-bytes'.  */)
 	    {
 	      if (MOST_POSITIVE_FIXNUM < i)
 		error ("List too long");
-	      QUIT;
+	      maybe_quit ();
 	    }
 	  sequence = XCDR (sequence);
 	}
@@ -178,7 +178,7 @@ which is at least the number of distinct elements.  */)
 	  halftail = XCDR (halftail);
 	  if ((lolen & (QUIT_COUNT_HEURISTIC - 1)) == 0)
 	    {
-	      QUIT;
+	      maybe_quit ();
 	      if (lolen == 0)
 		hilen += UINTMAX_MAX + 1.0;
 	    }
diff --git a/src/gnutls.c b/src/gnutls.c
index 65b83bad6b8..d0d7f2dfc84 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -390,7 +390,7 @@ gnutls_try_handshake (struct Lisp_Process *proc)
     {
       ret = gnutls_handshake (state);
       emacs_gnutls_handle_error (state, ret);
-      QUIT;
+      maybe_quit ();
     }
   while (ret < 0
 	 && gnutls_error_is_fatal (ret) == 0
diff --git a/src/indent.c b/src/indent.c
index 34449955a6c..23951a16eb6 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -1200,8 +1200,8 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
     continuation_glyph_width = 0;  /* In the fringe.  */
 #endif
 
-  immediate_quit = 1;
-  QUIT;
+  immediate_quit = true;
+  maybe_quit ();
 
   /* It's just impossible to be too paranoid here.  */
   eassert (from == BYTE_TO_CHAR (frombyte) && frombyte == CHAR_TO_BYTE (from));
@@ -1694,7 +1694,7 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
   /* Nonzero if have just continued a line */
   val_compute_motion.contin = (contin_hpos && prev_hpos == 0);
 
-  immediate_quit = 0;
+  immediate_quit = false;
   return &val_compute_motion;
 }
 
diff --git a/src/insdel.c b/src/insdel.c
index b93606ced85..3f933b0ad85 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -129,7 +129,7 @@ gap_left (ptrdiff_t charpos, ptrdiff_t bytepos, bool newgap)
 	 Change BYTEPOS to be where we have actually moved the gap to.
 	 Note that this cannot happen when we are called to make the
 	 gap larger or smaller, since make_gap_larger and
-	 make_gap_smaller prevent QUIT by setting inhibit-quit.  */
+	 make_gap_smaller set inhibit-quit.  */
       if (QUITP)
 	{
 	  bytepos = new_s1;
@@ -151,7 +151,7 @@ gap_left (ptrdiff_t charpos, ptrdiff_t bytepos, bool newgap)
   GPT = charpos;
   eassert (charpos <= bytepos);
   if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor.  */
-  QUIT;
+  maybe_quit ();
 }
 
 /* Move the gap to a position greater than the current GPT.
@@ -185,7 +185,7 @@ gap_right (ptrdiff_t charpos, ptrdiff_t bytepos)
 	 Change BYTEPOS to be where we have actually moved the gap to.
 	 Note that this cannot happen when we are called to make the
 	 gap larger or smaller, since make_gap_larger and
-	 make_gap_smaller prevent QUIT by setting inhibit-quit.  */
+	 make_gap_smaller set inhibit-quit.  */
       if (QUITP)
 	{
 	  bytepos = new_s1;
@@ -204,7 +204,7 @@ gap_right (ptrdiff_t charpos, ptrdiff_t bytepos)
   GPT_BYTE = bytepos;
   eassert (charpos <= bytepos);
   if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor.  */
-  QUIT;
+  maybe_quit ();
 }
 
 /* If the selected window's old pointm is adjacent or covered by the
@@ -464,7 +464,7 @@ make_gap_larger (ptrdiff_t nbytes_added)
 
   enlarge_buffer_text (current_buffer, nbytes_added);
 
-  /* Prevent quitting in gap_left.  We cannot allow a QUIT there,
+  /* Prevent quitting in gap_left.  We cannot allow a quit there,
      because that would leave the buffer text in an inconsistent
      state, with 2 gap holes instead of just one.  */
   tem = Vinhibit_quit;
@@ -512,7 +512,7 @@ make_gap_smaller (ptrdiff_t nbytes_removed)
   if (GAP_SIZE - nbytes_removed < GAP_BYTES_MIN)
     nbytes_removed = GAP_SIZE - GAP_BYTES_MIN;
 
-  /* Prevent quitting in gap_right.  We cannot allow a QUIT there,
+  /* Prevent quitting in gap_right.  We cannot allow a quit there,
      because that would leave the buffer text in an inconsistent
      state, with 2 gap holes instead of just one.  */
   tem = Vinhibit_quit;
diff --git a/src/keyboard.c b/src/keyboard.c
index 6aad0acc656..d41603b2e50 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -87,7 +87,7 @@ char const DEV_TTY[] = "/dev/tty";
 volatile int interrupt_input_blocked;
 
 /* True means an input interrupt or alarm signal has arrived.
-   The QUIT macro checks this.  */
+   The maybe_quit function checks this.  */
 volatile bool pending_signals;
 
 #define KBD_BUFFER_SIZE 4096
@@ -1416,7 +1416,7 @@ command_loop_1 (void)
 	  if (!NILP (Vquit_flag))
 	    {
 	      Vexecuting_kbd_macro = Qt;
-	      QUIT;		/* Make some noise.  */
+	      maybe_quit ();	/* Make some noise.  */
 				/* Will return since macro now empty.  */
 	    }
 	}
@@ -3591,7 +3591,7 @@ kbd_buffer_store_buffered_event (union buffered_input_event *event,
       if (immediate_quit && NILP (Vinhibit_quit))
 	{
 	  immediate_quit = false;
-	  QUIT;
+	  maybe_quit ();
 	}
     }
 }
@@ -7426,7 +7426,7 @@ menu_bar_items (Lisp_Object old)
   USE_SAFE_ALLOCA;
 
   /* In order to build the menus, we need to call the keymap
-     accessors.  They all call QUIT.  But this function is called
+     accessors.  They all call maybe_quit.  But this function is called
      during redisplay, during which a quit is fatal.  So inhibit
      quitting while building the menus.
      We do this instead of specbind because (1) errors will clear it anyway
@@ -7987,7 +7987,7 @@ tool_bar_items (Lisp_Object reuse, int *nitems)
   *nitems = 0;
 
   /* In order to build the menus, we need to call the keymap
-     accessors.  They all call QUIT.  But this function is called
+     accessors.  They all call maybe_quit.  But this function is called
      during redisplay, during which a quit is fatal.  So inhibit
      quitting while building the menus.  We do this instead of
      specbind because (1) errors will clear it anyway and (2) this
@@ -9806,7 +9806,7 @@ read_key_sequence_vs (Lisp_Object prompt, Lisp_Object continue_echo,
 
   if (!NILP (prompt))
     CHECK_STRING (prompt);
-  QUIT;
+  maybe_quit ();
 
   specbind (Qinput_method_exit_on_first_char,
 	    (NILP (cmd_loop) ? Qt : Qnil));
@@ -9840,7 +9840,7 @@ read_key_sequence_vs (Lisp_Object prompt, Lisp_Object continue_echo,
   if (i == -1)
     {
       Vquit_flag = Qt;
-      QUIT;
+      maybe_quit ();
     }
 
   return unbind_to (count,
@@ -10278,7 +10278,7 @@ clear_waiting_for_input (void)
 
    If we have a frame on the controlling tty, we assume that the
    SIGINT was generated by C-g, so we call handle_interrupt.
-   Otherwise, tell QUIT to kill Emacs.  */
+   Otherwise, tell maybe_quit to kill Emacs.  */
 
 static void
 handle_interrupt_signal (int sig)
@@ -10289,7 +10289,7 @@ handle_interrupt_signal (int sig)
     {
       /* If there are no frames there, let's pretend that we are a
          well-behaving UN*X program and quit.  We must not call Lisp
-         in a signal handler, so tell QUIT to exit when it is
+         in a signal handler, so tell maybe_quit to exit when it is
          safe.  */
       Vquit_flag = Qkill_emacs;
     }
diff --git a/src/keymap.c b/src/keymap.c
index 9e759478518..9caf55f98fb 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -523,7 +523,7 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx,
 		retval = Fcons (Qkeymap, Fcons (retval, retval_tail));
 	      }
 	  }
-	QUIT;
+	maybe_quit ();
       }
 
     return EQ (Qunbound, retval) ? get_keyelt (t_binding, autoload) : retval;
@@ -877,7 +877,7 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
 	     should be inserted before it.  */
 	  goto keymap_end;
 
-	QUIT;
+	maybe_quit ();
       }
 
   keymap_end:
@@ -1250,7 +1250,7 @@ recognize the default bindings, just as `read-key-sequence' does.  */)
       if (!CONSP (keymap))
 	return make_number (idx);
 
-      QUIT;
+      maybe_quit ();
     }
 }
 
@@ -2466,7 +2466,7 @@ where_is_internal (Lisp_Object definition, Lisp_Object keymaps,
 	   non-ascii prefixes like `C-down-mouse-2'.  */
 	continue;
 
-      QUIT;
+      maybe_quit ();
 
       data.definition = definition;
       data.noindirect = noindirect;
@@ -3173,7 +3173,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
 
   for (tail = map; CONSP (tail); tail = XCDR (tail))
     {
-      QUIT;
+      maybe_quit ();
 
       if (VECTORP (XCAR (tail))
 	  || CHAR_TABLE_P (XCAR (tail)))
@@ -3426,7 +3426,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
       int range_beg, range_end;
       Lisp_Object val;
 
-      QUIT;
+      maybe_quit ();
 
       if (i == stop)
 	{
diff --git a/src/lisp.h b/src/lisp.h
index 01a08a05f20..84d53bb1eec 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3119,18 +3119,18 @@ struct handler
 
 extern Lisp_Object memory_signal_data;
 
-/* Check quit-flag and quit if it is non-nil.
-   Typing C-g does not directly cause a quit; it only sets Vquit_flag.
-   So the program needs to do QUIT at times when it is safe to quit.
-   Every loop that might run for a long time or might not exit
-   ought to do QUIT at least once, at a safe place.
-   Unless that is impossible, of course.
-   But it is very desirable to avoid creating loops where QUIT is impossible.
-
-   Exception: if you set immediate_quit to true,
-   then the handler that responds to the C-g does the quit itself.
-   This is a good thing to do around a loop that has no side effects
-   and (in particular) cannot call arbitrary Lisp code.
+/* Check quit-flag and quit if it is non-nil.  Typing C-g does not
+   directly cause a quit; it only sets Vquit_flag.  So the program
+   needs to call maybe_quit at times when it is safe to quit.  Every
+   loop that might run for a long time or might not exit ought to call
+   maybe_quit at least once, at a safe place.  Unless that is
+   impossible, of course.  But it is very desirable to avoid creating
+   loops where maybe_quit is impossible.
+
+   Exception: if you set immediate_quit, the handler that responds to
+   the C-g does the quit itself.  This is a good thing to do around a
+   loop that has no side effects and (in particular) cannot call
+   arbitrary Lisp code.
 
    If quit-flag is set to `kill-emacs' the SIGINT handler has received
    a request to exit Emacs when it is safe to do.
@@ -3138,7 +3138,6 @@ extern Lisp_Object memory_signal_data;
    When not quitting, process any pending signals.  */
 
 extern void maybe_quit (void);
-#define QUIT maybe_quit ()
 
 /* True if ought to quit now.  */
 
diff --git a/src/lread.c b/src/lread.c
index 284fd1aafbc..ea2a1d1d858 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -451,7 +451,7 @@ readbyte_from_file (int c, Lisp_Object readcharfun)
   while (c == EOF && ferror (instream) && errno == EINTR)
     {
       unblock_input ();
-      QUIT;
+      maybe_quit ();
       block_input ();
       clearerr (instream);
       c = getc (instream);
@@ -1702,14 +1702,14 @@ build_load_history (Lisp_Object filename, bool entire)
 		     			  Fcons (newelt, XCDR (tem))));
 
 		  tem2 = XCDR (tem2);
-		  QUIT;
+		  maybe_quit ();
 		}
 	    }
 	}
       else
 	prev = tail;
       tail = XCDR (tail);
-      QUIT;
+      maybe_quit ();
     }
 
   /* If we're loading an entire file, cons the new assoc onto the
diff --git a/src/macros.c b/src/macros.c
index 3b29cc67cf8..f0ffda3f441 100644
--- a/src/macros.c
+++ b/src/macros.c
@@ -325,7 +325,7 @@ each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
 
       executing_kbd_macro_iterations = ++success_count;
 
-      QUIT;
+      maybe_quit ();
     }
   while (--repeat
 	 && (STRINGP (Vexecuting_kbd_macro) || VECTORP (Vexecuting_kbd_macro)));
diff --git a/src/minibuf.c b/src/minibuf.c
index d44bb44baee..1bbe276776e 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -1865,7 +1865,7 @@ single string, rather than a cons cell whose car is a string.  */)
 			      case_fold);
       if (EQ (tem, Qt))
 	return elt;
-      QUIT;
+      maybe_quit ();
     }
   return Qnil;
 }
diff --git a/src/print.c b/src/print.c
index dfaa489a98d..36d68a452ec 100644
--- a/src/print.c
+++ b/src/print.c
@@ -279,7 +279,7 @@ printchar (unsigned int ch, Lisp_Object fun)
       unsigned char str[MAX_MULTIBYTE_LENGTH];
       int len = CHAR_STRING (ch, str);
 
-      QUIT;
+      maybe_quit ();
 
       if (NILP (fun))
 	{
@@ -1352,7 +1352,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
 		max (sizeof " . #" + INT_STRLEN_BOUND (printmax_t),
 		     40))];
 
-  QUIT;
+  maybe_quit ();
 
   /* Detect circularities and truncate them.  */
   if (NILP (Vprint_circle))
@@ -1446,7 +1446,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
 
 	      FETCH_STRING_CHAR_ADVANCE (c, obj, i, i_byte);
 
-	      QUIT;
+	      maybe_quit ();
 
 	      if (multibyte
 		  ? (CHAR_BYTE8_P (c) && (c = CHAR_TO_BYTE8 (c), true))
@@ -1550,7 +1550,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
 	    /* Here, we must convert each multi-byte form to the
 	       corresponding character code before handing it to PRINTCHAR.  */
 	    FETCH_STRING_CHAR_ADVANCE (c, name, i, i_byte);
-	    QUIT;
+	    maybe_quit ();
 
 	    if (escapeflag)
 	      {
@@ -1707,7 +1707,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
 
 	  for (i = 0; i < size_in_chars; i++)
 	    {
-	      QUIT;
+	      maybe_quit ();
 	      c = bool_vector_uchar_data (obj)[i];
 	      if (c == '\n' && print_escape_newlines)
 		print_c_string ("\\n", printcharfun);
diff --git a/src/process.c b/src/process.c
index ab9657b15a4..dbd4358dd1a 100644
--- a/src/process.c
+++ b/src/process.c
@@ -3431,8 +3431,8 @@ connect_network_socket (Lisp_Object proc, Lisp_Object addrinfos,
 	  break;
 	}
 
-      immediate_quit = 1;
-      QUIT;
+      immediate_quit = true;
+      maybe_quit ();
 
       ret = connect (s, sa, addrlen);
       xerrno = errno;
@@ -3459,7 +3459,7 @@ connect_network_socket (Lisp_Object proc, Lisp_Object addrinfos,
 	retry_select:
 	  FD_ZERO (&fdset);
 	  FD_SET (s, &fdset);
-	  QUIT;
+	  maybe_quit ();
 	  sc = pselect (s + 1, NULL, &fdset, NULL, NULL, NULL);
 	  if (sc == -1)
 	    {
@@ -3481,7 +3481,7 @@ connect_network_socket (Lisp_Object proc, Lisp_Object addrinfos,
 	}
 #endif /* !WINDOWSNT */
 
-      immediate_quit = 0;
+      immediate_quit = false;
 
       /* Discard the unwind protect closing S.  */
       specpdl_ptr = specpdl + count;
@@ -3539,7 +3539,7 @@ connect_network_socket (Lisp_Object proc, Lisp_Object addrinfos,
 #endif
     }
 
-  immediate_quit = 0;
+  immediate_quit = false;
 
   if (s < 0)
     {
@@ -4012,8 +4012,8 @@ usage: (make-network-process &rest ARGS)  */)
       struct addrinfo *res, *lres;
       int ret;
 
-      immediate_quit = 1;
-      QUIT;
+      immediate_quit = true;
+      maybe_quit ();
 
       struct addrinfo hints;
       memset (&hints, 0, sizeof hints);
@@ -4034,7 +4034,7 @@ usage: (make-network-process &rest ARGS)  */)
 #else
 	error ("%s/%s getaddrinfo error %d", SSDATA (host), portstring, ret);
 #endif
-      immediate_quit = 0;
+      immediate_quit = false;
 
       for (lres = res; lres; lres = lres->ai_next)
 	addrinfos = Fcons (conv_addrinfo_to_lisp (lres), addrinfos);
@@ -5020,7 +5020,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
 	 since we want to return C-g as an input character.
 	 Otherwise, do pending quit if requested.  */
       if (read_kbd >= 0)
-	QUIT;
+	maybe_quit ();
       else if (pending_signals)
 	process_pending_signals ();
 
@@ -5748,7 +5748,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
     {
       /* Prevent input_pending from remaining set if we quit.  */
       clear_input_pending ();
-      QUIT;
+      maybe_quit ();
     }
 
   return got_some_output;
@@ -7486,7 +7486,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
 	 since we want to return C-g as an input character.
 	 Otherwise, do pending quit if requested.  */
       if (read_kbd >= 0)
-	QUIT;
+	maybe_quit ();
 
       /* Exit now if the cell we're waiting for became non-nil.  */
       if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
diff --git a/src/profiler.c b/src/profiler.c
index efc0cb316fc..88825bebdb2 100644
--- a/src/profiler.c
+++ b/src/profiler.c
@@ -174,8 +174,8 @@ record_backtrace (log_t *log, EMACS_INT count)
 	   some global flag so that some Elisp code can offload its
 	   data elsewhere, so as to avoid the eviction code.
 	   There are 2 ways to do that, AFAICT:
-	   - Set a flag checked in QUIT, such that QUIT can then call
-	     Fprofiler_cpu_log and stash the full log for later use.
+	   - Set a flag checked in maybe_quit, such that maybe_quit can then
+	     call Fprofiler_cpu_log and stash the full log for later use.
 	   - Set a flag check in post-gc-hook, so that Elisp code can call
 	     profiler-cpu-log.  That gives us more flexibility since that
 	     Elisp code can then do all kinds of fun stuff like write
diff --git a/src/regex.c b/src/regex.c
index db3f0c16a2d..f6e67afef4c 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -1729,12 +1729,9 @@ typedef struct
 /* Explicit quit checking is needed for Emacs, which uses polling to
    process input events.  */
 #ifdef emacs
-# define IMMEDIATE_QUIT_CHECK			\
-    do {					\
-      if (immediate_quit) QUIT;			\
-    } while (0)
+# define IMMEDIATE_QUIT_CHECK (immediate_quit ? maybe_quit () : (void) 0)
 #else
-# define IMMEDIATE_QUIT_CHECK    ((void)0)
+# define IMMEDIATE_QUIT_CHECK ((void) 0)
 #endif
 
 /* Structure to manage work area for range table.  */
diff --git a/src/search.c b/src/search.c
index d3045108705..f54f44c8818 100644
--- a/src/search.c
+++ b/src/search.c
@@ -276,8 +276,9 @@ looking_at_1 (Lisp_Object string, bool posix)
 			  posix,
 			  !NILP (BVAR (current_buffer, enable_multibyte_characters)));
 
-  immediate_quit = 1;
-  QUIT;			/* Do a pending quit right away, to avoid paradoxical behavior */
+  /* Do a pending quit right away, to avoid paradoxical behavior */
+  immediate_quit = true;
+  maybe_quit ();
 
   /* Get pointers and sizes of the two strings
      that make up the visible portion of the buffer. */
@@ -310,7 +311,7 @@ looking_at_1 (Lisp_Object string, bool posix)
 		  (NILP (Vinhibit_changing_match_data)
 		   ? &search_regs : NULL),
 		  ZV_BYTE - BEGV_BYTE);
-  immediate_quit = 0;
+  immediate_quit = false;
 #ifdef REL_ALLOC
   r_alloc_inhibit_buffer_relocation (0);
 #endif
@@ -398,7 +399,7 @@ string_match_1 (Lisp_Object regexp, Lisp_Object string, Lisp_Object start,
 			   ? BVAR (current_buffer, case_canon_table) : Qnil),
 			  posix,
 			  STRING_MULTIBYTE (string));
-  immediate_quit = 1;
+  immediate_quit = true;
   re_match_object = string;
 
   val = re_search (bufp, SSDATA (string),
@@ -406,7 +407,7 @@ string_match_1 (Lisp_Object regexp, Lisp_Object string, Lisp_Object start,
 		   SBYTES (string) - pos_byte,
 		   (NILP (Vinhibit_changing_match_data)
 		    ? &search_regs : NULL));
-  immediate_quit = 0;
+  immediate_quit = false;
 
   /* Set last_thing_searched only when match data is changed.  */
   if (NILP (Vinhibit_changing_match_data))
@@ -470,13 +471,13 @@ fast_string_match_internal (Lisp_Object regexp, Lisp_Object string,
 
   bufp = compile_pattern (regexp, 0, table,
 			  0, STRING_MULTIBYTE (string));
-  immediate_quit = 1;
+  immediate_quit = true;
   re_match_object = string;
 
   val = re_search (bufp, SSDATA (string),
 		   SBYTES (string), 0,
 		   SBYTES (string), 0);
-  immediate_quit = 0;
+  immediate_quit = false;
   return val;
 }
 
@@ -497,9 +498,9 @@ fast_c_string_match_ignore_case (Lisp_Object regexp,
   bufp = compile_pattern (regexp, 0,
 			  Vascii_canon_table, 0,
 			  0);
-  immediate_quit = 1;
+  immediate_quit = true;
   val = re_search (bufp, string, len, 0, len, 0);
-  immediate_quit = 0;
+  immediate_quit = false;
   return val;
 }
 
@@ -560,7 +561,7 @@ fast_looking_at (Lisp_Object regexp, ptrdiff_t pos, ptrdiff_t pos_byte,
     }
 
   buf = compile_pattern (regexp, 0, Qnil, 0, multibyte);
-  immediate_quit = 1;
+  immediate_quit = true;
 #ifdef REL_ALLOC
   /* Prevent ralloc.c from relocating the current buffer while
      searching it.  */
@@ -571,7 +572,7 @@ fast_looking_at (Lisp_Object regexp, ptrdiff_t pos, ptrdiff_t pos_byte,
 #ifdef REL_ALLOC
   r_alloc_inhibit_buffer_relocation (0);
 #endif
-  immediate_quit = 0;
+  immediate_quit = false;
 
   return len;
 }
@@ -703,7 +704,7 @@ find_newline (ptrdiff_t start, ptrdiff_t start_byte, ptrdiff_t end,
             ptrdiff_t next_change;
 	    int result = 1;
 
-            immediate_quit = 0;
+            immediate_quit = false;
             while (start < end && result)
 	      {
 		ptrdiff_t lim1;
@@ -809,7 +810,7 @@ find_newline (ptrdiff_t start, ptrdiff_t start_byte, ptrdiff_t end,
 
 	      if (--count == 0)
 		{
-		  immediate_quit = 0;
+		  immediate_quit = false;
 		  if (bytepos)
 		    *bytepos = lim_byte + next;
 		  return BYTE_TO_CHAR (lim_byte + next);
@@ -832,7 +833,7 @@ find_newline (ptrdiff_t start, ptrdiff_t start_byte, ptrdiff_t end,
             ptrdiff_t next_change;
 	    int result = 1;
 
-            immediate_quit = 0;
+            immediate_quit = false;
             while (start > end && result)
 	      {
 		ptrdiff_t lim1;
@@ -917,7 +918,7 @@ find_newline (ptrdiff_t start, ptrdiff_t start_byte, ptrdiff_t end,
 
 	      if (++count >= 0)
 		{
-		  immediate_quit = 0;
+		  immediate_quit = false;
 		  if (bytepos)
 		    *bytepos = ceiling_byte + prev + 1;
 		  return BYTE_TO_CHAR (ceiling_byte + prev + 1);
@@ -929,7 +930,7 @@ find_newline (ptrdiff_t start, ptrdiff_t start_byte, ptrdiff_t end,
         }
       }
 
-  immediate_quit = 0;
+  immediate_quit = false;
   if (shortage)
     *shortage = count * direction;
   if (bytepos)
@@ -1196,10 +1197,10 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
 			      trt, posix,
 			      !NILP (BVAR (current_buffer, enable_multibyte_characters)));
 
-      immediate_quit = 1;	/* Quit immediately if user types ^G,
+      immediate_quit = true;	/* Quit immediately if user types ^G,
 				   because letting this function finish
 				   can take too long. */
-      QUIT;			/* Do a pending quit right away,
+      maybe_quit ();		/* Do a pending quit right away,
 				   to avoid paradoxical behavior */
       /* Get pointers and sizes of the two strings
 	 that make up the visible portion of the buffer. */
@@ -1267,7 +1268,7 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
 	    }
 	  else
 	    {
-	      immediate_quit = 0;
+	      immediate_quit = false;
 #ifdef REL_ALLOC
               r_alloc_inhibit_buffer_relocation (0);
 #endif
@@ -1312,7 +1313,7 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
 	    }
 	  else
 	    {
-	      immediate_quit = 0;
+	      immediate_quit = false;
 #ifdef REL_ALLOC
               r_alloc_inhibit_buffer_relocation (0);
 #endif
@@ -1320,7 +1321,7 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
 	    }
 	  n--;
 	}
-      immediate_quit = 0;
+      immediate_quit = false;
 #ifdef REL_ALLOC
       r_alloc_inhibit_buffer_relocation (0);
 #endif
@@ -1927,7 +1928,7 @@ boyer_moore (EMACS_INT n, unsigned char *base_pat,
 	  < 0)
 	return (n * (0 - direction));
       /* First we do the part we can by pointers (maybe nothing) */
-      QUIT;
+      maybe_quit ();
       pat = base_pat;
       limit = pos_byte - dirlen + direction;
       if (direction > 0)
@@ -3274,7 +3275,7 @@ find_newline1 (ptrdiff_t start, ptrdiff_t start_byte, ptrdiff_t end,
 
 	      if (--count == 0)
 		{
-		  immediate_quit = 0;
+		  immediate_quit = false;
 		  if (bytepos)
 		    *bytepos = lim_byte + next;
 		  return BYTE_TO_CHAR (lim_byte + next);
@@ -3286,7 +3287,7 @@ find_newline1 (ptrdiff_t start, ptrdiff_t start_byte, ptrdiff_t end,
         }
       }
 
-  immediate_quit = 0;
+  immediate_quit = false;
   if (shortage)
     *shortage = count;
   if (bytepos)
diff --git a/src/syntax.c b/src/syntax.c
index 0ee1c746ec3..f9e4093765c 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -1426,8 +1426,8 @@ scan_words (register ptrdiff_t from, register EMACS_INT count)
   int ch0, ch1;
   Lisp_Object func, pos;
 
-  immediate_quit = 1;
-  QUIT;
+  immediate_quit = true;
+  maybe_quit ();
 
   SETUP_SYNTAX_TABLE (from, count);
 
@@ -1437,7 +1437,7 @@ scan_words (register ptrdiff_t from, register EMACS_INT count)
 	{
 	  if (from == end)
 	    {
-	      immediate_quit = 0;
+	      immediate_quit = false;
 	      return 0;
 	    }
 	  UPDATE_SYNTAX_TABLE_FORWARD (from);
@@ -1487,7 +1487,7 @@ scan_words (register ptrdiff_t from, register EMACS_INT count)
 	{
 	  if (from == beg)
 	    {
-	      immediate_quit = 0;
+	      immediate_quit = false;
 	      return 0;
 	    }
 	  DEC_BOTH (from, from_byte);
@@ -1536,7 +1536,7 @@ scan_words (register ptrdiff_t from, register EMACS_INT count)
       count++;
     }
 
-  immediate_quit = 0;
+  immediate_quit = false;
 
   return from;
 }
@@ -1921,7 +1921,7 @@ skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
 	stop = (pos >= GPT && GPT > XINT (lim)) ? GAP_END_ADDR : endp;
       }
 
-    immediate_quit = 1;
+    immediate_quit = true;
     /* This code may look up syntax tables using functions that rely on the
        gl_state object.  To make sure this object is not out of date,
        let's initialize it manually.
@@ -2064,7 +2064,7 @@ skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
       }
 
     SET_PT_BOTH (pos, pos_byte);
-    immediate_quit = 0;
+    immediate_quit = false;
 
     SAFE_FREE ();
     return make_number (PT - start_point);
@@ -2138,7 +2138,7 @@ skip_syntaxes (bool forwardp, Lisp_Object string, Lisp_Object lim)
     ptrdiff_t pos_byte = PT_BYTE;
     unsigned char *p, *endp, *stop;
 
-    immediate_quit = 1;
+    immediate_quit = true;
     SETUP_SYNTAX_TABLE (pos, forwardp ? 1 : -1);
 
     if (forwardp)
@@ -2224,7 +2224,7 @@ skip_syntaxes (bool forwardp, Lisp_Object string, Lisp_Object lim)
 
   done:
     SET_PT_BOTH (pos, pos_byte);
-    immediate_quit = 0;
+    immediate_quit = false;
 
     return make_number (PT - start_point);
   }
@@ -2412,8 +2412,8 @@ between them, return t; otherwise return nil.  */)
   count1 = XINT (count);
   stop = count1 > 0 ? ZV : BEGV;
 
-  immediate_quit = 1;
-  QUIT;
+  immediate_quit = true;
+  maybe_quit ();
 
   from = PT;
   from_byte = PT_BYTE;
@@ -2429,7 +2429,7 @@ between them, return t; otherwise return nil.  */)
 	  if (from == stop)
 	    {
 	      SET_PT_BOTH (from, from_byte);
-	      immediate_quit = 0;
+	      immediate_quit = false;
 	      return Qnil;
 	    }
 	  c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
@@ -2463,7 +2463,7 @@ between them, return t; otherwise return nil.  */)
 	comstyle = ST_COMMENT_STYLE;
       else if (code != Scomment)
 	{
-	  immediate_quit = 0;
+	  immediate_quit = false;
 	  DEC_BOTH (from, from_byte);
 	  SET_PT_BOTH (from, from_byte);
 	  return Qnil;
@@ -2474,7 +2474,7 @@ between them, return t; otherwise return nil.  */)
       from = out_charpos; from_byte = out_bytepos;
       if (!found)
 	{
-	  immediate_quit = 0;
+	  immediate_quit = false;
 	  SET_PT_BOTH (from, from_byte);
 	  return Qnil;
 	}
@@ -2494,7 +2494,7 @@ between them, return t; otherwise return nil.  */)
 	  if (from <= stop)
 	    {
 	      SET_PT_BOTH (BEGV, BEGV_BYTE);
-	      immediate_quit = 0;
+	      immediate_quit = false;
 	      return Qnil;
 	    }
 
@@ -2587,7 +2587,7 @@ between them, return t; otherwise return nil.  */)
 	  else if (code != Swhitespace || quoted)
 	    {
 	    leave:
-	      immediate_quit = 0;
+	      immediate_quit = false;
 	      INC_BOTH (from, from_byte);
 	      SET_PT_BOTH (from, from_byte);
 	      return Qnil;
@@ -2598,7 +2598,7 @@ between them, return t; otherwise return nil.  */)
     }
 
   SET_PT_BOTH (from, from_byte);
-  immediate_quit = 0;
+  immediate_quit = false;
   return Qt;
 }
 
@@ -2640,8 +2640,8 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
 
   from_byte = CHAR_TO_BYTE (from);
 
-  immediate_quit = 1;
-  QUIT;
+  immediate_quit = true;
+  maybe_quit ();
 
   SETUP_SYNTAX_TABLE (from, count);
   while (count > 0)
@@ -2801,7 +2801,7 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
       if (depth)
 	goto lose;
 
-      immediate_quit = 0;
+      immediate_quit = false;
       return Qnil;
 
       /* End of object reached */
@@ -2984,7 +2984,7 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
       if (depth)
 	goto lose;
 
-      immediate_quit = 0;
+      immediate_quit = false;
       return Qnil;
 
     done2:
@@ -2992,7 +2992,7 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
     }
 
 
-  immediate_quit = 0;
+  immediate_quit = false;
   XSETFASTINT (val, from);
   return val;
 
@@ -3173,8 +3173,8 @@ do { prev_from = from;				\
        UPDATE_SYNTAX_TABLE_FORWARD (from);	\
   } while (0)
 
-  immediate_quit = 1;
-  QUIT;
+  immediate_quit = true;
+  maybe_quit ();
 
   depth = state->depth;
   start_quoted = state->quoted;
@@ -3432,7 +3432,7 @@ do { prev_from = from;				\
                                 state->levelstarts);
   state->prev_syntax = (SYNTAX_FLAGS_COMSTARTEND_FIRST (prev_from_syntax)
                         || state->quoted) ? prev_from_syntax : Smax;
-  immediate_quit = 0;
+  immediate_quit = false;
 }
 
 /* Convert a (lisp) parse state to the internal form used in
diff --git a/src/sysdep.c b/src/sysdep.c
index 4316c21a1c7..e172dc0aed4 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -391,10 +391,10 @@ get_child_status (pid_t child, int *status, int options, bool interruptible)
       if (errno != EINTR)
 	emacs_abort ();
 
-      /* Note: the MS-Windows emulation of waitpid calls QUIT
+      /* Note: the MS-Windows emulation of waitpid calls maybe_quit
 	 internally.  */
       if (interruptible)
-	QUIT;
+	maybe_quit ();
     }
 
   /* If successful and status is requested, tell wait_reading_process_output
@@ -2383,7 +2383,7 @@ emacs_open (const char *file, int oflags, int mode)
     oflags |= O_BINARY;
   oflags |= O_CLOEXEC;
   while ((fd = open (file, oflags, mode)) < 0 && errno == EINTR)
-    QUIT;
+    maybe_quit ();
   if (! O_CLOEXEC && 0 <= fd)
     fcntl (fd, F_SETFD, FD_CLOEXEC);
   return fd;
@@ -2516,7 +2516,7 @@ emacs_read (int fildes, void *buf, ptrdiff_t nbyte)
 
   while ((rtnval = read (fildes, buf, nbyte)) == -1
 	 && (errno == EINTR))
-    QUIT;
+    maybe_quit ();
   return (rtnval);
 }
 
@@ -2538,7 +2538,7 @@ emacs_full_write (int fildes, char const *buf, ptrdiff_t nbyte,
 	{
 	  if (errno == EINTR)
 	    {
-	      /* I originally used `QUIT' but that might cause files to
+	      /* I originally used maybe_quit but that might cause files to
 		 be truncated if you hit C-g in the middle of it.  --Stef  */
 	      if (process_signals && pending_signals)
 		process_pending_signals ();
diff --git a/src/textprop.c b/src/textprop.c
index 7cb3d3c38e6..225ff28e57e 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -211,7 +211,7 @@ validate_plist (Lisp_Object list)
 	  if (! CONSP (tail))
 	    error ("Odd length text property list");
 	  tail = XCDR (tail);
-	  QUIT;
+	  maybe_quit ();
 	}
       while (CONSP (tail));
 
diff --git a/src/w32fns.c b/src/w32fns.c
index c24fce11fc8..6a576fcec27 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -778,7 +778,7 @@ w32_color_map_lookup (const char *colorname)
 	  break;
 	}
 
-      QUIT;
+      maybe_quit ();
     }
 
   unblock_input ();
@@ -3166,7 +3166,7 @@ signal_user_input (void)
   if (!NILP (Vthrow_on_input))
     {
       Vquit_flag = Vthrow_on_input;
-      /* Doing a QUIT from this thread is a bad idea, since this
+      /* Calling maybe_quit from this thread is a bad idea, since this
 	 unwinds the stack of the Lisp thread, and the Windows runtime
 	 rightfully barfs.  Disabled.  */
 #if 0
@@ -3174,8 +3174,8 @@ signal_user_input (void)
 	 do it now.  */
       if (immediate_quit && NILP (Vinhibit_quit))
 	{
-	  immediate_quit = 0;
-	  QUIT;
+	  immediate_quit = false;
+	  maybe_quit ();
 	}
 #endif
     }
diff --git a/src/w32notify.c b/src/w32notify.c
index 1f4cbe2df47..25205816bae 100644
--- a/src/w32notify.c
+++ b/src/w32notify.c
@@ -664,7 +664,7 @@ w32_get_watch_object (void *desc)
   Lisp_Object descriptor = make_pointer_integer (desc);
 
   /* This is called from the input queue handling code, inside a
-     critical section, so we cannot possibly QUIT if watch_list is not
+     critical section, so we cannot possibly quit if watch_list is not
      in the right condition.  */
   return NILP (watch_list) ? Qnil : assoc_no_quit (descriptor, watch_list);
 }
diff --git a/src/w32proc.c b/src/w32proc.c
index a7f2b4a9950..0aa248a6f7b 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -1449,7 +1449,7 @@ waitpid (pid_t pid, int *status, int options)
 
   do
     {
-      QUIT;
+      maybe_quit ();
       active = WaitForMultipleObjects (nh, wait_hnd, FALSE, timeout_ms);
     } while (active == WAIT_TIMEOUT && !dont_wait);
 
diff --git a/src/window.c b/src/window.c
index 0a6b94d4d1d..71a82b522c4 100644
--- a/src/window.c
+++ b/src/window.c
@@ -521,9 +521,10 @@ select_window (Lisp_Object window, Lisp_Object norecord,
   bset_last_selected_window (XBUFFER (w->contents), window);
 
  record_and_return:
-  /* record_buffer can run QUIT, so make sure it is run only after we have
-     re-established the invariant between selected_window and selected_frame,
-     otherwise the temporary broken invariant might "escape" (bug#14161).  */
+  /* record_buffer can call maybe_quit, so make sure it is run only
+     after we have re-established the invariant between
+     selected_window and selected_frame, otherwise the temporary
+     broken invariant might "escape" (Bug#14161).  */
   if (NILP (norecord))
     {
       w->use_time = ++window_select_count;
diff --git a/src/xdisp.c b/src/xdisp.c
index 168922ef06b..33661c882cd 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -22635,7 +22635,7 @@ move_elt_to_front (Lisp_Object elt, Lisp_Object list)
       else
 	prev = tail;
       tail = XCDR (tail);
-      QUIT;
+      maybe_quit ();
     }
 
   /* Not found--return unchanged LIST.  */
diff --git a/src/xselect.c b/src/xselect.c
index 47ccf6886bf..2249828fb4e 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -329,7 +329,7 @@ x_own_selection (Lisp_Object selection_name, Lisp_Object selection_value,
        Fcons (selection_data, dpyinfo->terminal->Vselection_alist));
 
     /* If we already owned the selection, remove the old selection
-       data.  Don't use Fdelq as that may QUIT.  */
+       data.  Don't use Fdelq as that may quit.  */
     if (!NILP (prev_value))
       {
 	/* We know it's not the CAR, so it's easy.  */
@@ -929,7 +929,7 @@ x_handle_selection_clear (struct selection_input_event *event)
       && local_selection_time > changed_owner_time)
     return;
 
-  /* Otherwise, really clear.  Don't use Fdelq as that may QUIT;.  */
+  /* Otherwise, really clear.  Don't use Fdelq as that may quit.  */
   Vselection_alist = dpyinfo->terminal->Vselection_alist;
   if (EQ (local_selection_data, CAR (Vselection_alist)))
     Vselection_alist = XCDR (Vselection_alist);
diff --git a/src/xterm.c b/src/xterm.c
index db561c902a6..80cf8ce1912 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -635,7 +635,7 @@ x_cr_export_frames (Lisp_Object frames, cairo_surface_type_t surface_type)
 	(*surface_set_size_func) (surface, width, height);
 
       unblock_input ();
-      QUIT;
+      maybe_quit ();
       block_input ();
     }