Add 2012 to FSF copyright years for Emacs files
[bpt/emacs.git] / src / macros.c
index c281c89..d43e375 100644 (file)
@@ -1,6 +1,6 @@
 /* Keyboard macros.
-   Copyright (C) 1985, 1986, 1993, 2000, 2001, 2002, 2003, 2004,
-                 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+
+Copyright (C) 1985-1986, 1993, 2000-2012  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -27,22 +27,15 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "window.h"
 #include "keyboard.h"
 
-Lisp_Object Qexecute_kbd_macro, Qkbd_macro_termination_hook;
-
-/* Kbd macro currently being executed (a string or vector).  */
-
-Lisp_Object Vexecuting_kbd_macro;
-
-/* Index of next character to fetch from that macro.  */
-
-EMACS_INT executing_kbd_macro_index;
+Lisp_Object Qexecute_kbd_macro;
+static Lisp_Object Qkbd_macro_termination_hook;
 
 /* Number of successful iterations so far
    for innermost keyboard macro.
    This is not bound at each level,
    so after an error, it describes the innermost interrupted macro.  */
 
-int executing_kbd_macro_iterations;
+EMACS_INT executing_kbd_macro_iterations;
 
 /* This is the macro that was executing.
    This is not bound at each level,
@@ -64,24 +57,24 @@ If optional second arg, NO-EXEC, is non-nil, do not re-execute last
 macro before appending to it. */)
   (Lisp_Object append, Lisp_Object no_exec)
 {
-  if (!NILP (current_kboard->defining_kbd_macro))
+  if (!NILP (KVAR (current_kboard, defining_kbd_macro)))
     error ("Already defining kbd macro");
 
   if (!current_kboard->kbd_macro_buffer)
     {
-      current_kboard->kbd_macro_bufsize = 30;
       current_kboard->kbd_macro_buffer
        = (Lisp_Object *)xmalloc (30 * sizeof (Lisp_Object));
+      current_kboard->kbd_macro_bufsize = 30;
     }
   update_mode_lines++;
   if (NILP (append))
     {
       if (current_kboard->kbd_macro_bufsize > 200)
        {
-         current_kboard->kbd_macro_bufsize = 30;
          current_kboard->kbd_macro_buffer
            = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer,
                                       30 * sizeof (Lisp_Object));
+         current_kboard->kbd_macro_bufsize = 30;
        }
       current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_buffer;
       current_kboard->kbd_macro_end = current_kboard->kbd_macro_buffer;
@@ -89,30 +82,34 @@ macro before appending to it. */)
     }
   else
     {
-      int i, len;
+      ptrdiff_t i;
+      EMACS_INT len;
       int cvt;
 
       /* Check the type of last-kbd-macro in case Lisp code changed it.  */
-      CHECK_VECTOR_OR_STRING (current_kboard->Vlast_kbd_macro);
+      CHECK_VECTOR_OR_STRING (KVAR (current_kboard, Vlast_kbd_macro));
 
-      len = XINT (Flength (current_kboard->Vlast_kbd_macro));
+      len = XINT (Flength (KVAR (current_kboard, Vlast_kbd_macro)));
 
       /* Copy last-kbd-macro into the buffer, in case the Lisp code
         has put another macro there.  */
       if (current_kboard->kbd_macro_bufsize < len + 30)
        {
-         current_kboard->kbd_macro_bufsize = len + 30;
+         if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object) - 30
+             < current_kboard->kbd_macro_bufsize)
+           memory_full (SIZE_MAX);
          current_kboard->kbd_macro_buffer
            = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer,
                                       (len + 30) * sizeof (Lisp_Object));
+         current_kboard->kbd_macro_bufsize = len + 30;
        }
 
       /* Must convert meta modifier when copying string to vector.  */
-      cvt = STRINGP (current_kboard->Vlast_kbd_macro);
+      cvt = STRINGP (KVAR (current_kboard, Vlast_kbd_macro));
       for (i = 0; i < len; i++)
        {
          Lisp_Object c;
-         c = Faref (current_kboard->Vlast_kbd_macro, make_number (i));
+         c = Faref (KVAR (current_kboard, Vlast_kbd_macro), make_number (i));
          if (cvt && NATNUMP (c) && (XFASTINT (c) & 0x80))
            XSETFASTINT (c, CHAR_META | (XFASTINT (c) & ~0x80));
          current_kboard->kbd_macro_buffer[i] = c;
@@ -124,12 +121,12 @@ macro before appending to it. */)
       /* Re-execute the macro we are appending to,
         for consistency of behavior.  */
       if (NILP (no_exec))
-       Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro,
+       Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro),
                            make_number (1), Qnil);
 
       message ("Appending to kbd macro...");
     }
-  current_kboard->defining_kbd_macro = Qt;
+  KVAR (current_kboard, defining_kbd_macro) = Qt;
 
   return Qnil;
 }
@@ -139,9 +136,9 @@ macro before appending to it. */)
 void
 end_kbd_macro (void)
 {
-  current_kboard->defining_kbd_macro = Qnil;
+  KVAR (current_kboard, defining_kbd_macro) = Qnil;
   update_mode_lines++;
-  current_kboard->Vlast_kbd_macro
+  KVAR (current_kboard, Vlast_kbd_macro)
     = make_event_array ((current_kboard->kbd_macro_end
                         - current_kboard->kbd_macro_buffer),
                        current_kboard->kbd_macro_buffer);
@@ -162,7 +159,7 @@ In Lisp, optional second arg LOOPFUNC may be a function that is called prior to
 each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
   (Lisp_Object repeat, Lisp_Object loopfunc)
 {
-  if (NILP (current_kboard->defining_kbd_macro))
+  if (NILP (KVAR (current_kboard, defining_kbd_macro)))
     error ("Not defining kbd macro");
 
   if (NILP (repeat))
@@ -170,19 +167,19 @@ each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
   else
     CHECK_NUMBER (repeat);
 
-  if (!NILP (current_kboard->defining_kbd_macro))
+  if (!NILP (KVAR (current_kboard, defining_kbd_macro)))
     {
       end_kbd_macro ();
       message ("Keyboard macro defined");
     }
 
   if (XFASTINT (repeat) == 0)
-    Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, repeat, loopfunc);
-  else
+    Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro), repeat, loopfunc);
+  else if (XINT (repeat) > 1)
     {
       XSETINT (repeat, XINT (repeat)-1);
-      if (XINT (repeat) > 0)
-       Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, repeat, loopfunc);
+      Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro),
+                         repeat, loopfunc);
     }
   return Qnil;
 }
@@ -194,18 +191,21 @@ store_kbd_macro_char (Lisp_Object c)
 {
   struct kboard *kb = current_kboard;
 
-  if (!NILP (kb->defining_kbd_macro))
+  if (!NILP (KVAR (kb, defining_kbd_macro)))
     {
       if (kb->kbd_macro_ptr - kb->kbd_macro_buffer == kb->kbd_macro_bufsize)
        {
-         int ptr_offset, end_offset, nbytes;
+         ptrdiff_t ptr_offset, end_offset, nbytes;
 
          ptr_offset = kb->kbd_macro_ptr - kb->kbd_macro_buffer;
          end_offset = kb->kbd_macro_end - kb->kbd_macro_buffer;
-         kb->kbd_macro_bufsize *= 2;
-         nbytes = kb->kbd_macro_bufsize * sizeof *kb->kbd_macro_buffer;
+         if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof *kb->kbd_macro_buffer / 2
+             < kb->kbd_macro_bufsize)
+           memory_full (SIZE_MAX);
+         nbytes = kb->kbd_macro_bufsize * (2 * sizeof *kb->kbd_macro_buffer);
          kb->kbd_macro_buffer
            = (Lisp_Object *) xrealloc (kb->kbd_macro_buffer, nbytes);
+         kb->kbd_macro_bufsize *= 2;
          kb->kbd_macro_ptr = kb->kbd_macro_buffer + ptr_offset;
          kb->kbd_macro_end = kb->kbd_macro_buffer + end_offset;
        }
@@ -256,21 +256,21 @@ each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
 {
   /* Don't interfere with recognition of the previous command
      from before this macro started.  */
-  Vthis_command = current_kboard->Vlast_command;
+  Vthis_command = KVAR (current_kboard, Vlast_command);
   /* C-x z after the macro should repeat the macro.  */
-  real_this_command = current_kboard->Vlast_kbd_macro;
+  real_this_command = KVAR (current_kboard, Vlast_kbd_macro);
 
-  if (! NILP (current_kboard->defining_kbd_macro))
+  if (! NILP (KVAR (current_kboard, defining_kbd_macro)))
     error ("Can't execute anonymous macro while defining one");
-  else if (NILP (current_kboard->Vlast_kbd_macro))
+  else if (NILP (KVAR (current_kboard, Vlast_kbd_macro)))
     error ("No kbd macro has been defined");
   else
-    Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro, prefix, loopfunc);
+    Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro), prefix, loopfunc);
 
   /* command_loop_1 sets this to nil before it returns;
      get back the last command within the macro
      so that it can be last, again, after we return.  */
-  Vthis_command = current_kboard->Vlast_command;
+  Vthis_command = KVAR (current_kboard, Vlast_command);
 
   return Qnil;
 }
@@ -302,9 +302,9 @@ each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
   Lisp_Object final;
   Lisp_Object tem;
   int pdlcount = SPECPDL_INDEX ();
-  int repeat = 1;
+  EMACS_INT repeat = 1;
   struct gcpro gcpro1, gcpro2;
-  int success_count = 0;
+  EMACS_INT success_count = 0;
 
   executing_kbd_macro_iterations = 0;
 
@@ -330,7 +330,7 @@ each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
       executing_kbd_macro = final;
       executing_kbd_macro_index = 0;
 
-      current_kboard->Vprefix_arg = Qnil;
+      KVAR (current_kboard, Vprefix_arg) = Qnil;
 
       if (!NILP (loopfunc))
        {
@@ -367,10 +367,13 @@ init_macros (void)
 void
 syms_of_macros (void)
 {
-  Qexecute_kbd_macro = intern_c_string ("execute-kbd-macro");
-  staticpro (&Qexecute_kbd_macro);
-  Qkbd_macro_termination_hook = intern_c_string ("kbd-macro-termination-hook");
-  staticpro (&Qkbd_macro_termination_hook);
+  DEFSYM (Qexecute_kbd_macro, "execute-kbd-macro");
+
+  DEFVAR_LISP ("kbd-macro-termination-hook", Vkbd_macro_termination_hook,
+               doc: /* Normal hook run whenever a keyboard macro terminates.
+This is run whether the macro ends normally or prematurely due to an error.  */);
+  Vkbd_macro_termination_hook = Qnil;
+  DEFSYM (Qkbd_macro_termination_hook, "kbd-macro-termination-hook");
 
   defsubr (&Sstart_kbd_macro);
   defsubr (&Send_kbd_macro);
@@ -384,16 +387,13 @@ syms_of_macros (void)
 The value is the symbol `append' while appending to the definition of
 an existing macro.  */);
 
-  DEFVAR_LISP ("executing-kbd-macro", &Vexecuting_kbd_macro,
+  DEFVAR_LISP ("executing-kbd-macro", Vexecuting_kbd_macro,
               doc: /* Currently executing keyboard macro (string or vector).
 This is nil when not executing a keyboard macro.  */);
 
-  DEFVAR_INT ("executing-kbd-macro-index", &executing_kbd_macro_index,
+  DEFVAR_INT ("executing-kbd-macro-index", executing_kbd_macro_index,
              doc: /* Index in currently executing keyboard macro; undefined if none executing.  */);
 
   DEFVAR_KBOARD ("last-kbd-macro", Vlast_kbd_macro,
                 doc: /* Last kbd macro defined, as a string or vector; nil if none defined.  */);
 }
-
-/* arch-tag: d293fcc9-2266-4163-9198-7fa0de12ec9e
-   (do not change this comment) */