Subject: Don't use 'register'; these days it's not needed.

From: Paul Eggert <[email-masked]>
Date: Sat, 02 Jun 2012 23:06:11 -0700

Attached is a patch to remove 'register' from the mainline
Emacs source code.  This is broken out of Bug#11604
and I will also follow up there.
=== modified file 'src/ChangeLog'
--- src/ChangeLog	2012-06-02 21:01:07 +0000
+++ src/ChangeLog	2012-06-03 05:55:23 +0000
@@ -1,3 +1,22 @@
+2012-06-03  Paul Eggert  <[email-masked]>
+
+	Don't use 'register'; these days it's not needed.
+	With recent compilers, 'register' doesn't significantly help
+	performance, and with older compilers there are some bugs.
+	Changing the default style to omit 'register' means that we can
+	assume that the code normally won't use 'register', so there's
+	no need for comments like "If we use `register' here, gcc-4.0.2 on
+	amd64 using -DUSE_LISP_UNION_TYPE complains".
+	* alloc.c, buffer.c, bytecode.c, callint.c, callproc.c, casefiddle.c:
+	* casetab.c, ccl.c, chartab.c, cm.c, cmds.c, coding.c, data.c, dired.c:
+	* dispnew.c, doc.c, doprnt.c, editfns.c, eval.c, fileio.c, filelock.c:
+	* floatfns.c, fns.c, frame.c, gmalloc.c, indent.c, insdel.c:
+	* intervals.c, keyboard.c, keymap.c, lread.c, marker.c, minibuf.c:
+	* print.c, process.c, ralloc.c, scroll.c, search.c, syntax.c, sysdep.c:
+	* term.c, termcap.c, textprop.c, tparam.c, undo.c, unexcoff.c:
+	* vm-limit.c, window.c, xdisp.c, xfns.c, xterm.c:
+	Omit 'register'.
+
 2012-06-02  Paul Eggert  <[email-masked]>
 
 	* sysdep.c (system_process_attributes): Improve comment.

=== modified file 'src/alloc.c'
--- src/alloc.c	2012-06-02 08:52:27 +0000
+++ src/alloc.c	2012-06-03 05:53:38 +0000
@@ -608,7 +608,7 @@
 static void *
 overrun_check_malloc (size_t size)
 {
-  register unsigned char *val;
+  unsigned char *val;
   int overhead = ++check_depth == 1 ? XMALLOC_OVERRUN_CHECK_OVERHEAD : 0;
   if (SIZE_MAX - overhead < size)
     abort ();
@@ -633,7 +633,7 @@
 static void *
 overrun_check_realloc (void *block, size_t size)
 {
-  register unsigned char *val = (unsigned char *) block;
+  unsigned char *val = (unsigned char *) block;
   int overhead = ++check_depth == 1 ? XMALLOC_OVERRUN_CHECK_OVERHEAD : 0;
   if (SIZE_MAX - overhead < size)
     abort ();
@@ -876,7 +876,7 @@
 Lisp_Object
 safe_alloca_unwind (Lisp_Object arg)
 {
-  register struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
+  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
 
   p->dogc = 0;
   xfree (p->pointer);
@@ -897,7 +897,7 @@
 static void *
 lisp_malloc (size_t nbytes, enum mem_type type)
 {
-  register void *val;
+  void *val;
 
   MALLOC_BLOCK_INPUT;
 
@@ -1520,7 +1520,7 @@
     {
       if (interval_block_index == INTERVAL_BLOCK_SIZE)
 	{
-	  register struct interval_block *newi;
+	  struct interval_block *newi;
 
 	  newi = (struct interval_block *) lisp_malloc (sizeof *newi,
 							MEM_TYPE_NON_LISP);
@@ -1545,7 +1545,7 @@
 /* Mark Lisp objects in interval I. */
 
 static void
-mark_interval (register INTERVAL i, Lisp_Object dummy)
+mark_interval (INTERVAL i, Lisp_Object dummy)
 {
   eassert (!i->gcmarkbit);		/* Intervals are never shared.  */
   i->gcmarkbit = 1;
@@ -1557,7 +1557,7 @@
    use the macro MARK_INTERVAL_TREE instead.  */
 
 static void
-mark_interval_tree (register INTERVAL tree)
+mark_interval_tree (INTERVAL tree)
 {
   /* No need to test if this tree has been marked already; this
      function is always called through the MARK_INTERVAL_TREE macro,
@@ -2347,8 +2347,8 @@
 INIT must be an integer that represents a character.  */)
   (Lisp_Object length, Lisp_Object init)
 {
-  register Lisp_Object val;
-  register unsigned char *p, *end;
+  Lisp_Object val;
+  unsigned char *p, *end;
   int c;
   EMACS_INT nbytes;
 
@@ -2394,7 +2394,7 @@
 LENGTH must be a number.  INIT matters only in whether it is t or nil.  */)
   (Lisp_Object length, Lisp_Object init)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   struct Lisp_Bool_Vector *p;
   ptrdiff_t length_in_chars;
   EMACS_INT length_in_elts;
@@ -2438,7 +2438,7 @@
 Lisp_Object
 make_string (const char *contents, ptrdiff_t nbytes)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   ptrdiff_t nchars, multibyte_nbytes;
 
   parse_str_as_multibyte ((const unsigned char *) contents, nbytes,
@@ -2458,7 +2458,7 @@
 Lisp_Object
 make_unibyte_string (const char *contents, ptrdiff_t length)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   val = make_uninit_string (length);
   memcpy (SDATA (val), contents, length);
   return val;
@@ -2472,7 +2472,7 @@
 make_multibyte_string (const char *contents,
 		       ptrdiff_t nchars, ptrdiff_t nbytes)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   val = make_uninit_multibyte_string (nchars, nbytes);
   memcpy (SDATA (val), contents, nbytes);
   return val;
@@ -2486,7 +2486,7 @@
 make_string_from_bytes (const char *contents,
 			ptrdiff_t nchars, ptrdiff_t nbytes)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   val = make_uninit_multibyte_string (nchars, nbytes);
   memcpy (SDATA (val), contents, nbytes);
   if (SBYTES (val) == SCHARS (val))
@@ -2504,7 +2504,7 @@
 make_specified_string (const char *contents,
 		       ptrdiff_t nchars, ptrdiff_t nbytes, int multibyte)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
 
   if (nchars < 0)
     {
@@ -2651,7 +2651,7 @@
 Lisp_Object
 make_float (double float_value)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
 
   /* eassert (!handling_signal); */
 
@@ -2668,7 +2668,7 @@
     {
       if (float_block_index == FLOAT_BLOCK_SIZE)
 	{
-	  register struct float_block *new;
+	  struct float_block *new;
 
 	  new = (struct float_block *) lisp_align_malloc (sizeof *new,
 							  MEM_TYPE_FLOAT);
@@ -2770,7 +2770,7 @@
        doc: /* Create a new cons, give it CAR and CDR as components, and return it.  */)
   (Lisp_Object car, Lisp_Object cdr)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
 
   /* eassert (!handling_signal); */
 
@@ -2787,7 +2787,7 @@
     {
       if (cons_block_index == CONS_BLOCK_SIZE)
 	{
-	  register struct cons_block *new;
+	  struct cons_block *new;
 	  new = (struct cons_block *) lisp_align_malloc (sizeof *new,
 							 MEM_TYPE_CONS);
 	  memset (new->gcmarkbits, 0, sizeof new->gcmarkbits);
@@ -2864,7 +2864,7 @@
 usage: (list &rest OBJECTS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   val = Qnil;
 
   while (nargs > 0)
@@ -2878,10 +2878,10 @@
 
 DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0,
        doc: /* Return a newly created list of length LENGTH, with each element being INIT.  */)
-  (register Lisp_Object length, Lisp_Object init)
+  (Lisp_Object length, Lisp_Object init)
 {
-  register Lisp_Object val;
-  register EMACS_INT size;
+  Lisp_Object val;
+  EMACS_INT size;
 
   CHECK_NATNUM (length);
   size = XFASTINT (length);
@@ -3060,12 +3060,12 @@
 DEFUN ("make-vector", Fmake_vector, Smake_vector, 2, 2, 0,
        doc: /* Return a newly created vector of length LENGTH, with each element being INIT.
 See also the function `vector'.  */)
-  (register Lisp_Object length, Lisp_Object init)
+  (Lisp_Object length, Lisp_Object init)
 {
   Lisp_Object vector;
-  register ptrdiff_t sizei;
-  register ptrdiff_t i;
-  register struct Lisp_Vector *p;
+  ptrdiff_t sizei;
+  ptrdiff_t i;
+  struct Lisp_Vector *p;
 
   CHECK_NATNUM (length);
 
@@ -3085,9 +3085,9 @@
 usage: (vector &rest OBJECTS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-  register Lisp_Object len, val;
+  Lisp_Object len, val;
   ptrdiff_t i;
-  register struct Lisp_Vector *p;
+  struct Lisp_Vector *p;
 
   XSETFASTINT (len, nargs);
   val = Fmake_vector (len, Qnil);
@@ -3116,9 +3116,9 @@
 usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INTERACTIVE-SPEC &rest ELEMENTS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-  register Lisp_Object len, val;
+  Lisp_Object len, val;
   ptrdiff_t i;
-  register struct Lisp_Vector *p;
+  struct Lisp_Vector *p;
 
   XSETFASTINT (len, nargs);
   if (!NILP (Vpurify_flag))
@@ -3205,8 +3205,8 @@
 Its value and function definition are void, and its property list is nil.  */)
   (Lisp_Object name)
 {
-  register Lisp_Object val;
-  register struct Lisp_Symbol *p;
+  Lisp_Object val;
+  struct Lisp_Symbol *p;
 
   CHECK_STRING (name);
 
@@ -3356,8 +3356,8 @@
 Lisp_Object
 make_save_value (void *pointer, ptrdiff_t integer)
 {
-  register Lisp_Object val;
-  register struct Lisp_Save_Value *p;
+  Lisp_Object val;
+  struct Lisp_Save_Value *p;
 
   val = allocate_misc ();
   XMISCTYPE (val) = Lisp_Misc_Save_Value;
@@ -3372,8 +3372,8 @@
        doc: /* Return a newly allocated marker which does not point at any place.  */)
   (void)
 {
-  register Lisp_Object val;
-  register struct Lisp_Marker *p;
+  Lisp_Object val;
+  struct Lisp_Marker *p;
 
   val = allocate_misc ();
   XMISCTYPE (val) = Lisp_Misc_Marker;
@@ -3403,7 +3403,7 @@
    Any number of arguments, even zero arguments, are allowed.  */
 
 Lisp_Object
-make_event_array (register int nargs, Lisp_Object *args)
+make_event_array (int nargs, Lisp_Object *args)
 {
   int i;
 
@@ -4416,7 +4416,7 @@
 test_setjmp (void)
 {
   char buf[10];
-  register int x;
+  int x;
   jmp_buf jbuf;
   int result = 0;
 
@@ -4911,7 +4911,7 @@
 Lisp_Object
 pure_cons (Lisp_Object car, Lisp_Object cdr)
 {
-  register Lisp_Object new;
+  Lisp_Object new;
   struct Lisp_Cons *p;
 
   p = (struct Lisp_Cons *) pure_alloc (sizeof *p, Lisp_Cons);
@@ -4927,7 +4927,7 @@
 static Lisp_Object
 make_pure_float (double num)
 {
-  register Lisp_Object new;
+  Lisp_Object new;
   struct Lisp_Float *p;
 
   p = (struct Lisp_Float *) pure_alloc (sizeof *p, Lisp_Float);
@@ -4959,7 +4959,7 @@
        doc: /* Make a copy of object OBJ in pure storage.
 Recursively copies contents of vectors and cons cells.
 Does not copy symbols.  Copies strings without text properties.  */)
-  (register Lisp_Object obj)
+  (Lisp_Object obj)
 {
   if (NILP (Vpurify_flag))
     return obj;
@@ -4984,8 +4984,8 @@
 			    STRING_MULTIBYTE (obj));
   else if (COMPILEDP (obj) || VECTORP (obj))
     {
-      register struct Lisp_Vector *vec;
-      register ptrdiff_t i;
+      struct Lisp_Vector *vec;
+      ptrdiff_t i;
       ptrdiff_t size;
 
       size = ASIZE (obj);
@@ -5062,7 +5062,7 @@
 See Info node `(elisp)Garbage Collection'.  */)
   (void)
 {
-  register struct specbinding *bind;
+  struct specbinding *bind;
   char stack_top_variable;
   ptrdiff_t i;
   int message_p;
@@ -5083,7 +5083,7 @@
   /* Don't keep undo information around forever.
      Do this early on, so it is no problem if the user quits.  */
   {
-    register struct buffer *nextb = all_buffers;
+    struct buffer *nextb = all_buffers;
 
     while (nextb)
       {
@@ -5191,7 +5191,7 @@
   mark_stack ();
 #else
   {
-    register struct gcpro *tail;
+    struct gcpro *tail;
     for (tail = gcprolist; tail; tail = tail->next)
       for (i = 0; i < tail->nvars; i++)
 	mark_object (tail->var[i]);
@@ -5229,7 +5229,7 @@
      for elements that update markers that were not marked,
      and delete them.  */
   {
-    register struct buffer *nextb = all_buffers;
+    struct buffer *nextb = all_buffers;
 
     while (nextb)
       {
@@ -5494,7 +5494,7 @@
 void
 mark_object (Lisp_Object arg)
 {
-  register Lisp_Object obj = arg;
+  Lisp_Object obj = arg;
 #ifdef GC_CHECK_MARKED_OBJECTS
   void *po;
   struct mem_node *m;
@@ -5552,7 +5552,7 @@
     {
     case Lisp_String:
       {
-	register struct Lisp_String *ptr = XSTRING (obj);
+	struct Lisp_String *ptr = XSTRING (obj);
 	if (STRING_MARKED_P (ptr))
 	  break;
 	CHECK_ALLOCATED_AND_LIVE (live_string_p);
@@ -5598,7 +5598,7 @@
 	   save the COMPILED_CONSTANTS element for last and avoid
 	   recursion there.  */
 	{
-	  register struct Lisp_Vector *ptr = XVECTOR (obj);
+	  struct Lisp_Vector *ptr = XVECTOR (obj);
 	  int size = ptr->header.size & PSEUDOVECTOR_SIZE_MASK;
 	  int i;
 
@@ -5614,13 +5614,13 @@
 	}
       else if (FRAMEP (obj))
 	{
-	  register struct frame *ptr = XFRAME (obj);
+	  struct frame *ptr = XFRAME (obj);
 	  mark_vectorlike (XVECTOR (obj));
 	  mark_face_cache (ptr->face_cache);
 	}
       else if (WINDOWP (obj))
 	{
-	  register struct Lisp_Vector *ptr = XVECTOR (obj);
+	  struct Lisp_Vector *ptr = XVECTOR (obj);
 	  struct window *w = XWINDOW (obj);
 	  mark_vectorlike (ptr);
 	  /* Mark glyphs for leaf windows.  Marking window matrices is
@@ -5653,7 +5653,7 @@
 
     case Lisp_Symbol:
       {
-	register struct Lisp_Symbol *ptr = XSYMBOL (obj);
+	struct Lisp_Symbol *ptr = XSYMBOL (obj);
 	struct Lisp_Symbol *ptrx;
 
 	if (ptr->gcmarkbit)
@@ -5724,7 +5724,7 @@
 	case Lisp_Misc_Save_Value:
 #if GC_MARK_STACK
 	  {
-	    register struct Lisp_Save_Value *ptr = XSAVE_VALUE (obj);
+	    struct Lisp_Save_Value *ptr = XSAVE_VALUE (obj);
 	    /* If DOGC is set, POINTER is the address of a memory
 	       area containing INTEGER potential Lisp_Objects.  */
 	    if (ptr->dogc)
@@ -5759,7 +5759,7 @@
 
     case Lisp_Cons:
       {
-	register struct Lisp_Cons *ptr = XCONS (obj);
+	struct Lisp_Cons *ptr = XCONS (obj);
 	if (CONS_MARKED_P (ptr))
 	  break;
 	CHECK_ALLOCATED_AND_LIVE (live_cons_p);
@@ -5801,8 +5801,8 @@
 static void
 mark_buffer (Lisp_Object buf)
 {
-  register struct buffer *buffer = XBUFFER (buf);
-  register Lisp_Object *ptr, tmp;
+  struct buffer *buffer = XBUFFER (buf);
+  Lisp_Object *ptr, tmp;
   Lisp_Object base_buffer;
 
   eassert (!VECTOR_MARKED_P (buffer));
@@ -5928,16 +5928,16 @@
 
   /* Put all unmarked conses on free list */
   {
-    register struct cons_block *cblk;
+    struct cons_block *cblk;
     struct cons_block **cprev = &cons_block;
-    register int lim = cons_block_index;
+    int lim = cons_block_index;
     EMACS_INT num_free = 0, num_used = 0;
 
     cons_free_list = 0;
 
     for (cblk = cons_block; cblk; cblk = *cprev)
       {
-	register int i = 0;
+	int i = 0;
 	int this_free = 0;
 	int ilim = (lim + BITS_PER_INT - 1) / BITS_PER_INT;
 
@@ -6005,16 +6005,16 @@
 
   /* Put all unmarked floats on free list */
   {
-    register struct float_block *fblk;
+    struct float_block *fblk;
     struct float_block **fprev = &float_block;
-    register int lim = float_block_index;
+    int lim = float_block_index;
     EMACS_INT num_free = 0, num_used = 0;
 
     float_free_list = 0;
 
     for (fblk = float_block; fblk; fblk = *fprev)
       {
-	register int i;
+	int i;
 	int this_free = 0;
 	for (i = 0; i < lim; i++)
 	  if (!FLOAT_MARKED_P (&fblk->floats[i]))
@@ -6051,16 +6051,16 @@
 
   /* Put all unmarked intervals on free list */
   {
-    register struct interval_block *iblk;
+    struct interval_block *iblk;
     struct interval_block **iprev = &interval_block;
-    register int lim = interval_block_index;
+    int lim = interval_block_index;
     EMACS_INT num_free = 0, num_used = 0;
 
     interval_free_list = 0;
 
     for (iblk = interval_block; iblk; iblk = *iprev)
       {
-	register int i;
+	int i;
 	int this_free = 0;
 
 	for (i = 0; i < lim; i++)
@@ -6100,9 +6100,9 @@
 
   /* Put all unmarked symbols on free list */
   {
-    register struct symbol_block *sblk;
+    struct symbol_block *sblk;
     struct symbol_block **sprev = &symbol_block;
-    register int lim = symbol_block_index;
+    int lim = symbol_block_index;
     EMACS_INT num_free = 0, num_used = 0;
 
     symbol_free_list = NULL;
@@ -6164,16 +6164,16 @@
   /* Put all unmarked misc's on free list.
      For a marker, first unchain it from the buffer it points into.  */
   {
-    register struct marker_block *mblk;
+    struct marker_block *mblk;
     struct marker_block **mprev = &marker_block;
-    register int lim = marker_block_index;
+    int lim = marker_block_index;
     EMACS_INT num_free = 0, num_used = 0;
 
     marker_free_list = 0;
 
     for (mblk = marker_block; mblk; mblk = *mprev)
       {
-	register int i;
+	int i;
 	int this_free = 0;
 
 	for (i = 0; i < lim; i++)
@@ -6220,7 +6220,7 @@
 
   /* Free all unmarked buffers */
   {
-    register struct buffer *buffer = all_buffers, *prev = 0, *next;
+    struct buffer *buffer = all_buffers, *prev = 0, *next;
 
     while (buffer)
       if (!VECTOR_MARKED_P (buffer))
@@ -6243,7 +6243,7 @@
 
   /* Free all unmarked vectors */
   {
-    register struct Lisp_Vector *vector = all_vectors, *prev = 0, *next;
+    struct Lisp_Vector *vector = all_vectors, *prev = 0, *next;
     total_vector_size = 0;
 
     while (vector)

=== modified file 'src/buffer.c'
--- src/buffer.c	2012-05-29 16:13:38 +0000
+++ src/buffer.c	2012-06-03 05:53:38 +0000
@@ -226,12 +226,12 @@
    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;
+      Lisp_Object elt, tem;
       elt = XCAR (tail);
       tem = Fstring_equal (Fcar (elt), key);
       if (!NILP (tem))
@@ -245,7 +245,7 @@
 BUFFER-OR-NAME must be either a string or a buffer.  If BUFFER-OR-NAME
 is a string and there is no buffer with that name, return nil.  If
 BUFFER-OR-NAME is a buffer, return it as given.  */)
-  (register Lisp_Object buffer_or_name)
+  (Lisp_Object buffer_or_name)
 {
   if (BUFFERP (buffer_or_name))
     return buffer_or_name;
@@ -259,9 +259,9 @@
 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
 If there is no such live buffer, return nil.
 See also `find-buffer-visiting'.  */)
-  (register Lisp_Object filename)
+  (Lisp_Object filename)
 {
-  register Lisp_Object tail, buf, tem;
+  Lisp_Object tail, buf, tem;
   Lisp_Object handler;
 
   CHECK_STRING (filename);
@@ -290,9 +290,9 @@
 }
 
 Lisp_Object
-get_truename_buffer (register Lisp_Object filename)
+get_truename_buffer (Lisp_Object filename)
 {
-  register Lisp_Object tail, buf, tem;
+  Lisp_Object tail, buf, tem;
 
   for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
     {
@@ -315,10 +315,10 @@
 
 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
 even if it is dead.  The return value is never nil.  */)
-  (register Lisp_Object buffer_or_name)
+  (Lisp_Object buffer_or_name)
 {
-  register Lisp_Object buffer, name;
-  register struct buffer *b;
+  Lisp_Object buffer, name;
+  struct buffer *b;
 
   buffer = Fget_buffer (buffer_or_name);
   if (!NILP (buffer))
@@ -704,7 +704,7 @@
    claims it doesn't belong to it.  */
 
 void
-reset_buffer (register struct buffer *b)
+reset_buffer (struct buffer *b)
 {
   BVAR (b, filename) = Qnil;
   BVAR (b, file_truename) = Qnil;
@@ -748,9 +748,9 @@
    we preserve those.  */
 
 static void
-reset_buffer_local_variables (register struct buffer *b, int permanent_too)
+reset_buffer_local_variables (struct buffer *b, int permanent_too)
 {
-  register int offset;
+  int offset;
   int i;
 
   /* Reset the major mode to Fundamental, together with all the
@@ -849,9 +849,9 @@
 \(starting at 2) until an unused name is found, and then return that name.
 Optional second argument IGNORE specifies a name that is okay to use (if
 it is in the sequence to be tried) even if a buffer with that name exists.  */)
-  (register Lisp_Object name, Lisp_Object ignore)
+  (Lisp_Object name, Lisp_Object ignore)
 {
-  register Lisp_Object gentemp, tem;
+  Lisp_Object gentemp, tem;
   ptrdiff_t count;
   char number[INT_BUFSIZE_BOUND (ptrdiff_t) + sizeof "<>"];
 
@@ -883,7 +883,7 @@
        doc: /* Return the name of BUFFER, as a string.
 BUFFER defaults to the current buffer.
 Return nil if BUFFER has been killed.  */)
-  (register Lisp_Object buffer)
+  (Lisp_Object buffer)
 {
   if (NILP (buffer))
     return BVAR (current_buffer, name);
@@ -894,7 +894,7 @@
 DEFUN ("buffer-file-name", Fbuffer_file_name, Sbuffer_file_name, 0, 1, 0,
        doc: /* Return name of file BUFFER is visiting, or nil if none.
 No argument or nil as argument means use the current buffer.  */)
-  (register Lisp_Object buffer)
+  (Lisp_Object buffer)
 {
   if (NILP (buffer))
     return BVAR (current_buffer, filename);
@@ -907,7 +907,7 @@
        doc: /* Return the base buffer of indirect buffer BUFFER.
 If BUFFER is not indirect, return nil.
 BUFFER defaults to the current buffer.  */)
-  (register Lisp_Object buffer)
+  (Lisp_Object buffer)
 {
   struct buffer *base;
   Lisp_Object base_buffer;
@@ -931,10 +931,10 @@
        doc: /* Return the value of VARIABLE in BUFFER.
 If VARIABLE does not have a buffer-local binding in BUFFER, the value
 is the default binding of the variable. */)
-  (register Lisp_Object variable, register Lisp_Object buffer)
+  (Lisp_Object variable, Lisp_Object buffer)
 {
-  register struct buffer *buf;
-  register Lisp_Object result;
+  struct buffer *buf;
+  Lisp_Object result;
   struct Lisp_Symbol *sym;
 
   CHECK_SYMBOL (variable);
@@ -999,7 +999,7 @@
 buffer_lisp_local_variables (struct buffer *buf)
 {
   Lisp_Object result = Qnil;
-  register Lisp_Object tail;
+  Lisp_Object tail;
   for (tail = BVAR (buf, local_var_alist); CONSP (tail); tail = XCDR (tail))
     {
       Lisp_Object val, elt;
@@ -1032,10 +1032,10 @@
 For a symbol that is locally unbound, just the symbol appears in the value.
 Note that storing new VALUEs in these elements doesn't change the variables.
 No argument or nil as argument means use current buffer as BUFFER.  */)
-  (register Lisp_Object buffer)
+  (Lisp_Object buffer)
 {
-  register struct buffer *buf;
-  register Lisp_Object result;
+  struct buffer *buf;
+  Lisp_Object result;
 
   if (NILP (buffer))
     buf = current_buffer;
@@ -1077,9 +1077,9 @@
        0, 1, 0,
        doc: /* Return t if BUFFER was modified since its file was last read or saved.
 No argument or nil as argument means use current buffer as BUFFER.  */)
-  (register Lisp_Object buffer)
+  (Lisp_Object buffer)
 {
-  register struct buffer *buf;
+  struct buffer *buf;
   if (NILP (buffer))
     buf = current_buffer;
   else
@@ -1095,10 +1095,10 @@
        1, 1, 0,
        doc: /* Mark current buffer as modified or unmodified according to FLAG.
 A non-nil FLAG means mark the buffer modified.  */)
-  (register Lisp_Object flag)
+  (Lisp_Object flag)
 {
-  register int already;
-  register Lisp_Object fn;
+  int already;
+  Lisp_Object fn;
   Lisp_Object buffer, window;
 
 #ifdef CLASH_DETECTION
@@ -1194,9 +1194,9 @@
 Each buffer has a tick counter which is incremented each time the
 text in that buffer is changed.  It wraps around occasionally.
 No argument or nil as argument means use current buffer as BUFFER.  */)
-  (register Lisp_Object buffer)
+  (Lisp_Object buffer)
 {
-  register struct buffer *buf;
+  struct buffer *buf;
   if (NILP (buffer))
     buf = current_buffer;
   else
@@ -1218,9 +1218,9 @@
 you can tell whether a character change occurred in that buffer in
 between these calls.  No argument or nil as argument means use current
 buffer as BUFFER.  */)
-  (register Lisp_Object buffer)
+  (Lisp_Object buffer)
 {
-  register struct buffer *buf;
+  struct buffer *buf;
   if (NILP (buffer))
     buf = current_buffer;
   else
@@ -1244,9 +1244,9 @@
 Interactively, you can set UNIQUE with a prefix argument.
 We return the name we actually gave the buffer.
 This does not change the name of the visited file (if any).  */)
-  (register Lisp_Object newname, Lisp_Object unique)
+  (Lisp_Object newname, Lisp_Object unique)
 {
-  register Lisp_Object tem, buf;
+  Lisp_Object tem, buf;
 
   CHECK_STRING (newname);
 
@@ -1299,7 +1299,7 @@
 The buffer is found by scanning the selected or specified frame's buffer
 list first, followed by the list of all buffers.  If no other buffer
 exists, return the buffer `*scratch*' (creating it if necessary).  */)
-  (register Lisp_Object buffer, Lisp_Object visible_ok, Lisp_Object frame)
+  (Lisp_Object buffer, Lisp_Object visible_ok, Lisp_Object frame)
 {
   Lisp_Object Fset_buffer_major_mode (Lisp_Object buffer);
   Lisp_Object tail, buf, pred;
@@ -1399,7 +1399,7 @@
        0, 1, "",
        doc: /* Start keeping undo information for buffer BUFFER.
 No argument or nil as argument means do this for the current buffer.  */)
-  (register Lisp_Object buffer)
+  (Lisp_Object buffer)
 {
   Lisp_Object real_buffer;
 
@@ -1443,9 +1443,9 @@
   (Lisp_Object buffer_or_name)
 {
   Lisp_Object buffer;
-  register struct buffer *b;
-  register Lisp_Object tem;
-  register struct Lisp_Marker *m;
+  struct buffer *b;
+  Lisp_Object tem;
+  struct Lisp_Marker *m;
   struct gcpro gcpro1;
 
   if (NILP (buffer_or_name))
@@ -1678,7 +1678,7 @@
 record_buffer (Lisp_Object buffer)
 {
   Lisp_Object aelt, aelt_cons, tem;
-  register struct frame *f = XFRAME (selected_frame);
+  struct frame *f = XFRAME (selected_frame);
 
   CHECK_BUFFER (buffer);
 
@@ -1716,7 +1716,7 @@
   (Lisp_Object buffer)
 {
   Lisp_Object aelt, aelt_cons, tem;
-  register struct frame *f = XFRAME (selected_frame);
+  struct frame *f = XFRAME (selected_frame);
 
   CHECK_BUFFER (buffer);
 
@@ -1787,7 +1787,7 @@
        doc: /* Return the current buffer as a Lisp object.  */)
   (void)
 {
-  register Lisp_Object buf;
+  Lisp_Object buf;
   XSETBUFFER (buf, current_buffer);
   return buf;
 }
@@ -1802,7 +1802,7 @@
    time, and that increments windows_or_buffers_changed.  */
 
 void
-set_buffer_internal (register struct buffer *b)
+set_buffer_internal (struct buffer *b)
 {
   if (current_buffer != b)
     set_buffer_internal_1 (b);
@@ -1812,10 +1812,10 @@
    This is used by redisplay.  */
 
 void
-set_buffer_internal_1 (register struct buffer *b)
+set_buffer_internal_1 (struct buffer *b)
 {
-  register struct buffer *old_buf;
-  register Lisp_Object tail;
+  struct buffer *old_buf;
+  Lisp_Object tail;
 
 #ifdef USE_MMAP_FOR_BUFFERS
   if (b->text->beg == NULL)
@@ -1876,7 +1876,7 @@
 void
 set_buffer_temp (struct buffer *b)
 {
-  register struct buffer *old_buf;
+  struct buffer *old_buf;
 
   if (current_buffer == b)
     return;
@@ -1900,9 +1900,9 @@
 temporarily.  This function does not display the buffer, so its effect
 ends when the current command terminates.  Use `switch-to-buffer' or
 `pop-to-buffer' to switch buffers permanently.  */)
-  (register Lisp_Object buffer_or_name)
+  (Lisp_Object buffer_or_name)
 {
-  register Lisp_Object buffer;
+  Lisp_Object buffer;
   buffer = Fget_buffer (buffer_or_name);
   if (NILP (buffer))
     nsberror (buffer_or_name);
@@ -1952,7 +1952,7 @@
 }
 
 void
-validate_region (register Lisp_Object *b, register Lisp_Object *e)
+validate_region (Lisp_Object *b, Lisp_Object *e)
 {
   CHECK_NUMBER_COERCE_MARKER (*b);
   CHECK_NUMBER_COERCE_MARKER (*e);
@@ -3315,7 +3315,7 @@
    Such an overlay might even have negative size at this point.
    If so, we'll make the overlay empty. */
 void
-fix_start_end_in_overlays (register ptrdiff_t start, register ptrdiff_t end)
+fix_start_end_in_overlays (ptrdiff_t start, ptrdiff_t end)
 {
   Lisp_Object overlay;
   struct Lisp_Overlay *before_list IF_LINT (= NULL);

=== modified file 'src/bytecode.c'
--- src/bytecode.c	2012-02-10 18:58:48 +0000
+++ src/bytecode.c	2012-06-03 05:53:38 +0000
@@ -942,7 +942,7 @@
 
 	case Bsave_window_excursion: /* Obsolete since 24.1.  */
 	  {
-	    register ptrdiff_t count1 = SPECPDL_INDEX ();
+	    ptrdiff_t count1 = SPECPDL_INDEX ();
 	    record_unwind_protect (Fset_window_configuration,
 				   Fcurrent_window_configuration (Qnil));
 	    BEFORE_POTENTIAL_GC ();

=== modified file 'src/callint.c'
--- src/callint.c	2012-06-02 19:21:34 +0000
+++ src/callint.c	2012-06-03 05:55:23 +0000
@@ -122,7 +122,7 @@
 /* Quotify EXP: if EXP is constant, return it.
    If EXP is not constant, return (quote EXP).  */
 static Lisp_Object
-quotify_arg (register Lisp_Object exp)
+quotify_arg (Lisp_Object exp)
 {
   if (CONSP (exp)
       || (SYMBOLP (exp)
@@ -136,7 +136,7 @@
 static Lisp_Object
 quotify_args (Lisp_Object exp)
 {
-  register Lisp_Object tail;
+  Lisp_Object tail;
   Lisp_Object next;
   for (tail = exp; CONSP (tail); tail = next)
     {

=== modified file 'src/callproc.c'
--- src/callproc.c	2012-05-30 14:20:45 +0000
+++ src/callproc.c	2012-06-03 05:53:38 +0000
@@ -202,7 +202,7 @@
   ptrdiff_t count = SPECPDL_INDEX ();
   USE_SAFE_ALLOCA;
 
-  register const unsigned char **new_argv;
+  const unsigned char **new_argv;
   /* File to use for stderr in the child.
      t means use same as standard output.  */
   Lisp_Object error_file;
@@ -498,8 +498,8 @@
   {
     /* child_setup must clobber environ in systems with true vfork.
        Protect it from permanent change.  */
-    register char **save_environ = environ;
-    register int fd1 = fd[1];
+    char **save_environ = environ;
+    int fd1 = fd[1];
     int fd_error = fd1;
 #ifdef HAVE_WORKING_VFORK
     sigset_t procmask;
@@ -769,7 +769,7 @@
 
   if (output_to_buffer)
     {
-      register int nread;
+      int nread;
       int first = 1;
       EMACS_INT total_read = 0;
       int carryover = 0;
@@ -970,7 +970,7 @@
 {
   struct gcpro gcpro1;
   Lisp_Object filename_string;
-  register Lisp_Object start, end;
+  Lisp_Object start, end;
   ptrdiff_t count = SPECPDL_INDEX ();
   /* Qt denotes we have not yet called Ffind_operation_coding_system.  */
   Lisp_Object coding_systems;
@@ -1139,7 +1139,7 @@
    executable directory by the parent.  */
 
 int
-child_setup (int in, int out, int err, register char **new_argv, int set_pgrp, Lisp_Object current_dir)
+child_setup (int in, int out, int err, char **new_argv, int set_pgrp, Lisp_Object current_dir)
 {
   char **env;
   char *pwd_var;
@@ -1166,7 +1166,7 @@
      static variables as if the superior had done alloca and will be
      cleaned up in the usual way. */
   {
-    register char *temp;
+    char *temp;
     size_t i; /* size_t, because ptrdiff_t might overflow here!  */
 
     i = SBYTES (current_dir);
@@ -1208,10 +1208,10 @@
 
   /* Set `env' to a vector of the strings in the environment.  */
   {
-    register Lisp_Object tem;
-    register char **new_env;
+    Lisp_Object tem;
+    char **new_env;
     char **p, **q;
-    register int new_length;
+    int new_length;
     Lisp_Object display = Qnil;
 
     new_length = 0;
@@ -1537,7 +1537,7 @@
 {
   char *data_dir = egetenv ("EMACSDATA");
 
-  register char * sh;
+  char *sh;
   Lisp_Object tempdir;
 
   if (!NILP (Vinstallation_directory))

=== modified file 'src/casefiddle.c'
--- src/casefiddle.c	2012-02-10 18:58:48 +0000
+++ src/casefiddle.c	2012-06-03 05:53:38 +0000
@@ -35,8 +35,8 @@
 static Lisp_Object
 casify_object (enum case_action flag, Lisp_Object obj)
 {
-  register int c, c1;
-  register int inword = flag == CASE_DOWN;
+  int c, c1;
+  int inword = flag == CASE_DOWN;
 
   /* If the case table is flagged as modified, rescan it.  */
   if (NILP (XCHAR_TABLE (BVAR (current_buffer, downcase_table))->extras[1]))
@@ -190,9 +190,9 @@
 static void
 casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e)
 {
-  register int c;
-  register int inword = flag == CASE_DOWN;
-  register int multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
+  int c;
+  int inword = flag == CASE_DOWN;
+  int multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
   ptrdiff_t start, end;
   ptrdiff_t start_byte;

=== modified file 'src/casetab.c'
--- src/casetab.c	2012-02-10 18:58:48 +0000
+++ src/casetab.c	2012-06-03 05:53:38 +0000
@@ -245,7 +245,7 @@
 void
 init_casetab_once (void)
 {
-  register int i;
+  int i;
   Lisp_Object down, up;
   DEFSYM (Qcase_table, "case-table");

=== modified file 'src/ccl.c'
--- src/ccl.c	2012-02-10 18:58:48 +0000
+++ src/ccl.c	2012-06-03 05:53:38 +0000
@@ -874,10 +874,10 @@
 void
 ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size, int dst_size, Lisp_Object charset_list)
 {
-  register int *reg = ccl->reg;
-  register int ic = ccl->ic;
-  register int code = 0, field1, field2;
-  register Lisp_Object *ccl_prog = ccl->prog;
+  int *reg = ccl->reg;
+  int ic = ccl->ic;
+  int code = 0, field1, field2;
+  Lisp_Object *ccl_prog = ccl->prog;
   int *src = source, *src_end = src + src_size;
   int *dst = destination, *dst_end = dst + dst_size;
   int jump_address;

=== modified file 'src/chartab.c'
--- src/chartab.c	2011-12-11 00:56:50 +0000
+++ src/chartab.c	2012-06-03 05:53:38 +0000
@@ -93,7 +93,7 @@
 property, the property's value should be an integer between 0 and 10
 that specifies how many extra slots the char-table has.  Otherwise,
 the char-table has no extra slot.  */)
-  (register Lisp_Object purpose, Lisp_Object init)
+  (Lisp_Object purpose, Lisp_Object init)
 {
   Lisp_Object vector;
   Lisp_Object n;

=== modified file 'src/cm.c'
--- src/cm.c	2012-01-19 07:21:25 +0000
+++ src/cm.c	2012-06-03 05:53:38 +0000
@@ -182,16 +182,16 @@
 calccost (struct tty_display_info *tty,
           int srcy, int srcx, int dsty, int dstx, int doit)
 {
-    register int    deltay,
-                    deltax,
-                    c,
-                    totalcost;
+    int     deltay,
+	    deltax,
+	    c,
+	    totalcost;
     int     ntabs,
             n2tabs,
             tabx,
             tab2x,
             tabcost;
-    register const char *p;
+    const char *p;
 
     /* If have just wrapped on a terminal with xn,
        don't believe the cursor position: give up here

=== modified file 'src/cmds.c'
--- src/cmds.c	2012-02-10 18:58:48 +0000
+++ src/cmds.c	2012-06-03 05:53:38 +0000
@@ -329,7 +329,7 @@
 {
   int hairy = 0;
   Lisp_Object tem;
-  register enum syntaxcode synt;
+  enum syntaxcode synt;
   Lisp_Object overwrite;
   /* Length of multi-byte form of C.  */
   int len;

=== modified file 'src/coding.c'
--- src/coding.c	2012-05-26 22:27:21 +0000
+++ src/coding.c	2012-06-03 05:53:38 +0000
@@ -9405,7 +9405,7 @@
   (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object operation, target_idx, target, val;
-  register Lisp_Object chain;
+  Lisp_Object chain;
 
   if (nargs < 2)
     error ("Too few arguments");

=== modified file 'src/data.c'
--- src/data.c	2012-05-30 03:59:42 +0000
+++ src/data.c	2012-06-03 05:53:38 +0000
@@ -101,7 +101,7 @@

 Lisp_Object
-wrong_type_argument (register Lisp_Object predicate, register Lisp_Object value)
+wrong_type_argument (Lisp_Object predicate, Lisp_Object value)
 {
   /* If VALUE is not even a valid Lisp object, we'd want to abort here
      where we can get a backtrace showing where it came from.  We used
@@ -349,7 +349,7 @@
 
 DEFUN ("sequencep", Fsequencep, Ssequencep, 1, 1, 0,
        doc: /* Return t if OBJECT is a sequence (list or array).  */)
-  (register Lisp_Object object)
+  (Lisp_Object object)
 {
   if (CONSP (object) || NILP (object) || ARRAYP (object))
     return Qt;
@@ -395,7 +395,7 @@
 
 DEFUN ("char-or-string-p", Fchar_or_string_p, Schar_or_string_p, 1, 1, 0,
        doc: /* Return t if OBJECT is a character or a string.  */)
-  (register Lisp_Object object)
+  (Lisp_Object object)
 {
   if (CHARACTERP (object) || STRINGP (object))
     return Qt;
@@ -413,7 +413,7 @@
 
 DEFUN ("integer-or-marker-p", Finteger_or_marker_p, Sinteger_or_marker_p, 1, 1, 0,
        doc: /* Return t if OBJECT is an integer or a marker (editor pointer).  */)
-  (register Lisp_Object object)
+  (Lisp_Object object)
 {
   if (MARKERP (object) || INTEGERP (object))
     return Qt;
@@ -467,7 +467,7 @@
 
 See Info node `(elisp)Cons Cells' for a discussion of related basic
 Lisp concepts such as car, cdr, cons cell and list.  */)
-  (register Lisp_Object list)
+  (Lisp_Object list)
 {
   return CAR (list);
 }
@@ -485,7 +485,7 @@
 
 See Info node `(elisp)Cons Cells' for a discussion of related basic
 Lisp concepts such as cdr, car, cons cell and list.  */)
-  (register Lisp_Object list)
+  (Lisp_Object list)
 {
   return CDR (list);
 }
@@ -499,7 +499,7 @@
 
 DEFUN ("setcar", Fsetcar, Ssetcar, 2, 2, 0,
        doc: /* Set the car of CELL to be NEWCAR.  Returns NEWCAR.  */)
-  (register Lisp_Object cell, Lisp_Object newcar)
+  (Lisp_Object cell, Lisp_Object newcar)
 {
   CHECK_CONS (cell);
   CHECK_IMPURE (cell);
@@ -509,7 +509,7 @@
 
 DEFUN ("setcdr", Fsetcdr, Ssetcdr, 2, 2, 0,
        doc: /* Set the cdr of CELL to be NEWCDR.  Returns NEWCDR.  */)
-  (register Lisp_Object cell, Lisp_Object newcdr)
+  (Lisp_Object cell, Lisp_Object newcdr)
 {
   CHECK_CONS (cell);
   CHECK_IMPURE (cell);
@@ -521,7 +521,7 @@
 
 DEFUN ("boundp", Fboundp, Sboundp, 1, 1, 0,
        doc: /* Return t if SYMBOL's value is not void.  */)
-  (register Lisp_Object symbol)
+  (Lisp_Object symbol)
 {
   Lisp_Object valcontents;
   struct Lisp_Symbol *sym;
@@ -559,7 +559,7 @@
 
 DEFUN ("fboundp", Ffboundp, Sfboundp, 1, 1, 0,
        doc: /* Return t if SYMBOL's function definition is not void.  */)
-  (register Lisp_Object symbol)
+  (Lisp_Object symbol)
 {
   CHECK_SYMBOL (symbol);
   return (EQ (XSYMBOL (symbol)->function, Qunbound) ? Qnil : Qt);
@@ -568,7 +568,7 @@
 DEFUN ("makunbound", Fmakunbound, Smakunbound, 1, 1, 0,
        doc: /* Make SYMBOL's value be void.
 Return SYMBOL.  */)
-  (register Lisp_Object symbol)
+  (Lisp_Object symbol)
 {
   CHECK_SYMBOL (symbol);
   if (SYMBOL_CONSTANT_P (symbol))
@@ -580,7 +580,7 @@
 DEFUN ("fmakunbound", Ffmakunbound, Sfmakunbound, 1, 1, 0,
        doc: /* Make SYMBOL's function definition be void.
 Return SYMBOL.  */)
-  (register Lisp_Object symbol)
+  (Lisp_Object symbol)
 {
   CHECK_SYMBOL (symbol);
   if (NILP (symbol) || EQ (symbol, Qt))
@@ -591,7 +591,7 @@
 
 DEFUN ("symbol-function", Fsymbol_function, Ssymbol_function, 1, 1, 0,
        doc: /* Return SYMBOL's function definition.  Error if that is void.  */)
-  (register Lisp_Object symbol)
+  (Lisp_Object symbol)
 {
   CHECK_SYMBOL (symbol);
   if (!EQ (XSYMBOL (symbol)->function, Qunbound))
@@ -601,7 +601,7 @@
 
 DEFUN ("symbol-plist", Fsymbol_plist, Ssymbol_plist, 1, 1, 0,
        doc: /* Return SYMBOL's property list.  */)
-  (register Lisp_Object symbol)
+  (Lisp_Object symbol)
 {
   CHECK_SYMBOL (symbol);
   return XSYMBOL (symbol)->plist;
@@ -609,9 +609,9 @@
 
 DEFUN ("symbol-name", Fsymbol_name, Ssymbol_name, 1, 1, 0,
        doc: /* Return SYMBOL's name, a string.  */)
-  (register Lisp_Object symbol)
+  (Lisp_Object symbol)
 {
-  register Lisp_Object name;
+  Lisp_Object name;
 
   CHECK_SYMBOL (symbol);
   name = SYMBOL_NAME (symbol);
@@ -620,9 +620,9 @@
 
 DEFUN ("fset", Ffset, Sfset, 2, 2, 0,
        doc: /* Set SYMBOL's function definition to DEFINITION, and return DEFINITION.  */)
-  (register Lisp_Object symbol, Lisp_Object definition)
+  (Lisp_Object symbol, Lisp_Object definition)
 {
-  register Lisp_Object function;
+  Lisp_Object function;
 
   CHECK_SYMBOL (symbol);
   if (NILP (symbol) || EQ (symbol, Qt))
@@ -652,7 +652,7 @@
 The optional third argument DOCSTRING specifies the documentation string
 for SYMBOL; if it is omitted or nil, SYMBOL uses the documentation string
 determined by DEFINITION.  */)
-  (register Lisp_Object symbol, Lisp_Object definition, Lisp_Object docstring)
+  (Lisp_Object symbol, Lisp_Object definition, Lisp_Object docstring)
 {
   CHECK_SYMBOL (symbol);
   if (CONSP (XSYMBOL (symbol)->function)
@@ -671,7 +671,7 @@
 
 DEFUN ("setplist", Fsetplist, Ssetplist, 2, 2, 0,
        doc: /* Set SYMBOL's property list to NEWPLIST, and return NEWPLIST.  */)
-  (register Lisp_Object symbol, Lisp_Object newplist)
+  (Lisp_Object symbol, Lisp_Object newplist)
 {
   CHECK_SYMBOL (symbol);
   XSYMBOL (symbol)->plist = newplist;
@@ -824,9 +824,9 @@
    swap_in_symval_forwarding for that.  */
 
 Lisp_Object
-do_symval_forwarding (register union Lisp_Fwd *valcontents)
+do_symval_forwarding (union Lisp_Fwd *valcontents)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   switch (XFWDTYPE (valcontents))
     {
     case Lisp_Fwd_Int:
@@ -870,7 +870,8 @@
    current buffer.  This only plays a role for per-buffer variables.  */
 
 static void
-store_symval_forwarding (union Lisp_Fwd *valcontents, register Lisp_Object newval, struct buffer *buf)
+store_symval_forwarding (union Lisp_Fwd *valcontents, Lisp_Object newval,
+			 struct buffer *buf)
 {
   switch (XFWDTYPE (valcontents))
     {
@@ -979,7 +980,7 @@
 static void
 swap_in_symval_forwarding (struct Lisp_Symbol *symbol, struct Lisp_Buffer_Local_Value *blv)
 {
-  register Lisp_Object tem1;
+  Lisp_Object tem1;
 
   eassert (blv == SYMBOL_BLV (symbol));
 
@@ -1067,7 +1068,7 @@
 
 DEFUN ("set", Fset, Sset, 2, 2, 0,
        doc: /* Set SYMBOL's value to NEWVAL, and return NEWVAL.  */)
-  (register Lisp_Object symbol, Lisp_Object newval)
+  (Lisp_Object symbol, Lisp_Object newval)
 {
   set_internal (symbol, newval, Qnil, 0);
   return newval;
@@ -1116,7 +1117,8 @@
    If BINDFLAG is nonzero, we don't do that.  */
 
 void
-set_internal (register Lisp_Object symbol, register Lisp_Object newval, register Lisp_Object where, int bindflag)
+set_internal (Lisp_Object symbol, Lisp_Object newval, Lisp_Object where,
+	      int bindflag)
 {
   int voide = EQ (newval, Qunbound);
   struct Lisp_Symbol *sym;
@@ -1317,7 +1319,7 @@
 for this variable.  */)
   (Lisp_Object symbol)
 {
-  register Lisp_Object value;
+  Lisp_Object value;
 
   value = default_value (symbol);
   return (EQ (value, Qunbound) ? Qnil : Qt);
@@ -1330,7 +1332,7 @@
 local bindings in certain buffers.  */)
   (Lisp_Object symbol)
 {
-  register Lisp_Object value;
+  Lisp_Object value;
 
   value = default_value (symbol);
   if (!EQ (value, Qunbound))
@@ -1424,8 +1426,8 @@
 usage: (setq-default [VAR VALUE]...)  */)
   (Lisp_Object args)
 {
-  register Lisp_Object args_left;
-  register Lisp_Object val, symbol;
+  Lisp_Object args_left;
+  Lisp_Object val, symbol;
   struct gcpro gcpro1;
 
   if (NILP (args))
@@ -1496,7 +1498,7 @@
 which makes a variable local in just one buffer.
 
 The function `default-value' gets the default value and `set-default' sets it.  */)
-  (register Lisp_Object variable)
+  (Lisp_Object variable)
 {
   struct Lisp_Symbol *sym;
   struct Lisp_Buffer_Local_Value *blv = NULL;
@@ -1573,9 +1575,9 @@
 
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.  */)
-  (register Lisp_Object variable)
+  (Lisp_Object variable)
 {
-  register Lisp_Object tem;
+  Lisp_Object tem;
   int forwarded IF_LINT (= 0);
   union Lisp_Val_Fwd valcontents IF_LINT (= {0});
   struct Lisp_Symbol *sym;
@@ -1674,9 +1676,9 @@
        1, 1, "vKill Local Variable: ",
        doc: /* Make VARIABLE no longer have a separate value in the current buffer.
 From now on the default value will apply in this buffer.  Return VARIABLE.  */)
-  (register Lisp_Object variable)
+  (Lisp_Object variable)
 {
-  register Lisp_Object tem;
+  Lisp_Object tem;
   struct Lisp_Buffer_Local_Value *blv;
   struct Lisp_Symbol *sym;
 
@@ -1762,7 +1764,7 @@
 Note that since Emacs 23.1, variables cannot be both buffer-local and
 frame-local any more (buffer-local bindings used to take precedence over
 frame-local bindings).  */)
-  (register Lisp_Object variable)
+  (Lisp_Object variable)
 {
   int forwarded;
   union Lisp_Val_Fwd valcontents;
@@ -1817,9 +1819,9 @@
        1, 2, 0,
        doc: /* Non-nil if VARIABLE has a local binding in buffer BUFFER.
 BUFFER defaults to the current buffer.  */)
-  (register Lisp_Object variable, Lisp_Object buffer)
+  (Lisp_Object variable, Lisp_Object buffer)
 {
-  register struct buffer *buf;
+  struct buffer *buf;
   struct Lisp_Symbol *sym;
 
   if (NILP (buffer))
@@ -1882,7 +1884,7 @@
 will produce a buffer local binding.  See Info node
 `(elisp)Creating Buffer-Local'.
 BUFFER defaults to the current buffer.  */)
-  (register Lisp_Object variable, Lisp_Object buffer)
+  (Lisp_Object variable, Lisp_Object buffer)
 {
   struct Lisp_Symbol *sym;
 
@@ -1915,7 +1917,7 @@
 If the current binding is buffer-local, the value is the current buffer.
 If the current binding is frame-local, the value is the selected frame.
 If the current binding is global (the default), the value is nil.  */)
-  (register Lisp_Object variable)
+  (Lisp_Object variable)
 {
   struct Lisp_Symbol *sym;
 
@@ -2005,7 +2007,7 @@
    This is like Findirect_function, except that it doesn't signal an
    error if the chain ends up unbound.  */
 Lisp_Object
-indirect_function (register Lisp_Object object)
+indirect_function (Lisp_Object object)
 {
   Lisp_Object tortoise, hare;
 
@@ -2037,7 +2039,7 @@
 Optional arg NOERROR non-nil means to return nil instead of signaling.
 Signal a cyclic-function-indirection error if there is a loop in the
 function chain of symbols.  */)
-  (register Lisp_Object object, Lisp_Object noerror)
+  (Lisp_Object object, Lisp_Object noerror)
 {
   Lisp_Object result;
 
@@ -2061,9 +2063,9 @@
        doc: /* Return the element of ARRAY at index IDX.
 ARRAY may be a vector, a string, a char-table, a bool-vector,
 or a byte-code object.  IDX starts at 0.  */)
-  (register Lisp_Object array, Lisp_Object idx)
+  (Lisp_Object array, Lisp_Object idx)
 {
-  register EMACS_INT idxval;
+  EMACS_INT idxval;
 
   CHECK_NUMBER (idx);
   idxval = XINT (idx);
@@ -2116,9 +2118,9 @@
        doc: /* Store into the element of ARRAY at index IDX the value NEWELT.
 Return NEWELT.  ARRAY may be a vector, a string, a char-table or a
 bool-vector.  IDX starts at 0.  */)
-  (register Lisp_Object array, Lisp_Object idx, Lisp_Object newelt)
+  (Lisp_Object array, Lisp_Object idx, Lisp_Object newelt)
 {
-  register EMACS_INT idxval;
+  EMACS_INT idxval;
 
   CHECK_NUMBER (idx);
   idxval = XINT (idx);
@@ -2272,21 +2274,21 @@
 
 DEFUN ("=", Feqlsign, Seqlsign, 2, 2, 0,
        doc: /* Return t if two args, both numbers or markers, are equal.  */)
-  (register Lisp_Object num1, Lisp_Object num2)
+  (Lisp_Object num1, Lisp_Object num2)
 {
   return arithcompare (num1, num2, equal);
 }
 
 DEFUN ("<", Flss, Slss, 2, 2, 0,
        doc: /* Return t if first arg is less than second arg.  Both must be numbers or markers.  */)
-  (register Lisp_Object num1, Lisp_Object num2)
+  (Lisp_Object num1, Lisp_Object num2)
 {
   return arithcompare (num1, num2, less);
 }
 
 DEFUN (">", Fgtr, Sgtr, 2, 2, 0,
        doc: /* Return t if first arg is greater than second arg.  Both must be numbers or markers.  */)
-  (register Lisp_Object num1, Lisp_Object num2)
+  (Lisp_Object num1, Lisp_Object num2)
 {
   return arithcompare (num1, num2, grtr);
 }
@@ -2294,7 +2296,7 @@
 DEFUN ("<=", Fleq, Sleq, 2, 2, 0,
        doc: /* Return t if first arg is less than or equal to second arg.
 Both must be numbers or markers.  */)
-  (register Lisp_Object num1, Lisp_Object num2)
+  (Lisp_Object num1, Lisp_Object num2)
 {
   return arithcompare (num1, num2, less_or_equal);
 }
@@ -2302,21 +2304,21 @@
 DEFUN (">=", Fgeq, Sgeq, 2, 2, 0,
        doc: /* Return t if first arg is greater than or equal to second arg.
 Both must be numbers or markers.  */)
-  (register Lisp_Object num1, Lisp_Object num2)
+  (Lisp_Object num1, Lisp_Object num2)
 {
   return arithcompare (num1, num2, grtr_or_equal);
 }
 
 DEFUN ("/=", Fneq, Sneq, 2, 2, 0,
        doc: /* Return t if first arg is not equal to second arg.  Both must be numbers or markers.  */)
-  (register Lisp_Object num1, Lisp_Object num2)
+  (Lisp_Object num1, Lisp_Object num2)
 {
   return arithcompare (num1, num2, notequal);
 }
 
 DEFUN ("zerop", Fzerop, Szerop, 1, 1, 0,
        doc: /* Return t if NUMBER is zero.  */)
-  (register Lisp_Object number)
+  (Lisp_Object number)
 {
   CHECK_NUMBER_OR_FLOAT (number);
 
@@ -2468,10 +2470,10 @@
 If BASE, interpret STRING as a number in that base.  If BASE isn't
 present, base 10 is used.  BASE must be between 2 and 16 (inclusive).
 If the base used is not 10, STRING is always parsed as integer.  */)
-  (register Lisp_Object string, Lisp_Object base)
+  (Lisp_Object string, Lisp_Object base)
 {
-  register char *p;
-  register int b;
+  char *p;
+  int b;
   Lisp_Object val;
 
   CHECK_STRING (string);
@@ -2512,10 +2514,10 @@
 static Lisp_Object
 arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   ptrdiff_t argnum;
-  register EMACS_INT accum = 0;
-  register EMACS_INT next;
+  EMACS_INT accum = 0;
+  EMACS_INT next;
 
   int overflow = 0;
   ptrdiff_t ok_args;
@@ -2625,7 +2627,7 @@
 float_arith_driver (double accum, ptrdiff_t argnum, enum arithop code,
 		    ptrdiff_t nargs, Lisp_Object *args)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   double next;
 
   for (; argnum < nargs; argnum++)
@@ -2724,7 +2726,7 @@
 DEFUN ("%", Frem, Srem, 2, 2, 0,
        doc: /* Return remainder of X divided by Y.
 Both must be integers or markers.  */)
-  (register Lisp_Object x, Lisp_Object y)
+  (Lisp_Object x, Lisp_Object y)
 {
   Lisp_Object val;
 
@@ -2764,7 +2766,7 @@
        doc: /* Return X modulo Y.
 The result falls between zero (inclusive) and Y (exclusive).
 Both X and Y must be numbers or markers.  */)
-  (register Lisp_Object x, Lisp_Object y)
+  (Lisp_Object x, Lisp_Object y)
 {
   Lisp_Object val;
   EMACS_INT i1, i2;
@@ -2840,9 +2842,9 @@
        doc: /* Return VALUE with its bits shifted left by COUNT.
 If COUNT is negative, shifting is actually to the right.
 In this case, the sign bit is duplicated.  */)
-  (register Lisp_Object value, Lisp_Object count)
+  (Lisp_Object value, Lisp_Object count)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
 
   CHECK_NUMBER (value);
   CHECK_NUMBER (count);
@@ -2862,9 +2864,9 @@
        doc: /* Return VALUE with its bits shifted left by COUNT.
 If COUNT is negative, shifting is actually to the right.
 In this case, zeros are shifted in on the left.  */)
-  (register Lisp_Object value, Lisp_Object count)
+  (Lisp_Object value, Lisp_Object count)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
 
   CHECK_NUMBER (value);
   CHECK_NUMBER (count);
@@ -2883,7 +2885,7 @@
 DEFUN ("1+", Fadd1, Sadd1, 1, 1, 0,
        doc: /* Return NUMBER plus one.  NUMBER may be a number or a marker.
 Markers are converted to integers.  */)
-  (register Lisp_Object number)
+  (Lisp_Object number)
 {
   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (number);
 
@@ -2897,7 +2899,7 @@
 DEFUN ("1-", Fsub1, Ssub1, 1, 1, 0,
        doc: /* Return NUMBER minus one.  NUMBER may be a number or a marker.
 Markers are converted to integers.  */)
-  (register Lisp_Object number)
+  (Lisp_Object number)
 {
   CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (number);
 
@@ -2910,7 +2912,7 @@
 
 DEFUN ("lognot", Flognot, Slognot, 1, 1, 0,
        doc: /* Return the bitwise complement of NUMBER.  NUMBER must be an integer.  */)
-  (register Lisp_Object number)
+  (Lisp_Object number)
 {
   CHECK_NUMBER (number);
   XSETINT (number, ~XINT (number));

=== modified file 'src/dired.c'
--- src/dired.c	2012-04-22 00:53:32 +0000
+++ src/dired.c	2012-06-03 05:53:38 +0000
@@ -787,7 +787,7 @@
 static ptrdiff_t
 scmp (const char *s1, const char *s2, ptrdiff_t len)
 {
-  register ptrdiff_t l = len;
+  ptrdiff_t l = len;
 
   if (completion_ignore_case)
     {

=== modified file 'src/dispnew.c'
--- src/dispnew.c	2012-05-30 19:23:37 +0000
+++ src/dispnew.c	2012-06-03 05:53:38 +0000
@@ -848,7 +848,7 @@
    current matrix.  */
 
 void
-clear_current_matrices (register struct frame *f)
+clear_current_matrices (struct frame *f)
 {
   /* Clear frame current matrix, if we have one.  */
   if (f->current_matrix)
@@ -873,7 +873,7 @@
 /* Clear out all display lines of F for a coming redisplay.  */
 
 void
-clear_desired_matrices (register struct frame *f)
+clear_desired_matrices (struct frame *f)
 {
   if (f->desired_matrix)
     clear_glyph_matrix (f->desired_matrix);
@@ -4889,7 +4889,7 @@
   int *new_hash = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
   int *draw_cost = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
   int *old_draw_cost = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
-  register int i;
+  int i;
   int free_at_end_vpos = FRAME_LINES (frame);
   struct glyph_matrix *current_matrix = frame->current_matrix;
   struct glyph_matrix *desired_matrix = frame->desired_matrix;
@@ -5724,7 +5724,8 @@
    safe to change frame sizes while a redisplay is in progress.  */
 
 void
-change_frame_size (register struct frame *f, int newheight, int newwidth, int pretend, int delay, int safe)
+change_frame_size (struct frame *f, int newheight, int newwidth,
+		   int pretend, int delay, int safe)
 {
   Lisp_Object tail, frame;
 
@@ -5743,7 +5744,8 @@
 }
 
 static void
-change_frame_size_1 (register struct frame *f, int newheight, int newwidth, int pretend, int delay, int safe)
+change_frame_size_1 (struct frame *f, int newheight, int newwidth,
+		     int pretend, int delay, int safe)
 {
   int new_frame_total_cols;
   ptrdiff_t count = SPECPDL_INDEX ();

=== modified file 'src/doc.c'
--- src/doc.c	2012-05-31 06:06:42 +0000
+++ src/doc.c	2012-06-03 05:53:38 +0000
@@ -83,9 +83,9 @@
 get_doc_string (Lisp_Object filepos, int unibyte, int definition)
 {
   char *from, *to;
-  register int fd;
-  register char *name;
-  register char *p, *p1;
+  int fd;
+  char *name;
+  char *p, *p1;
   ptrdiff_t minsize;
   int offset;
   EMACS_INT position;
@@ -564,9 +564,9 @@
 {
   int fd;
   char buf[1024 + 1];
-  register int filled;
-  register EMACS_INT pos;
-  register char *p;
+  int filled;
+  EMACS_INT pos;
+  char *p;
   Lisp_Object sym;
   char *name;
   int skip_file = 0;
@@ -625,7 +625,7 @@
   pos = 0;
   while (1)
     {
-      register char *end;
+      char *end;
       if (filled < 512)
 	filled += emacs_read (fd, &buf[filled], sizeof buf - 1 - filled);
       if (!filled)
@@ -726,8 +726,8 @@
 {
   char *buf;
   int changed = 0;
-  register unsigned char *strp;
-  register char *bufp;
+  unsigned char *strp;
+  char *bufp;
   ptrdiff_t idx;
   ptrdiff_t bsize;
   Lisp_Object tem;

=== modified file 'src/doprnt.c'
--- src/doprnt.c	2012-02-10 18:58:48 +0000
+++ src/doprnt.c	2012-06-03 05:53:38 +0000
@@ -136,7 +136,7 @@
 	const char *format_end, va_list ap)
 {
   const char *fmt = format;	/* Pointer into format string */
-  register char *bufptr = buffer; /* Pointer into output buffer.. */
+  char *bufptr = buffer; /* Pointer into output buffer.. */
 
   /* Use this for sprintf unless we need something really big.  */
   char tembuf[DBL_MAX_10_EXP + 100];
@@ -150,7 +150,7 @@
   /* Buffer we have got with malloc.  */
   char *big_buffer = NULL;
 
-  register size_t tem;
+  size_t tem;
   char *string;
   char fixed_buffer[20];	/* Default buffer for small formatting. */
   char *fmtcpy;

=== modified file 'src/editfns.c'
--- src/editfns.c	2012-05-25 19:24:54 +0000
+++ src/editfns.c	2012-06-03 05:53:38 +0000
@@ -95,7 +95,7 @@
 init_editfns (void)
 {
   const char *user_name;
-  register char *p;
+  char *p;
   struct passwd *pw;	/* password entry for the current user */
   Lisp_Object tem;
 
@@ -192,9 +192,9 @@
 
 DEFUN ("string-to-char", Fstring_to_char, Sstring_to_char, 1, 1, 0,
        doc: /* Return the first character in STRING.  */)
-  (register Lisp_Object string)
+  (Lisp_Object string)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   CHECK_STRING (string);
   if (SCHARS (string))
     {
@@ -211,7 +211,7 @@
 static Lisp_Object
 buildmark (ptrdiff_t charpos, ptrdiff_t bytepos)
 {
-  register Lisp_Object mark;
+  Lisp_Object mark;
   mark = Fmake_marker ();
   set_marker_both (mark, Qnil, charpos, bytepos);
   return mark;
@@ -239,7 +239,7 @@
 Beginning of buffer is position (point-min), end is (point-max).
 
 The return value is POSITION.  */)
-  (register Lisp_Object position)
+  (Lisp_Object position)
 {
   ptrdiff_t pos;
 
@@ -373,7 +373,7 @@
    window-specific overlays are considered only if they are associated
    with OBJECT. */
 Lisp_Object
-get_pos_property (Lisp_Object position, register Lisp_Object prop, Lisp_Object object)
+get_pos_property (Lisp_Object position, Lisp_Object prop, Lisp_Object object)
 {
   CHECK_NUMBER_COERCE_MARKER (position);
 
@@ -950,7 +950,7 @@
 usage: (save-excursion &rest BODY)  */)
   (Lisp_Object args)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   ptrdiff_t count = SPECPDL_INDEX ();
 
   record_unwind_protect (save_excursion_restore, save_excursion_save ());
@@ -1146,7 +1146,7 @@
 If POS is out of range, the value is nil.  */)
   (Lisp_Object pos)
 {
-  register ptrdiff_t pos_byte;
+  ptrdiff_t pos_byte;
 
   if (NILP (pos))
     {
@@ -1178,8 +1178,8 @@
 If POS is out of range, the value is nil.  */)
   (Lisp_Object pos)
 {
-  register Lisp_Object val;
-  register ptrdiff_t pos_byte;
+  Lisp_Object val;
+  ptrdiff_t pos_byte;
 
   if (NILP (pos))
     {
@@ -1291,7 +1291,7 @@
   (Lisp_Object uid)
 {
   struct passwd *pw;
-  register char *p, *q;
+  char *p, *q;
   Lisp_Object full;
 
   if (NILP (uid))
@@ -1327,7 +1327,7 @@
   /* Substitute the login name for the &, upcasing the first character.  */
   if (q)
     {
-      register char *r;
+      char *r;
       Lisp_Object login;
 
       login = Fuser_login_name (make_number (pw->pw_uid));
@@ -2185,7 +2185,7 @@
 			 int inherit, ptrdiff_t nargs, Lisp_Object *args)
 {
   ptrdiff_t argnum;
-  register Lisp_Object val;
+  Lisp_Object val;
 
   for (argnum = 0; argnum < nargs; argnum++)
     {
@@ -2317,7 +2317,7 @@
   (Lisp_Object character, Lisp_Object count, Lisp_Object inherit)
 {
   int i, stringlen;
-  register ptrdiff_t n;
+  ptrdiff_t n;
   int c, len;
   unsigned char str[MAX_MULTIBYTE_LENGTH];
   char string[4000];
@@ -2490,7 +2490,7 @@
 use `buffer-substring-no-properties' instead.  */)
   (Lisp_Object start, Lisp_Object end)
 {
-  register ptrdiff_t b, e;
+  ptrdiff_t b, e;
 
   validate_region (&start, &end);
   b = XINT (start);
@@ -2506,7 +2506,7 @@
 they can be in either order.  */)
   (Lisp_Object start, Lisp_Object end)
 {
-  register ptrdiff_t b, e;
+  ptrdiff_t b, e;
 
   validate_region (&start, &end);
   b = XINT (start);
@@ -2532,8 +2532,8 @@
 They default to the values of (point-min) and (point-max) in BUFFER.  */)
   (Lisp_Object buffer, Lisp_Object start, Lisp_Object end)
 {
-  register EMACS_INT b, e, temp;
-  register struct buffer *bp, *obuf;
+  EMACS_INT b, e, temp;
+  struct buffer *bp, *obuf;
   Lisp_Object buf;
 
   buf = Fget_buffer (buffer);
@@ -2585,9 +2585,9 @@
 determines whether case is significant or ignored.  */)
   (Lisp_Object buffer1, Lisp_Object start1, Lisp_Object end1, Lisp_Object buffer2, Lisp_Object start2, Lisp_Object end2)
 {
-  register EMACS_INT begp1, endp1, begp2, endp2, temp;
-  register struct buffer *bp1, *bp2;
-  register Lisp_Object trt
+  EMACS_INT begp1, endp1, begp2, endp2, temp;
+  struct buffer *bp1, *bp2;
+  Lisp_Object trt
     = (!NILP (BVAR (current_buffer, case_fold_search))
        ? BVAR (current_buffer, case_canon_table) : Qnil);
   ptrdiff_t chars = 0;
@@ -2752,7 +2752,7 @@
 Both characters must have the same length of multi-byte form.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object fromchar, Lisp_Object tochar, Lisp_Object noundo)
 {
-  register ptrdiff_t pos, pos_byte, stop, i, len, end_byte;
+  ptrdiff_t pos, pos_byte, stop, i, len, end_byte;
   /* Keep track of the first change in the buffer:
      if 0 we haven't found it yet.
      if < 0 we've found it and we've run the before-change-function.
@@ -2996,10 +2996,10 @@
 TABLE is a string or a char-table; the Nth character in it is the
 mapping for the character with code N.
 It returns the number of characters changed.  */)
-  (Lisp_Object start, Lisp_Object end, register Lisp_Object table)
+  (Lisp_Object start, Lisp_Object end, Lisp_Object table)
 {
-  register unsigned char *tt;	/* Trans table. */
-  register int nc;		/* New character. */
+  unsigned char *tt;	/* Trans table. */
+  int nc;		/* New character. */
   int cnt;			/* Number of changes made. */
   ptrdiff_t size;		/* Size of translate table. */
   ptrdiff_t pos, pos_byte, end_pos;
@@ -3033,7 +3033,7 @@
   cnt = 0;
   for (; pos < end_pos; )
     {
-      register unsigned char *p = BYTE_POS_ADDR (pos_byte);
+      unsigned char *p = BYTE_POS_ADDR (pos_byte);
       unsigned char *str, buf[MAX_MULTIBYTE_LENGTH];
       int len, str_len;
       int oc;
@@ -3199,7 +3199,7 @@
 
 When calling from a program, pass two arguments; positions (integers
 or markers) bounding the text that should remain visible.  */)
-  (register Lisp_Object start, Lisp_Object end)
+  (Lisp_Object start, Lisp_Object end)
 {
   CHECK_NUMBER_COERCE_MARKER (start);
   CHECK_NUMBER_COERCE_MARKER (end);
@@ -3337,7 +3337,7 @@
 usage: (save-restriction &rest BODY)  */)
   (Lisp_Object body)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   ptrdiff_t count = SPECPDL_INDEX ();
 
   record_unwind_protect (save_restriction_restore, save_restriction_save ());
@@ -3379,7 +3379,7 @@
     }
   else
     {
-      register Lisp_Object val;
+      Lisp_Object val;
       val = Fformat (nargs, args);
       message3 (val, SBYTES (val), STRING_MULTIBYTE (val));
       return val;
@@ -3405,7 +3405,7 @@
     }
   else
     {
-      register Lisp_Object val;
+      Lisp_Object val;
       val = Fformat (nargs, args);
 #ifdef HAVE_MENUS
       /* The MS-DOS frames support popup menus even though they are
@@ -3560,7 +3560,7 @@
   ptrdiff_t max_bufsize = STRING_BYTES_BOUND + 1;
   char *p;
   Lisp_Object buf_save_value IF_LINT (= {0});
-  register char *format, *end, *format_start;
+  char *format, *end, *format_start;
   ptrdiff_t formatlen, nchars;
   /* Nonzero if the format is multibyte.  */
   int multibyte_format = 0;
@@ -4314,7 +4314,7 @@
        doc: /* Return t if two characters match, optionally ignoring case.
 Both arguments must be characters (i.e. integers).
 Case is ignored if `case-fold-search' is non-nil in the current buffer.  */)
-  (register Lisp_Object c1, Lisp_Object c2)
+  (Lisp_Object c1, Lisp_Object c2)
 {
   int i1, i2;
   /* Check they're chars, not just integers, otherwise we could get array
@@ -4363,8 +4363,8 @@
 		   ptrdiff_t start1_byte, ptrdiff_t end1_byte,
 		   ptrdiff_t start2_byte, ptrdiff_t end2_byte)
 {
-  register ptrdiff_t amt1, amt1_byte, amt2, amt2_byte, diff, diff_byte, mpos;
-  register struct Lisp_Marker *marker;
+  ptrdiff_t amt1, amt1_byte, amt2, amt2_byte, diff, diff_byte, mpos;
+  struct Lisp_Marker *marker;
 
   /* Update point as if it were a marker.  */
   if (PT < start1)
@@ -4437,7 +4437,7 @@
 Transposing beyond buffer boundaries is an error.  */)
   (Lisp_Object startr1, Lisp_Object endr1, Lisp_Object startr2, Lisp_Object endr2, Lisp_Object leave_markers)
 {
-  register ptrdiff_t start1, end1, start2, end2;
+  ptrdiff_t start1, end1, start2, end2;
   ptrdiff_t start1_byte, start2_byte, len1_byte, len2_byte;
   ptrdiff_t gap, len1, len_mid, len2;
   unsigned char *start1_addr, *start2_addr, *temp;
@@ -4460,7 +4460,7 @@
   /* Swap the regions if they're reversed.  */
   if (start2 < end1)
     {
-      register ptrdiff_t glumph = start1;
+      ptrdiff_t glumph = start1;
       start1 = start2;
       start2 = glumph;
       glumph = end1;

=== modified file 'src/emacs.c'
--- src/emacs.c	2012-05-30 19:23:37 +0000
+++ src/emacs.c	2012-06-03 05:53:38 +0000
@@ -405,7 +405,7 @@
 static void
 init_cmdargs (int argc, char **argv, int skip_args)
 {
-  register int i;
+  int i;
   Lisp_Object name, dir, handler;
   ptrdiff_t count = SPECPDL_INDEX ();
   Lisp_Object raw_name;

=== modified file 'src/eval.c'
--- src/eval.c	2012-05-30 03:59:42 +0000
+++ src/eval.c	2012-06-03 05:53:38 +0000
@@ -254,7 +254,7 @@
 usage: (or CONDITIONS...)  */)
   (Lisp_Object args)
 {
-  register Lisp_Object val = Qnil;
+  Lisp_Object val = Qnil;
   struct gcpro gcpro1;
 
   GCPRO1 (args);
@@ -278,7 +278,7 @@
 usage: (and CONDITIONS...)  */)
   (Lisp_Object args)
 {
-  register Lisp_Object val = Qt;
+  Lisp_Object val = Qt;
   struct gcpro gcpro1;
 
   GCPRO1 (args);
@@ -303,7 +303,7 @@
 usage: (if COND THEN ELSE...)  */)
   (Lisp_Object args)
 {
-  register Lisp_Object cond;
+  Lisp_Object cond;
   struct gcpro gcpro1;
 
   GCPRO1 (args);
@@ -327,7 +327,7 @@
 usage: (cond CLAUSES...)  */)
   (Lisp_Object args)
 {
-  register Lisp_Object clause, val;
+  Lisp_Object clause, val;
   struct gcpro gcpro1;
 
   val = Qnil;
@@ -354,7 +354,7 @@
 usage: (progn BODY...)  */)
   (Lisp_Object args)
 {
-  register Lisp_Object val = Qnil;
+  Lisp_Object val = Qnil;
   struct gcpro gcpro1;
 
   GCPRO1 (args);
@@ -377,7 +377,7 @@
   (Lisp_Object args)
 {
   Lisp_Object val;
-  register Lisp_Object args_left;
+  Lisp_Object args_left;
   struct gcpro gcpro1, gcpro2;
 
   args_left = args;
@@ -418,8 +418,8 @@
 usage: (setq [SYM VAL]...)  */)
   (Lisp_Object args)
 {
-  register Lisp_Object args_left;
-  register Lisp_Object val, sym, lex_binding;
+  Lisp_Object args_left;
+  Lisp_Object val, sym, lex_binding;
   struct gcpro gcpro1;
 
   if (NILP (args))
@@ -680,7 +680,7 @@
 usage: (defvar SYMBOL &optional INITVALUE DOCSTRING)  */)
   (Lisp_Object args)
 {
-  register Lisp_Object sym, tem, tail;
+  Lisp_Object sym, tem, tail;
 
   sym = Fcar (args);
   tail = Fcdr (args);
@@ -767,7 +767,7 @@
 usage: (defconst SYMBOL INITVALUE [DOCSTRING])  */)
   (Lisp_Object args)
 {
-  register Lisp_Object sym, tem;
+  Lisp_Object sym, tem;
 
   sym = Fcar (args);
   if (!NILP (Fcdr (Fcdr (Fcdr (args)))))
@@ -863,7 +863,7 @@
   (Lisp_Object args)
 {
   Lisp_Object *temps, tem, lexenv;
-  register Lisp_Object elt, varlist;
+  Lisp_Object elt, varlist;
   ptrdiff_t count = SPECPDL_INDEX ();
   ptrdiff_t argnum;
   struct gcpro gcpro1, gcpro2;
@@ -959,7 +959,7 @@
   (Lisp_Object form, Lisp_Object environment)
 {
   /* With cleanups from Hallvard Furuseth.  */
-  register Lisp_Object expander, sym, def, tem;
+  Lisp_Object expander, sym, def, tem;
 
   while (1)
     {
@@ -1036,7 +1036,7 @@
 usage: (catch TAG BODY...)  */)
   (Lisp_Object args)
 {
-  register Lisp_Object tag;
+  Lisp_Object tag;
   struct gcpro gcpro1;
 
   GCPRO1 (args);
@@ -1097,7 +1097,7 @@
 static void
 unwind_to_catch (struct catchtag *catch, Lisp_Object value)
 {
-  register int last_time;
+  int last_time;
 
   /* Save the value in the tag.  */
   catch->val = value;
@@ -1144,9 +1144,9 @@
 DEFUN ("throw", Fthrow, Sthrow, 2, 2, 0,
        doc: /* Throw to the catch for TAG and return VALUE from it.
 Both TAG and VALUE are evalled.  */)
-  (register Lisp_Object tag, Lisp_Object value)
+  (Lisp_Object tag, Lisp_Object value)
 {
-  register struct catchtag *c;
+  struct catchtag *c;
 
   if (!NILP (tag))
     for (c = catchlist; c; c = c->next)
@@ -1202,7 +1202,7 @@
 usage: (condition-case VAR BODYFORM &rest HANDLERS)  */)
   (Lisp_Object args)
 {
-  register Lisp_Object bodyform, handlers;
+  Lisp_Object bodyform, handlers;
   volatile Lisp_Object var;
 
   var      = Fcar (args);
@@ -1482,7 +1482,7 @@
   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;
   struct backtrace *bp;
 
@@ -1739,7 +1739,7 @@
 static Lisp_Object
 find_handler_clause (Lisp_Object handlers, Lisp_Object conditions)
 {
-  register Lisp_Object h;
+  Lisp_Object h;
 
   /* t is used by handlers for all conditions, set up by C code.  */
   if (EQ (handlers, Qt))
@@ -1831,8 +1831,8 @@
 then strings and vectors are not accepted.  */)
   (Lisp_Object function, Lisp_Object for_call_interactively)
 {
-  register Lisp_Object fun;
-  register Lisp_Object funcar;
+  Lisp_Object fun;
+  Lisp_Object funcar;
   Lisp_Object if_prop = Qnil;
 
   fun = function;
@@ -1925,7 +1925,7 @@
 Lisp_Object
 un_autoload (Lisp_Object oldqueue)
 {
-  register Lisp_Object queue, first, second;
+  Lisp_Object queue, first, second;
 
   /* Queue to unwind is current value of Vautoload_queue.
      oldqueue is the shadowed value to leave in Vautoload_queue.  */
@@ -2083,7 +2083,7 @@
       Lisp_Object numargs;
       Lisp_Object argvals[8];
       Lisp_Object args_left;
-      register int i, maxargs;
+      int i, maxargs;
 
       args_left = original_args;
       numargs = Flength (args_left);
@@ -2235,8 +2235,8 @@
 {
   ptrdiff_t i;
   EMACS_INT numargs;
-  register Lisp_Object spread_arg;
-  register Lisp_Object *funcall_args;
+  Lisp_Object spread_arg;
+  Lisp_Object *funcall_args;
   Lisp_Object fun, retval;
   struct gcpro gcpro1;
   USE_SAFE_ALLOCA;
@@ -2730,7 +2730,7 @@
   Lisp_Object lisp_numargs;
   Lisp_Object val;
   struct backtrace backtrace;
-  register Lisp_Object *internal_args;
+  Lisp_Object *internal_args;
   ptrdiff_t i;
 
   QUIT;
@@ -2886,9 +2886,9 @@
   Lisp_Object args_left;
   ptrdiff_t i;
   EMACS_INT numargs;
-  register Lisp_Object *arg_vector;
+  Lisp_Object *arg_vector;
   struct gcpro gcpro1, gcpro2, gcpro3;
-  register Lisp_Object tem;
+  Lisp_Object tem;
   USE_SAFE_ALLOCA;
 
   numargs = XFASTINT (Flength (args));
@@ -2927,7 +2927,7 @@
 
 static Lisp_Object
 funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
-		register Lisp_Object *arg_vector)
+		Lisp_Object *arg_vector)
 {
   Lisp_Object val, syms_left, next, lexenv;
   ptrdiff_t count = SPECPDL_INDEX ();
@@ -3069,7 +3069,7 @@
 static void
 grow_specpdl (void)
 {
-  register ptrdiff_t count = SPECPDL_INDEX ();
+  ptrdiff_t count = SPECPDL_INDEX ();
   ptrdiff_t max_size = min (max_specpdl_size, PTRDIFF_MAX);
   if (max_size <= specpdl_size)
     {
@@ -3287,8 +3287,8 @@
 The debugger is entered when that frame exits, if the flag is non-nil.  */)
   (Lisp_Object level, Lisp_Object flag)
 {
-  register struct backtrace *backlist = backtrace_list;
-  register EMACS_INT i;
+  struct backtrace *backlist = backtrace_list;
+  EMACS_INT i;
 
   CHECK_NUMBER (level);
 
@@ -3308,7 +3308,7 @@
 Output stream used is value of `standard-output'.  */)
   (void)
 {
-  register struct backtrace *backlist = backtrace_list;
+  struct backtrace *backlist = backtrace_list;
   Lisp_Object tail;
   Lisp_Object tem;
   struct gcpro gcpro1;
@@ -3375,8 +3375,8 @@
 If NFRAMES is more than the number of frames, the value is nil.  */)
   (Lisp_Object nframes)
 {
-  register struct backtrace *backlist = backtrace_list;
-  register EMACS_INT i;
+  struct backtrace *backlist = backtrace_list;
+  EMACS_INT i;
   Lisp_Object tem;
 
   CHECK_NATNUM (nframes);
@@ -3405,7 +3405,7 @@
 void
 mark_backtrace (void)
 {
-  register struct backtrace *backlist;
+  struct backtrace *backlist;
   ptrdiff_t i;
 
   for (backlist = backtrace_list; backlist; backlist = backlist->next)

=== modified file 'src/fileio.c'
--- src/fileio.c	2012-06-01 03:41:03 +0000
+++ src/fileio.c	2012-06-03 05:53:38 +0000
@@ -315,11 +315,11 @@
   (Lisp_Object filename)
 {
 #ifndef DOS_NT
-  register const char *beg;
+  const char *beg;
 #else
-  register char *beg;
+  char *beg;
 #endif
-  register const char *p;
+  const char *p;
   Lisp_Object handler;
 
   CHECK_STRING (filename);
@@ -392,7 +392,7 @@
 or the entire name if it contains no slash.  */)
   (Lisp_Object filename)
 {
-  register const char *beg, *p, *end;
+  const char *beg, *p, *end;
   Lisp_Object handler;
 
   CHECK_STRING (filename);
@@ -1360,7 +1360,7 @@
 {
   unsigned char *nm;
 
-  register unsigned char *newdir, *p, *o;
+  unsigned char *newdir, *p, *o;
   ptrdiff_t tlen;
   unsigned char *target;
   struct passwd *pw;
@@ -1566,7 +1566,7 @@
 {
   char *nm;
 
-  register char *s, *p, *o, *x, *endp;
+  char *s, *p, *o, *x, *endp;
   char *target = NULL;
   int total = 0;
   int substituted = 0;
@@ -1769,7 +1769,7 @@
 Lisp_Object
 expand_and_dir_to_file (Lisp_Object filename, Lisp_Object defdir)
 {
-  register Lisp_Object absname;
+  Lisp_Object absname;
 
   absname = Fexpand_file_name (filename, defdir);
 
@@ -1799,7 +1799,7 @@
 barf_or_query_if_file_exists (Lisp_Object absname, const char *querystring,
 			      int interactive, struct stat *statptr, int quick)
 {
-  register Lisp_Object tem, encoded_filename;
+  Lisp_Object tem, encoded_filename;
   struct stat statbuf;
   struct gcpro gcpro1;
 
@@ -2708,7 +2708,7 @@
 See `file-symlink-p' to distinguish symlinks.  */)
   (Lisp_Object filename)
 {
-  register Lisp_Object absname;
+  Lisp_Object absname;
   struct stat st;
   Lisp_Object handler;
 
@@ -2762,7 +2762,7 @@
 See `file-symlink-p' to distinguish symlinks.  */)
   (Lisp_Object filename)
 {
-  register Lisp_Object absname;
+  Lisp_Object absname;
   struct stat st;
   Lisp_Object handler;
 
@@ -3252,12 +3252,12 @@
   (Lisp_Object filename, Lisp_Object visit, Lisp_Object beg, Lisp_Object end, Lisp_Object replace)
 {
   struct stat st;
-  register int fd;
+  int fd;
   ptrdiff_t inserted = 0;
   int nochange = 0;
-  register ptrdiff_t how_much;
+  ptrdiff_t how_much;
   off_t beg_offset, end_offset;
-  register int unprocessed;
+  int unprocessed;
   ptrdiff_t count = SPECPDL_INDEX ();
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
   Lisp_Object handler, val, insval, orig_filename, old_undo;
@@ -4539,7 +4539,7 @@
 `write-region-post-annotation-function' at the end.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object filename, Lisp_Object append, Lisp_Object visit, Lisp_Object lockname, Lisp_Object mustbenew)
 {
-  register int desc;
+  int desc;
   int failure;
   int save_errno = 0;
   const char *fn;
@@ -4945,7 +4945,7 @@
 
 static int
 a_write (int desc, Lisp_Object string, ptrdiff_t pos,
-	 register ptrdiff_t nchars, Lisp_Object *annot,
+	 ptrdiff_t nchars, Lisp_Object *annot,
 	 struct coding_system *coding)
 {
   Lisp_Object tem;
@@ -5162,7 +5162,7 @@
     }
   else
     {
-      register Lisp_Object filename;
+      Lisp_Object filename;
       struct stat st;
       Lisp_Object handler;

=== modified file 'src/filelock.c'
--- src/filelock.c	2012-05-10 00:55:57 +0000
+++ src/filelock.c	2012-06-03 05:53:38 +0000
@@ -298,9 +298,9 @@
    fill_in_lock_file_name (lock, (file)))
 
 static void
-fill_in_lock_file_name (register char *lockfile, register Lisp_Object fn)
+fill_in_lock_file_name (char *lockfile, Lisp_Object fn)
 {
-  register char *p;
+  char *p;
   struct stat st;
   int count = 0;
 
@@ -336,7 +336,7 @@
 static int
 lock_file_1 (char *lfname, int force)
 {
-  register int err;
+  int err;
   printmax_t boot, pid;
   const char *user_name;
   const char *host_name;
@@ -497,7 +497,7 @@
    Return -1 if cannot lock for any other reason.  */
 
 static int
-lock_if_free (lock_info_type *clasher, register char *lfname)
+lock_if_free (lock_info_type *clasher, char *lfname)
 {
   while (lock_file_1 (lfname, 0) == 0)
     {
@@ -542,8 +542,8 @@
 void
 lock_file (Lisp_Object fn)
 {
-  register Lisp_Object attack, orig_fn, encoded_fn;
-  register char *lfname, *locker;
+  Lisp_Object attack, orig_fn, encoded_fn;
+  char *lfname, *locker;
   ptrdiff_t locker_size;
   lock_info_type lock_info;
   printmax_t pid;
@@ -571,7 +571,7 @@
   /* See if this file is visited and has changed on disk since it was
      visited.  */
   {
-    register Lisp_Object subject_buf;
+    Lisp_Object subject_buf;
 
     subject_buf = get_truename_buffer (orig_fn);
 
@@ -610,9 +610,9 @@
 }
 
 void
-unlock_file (register Lisp_Object fn)
+unlock_file (Lisp_Object fn)
 {
-  register char *lfname;
+  char *lfname;
 
   fn = Fexpand_file_name (fn, Qnil);
   fn = ENCODE_FILE (fn);
@@ -626,8 +626,8 @@
 void
 unlock_all_files (void)
 {
-  register Lisp_Object tail;
-  register struct buffer *b;
+  Lisp_Object tail;
+  struct buffer *b;
 
   for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
     {
@@ -686,7 +686,7 @@
   (Lisp_Object filename)
 {
   Lisp_Object ret;
-  register char *lfname;
+  char *lfname;
   int owner;
   lock_info_type locker;

=== modified file 'src/floatfns.c'
--- src/floatfns.c	2012-02-10 18:58:48 +0000
+++ src/floatfns.c	2012-06-03 05:53:38 +0000
@@ -205,7 +205,7 @@
 
 DEFUN ("acos", Facos, Sacos, 1, 1, 0,
        doc: /* Return the inverse cosine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -218,7 +218,7 @@
 
 DEFUN ("asin", Fasin, Sasin, 1, 1, 0,
        doc: /* Return the inverse sine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -235,7 +235,7 @@
 If two arguments Y and X are given, return the inverse tangent of Y
 divided by X, i.e. the angle in radians between the vector (X, Y)
 and the x-axis.  */)
-  (register Lisp_Object y, Lisp_Object x)
+  (Lisp_Object y, Lisp_Object x)
 {
   double d = extract_float (y);
 
@@ -252,7 +252,7 @@
 
 DEFUN ("cos", Fcos, Scos, 1, 1, 0,
        doc: /* Return the cosine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = cos (d), "cos", arg);
@@ -261,7 +261,7 @@
 
 DEFUN ("sin", Fsin, Ssin, 1, 1, 0,
        doc: /* Return the sine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = sin (d), "sin", arg);
@@ -270,7 +270,7 @@
 
 DEFUN ("tan", Ftan, Stan, 1, 1, 0,
        doc: /* Return the tangent of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   double c = cos (d);
@@ -349,7 +349,7 @@
 
 DEFUN ("bessel-j0", Fbessel_j0, Sbessel_j0, 1, 1, 0,
        doc: /* Return the bessel function j0 of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = j0 (d), "bessel-j0", arg);
@@ -358,7 +358,7 @@
 
 DEFUN ("bessel-j1", Fbessel_j1, Sbessel_j1, 1, 1, 0,
        doc: /* Return the bessel function j1 of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = j1 (d), "bessel-j1", arg);
@@ -368,7 +368,7 @@
 DEFUN ("bessel-jn", Fbessel_jn, Sbessel_jn, 2, 2, 0,
        doc: /* Return the order N bessel function output jn of ARG.
 The first arg (the order) is truncated to an integer.  */)
-  (register Lisp_Object n, Lisp_Object arg)
+  (Lisp_Object n, Lisp_Object arg)
 {
   int i1 = extract_float (n);
   double f2 = extract_float (arg);
@@ -379,7 +379,7 @@
 
 DEFUN ("bessel-y0", Fbessel_y0, Sbessel_y0, 1, 1, 0,
        doc: /* Return the bessel function y0 of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = y0 (d), "bessel-y0", arg);
@@ -388,7 +388,7 @@
 
 DEFUN ("bessel-y1", Fbessel_y1, Sbessel_y1, 1, 1, 0,
        doc: /* Return the bessel function y1 of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = y1 (d), "bessel-y0", arg);
@@ -398,7 +398,7 @@
 DEFUN ("bessel-yn", Fbessel_yn, Sbessel_yn, 2, 2, 0,
        doc: /* Return the order N bessel function output yn of ARG.
 The first arg (the order) is truncated to an integer.  */)
-  (register Lisp_Object n, Lisp_Object arg)
+  (Lisp_Object n, Lisp_Object arg)
 {
   int i1 = extract_float (n);
   double f2 = extract_float (arg);
@@ -413,7 +413,7 @@
 
 DEFUN ("erf", Ferf, Serf, 1, 1, 0,
        doc: /* Return the mathematical error function of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = erf (d), "erf", arg);
@@ -422,7 +422,7 @@
 
 DEFUN ("erfc", Ferfc, Serfc, 1, 1, 0,
        doc: /* Return the complementary error function of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = erfc (d), "erfc", arg);
@@ -431,7 +431,7 @@
 
 DEFUN ("log-gamma", Flog_gamma, Slog_gamma, 1, 1, 0,
        doc: /* Return the log gamma of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = lgamma (d), "log-gamma", arg);
@@ -440,7 +440,7 @@
 
 DEFUN ("cube-root", Fcube_root, Scube_root, 1, 1, 0,
        doc: /* Return the cube root of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef HAVE_CBRT
@@ -458,7 +458,7 @@
 
 DEFUN ("exp", Fexp, Sexp, 1, 1, 0,
        doc: /* Return the exponential base e of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -474,7 +474,7 @@
 
 DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0,
        doc: /* Return the exponential ARG1 ** ARG2.  */)
-  (register Lisp_Object arg1, Lisp_Object arg2)
+  (Lisp_Object arg1, Lisp_Object arg2)
 {
   double f1, f2, f3;
 
@@ -520,7 +520,7 @@
 DEFUN ("log", Flog, Slog, 1, 2, 0,
        doc: /* Return the natural logarithm of ARG.
 If the optional argument BASE is given, return log ARG using that base.  */)
-  (register Lisp_Object arg, Lisp_Object base)
+  (Lisp_Object arg, Lisp_Object base)
 {
   double d = extract_float (arg);
 
@@ -548,7 +548,7 @@
 
 DEFUN ("log10", Flog10, Slog10, 1, 1, 0,
        doc: /* Return the logarithm base 10 of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -561,7 +561,7 @@
 
 DEFUN ("sqrt", Fsqrt, Ssqrt, 1, 1, 0,
        doc: /* Return the square root of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -576,7 +576,7 @@
 
 DEFUN ("acosh", Facosh, Sacosh, 1, 1, 0,
        doc: /* Return the inverse hyperbolic cosine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -593,7 +593,7 @@
 
 DEFUN ("asinh", Fasinh, Sasinh, 1, 1, 0,
        doc: /* Return the inverse hyperbolic sine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef HAVE_INVERSE_HYPERBOLIC
@@ -606,7 +606,7 @@
 
 DEFUN ("atanh", Fatanh, Satanh, 1, 1, 0,
        doc: /* Return the inverse hyperbolic tangent of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -623,7 +623,7 @@
 
 DEFUN ("cosh", Fcosh, Scosh, 1, 1, 0,
        doc: /* Return the hyperbolic cosine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -636,7 +636,7 @@
 
 DEFUN ("sinh", Fsinh, Ssinh, 1, 1, 0,
        doc: /* Return the hyperbolic sine of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -649,7 +649,7 @@
 
 DEFUN ("tanh", Ftanh, Stanh, 1, 1, 0,
        doc: /* Return the hyperbolic tangent of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = tanh (d), "tanh", arg);
@@ -659,7 +659,7 @@
 
 DEFUN ("abs", Fabs, Sabs, 1, 1, 0,
        doc: /* Return the absolute value of ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   CHECK_NUMBER_OR_FLOAT (arg);
 
@@ -673,7 +673,7 @@
 
 DEFUN ("float", Ffloat, Sfloat, 1, 1, 0,
        doc: /* Return the floating point number equal to ARG.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   CHECK_NUMBER_OR_FLOAT (arg);
 
@@ -908,7 +908,7 @@
 DEFUN ("fceiling", Ffceiling, Sfceiling, 1, 1, 0,
        doc: /* Return the smallest integer no less than ARG, as a float.
 \(Round toward +inf.\)  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = ceil (d), "fceiling", arg);
@@ -918,7 +918,7 @@
 DEFUN ("ffloor", Fffloor, Sffloor, 1, 1, 0,
        doc: /* Return the largest integer no greater than ARG, as a float.
 \(Round towards -inf.\)  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = floor (d), "ffloor", arg);
@@ -927,7 +927,7 @@
 
 DEFUN ("fround", Ffround, Sfround, 1, 1, 0,
        doc: /* Return the nearest integer to ARG, as a float.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = emacs_rint (d), "fround", arg);
@@ -937,7 +937,7 @@
 DEFUN ("ftruncate", Fftruncate, Sftruncate, 1, 1, 0,
        doc: /* Truncate a floating point number to an integral float value.
 Rounds the value toward zero.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   double d = extract_float (arg);
   if (d >= 0.0)

=== modified file 'src/fns.c'
--- src/fns.c	2012-05-25 18:19:24 +0000
+++ src/fns.c	2012-06-03 05:53:38 +0000
@@ -115,9 +115,9 @@
 If the string contains multibyte characters, this is not necessarily
 the number of bytes in the string; it is the number of characters.
 To get the number of bytes, use `string-bytes'.  */)
-  (register Lisp_Object sequence)
+  (Lisp_Object sequence)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
 
   if (STRINGP (sequence))
     XSETFASTINT (val, SCHARS (sequence));
@@ -214,7 +214,7 @@
        doc: /* Return t if two strings have identical contents.
 Case is significant, but text properties are ignored.
 Symbols are also allowed; their print names are used instead.  */)
-  (register Lisp_Object s1, Lisp_Object s2)
+  (Lisp_Object s1, Lisp_Object s2)
 {
   if (SYMBOLP (s1))
     s1 = SYMBOL_NAME (s1);
@@ -246,8 +246,8 @@
   N - 1 is the number of characters that match at the beginning.  */)
   (Lisp_Object str1, Lisp_Object start1, Lisp_Object end1, Lisp_Object str2, Lisp_Object start2, Lisp_Object end2, Lisp_Object ignore_case)
 {
-  register ptrdiff_t end1_char, end2_char;
-  register ptrdiff_t i1, i1_byte, i2, i2_byte;
+  ptrdiff_t end1_char, end2_char;
+  ptrdiff_t i1, i1_byte, i2, i2_byte;
 
   CHECK_STRING (str1);
   CHECK_STRING (str2);
@@ -339,10 +339,10 @@
        doc: /* Return t if first arg string is less than second in lexicographic order.
 Case is significant.
 Symbols are also allowed; their print names are used instead.  */)
-  (register Lisp_Object s1, Lisp_Object s2)
+  (Lisp_Object s1, Lisp_Object s2)
 {
-  register ptrdiff_t end;
-  register ptrdiff_t i1, i1_byte, i2, i2_byte;
+  ptrdiff_t end;
+  ptrdiff_t i1, i1_byte, i2, i2_byte;
 
   if (SYMBOLP (s1))
     s1 = SYMBOL_NAME (s1);
@@ -474,12 +474,12 @@
 	enum Lisp_Type target_type, int last_special)
 {
   Lisp_Object val;
-  register Lisp_Object tail;
-  register Lisp_Object this;
+  Lisp_Object tail;
+  Lisp_Object this;
   ptrdiff_t toindex;
   ptrdiff_t toindex_byte = 0;
-  register EMACS_INT result_len;
-  register EMACS_INT result_len_byte;
+  EMACS_INT result_len;
+  EMACS_INT result_len_byte;
   ptrdiff_t argnum;
   Lisp_Object last_tail;
   Lisp_Object prev;
@@ -615,8 +615,8 @@
     {
       Lisp_Object thislen;
       ptrdiff_t thisleni = 0;
-      register ptrdiff_t thisindex = 0;
-      register ptrdiff_t thisindex_byte = 0;
+      ptrdiff_t thisindex = 0;
+      ptrdiff_t thisindex_byte = 0;
 
       this = args[argnum];
       if (!CONSP (this))
@@ -656,7 +656,7 @@
 	/* Copy element by element.  */
 	while (1)
 	  {
-	    register Lisp_Object elt;
+	    Lisp_Object elt;
 
 	    /* Fetch next element of `this' arg into `elt', or break if
 	       `this' is exhausted. */
@@ -1121,7 +1121,7 @@
 Elements of ALIST that are not conses are also shared.  */)
   (Lisp_Object alist)
 {
-  register Lisp_Object tem;
+  Lisp_Object tem;
 
   CHECK_LIST (alist);
   if (NILP (alist))
@@ -1129,7 +1129,7 @@
   alist = concat (1, &alist, Lisp_Cons, 0);
   for (tem = alist; CONSP (tem); tem = XCDR (tem))
     {
-      register Lisp_Object car;
+      Lisp_Object car;
       car = XCAR (tem);
 
       if (CONSP (car))
@@ -1149,7 +1149,7 @@
 The STRING argument may also be a vector.  In that case, the return
 value is a new vector that contains the elements between index FROM
 \(inclusive) and index TO (exclusive) of that vector argument.  */)
-  (Lisp_Object string, register Lisp_Object from, Lisp_Object to)
+  (Lisp_Object string, Lisp_Object from, Lisp_Object to)
 {
   Lisp_Object res;
   ptrdiff_t size;
@@ -1207,7 +1207,7 @@
 If FROM or TO is negative, it counts from the end.
 
 With one argument, just copy STRING without its properties.  */)
-  (Lisp_Object string, register Lisp_Object from, Lisp_Object to)
+  (Lisp_Object string, Lisp_Object from, Lisp_Object to)
 {
   ptrdiff_t size;
   EMACS_INT from_char, to_char;
@@ -1306,7 +1306,7 @@
 
 DEFUN ("elt", Felt, Selt, 2, 2, 0,
        doc: /* Return element of SEQUENCE at index N.  */)
-  (register Lisp_Object sequence, Lisp_Object n)
+  (Lisp_Object sequence, Lisp_Object n)
 {
   CHECK_NUMBER (n);
   if (CONSP (sequence) || NILP (sequence))
@@ -1320,12 +1320,12 @@
 DEFUN ("member", Fmember, Smember, 2, 2, 0,
        doc: /* Return non-nil if ELT is an element of LIST.  Comparison done with `equal'.
 The value is actually the tail of LIST whose car is ELT.  */)
-  (register Lisp_Object elt, Lisp_Object list)
+  (Lisp_Object elt, Lisp_Object list)
 {
-  register Lisp_Object tail;
+  Lisp_Object tail;
   for (tail = list; CONSP (tail); tail = XCDR (tail))
     {
-      register Lisp_Object tem;
+      Lisp_Object tem;
       CHECK_LIST_CONS (tail, list);
       tem = XCAR (tail);
       if (! NILP (Fequal (elt, tem)))
@@ -1338,7 +1338,7 @@
 DEFUN ("memq", Fmemq, Smemq, 2, 2, 0,
        doc: /* Return non-nil if ELT is an element of LIST.  Comparison done with `eq'.
 The value is actually the tail of LIST whose car is ELT.  */)
-  (register Lisp_Object elt, Lisp_Object list)
+  (Lisp_Object elt, Lisp_Object list)
 {
   while (1)
     {
@@ -1364,16 +1364,16 @@
 DEFUN ("memql", Fmemql, Smemql, 2, 2, 0,
        doc: /* Return non-nil if ELT is an element of LIST.  Comparison done with `eql'.
 The value is actually the tail of LIST whose car is ELT.  */)
-  (register Lisp_Object elt, Lisp_Object list)
+  (Lisp_Object elt, Lisp_Object list)
 {
-  register Lisp_Object tail;
+  Lisp_Object tail;
 
   if (!FLOATP (elt))
     return Fmemq (elt, list);
 
   for (tail = list; CONSP (tail); tail = XCDR (tail))
     {
-      register Lisp_Object tem;
+      Lisp_Object tem;
       CHECK_LIST_CONS (tail, list);
       tem = XCAR (tail);
       if (FLOATP (tem) && internal_equal (elt, tem, 0, 0))
@@ -1483,7 +1483,7 @@
 DEFUN ("rassq", Frassq, Srassq, 2, 2, 0,
        doc: /* Return non-nil if KEY is `eq' to the cdr of an element of LIST.
 The value is actually the first element of LIST whose cdr is KEY.  */)
-  (register Lisp_Object key, Lisp_Object list)
+  (Lisp_Object key, Lisp_Object list)
 {
   while (1)
     {
@@ -1553,10 +1553,10 @@
 If the first member of LIST is ELT, there is no way to remove it by side effect;
 therefore, write `(setq foo (delq element foo))'
 to be sure of changing the value of `foo'.  */)
-  (register Lisp_Object elt, Lisp_Object list)
+  (Lisp_Object elt, Lisp_Object list)
 {
-  register Lisp_Object tail, prev;
-  register Lisp_Object tem;
+  Lisp_Object tail, prev;
+  Lisp_Object tem;
 
   tail = list;
   prev = Qnil;
@@ -1704,7 +1704,7 @@
 Return the reversed list.  */)
   (Lisp_Object list)
 {
-  register Lisp_Object prev, tail, next;
+  Lisp_Object prev, tail, next;
 
   if (NILP (list)) return list;
   prev = Qnil;
@@ -1747,7 +1747,7 @@
   (Lisp_Object list, Lisp_Object predicate)
 {
   Lisp_Object front, back;
-  register Lisp_Object len, tem;
+  Lisp_Object len, tem;
   struct gcpro gcpro1, gcpro2;
   EMACS_INT length;
 
@@ -1773,9 +1773,9 @@
 merge (Lisp_Object org_l1, Lisp_Object org_l2, Lisp_Object pred)
 {
   Lisp_Object value;
-  register Lisp_Object tail;
+  Lisp_Object tail;
   Lisp_Object tem;
-  register Lisp_Object l1, l2;
+  Lisp_Object l1, l2;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 
   l1 = org_l1;
@@ -1880,9 +1880,9 @@
 otherwise the new PROP VAL pair is added.  The new plist is returned;
 use `(setq x (plist-put x prop val))' to be sure to use the new value.
 The PLIST is modified by side effects.  */)
-  (Lisp_Object plist, register Lisp_Object prop, Lisp_Object val)
+  (Lisp_Object plist, Lisp_Object prop, Lisp_Object val)
 {
-  register Lisp_Object tail, prev;
+  Lisp_Object tail, prev;
   Lisp_Object newcell;
   prev = Qnil;
   for (tail = plist; CONSP (tail) && CONSP (XCDR (tail));
@@ -1949,9 +1949,9 @@
 otherwise the new PROP VAL pair is added.  The new plist is returned;
 use `(setq x (lax-plist-put x prop val))' to be sure to use the new value.
 The PLIST is modified by side effects.  */)
-  (Lisp_Object plist, register Lisp_Object prop, Lisp_Object val)
+  (Lisp_Object plist, Lisp_Object prop, Lisp_Object val)
 {
-  register Lisp_Object tail, prev;
+  Lisp_Object tail, prev;
   Lisp_Object newcell;
   prev = Qnil;
   for (tail = plist; CONSP (tail) && CONSP (XCDR (tail));
@@ -1993,7 +1993,7 @@
 Numbers are compared by value, but integers cannot equal floats.
  (Use `=' if you want integers and floats to be able to be equal.)
 Symbols must match exactly.  */)
-  (register Lisp_Object o1, Lisp_Object o2)
+  (Lisp_Object o1, Lisp_Object o2)
 {
   return internal_equal (o1, o2, 0, 0) ? Qt : Qnil;
 }
@@ -2002,7 +2002,7 @@
        doc: /* Return t if two Lisp objects have similar structure and contents.
 This is like `equal' except that it compares the text properties
 of strings.  (`equal' ignores text properties.)  */)
-  (register Lisp_Object o1, Lisp_Object o2)
+  (Lisp_Object o1, Lisp_Object o2)
 {
   return internal_equal (o1, o2, 0, 1) ? Qt : Qnil;
 }
@@ -2012,7 +2012,7 @@
    PROPS, if non-nil, means compare string text properties too.  */
 
 static int
-internal_equal (register Lisp_Object o1, register Lisp_Object o2, int depth, int props)
+internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, int props)
 {
   if (depth > 200)
     error ("Stack overflow in equal");
@@ -2068,7 +2068,7 @@
 
     case Lisp_Vectorlike:
       {
-	register int i;
+	int i;
 	ptrdiff_t size = ASIZE (o1);
 	/* Pseudovectors have the type encoded in the size field, so this test
 	   actually checks that the objects have the same type as well as the
@@ -2136,11 +2136,11 @@
 ARRAY is a vector, string, char-table, or bool-vector.  */)
   (Lisp_Object array, Lisp_Object item)
 {
-  register ptrdiff_t size, idx;
+  ptrdiff_t size, idx;
 
   if (VECTORP (array))
     {
-      register Lisp_Object *p = XVECTOR (array)->contents;
+      Lisp_Object *p = XVECTOR (array)->contents;
       size = ASIZE (array);
       for (idx = 0; idx < size; idx++)
 	p[idx] = item;
@@ -2155,7 +2155,7 @@
     }
   else if (STRINGP (array))
     {
-      register unsigned char *p = SDATA (array);
+      unsigned char *p = SDATA (array);
       int charval;
       CHECK_CHARACTER (item);
       charval = XFASTINT (item);
@@ -2178,7 +2178,7 @@
     }
   else if (BOOL_VECTOR_P (array))
     {
-      register unsigned char *p = XBOOL_VECTOR (array)->data;
+      unsigned char *p = XBOOL_VECTOR (array)->data;
       size =
 	((XBOOL_VECTOR (array)->size + BOOL_VECTOR_BITS_PER_CHAR - 1)
 	 / BOOL_VECTOR_BITS_PER_CHAR);
@@ -2228,7 +2228,7 @@
   (ptrdiff_t nargs, Lisp_Object *args)
 {
   ptrdiff_t argnum;
-  register Lisp_Object tail, tem, val;
+  Lisp_Object tail, tem, val;
 
   val = tail = Qnil;
 
@@ -2268,9 +2268,9 @@
 static void
 mapcar1 (EMACS_INT leni, Lisp_Object *vals, Lisp_Object fn, Lisp_Object seq)
 {
-  register Lisp_Object tail;
+  Lisp_Object tail;
   Lisp_Object dummy;
-  register EMACS_INT i;
+  EMACS_INT i;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
   if (vals)
@@ -2349,10 +2349,10 @@
   (Lisp_Object function, Lisp_Object sequence, Lisp_Object separator)
 {
   Lisp_Object len;
-  register EMACS_INT leni;
+  EMACS_INT leni;
   EMACS_INT nargs;
   ptrdiff_t i;
-  register Lisp_Object *args;
+  Lisp_Object *args;
   struct gcpro gcpro1;
   Lisp_Object ret;
   USE_SAFE_ALLOCA;
@@ -2388,9 +2388,9 @@
 SEQUENCE may be a list, a vector, a bool-vector, or a string.  */)
   (Lisp_Object function, Lisp_Object sequence)
 {
-  register Lisp_Object len;
-  register EMACS_INT leni;
-  register Lisp_Object *args;
+  Lisp_Object len;
+  EMACS_INT leni;
+  Lisp_Object *args;
   Lisp_Object ret;
   USE_SAFE_ALLOCA;
 
@@ -2415,7 +2415,7 @@
 SEQUENCE may be a list, a vector, a bool-vector, or a string.  */)
   (Lisp_Object function, Lisp_Object sequence)
 {
-  register EMACS_INT leni;
+  EMACS_INT leni;
 
   leni = XFASTINT (Flength (sequence));
   if (CHAR_TABLE_P (sequence))
@@ -2450,7 +2450,7 @@
 is nil, and `use-dialog-box' is non-nil.  */)
   (Lisp_Object prompt)
 {
-  register Lisp_Object ans;
+  Lisp_Object ans;
   Lisp_Object args[2];
   struct gcpro gcpro1;
 
@@ -2552,7 +2552,7 @@
 SUBFEATURE can be used to check a specific subfeature of FEATURE.  */)
   (Lisp_Object feature, Lisp_Object subfeature)
 {
-  register Lisp_Object tem;
+  Lisp_Object tem;
   CHECK_SYMBOL (feature);
   tem = Fmemq (feature, Vfeatures);
   if (!NILP (tem) && !NILP (subfeature))
@@ -2566,7 +2566,7 @@
 particular subfeatures supported in this version of FEATURE.  */)
   (Lisp_Object feature, Lisp_Object subfeatures)
 {
-  register Lisp_Object tem;
+  Lisp_Object tem;
   CHECK_SYMBOL (feature);
   CHECK_LIST (subfeatures);
   if (!NILP (Vautoload_queue))
@@ -2613,7 +2613,7 @@
 The normal messages at start and end of loading FILENAME are suppressed.  */)
   (Lisp_Object feature, Lisp_Object filename, Lisp_Object noerror)
 {
-  register Lisp_Object tem;
+  Lisp_Object tem;
   struct gcpro gcpro1, gcpro2;
   int from_file = load_in_progress;
 
@@ -4581,8 +4581,8 @@
   ptrdiff_t size;
   EMACS_INT start_char = 0, end_char = 0;
   ptrdiff_t start_byte, end_byte;
-  register EMACS_INT b, e;
-  register struct buffer *bp;
+  EMACS_INT b, e;
+  struct buffer *bp;
   EMACS_INT temp;
   int digest_size;
   void *(*hash_func) (const char *, size_t, void *);

=== modified file 'src/frame.c'
--- src/frame.c	2012-06-01 03:41:03 +0000
+++ src/frame.c	2012-06-03 05:53:38 +0000
@@ -260,9 +260,9 @@
 make_frame (int mini_p)
 {
   Lisp_Object frame;
-  register struct frame *f;
-  register Lisp_Object root_window;
-  register Lisp_Object mini_window;
+  struct frame *f;
+  Lisp_Object root_window;
+  Lisp_Object mini_window;
 
   f = allocate_frame ();
   XSETFRAME (frame, f);
@@ -410,9 +410,10 @@
    default (the global minibuffer).  */
 
 struct frame *
-make_frame_without_minibuffer (register Lisp_Object mini_window, KBOARD *kb, Lisp_Object display)
+make_frame_without_minibuffer (Lisp_Object mini_window, KBOARD *kb,
+			       Lisp_Object display)
 {
-  register struct frame *f;
+  struct frame *f;
   struct gcpro gcpro1;
 
   if (!NILP (mini_window))
@@ -463,9 +464,9 @@
 {
   /* First make a frame containing just a root window, no minibuffer.  */
 
-  register struct frame *f = make_frame (0);
-  register Lisp_Object mini_window;
-  register Lisp_Object frame;
+  struct frame *f = make_frame (0);
+  Lisp_Object mini_window;
+  Lisp_Object frame;
 
   XSETFRAME (frame, f);
 
@@ -549,7 +550,7 @@
 static struct frame *
 make_terminal_frame (struct terminal *terminal)
 {
-  register struct frame *f;
+  struct frame *f;
   Lisp_Object frame;
   char name[sizeof "F" + INT_STRLEN_BOUND (printmax_t)];
 
@@ -1152,10 +1153,6 @@
   described for Fdelete_frame.  */
 Lisp_Object
 delete_frame (Lisp_Object frame, Lisp_Object force)
-     /* If we use `register' here, gcc-4.0.2 on amd64 using
-	-DUSE_LISP_UNION_TYPE complains further down that we're getting the
-	address of `force'.  Go figure.  */
-
 {
   struct frame *f;
   struct frame *sf = SELECTED_FRAME ();
@@ -1979,9 +1976,9 @@
 static
 #endif
 Lisp_Object
-get_frame_param (register struct frame *frame, Lisp_Object prop)
+get_frame_param (struct frame *frame, Lisp_Object prop)
 {
-  register Lisp_Object tem;
+  Lisp_Object tem;
 
   tem = Fassq (prop, frame->param_alist);
   if (EQ (tem, Qnil))
@@ -2027,7 +2024,7 @@
 void
 store_in_alist (Lisp_Object *alistptr, Lisp_Object prop, Lisp_Object val)
 {
-  register Lisp_Object tem;
+  Lisp_Object tem;
 
   tem = Fassq (prop, *alistptr);
   if (EQ (tem, Qnil))
@@ -2094,7 +2091,7 @@
 void
 store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
 {
-  register Lisp_Object old_alist_elt;
+  Lisp_Object old_alist_elt;
 
   /* The buffer-list parameters are stored in a special place and not
      in the alist.  All buffers must be live.  */
@@ -2377,7 +2374,7 @@
   (Lisp_Object frame, Lisp_Object alist)
 {
   FRAME_PTR f;
-  register Lisp_Object tail, prop, val;
+  Lisp_Object tail, prop, val;
 
   if (EQ (frame, Qnil))
     frame = selected_frame;
@@ -2567,7 +2564,7 @@
 but that the idea of the actual height of the frame should not be changed.  */)
   (Lisp_Object frame, Lisp_Object lines, Lisp_Object pretend)
 {
-  register struct frame *f;
+  struct frame *f;
 
   CHECK_TYPE_RANGED_INTEGER (int, lines);
   if (NILP (frame))
@@ -2595,7 +2592,7 @@
 but that the idea of the actual width of the frame should not be changed.  */)
   (Lisp_Object frame, Lisp_Object cols, Lisp_Object pretend)
 {
-  register struct frame *f;
+  struct frame *f;
   CHECK_TYPE_RANGED_INTEGER (int, cols);
   if (NILP (frame))
     frame = selected_frame;
@@ -2620,7 +2617,7 @@
        doc: /* Sets size of FRAME to COLS by ROWS, measured in characters.  */)
   (Lisp_Object frame, Lisp_Object cols, Lisp_Object rows)
 {
-  register struct frame *f;
+  struct frame *f;
 
   CHECK_LIVE_FRAME (frame);
   CHECK_TYPE_RANGED_INTEGER (int, cols);
@@ -2652,7 +2649,7 @@
 the rightmost or bottommost possible position (that stays within the screen).  */)
   (Lisp_Object frame, Lisp_Object xoffset, Lisp_Object yoffset)
 {
-  register struct frame *f;
+  struct frame *f;
 
   CHECK_LIVE_FRAME (frame);
   CHECK_TYPE_RANGED_INTEGER (int, xoffset);
@@ -2850,7 +2847,7 @@
 	  || EQ (prop, Qbackground_color)
 	  || EQ (prop, Qfont))
 	{
-	  register Lisp_Object param_index, old_value;
+	  Lisp_Object param_index, old_value;
 
 	  old_value = get_frame_param (f, prop);
 	  if (NILP (Fequal (val, old_value)))
@@ -2900,7 +2897,7 @@
 	continue;
       else
 	{
-	  register Lisp_Object param_index, old_value;
+	  Lisp_Object param_index, old_value;
 
 	  old_value = get_frame_param (f, prop);
 
@@ -3649,7 +3646,7 @@
 static Lisp_Object
 xrdb_get_resource (XrmDatabase rdb, Lisp_Object attribute, Lisp_Object class, Lisp_Object component, Lisp_Object subclass)
 {
-  register char *value;
+  char *value;
   char *name_key;
   char *class_key;
 
@@ -3781,7 +3778,7 @@
 x_get_arg (Display_Info *dpyinfo, Lisp_Object alist, Lisp_Object param,
 	   const char *attribute, const char *class, enum resource_types type)
 {
-  register Lisp_Object tem;
+  Lisp_Object tem;
 
   tem = Fassq (param, alist);
 
@@ -4008,7 +4005,7 @@
 int
 x_figure_window_size (struct frame *f, Lisp_Object parms, int toolbar_p)
 {
-  register Lisp_Object tem0, tem1, tem2;
+  Lisp_Object tem0, tem1, tem2;
   long window_prompting = 0;
   Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);

=== modified file 'src/gmalloc.c'
--- src/gmalloc.c	2012-05-21 15:36:54 +0000
+++ src/gmalloc.c	2012-06-03 05:53:38 +0000
@@ -702,7 +702,7 @@
 {
   void *result;
   size_t block, blocks, lastblocks, start;
-  register size_t i;
+  size_t i;
   struct list *next;
 
   /* ANSI C allows `malloc (0)' to either return NULL, or to return a
@@ -727,7 +727,7 @@
     {
       /* Small allocation to receive a fragment of a block.
 	 Determine the logarithm to base two of the fragment size. */
-      register size_t log = 1;
+      size_t log = 1;
       --size;
       while ((size /= 2) != 0)
 	++log;
@@ -991,14 +991,14 @@
 {
   int type;
   size_t block, blocks;
-  register size_t i;
+  size_t i;
   struct list *prev, *next;
   void *curbrk;
   const size_t lesscore_threshold
     /* Threshold of free space at which we will return some to the system.  */
     = FINAL_FREE_BLOCKS + 2 * __malloc_extra_blocks;
 
-  register struct alignlist *l;
+  struct alignlist *l;
 
   if (ptr == NULL)
     return;
@@ -1149,7 +1149,7 @@
 	  /* Now see if we can return stuff to the system.  */
 	  if (block + blocks == _heaplimit && blocks >= lesscore_threshold)
 	    {
-	      register size_t bytes = blocks * BLOCKSIZE;
+	      size_t bytes = blocks * BLOCKSIZE;
 	      _heaplimit -= blocks;
 	      (*__morecore) (-bytes);
 	      _heapinfo[_heapinfo[block].free.prev].free.next
@@ -1493,9 +1493,9 @@
 /* Allocate an array of NMEMB elements each SIZE bytes long.
    The entire array is initialized to zeros.  */
 void *
-calloc (register size_t nmemb, register size_t size)
+calloc (size_t nmemb, size_t size)
 {
-  register void *result = malloc (nmemb * size);
+  void *result = malloc (nmemb * size);
 
   if (result != NULL)
     (void) memset (result, 0, nmemb * size);

=== modified file 'src/indent.c'
--- src/indent.c	2012-04-22 00:53:32 +0000
+++ src/indent.c	2012-06-03 05:53:38 +0000
@@ -321,14 +321,14 @@
 ptrdiff_t
 current_column (void)
 {
-  register ptrdiff_t col;
-  register unsigned char *ptr, *stop;
-  register int tab_seen;
+  ptrdiff_t col;
+  unsigned char *ptr, *stop;
+  int tab_seen;
   ptrdiff_t post_tab;
-  register int c;
+  int c;
   int tab_width = SANE_TAB_WIDTH (current_buffer);
   int ctl_arrow = !NILP (BVAR (current_buffer, ctl_arrow));
-  register struct Lisp_Char_Table *dp = buffer_display_table ();
+  struct Lisp_Char_Table *dp = buffer_display_table ();
 
   if (PT == last_known_column_point
       && MODIFF == last_known_column_modified)
@@ -514,15 +514,15 @@
 scan_for_column (ptrdiff_t *endpos, EMACS_INT *goalcol, ptrdiff_t *prevcol)
 {
   int tab_width = SANE_TAB_WIDTH (current_buffer);
-  register int ctl_arrow = !NILP (BVAR (current_buffer, ctl_arrow));
-  register struct Lisp_Char_Table *dp = buffer_display_table ();
+  int ctl_arrow = !NILP (BVAR (current_buffer, ctl_arrow));
+  struct Lisp_Char_Table *dp = buffer_display_table ();
   int multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
   struct composition_it cmp_it;
   Lisp_Object window;
   struct window *w;
 
   /* Start the scan at the beginning of this line with column number 0.  */
-  register ptrdiff_t col = 0, prev_col = 0;
+  ptrdiff_t col = 0, prev_col = 0;
   EMACS_INT goal = goalcol ? *goalcol : MOST_POSITIVE_FIXNUM;
   ptrdiff_t end = endpos ? *endpos : PT;
   ptrdiff_t scan, scan_byte;
@@ -724,14 +724,14 @@
 static double
 string_display_width (Lisp_Object string, Lisp_Object beg, Lisp_Object end)
 {
-  register int col;
-  register unsigned char *ptr, *stop;
-  register int tab_seen;
+  int col;
+  unsigned char *ptr, *stop;
+  int tab_seen;
   int post_tab;
-  register int c;
+  int c;
   int tab_width = SANE_TAB_WIDTH (current_buffer);
   int ctl_arrow = !NILP (current_buffer->ctl_arrow);
-  register struct Lisp_Char_Table *dp = buffer_display_table ();
+  struct Lisp_Char_Table *dp = buffer_display_table ();
   int b, e;
 
   if (NILP (end))
@@ -804,7 +804,7 @@
   (Lisp_Object column, Lisp_Object minimum)
 {
   EMACS_INT mincol;
-  register ptrdiff_t fromcol;
+  ptrdiff_t fromcol;
   int tab_width = SANE_TAB_WIDTH (current_buffer);
 
   CHECK_NUMBER (column);
@@ -863,10 +863,10 @@
 static ptrdiff_t
 position_indentation (ptrdiff_t pos_byte)
 {
-  register ptrdiff_t column = 0;
+  ptrdiff_t column = 0;
   int tab_width = SANE_TAB_WIDTH (current_buffer);
-  register unsigned char *p;
-  register unsigned char *stop;
+  unsigned char *p;
+  unsigned char *stop;
   unsigned char *start;
   ptrdiff_t next_boundary_byte = pos_byte;
   ptrdiff_t ceiling = next_boundary_byte;
@@ -1108,15 +1108,15 @@
 struct position *
 compute_motion (ptrdiff_t from, EMACS_INT fromvpos, EMACS_INT fromhpos, int did_motion, ptrdiff_t to, EMACS_INT tovpos, EMACS_INT tohpos, EMACS_INT width, ptrdiff_t hscroll, int tab_offset, struct window *win)
 {
-  register EMACS_INT hpos = fromhpos;
-  register EMACS_INT vpos = fromvpos;
+  EMACS_INT hpos = fromhpos;
+  EMACS_INT vpos = fromvpos;
 
-  register ptrdiff_t pos;
+  ptrdiff_t pos;
   ptrdiff_t pos_byte;
-  register int c = 0;
+  int c = 0;
   int tab_width = SANE_TAB_WIDTH (current_buffer);
-  register int ctl_arrow = !NILP (BVAR (current_buffer, ctl_arrow));
-  register struct Lisp_Char_Table *dp = window_display_table (win);
+  int ctl_arrow = !NILP (BVAR (current_buffer, ctl_arrow));
+  struct Lisp_Char_Table *dp = window_display_table (win);
   EMACS_INT selective
     = (INTEGERP (BVAR (current_buffer, selective_display))
        ? XINT (BVAR (current_buffer, selective_display))
@@ -1815,14 +1815,14 @@
 static struct position val_vmotion;
 
 struct position *
-vmotion (register ptrdiff_t from, register EMACS_INT vtarget, struct window *w)
+vmotion (ptrdiff_t from, EMACS_INT vtarget, struct window *w)
 {
   ptrdiff_t hscroll = XINT (w->hscroll);
   struct position pos;
   /* vpos is cumulative vertical position, changed as from is changed */
-  register EMACS_INT vpos = 0;
+  EMACS_INT vpos = 0;
   ptrdiff_t prevline;
-  register ptrdiff_t first;
+  ptrdiff_t first;
   ptrdiff_t from_byte;
   ptrdiff_t lmargin = hscroll > 0 ? 1 - hscroll : 0;
   ptrdiff_t selective

=== modified file 'src/insdel.c'
--- src/insdel.c	2012-05-25 18:19:24 +0000
+++ src/insdel.c	2012-06-03 05:53:38 +0000
@@ -73,7 +73,7 @@
 static void
 check_markers (void)
 {
-  register struct Lisp_Marker *tail;
+  struct Lisp_Marker *tail;
   int multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
 
   for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
@@ -118,8 +118,8 @@
 static void
 gap_left (ptrdiff_t charpos, ptrdiff_t bytepos, int newgap)
 {
-  register unsigned char *to, *from;
-  register ptrdiff_t i;
+  unsigned char *to, *from;
+  ptrdiff_t i;
   ptrdiff_t new_s1;
 
   if (!newgap)
@@ -173,8 +173,8 @@
 static void
 gap_right (ptrdiff_t charpos, ptrdiff_t bytepos)
 {
-  register unsigned char *to, *from;
-  register ptrdiff_t i;
+  unsigned char *to, *from;
+  ptrdiff_t i;
   ptrdiff_t new_s1;
 
   BUF_COMPUTE_UNCHANGED (current_buffer, charpos, GPT);
@@ -229,8 +229,8 @@
 			   ptrdiff_t to, ptrdiff_t to_byte)
 {
   Lisp_Object marker;
-  register struct Lisp_Marker *m;
-  register ptrdiff_t charpos;
+  struct Lisp_Marker *m;
+  ptrdiff_t charpos;
 
   for (m = BUF_MARKERS (current_buffer); m; m = m->next)
     {
@@ -358,7 +358,7 @@
 			    ptrdiff_t old_chars, ptrdiff_t old_bytes,
 			    ptrdiff_t new_chars, ptrdiff_t new_bytes)
 {
-  register struct Lisp_Marker *m;
+  struct Lisp_Marker *m;
   ptrdiff_t prev_to_byte = from_byte + old_bytes;
   ptrdiff_t diff_chars = new_chars - old_chars;
   ptrdiff_t diff_bytes = new_bytes - old_bytes;
@@ -1704,7 +1704,7 @@
 del_range_2 (ptrdiff_t from, ptrdiff_t from_byte,
 	     ptrdiff_t to, ptrdiff_t to_byte, int ret_string)
 {
-  register ptrdiff_t nbytes_del, nchars_del;
+  ptrdiff_t nbytes_del, nchars_del;
   Lisp_Object deletion;
 
   CHECK_MARKERS ();

=== modified file 'src/intervals.c'
--- src/intervals.c	2012-05-25 18:19:24 +0000
+++ src/intervals.c	2012-06-03 05:53:38 +0000
@@ -95,7 +95,7 @@
 /* Make the interval TARGET have exactly the properties of SOURCE */
 
 void
-copy_properties (register INTERVAL source, register INTERVAL target)
+copy_properties (INTERVAL source, INTERVAL target)
 {
   if (DEFAULT_INTERVAL_P (source) && DEFAULT_INTERVAL_P (target))
     return;
@@ -109,9 +109,9 @@
    is added to TARGET if TARGET has no such property as yet.  */
 
 static void
-merge_properties (register INTERVAL source, register INTERVAL target)
+merge_properties (INTERVAL source, INTERVAL target)
 {
-  register Lisp_Object o, sym, val;
+  Lisp_Object o, sym, val;
 
   if (DEFAULT_INTERVAL_P (source) && DEFAULT_INTERVAL_P (target))
     return;
@@ -149,8 +149,8 @@
 int
 intervals_equal (INTERVAL i0, INTERVAL i1)
 {
-  register Lisp_Object i0_cdr, i0_sym;
-  register Lisp_Object i1_cdr, i1_val;
+  Lisp_Object i0_cdr, i0_sym;
+  Lisp_Object i1_cdr, i1_val;
 
   if (DEFAULT_INTERVAL_P (i0) && DEFAULT_INTERVAL_P (i1))
     return 1;
@@ -290,7 +290,7 @@
 static INTERVAL
 root_interval (INTERVAL interval)
 {
-  register INTERVAL i = interval;
+  INTERVAL i = interval;
 
   while (! ROOT_INTERVAL_P (i))
     i = INTERVAL_PARENT (i);
@@ -399,7 +399,7 @@
 static INTERVAL
 balance_an_interval (INTERVAL i)
 {
-  register ptrdiff_t old_diff, new_diff;
+  ptrdiff_t old_diff, new_diff;
 
   while (1)
     {
@@ -434,7 +434,7 @@
    Lisp Object.  */
 
 static inline INTERVAL
-balance_possible_root_interval (register INTERVAL interval)
+balance_possible_root_interval (INTERVAL interval)
 {
   Lisp_Object parent;
   int have_parent = 0;
@@ -464,7 +464,7 @@
    (the amount of text).  */
 
 static INTERVAL
-balance_intervals_internal (register INTERVAL tree)
+balance_intervals_internal (INTERVAL tree)
 {
   /* Balance within each side.  */
   if (tree->left)
@@ -610,11 +610,11 @@
    will update this cache based on the result of find_interval.  */
 
 INTERVAL
-find_interval (register INTERVAL tree, register ptrdiff_t position)
+find_interval (INTERVAL tree, ptrdiff_t position)
 {
   /* The distance from the left edge of the subtree at TREE
                     to POSITION.  */
-  register ptrdiff_t relative_position;
+  ptrdiff_t relative_position;
 
   if (NULL_INTERVAL_P (tree))
     return NULL_INTERVAL;
@@ -664,10 +664,10 @@
    find_interval).  */
 
 INTERVAL
-next_interval (register INTERVAL interval)
+next_interval (INTERVAL interval)
 {
-  register INTERVAL i = interval;
-  register ptrdiff_t next_position;
+  INTERVAL i = interval;
+  ptrdiff_t next_position;
 
   if (NULL_INTERVAL_P (i))
     return NULL_INTERVAL;
@@ -703,9 +703,9 @@
    find_interval).  */
 
 INTERVAL
-previous_interval (register INTERVAL interval)
+previous_interval (INTERVAL interval)
 {
-  register INTERVAL i;
+  INTERVAL i;
 
   if (NULL_INTERVAL_P (interval))
     return NULL_INTERVAL;
@@ -742,7 +742,7 @@
    To speed up the process, we assume that the ->position of
    I and all its parents is already uptodate.  */
 INTERVAL
-update_interval (register INTERVAL i, ptrdiff_t pos)
+update_interval (INTERVAL i, ptrdiff_t pos)
 {
   if (NULL_INTERVAL_P (i))
     return NULL_INTERVAL;
@@ -802,8 +802,8 @@
 adjust_intervals_for_insertion (INTERVAL tree, ptrdiff_t position,
 				ptrdiff_t length)
 {
-  register ptrdiff_t relative_position;
-  register INTERVAL this;
+  ptrdiff_t relative_position;
+  INTERVAL this;
 
   if (TOTAL_LENGTH (tree) == 0)	/* Paranoia */
     abort ();
@@ -863,8 +863,8 @@
 adjust_intervals_for_insertion (INTERVAL tree,
 				ptrdiff_t position, ptrdiff_t length)
 {
-  register INTERVAL i;
-  register INTERVAL temp;
+  INTERVAL i;
+  INTERVAL temp;
   int eobp = 0;
   Lisp_Object parent;
   ptrdiff_t offset;
@@ -963,7 +963,7 @@
      both of them.  We have to do this too, if we are at BEG or Z.  */
   if (position == i->position || eobp)
     {
-      register INTERVAL prev;
+      INTERVAL prev;
 
       if (position == BEG)
 	prev = 0;
@@ -1089,9 +1089,9 @@
 static Lisp_Object
 merge_properties_sticky (Lisp_Object pleft, Lisp_Object pright)
 {
-  register Lisp_Object props, front, rear;
+  Lisp_Object props, front, rear;
   Lisp_Object lfront, lrear, rfront, rrear;
-  register Lisp_Object tail1, tail2, sym, lval, rval, cat;
+  Lisp_Object tail1, tail2, sym, lval, rval, cat;
   int use_left, use_right;
   int lpresent;
 
@@ -1223,10 +1223,10 @@
    storing the resulting subtree into its parent.  */
 
 static INTERVAL
-delete_node (register INTERVAL i)
+delete_node (INTERVAL i)
 {
-  register INTERVAL migrate, this;
-  register ptrdiff_t migrate_amt;
+  INTERVAL migrate, this;
+  ptrdiff_t migrate_amt;
 
   if (NULL_INTERVAL_P (i->left))
     return i->right;
@@ -1256,9 +1256,9 @@
    for the length of I.  */
 
 static void
-delete_interval (register INTERVAL i)
+delete_interval (INTERVAL i)
 {
-  register INTERVAL parent;
+  INTERVAL parent;
   ptrdiff_t amt = LENGTH (i);
 
   if (amt > 0)			/* Only used on zero-length intervals now.  */
@@ -1310,10 +1310,9 @@
    deleting the appropriate amount of text.  */
 
 static ptrdiff_t
-interval_deletion_adjustment (register INTERVAL tree, register ptrdiff_t from,
-			      register ptrdiff_t amount)
+interval_deletion_adjustment (INTERVAL tree, ptrdiff_t from, ptrdiff_t amount)
 {
-  register ptrdiff_t relative_position = from;
+  ptrdiff_t relative_position = from;
 
   if (NULL_INTERVAL_P (tree))
     return 0;
@@ -1374,8 +1373,8 @@
 adjust_intervals_for_deletion (struct buffer *buffer,
 			       ptrdiff_t start, ptrdiff_t length)
 {
-  register ptrdiff_t left_to_delete = length;
-  register INTERVAL tree = BUF_INTERVALS (buffer);
+  ptrdiff_t left_to_delete = length;
+  INTERVAL tree = BUF_INTERVALS (buffer);
   Lisp_Object parent;
   ptrdiff_t offset;
 
@@ -1451,10 +1450,10 @@
    interval.  */
 
 static INTERVAL
-merge_interval_right (register INTERVAL i)
+merge_interval_right (INTERVAL i)
 {
-  register ptrdiff_t absorb = LENGTH (i);
-  register INTERVAL successor;
+  ptrdiff_t absorb = LENGTH (i);
+  INTERVAL successor;
 
   /* Zero out this interval.  */
   i->total_length -= absorb;
@@ -1507,10 +1506,10 @@
    The caller must verify that this is not the first (leftmost) interval.  */
 
 INTERVAL
-merge_interval_left (register INTERVAL i)
+merge_interval_left (INTERVAL i)
 {
-  register ptrdiff_t absorb = LENGTH (i);
-  register INTERVAL predecessor;
+  ptrdiff_t absorb = LENGTH (i);
+  INTERVAL predecessor;
 
   /* Zero out this interval.  */
   i->total_length -= absorb;
@@ -1563,7 +1562,7 @@
 static INTERVAL
 reproduce_tree (INTERVAL source, INTERVAL parent)
 {
-  register INTERVAL t = make_interval ();
+  INTERVAL t = make_interval ();
 
   memcpy (t, source, INTERVAL_SIZE);
   copy_properties (source, t);
@@ -1579,7 +1578,7 @@
 static INTERVAL
 reproduce_tree_obj (INTERVAL source, Lisp_Object parent)
 {
-  register INTERVAL t = make_interval ();
+  INTERVAL t = make_interval ();
 
   memcpy (t, source, INTERVAL_SIZE);
   copy_properties (source, t);
@@ -1679,8 +1678,8 @@
 			     ptrdiff_t length, struct buffer *buffer,
 			     int inherit)
 {
-  register INTERVAL under, over, this;
-  register INTERVAL tree;
+  INTERVAL under, over, this;
+  INTERVAL tree;
   ptrdiff_t over_used;
 
   tree = BUF_INTERVALS (buffer);
@@ -1817,19 +1816,19 @@
    and for PROP appearing on the default-text-properties list.  */
 
 Lisp_Object
-textget (Lisp_Object plist, register Lisp_Object prop)
+textget (Lisp_Object plist, Lisp_Object prop)
 {
   return lookup_char_property (plist, prop, 1);
 }
 
 Lisp_Object
-lookup_char_property (Lisp_Object plist, register Lisp_Object prop, int textprop)
+lookup_char_property (Lisp_Object plist, Lisp_Object prop, int textprop)
 {
-  register Lisp_Object tail, fallback = Qnil;
+  Lisp_Object tail, fallback = Qnil;
 
   for (tail = plist; CONSP (tail); tail = Fcdr (XCDR (tail)))
     {
-      register Lisp_Object tem;
+      Lisp_Object tem;
       tem = XCAR (tail);
       if (EQ (prop, tem))
 	return Fcar (XCDR (tail));
@@ -1950,7 +1949,7 @@
 void
 set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
 {
-  register INTERVAL to, from, toprev, fromprev;
+  INTERVAL to, from, toprev, fromprev;
   ptrdiff_t buffer_point;
   ptrdiff_t old_position = PT;
   /* This ensures that we move forward past intangible text when the
@@ -2279,8 +2278,7 @@
    POSITION must be in the accessible part of BUFFER.  */
 
 Lisp_Object
-get_local_map (register ptrdiff_t position, register struct buffer *buffer,
-	       Lisp_Object type)
+get_local_map (ptrdiff_t position, struct buffer *buffer, Lisp_Object type)
 {
   Lisp_Object prop, lispy_position, lispy_buffer;
   ptrdiff_t old_begv, old_zv, old_begv_byte, old_zv_byte;
@@ -2332,8 +2330,8 @@
 INTERVAL
 copy_intervals (INTERVAL tree, ptrdiff_t start, ptrdiff_t length)
 {
-  register INTERVAL i, new, t;
-  register ptrdiff_t got, prevlen;
+  INTERVAL i, new, t;
+  ptrdiff_t got, prevlen;
 
   if (NULL_INTERVAL_P (tree) || length <= 0)
     return NULL_INTERVAL;

=== modified file 'src/keyboard.c'
--- src/keyboard.c	2012-06-02 19:21:34 +0000
+++ src/keyboard.c	2012-06-03 05:55:23 +0000
@@ -1149,7 +1149,7 @@
 Lisp_Object
 command_loop_2 (Lisp_Object ignore)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
 
   do
     val = internal_condition_case (command_loop_1, Qerror, cmd_error);
@@ -3500,7 +3500,7 @@
 #endif	/* Store an event obtained at interrupt level into kbd_buffer, fifo */
 
 void
-kbd_buffer_store_event (register struct input_event *event)
+kbd_buffer_store_event (struct input_event *event)
 {
   kbd_buffer_store_event_hold (event, 0);
 }
@@ -3518,7 +3518,7 @@
  */
 
 void
-kbd_buffer_store_event_hold (register struct input_event *event,
+kbd_buffer_store_event_hold (struct input_event *event,
 			     struct input_event *hold_quit)
 {
   if (event->kind == NO_EVENT)
@@ -3529,7 +3529,7 @@
 
   if (event->kind == ASCII_KEYSTROKE_EVENT)
     {
-      register int c = event->code & 0377;
+      int c = event->code & 0377;
 
       if (event->modifiers & ctrl_modifier)
 	c = make_ctrl_char (c);
@@ -3653,7 +3653,7 @@
 /* Put an input event back in the head of the event queue.  */
 
 void
-kbd_buffer_unget_event (register struct input_event *event)
+kbd_buffer_unget_event (struct input_event *event)
 {
   if (kbd_fetch_ptr == kbd_buffer)
     kbd_fetch_ptr = kbd_buffer + KBD_BUFFER_SIZE;
@@ -8550,7 +8550,7 @@
 			       ptrdiff_t nmaps, Lisp_Object *maps)
 {
   ptrdiff_t mapno;
-  register Lisp_Object name;
+  Lisp_Object name;
   ptrdiff_t nlength;
   /* FIXME: Use the minibuffer's frame width.  */
   ptrdiff_t width = FRAME_COLS (SELECTED_FRAME ()) - 4;
@@ -10161,7 +10161,7 @@
   (Lisp_Object prompt, Lisp_Object continue_echo, Lisp_Object dont_downcase_last, Lisp_Object can_return_switch_frame, Lisp_Object cmd_loop)
 {
   Lisp_Object keybuf[30];
-  register int i;
+  int i;
   struct gcpro gcpro1;
   ptrdiff_t count = SPECPDL_INDEX ();
 
@@ -10218,7 +10218,7 @@
   (Lisp_Object prompt, Lisp_Object continue_echo, Lisp_Object dont_downcase_last, Lisp_Object can_return_switch_frame, Lisp_Object cmd_loop)
 {
   Lisp_Object keybuf[30];
-  register int i;
+  int i;
   struct gcpro gcpro1;
   ptrdiff_t count = SPECPDL_INDEX ();
 
@@ -10277,8 +10277,8 @@
 a special event, so ignore the prefix argument and don't clear it.  */)
   (Lisp_Object cmd, Lisp_Object record_flag, Lisp_Object keys, Lisp_Object special)
 {
-  register Lisp_Object final;
-  register Lisp_Object tem;
+  Lisp_Object final;
+  Lisp_Object tem;
   Lisp_Object prefixarg;
 
   debug_on_next_call = 0;
@@ -10700,11 +10700,11 @@
 stuff_buffered_input (Lisp_Object stuffstring)
 {
 #ifdef SIGTSTP  /* stuff_char is defined if SIGTSTP.  */
-  register unsigned char *p;
+  unsigned char *p;
 
   if (STRINGP (stuffstring))
     {
-      register ptrdiff_t count;
+      ptrdiff_t count;
 
       p = SDATA (stuffstring);
       count = SBYTES (stuffstring);

=== modified file 'src/keymap.c'
--- src/keymap.c	2012-05-31 06:06:42 +0000
+++ src/keymap.c	2012-06-03 05:53:38 +0000
@@ -792,7 +792,7 @@
 }
 
 static Lisp_Object
-store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
+store_in_keymap (Lisp_Object keymap, Lisp_Object idx, Lisp_Object def)
 {
   /* Flush any reverse-map cache.  */
   where_is_cache = Qnil;
@@ -1046,7 +1046,7 @@
 is not copied.  */)
   (Lisp_Object keymap)
 {
-  register Lisp_Object copy, tail;
+  Lisp_Object copy, tail;
   keymap = get_keymap (keymap, 1, 0);
   copy = tail = Fcons (Qkeymap, Qnil);
   keymap = XCDR (keymap);		/* Skip the `keymap' symbol.  */
@@ -1117,9 +1117,9 @@
 binding KEY to DEF is added at the front of KEYMAP.  */)
   (Lisp_Object keymap, Lisp_Object key, Lisp_Object def)
 {
-  register ptrdiff_t idx;
-  register Lisp_Object c;
-  register Lisp_Object cmd;
+  ptrdiff_t idx;
+  Lisp_Object c;
+  Lisp_Object cmd;
   int metized = 0;
   int meta_bit;
   ptrdiff_t length;
@@ -1274,9 +1274,9 @@
 recognize the default bindings, just as `read-key-sequence' does.  */)
   (Lisp_Object keymap, Lisp_Object key, Lisp_Object accept_default)
 {
-  register ptrdiff_t idx;
-  register Lisp_Object cmd;
-  register Lisp_Object c;
+  ptrdiff_t idx;
+  Lisp_Object cmd;
+  Lisp_Object c;
   ptrdiff_t length;
   int t_ok = !NILP (accept_default);
   struct gcpro gcpro1, gcpro2;
@@ -1751,7 +1751,7 @@
 bindings; see the description of `lookup-key' for more details about this.  */)
   (Lisp_Object keys, Lisp_Object accept_default)
 {
-  register Lisp_Object map;
+  Lisp_Object map;
   map = BVAR (current_buffer, keymap);
   if (NILP (map))
     return Qnil;
@@ -2027,7 +2027,7 @@
   for (tail = maps; CONSP (tail); tail = XCDR (tail))
     {
       struct accessible_keymaps_data data;
-      register Lisp_Object thismap = Fcdr (XCAR (tail));
+      Lisp_Object thismap = Fcdr (XCAR (tail));
       Lisp_Object last;
 
       data.thisseq = Fcar (XCAR (tail));
@@ -2330,7 +2330,7 @@
 }
 
 static char *
-push_text_char_description (register unsigned int c, register char *p)
+push_text_char_description (unsigned int c, char *p)
 {
   if (c >= 0200)
     {
@@ -2518,7 +2518,7 @@
   for (; CONSP (maps); maps = XCDR (maps))
     {
       /* Key sequence to reach map, and the map that it reaches */
-      register Lisp_Object this, map, tem;
+      Lisp_Object this, map, tem;
 
       /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
 	 [M-CHAR] sequences, check if last character of the sequence
@@ -2823,7 +2823,7 @@
 {
   Lisp_Object outbuf, shadow;
   int nomenu = NILP (menus);
-  register Lisp_Object start1;
+  Lisp_Object start1;
   struct gcpro gcpro1;
 
   const char *alternate_heading
@@ -3054,7 +3054,7 @@
 
   for (; CONSP (maps); maps = XCDR (maps))
     {
-      register Lisp_Object elt, elt_prefix, tail;
+      Lisp_Object elt, elt_prefix, tail;
 
       elt = XCAR (maps);
       elt_prefix = Fcar (elt);
@@ -3119,7 +3119,7 @@
 static void
 describe_command (Lisp_Object definition, Lisp_Object args)
 {
-  register Lisp_Object tem1;
+  Lisp_Object tem1;
   ptrdiff_t column = current_column ();
   int description_column;
 
@@ -3155,7 +3155,7 @@
 static void
 describe_translation (Lisp_Object definition, Lisp_Object args)
 {
-  register Lisp_Object tem1;
+  Lisp_Object tem1;
 
   Findent_to (make_number (16), make_number (1));
 
@@ -3646,7 +3646,7 @@
 static void
 apropos_accum (Lisp_Object symbol, Lisp_Object string)
 {
-  register Lisp_Object tem;
+  Lisp_Object tem;
 
   tem = Fstring_match (string, Fsymbol_name (symbol), Qnil);
   if (!NILP (tem) && !NILP (apropos_predicate))

=== modified file 'src/lread.c'
--- src/lread.c	2012-05-30 03:59:42 +0000
+++ src/lread.c	2012-06-03 05:53:38 +0000
@@ -191,7 +191,7 @@
 readchar (Lisp_Object readcharfun, int *multibyte)
 {
   Lisp_Object tem;
-  register int c;
+  int c;
   int (*readbyte) (int, Lisp_Object);
   unsigned char buf[MAX_MULTIBYTE_LENGTH];
   int i, len;
@@ -204,7 +204,7 @@
 
   if (BUFFERP (readcharfun))
     {
-      register struct buffer *inbuffer = XBUFFER (readcharfun);
+      struct buffer *inbuffer = XBUFFER (readcharfun);
 
       ptrdiff_t pt_byte = BUF_PT_BYTE (inbuffer);
 
@@ -233,7 +233,7 @@
     }
   if (MARKERP (readcharfun))
     {
-      register struct buffer *inbuffer = XMARKER (readcharfun)->buffer;
+      struct buffer *inbuffer = XMARKER (readcharfun)->buffer;
 
       ptrdiff_t bytepos = marker_byte_position (readcharfun);
 
@@ -764,7 +764,7 @@
        doc: /* Don't use this yourself.  */)
   (void)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   BLOCK_INPUT;
   XSETINT (val, getc (instream));
   UNBLOCK_INPUT;
@@ -1020,8 +1020,8 @@
 Return t if the file exists and loads successfully.  */)
   (Lisp_Object file, Lisp_Object noerror, Lisp_Object nomessage, Lisp_Object nosuffix, Lisp_Object must_suffix)
 {
-  register FILE *stream;
-  register int fd = -1;
+  FILE *stream;
+  int fd = -1;
   ptrdiff_t count = SPECPDL_INDEX ();
   struct gcpro gcpro1, gcpro2, gcpro3;
   Lisp_Object found, efound, hist_file_name;
@@ -1391,7 +1391,7 @@
 static int
 complete_filename_p (Lisp_Object pathname)
 {
-  register const unsigned char *s = SDATA (pathname);
+  const unsigned char *s = SDATA (pathname);
   return (IS_DIRECTORY_SEP (s[0])
 	  || (SCHARS (pathname) > 2
 	      && IS_DEVICE_SEP (s[1]) && IS_DIRECTORY_SEP (s[2])));
@@ -1441,10 +1441,10 @@
 int
 openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes, Lisp_Object *storeptr, Lisp_Object predicate)
 {
-  register int fd;
+  int fd;
   ptrdiff_t fn_size = 100;
   char buf[100];
-  register char *fn = buf;
+  char *fn = buf;
   int absolute = 0;
   ptrdiff_t want_length;
   Lisp_Object filename;
@@ -1597,9 +1597,9 @@
 static void
 build_load_history (Lisp_Object filename, int entire)
 {
-  register Lisp_Object tail, prev, newelt;
-  register Lisp_Object tem, tem2;
-  register int foundit = 0;
+  Lisp_Object tail, prev, newelt;
+  Lisp_Object tem, tem2;
+  int foundit = 0;
 
   tail = Vload_history;
   prev = Qnil;
@@ -1688,8 +1688,8 @@
 	      Lisp_Object unibyte, Lisp_Object readfun,
 	      Lisp_Object start, Lisp_Object end)
 {
-  register int c;
-  register Lisp_Object val;
+  int c;
+  Lisp_Object val;
   ptrdiff_t count = SPECPDL_INDEX ();
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
   struct buffer *b = 0;
@@ -2045,7 +2045,7 @@
 static Lisp_Object
 read0 (Lisp_Object readcharfun)
 {
-  register Lisp_Object val;
+  Lisp_Object val;
   int c;
 
   val = read1 (readcharfun, &c, 0);
@@ -2065,7 +2065,7 @@
 static int
 read_escape (Lisp_Object readcharfun, int stringp)
 {
-  register int c = READCHAR;
+  int c = READCHAR;
   /* \u allows up to four hex digits, \U up to eight.  Default to the
      behavior for \u, and change this value in the case that \U is seen.  */
   int unicode_hex_count = 4;
@@ -2179,8 +2179,8 @@
     case '7':
       /* An octal escape, as in ANSI C.  */
       {
-	register int i = c - '0';
-	register int count = 0;
+	int i = c - '0';
+	int count = 0;
 	while (++count < 3)
 	  {
 	    if ((c = READCHAR) >= '0' && c <= '7')
@@ -2369,9 +2369,9 @@
    FIRST_IN_LIST is nonzero if this is the first element of a list.  */
 
 static Lisp_Object
-read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
+read1 (Lisp_Object readcharfun, int *pch, int first_in_list)
 {
-  register int c;
+  int c;
   unsigned uninterned_symbol = 0;
   int multibyte;
 
@@ -2886,7 +2886,7 @@
       {
 	char *p = read_buffer;
 	char *end = read_buffer + read_buffer_size;
-	register int ch;
+	int ch;
 	/* Nonzero if we saw an escape sequence specifying
 	   a multibyte character.  */
 	int force_multibyte = 0;
@@ -3399,9 +3399,9 @@
 read_vector (Lisp_Object readcharfun, int bytecodeflag)
 {
   ptrdiff_t i, size;
-  register Lisp_Object *ptr;
-  register Lisp_Object tem, item, vector;
-  register struct Lisp_Cons *otem;
+  Lisp_Object *ptr;
+  Lisp_Object tem, item, vector;
+  struct Lisp_Cons *otem;
   Lisp_Object len;
 
   tem = read_list (1, readcharfun);
@@ -3476,10 +3476,10 @@
 /* FLAG = 1 means check for ] to terminate rather than ) and .  */
 
 static Lisp_Object
-read_list (int flag, register Lisp_Object readcharfun)
+read_list (int flag, Lisp_Object readcharfun)
 {
   Lisp_Object val, tail;
-  register Lisp_Object elt, tem;
+  Lisp_Object elt, tem;
   struct gcpro gcpro1, gcpro2;
   /* 0 is the normal case.
      1 means this list is a doc reference; replace it with the number 0.
@@ -3718,7 +3718,7 @@
 it defaults to the value of `obarray'.  */)
   (Lisp_Object string, Lisp_Object obarray)
 {
-  register Lisp_Object tem, sym, *ptr;
+  Lisp_Object tem, sym, *ptr;
 
   if (NILP (obarray)) obarray = Vobarray;
   obarray = check_obarray (obarray);
@@ -3765,7 +3765,7 @@
 it defaults to the value of `obarray'.  */)
   (Lisp_Object name, Lisp_Object obarray)
 {
-  register Lisp_Object tem, string;
+  Lisp_Object tem, string;
 
   if (NILP (obarray)) obarray = Vobarray;
   obarray = check_obarray (obarray);
@@ -3793,7 +3793,7 @@
 OBARRAY defaults to the value of the variable `obarray'.  */)
   (Lisp_Object name, Lisp_Object obarray)
 {
-  register Lisp_Object string, tem;
+  Lisp_Object string, tem;
   size_t hash;
 
   if (NILP (obarray)) obarray = Vobarray;
@@ -3861,11 +3861,12 @@
    Also store the bucket number in oblookup_last_bucket_number.  */
 
 Lisp_Object
-oblookup (Lisp_Object obarray, register const char *ptr, ptrdiff_t size, ptrdiff_t size_byte)
+oblookup (Lisp_Object obarray, const char *ptr,
+	  ptrdiff_t size, ptrdiff_t size_byte)
 {
   size_t hash;
   size_t obsize;
-  register Lisp_Object tail;
+  Lisp_Object tail;
   Lisp_Object bucket, tem;
 
   if (!VECTORP (obarray)
@@ -3901,7 +3902,7 @@
 map_obarray (Lisp_Object obarray, void (*fn) (Lisp_Object, Lisp_Object), Lisp_Object arg)
 {
   ptrdiff_t i;
-  register Lisp_Object tail;
+  Lisp_Object tail;
   CHECK_VECTOR (obarray);
   for (i = ASIZE (obarray) - 1; i >= 0; i--)
     {

=== modified file 'src/marker.c'
--- src/marker.c	2012-02-10 18:58:48 +0000
+++ src/marker.c	2012-06-03 05:53:38 +0000
@@ -424,9 +424,9 @@
 DEFUN ("marker-buffer", Fmarker_buffer, Smarker_buffer, 1, 1, 0,
        doc: /* Return the buffer that MARKER points into, or nil if none.
 Returns nil if MARKER points into a dead buffer.  */)
-  (register Lisp_Object marker)
+  (Lisp_Object marker)
 {
-  register Lisp_Object buf;
+  Lisp_Object buf;
   CHECK_MARKER (marker);
   if (XMARKER (marker)->buffer)
     {
@@ -461,10 +461,10 @@
 Returns MARKER.  */)
   (Lisp_Object marker, Lisp_Object position, Lisp_Object buffer)
 {
-  register ptrdiff_t charno;
-  register ptrdiff_t bytepos;
-  register struct buffer *b;
-  register struct Lisp_Marker *m;
+  ptrdiff_t charno;
+  ptrdiff_t bytepos;
+  struct buffer *b;
+  struct Lisp_Marker *m;
 
   CHECK_MARKER (marker);
   m = XMARKER (marker);
@@ -530,10 +530,10 @@
 Lisp_Object
 set_marker_restricted (Lisp_Object marker, Lisp_Object pos, Lisp_Object buffer)
 {
-  register ptrdiff_t charno;
-  register ptrdiff_t bytepos;
-  register struct buffer *b;
-  register struct Lisp_Marker *m;
+  ptrdiff_t charno;
+  ptrdiff_t bytepos;
+  struct buffer *b;
+  struct Lisp_Marker *m;
 
   CHECK_MARKER (marker);
   m = XMARKER (marker);
@@ -599,8 +599,8 @@
 Lisp_Object
 set_marker_both (Lisp_Object marker, Lisp_Object buffer, ptrdiff_t charpos, ptrdiff_t bytepos)
 {
-  register struct buffer *b;
-  register struct Lisp_Marker *m;
+  struct buffer *b;
+  struct Lisp_Marker *m;
 
   CHECK_MARKER (marker);
   m = XMARKER (marker);
@@ -647,8 +647,8 @@
 Lisp_Object
 set_marker_restricted_both (Lisp_Object marker, Lisp_Object buffer, ptrdiff_t charpos, ptrdiff_t bytepos)
 {
-  register struct buffer *b;
-  register struct Lisp_Marker *m;
+  struct buffer *b;
+  struct Lisp_Marker *m;
 
   CHECK_MARKER (marker);
   m = XMARKER (marker);
@@ -706,10 +706,10 @@
    including those in chain fields of markers.  */
 
 void
-unchain_marker (register struct Lisp_Marker *marker)
+unchain_marker (struct Lisp_Marker *marker)
 {
-  register struct Lisp_Marker *tail, *prev, *next;
-  register struct buffer *b;
+  struct Lisp_Marker *tail, *prev, *next;
+  struct buffer *b;
 
   b = marker->buffer;
   if (b == 0)
@@ -758,8 +758,8 @@
 ptrdiff_t
 marker_position (Lisp_Object marker)
 {
-  register struct Lisp_Marker *m = XMARKER (marker);
-  register struct buffer *buf = m->buffer;
+  struct Lisp_Marker *m = XMARKER (marker);
+  struct buffer *buf = m->buffer;
 
   if (!buf)
     error ("Marker does not point anywhere");
@@ -772,9 +772,9 @@
 ptrdiff_t
 marker_byte_position (Lisp_Object marker)
 {
-  register struct Lisp_Marker *m = XMARKER (marker);
-  register struct buffer *buf = m->buffer;
-  register ptrdiff_t i = m->bytepos;
+  struct Lisp_Marker *m = XMARKER (marker);
+  struct buffer *buf = m->buffer;
+  ptrdiff_t i = m->bytepos;
 
   if (!buf)
     error ("Marker does not point anywhere");
@@ -792,9 +792,9 @@
 If MARKER is not specified, the new marker does not point anywhere.
 The optional argument TYPE specifies the insertion type of the new marker;
 see `marker-insertion-type'.  */)
-  (register Lisp_Object marker, Lisp_Object type)
+  (Lisp_Object marker, Lisp_Object type)
 {
-  register Lisp_Object new;
+  Lisp_Object new;
 
   if (!NILP (marker))
   CHECK_TYPE (INTEGERP (marker) || MARKERP (marker), Qinteger_or_marker_p, marker);
@@ -810,7 +810,7 @@
        Smarker_insertion_type, 1, 1, 0,
        doc: /* Return insertion type of MARKER: t if it stays after inserted text.
 The value nil means the marker stays before text inserted there.  */)
-  (register Lisp_Object marker)
+  (Lisp_Object marker)
 {
   CHECK_MARKER (marker);
   return XMARKER (marker)->insertion_type ? Qt : Qnil;
@@ -834,8 +834,8 @@
        doc: /* Return t if there are markers pointing at POSITION in the current buffer.  */)
   (Lisp_Object position)
 {
-  register struct Lisp_Marker *tail;
-  register ptrdiff_t charno;
+  struct Lisp_Marker *tail;
+  ptrdiff_t charno;
 
   charno = clip_to_bounds (BEG, XINT (position), Z);

=== modified file 'src/minibuf.c'
--- src/minibuf.c	2012-06-02 17:03:49 +0000
+++ src/minibuf.c	2012-06-03 05:55:23 +0000
@@ -1902,16 +1902,16 @@
 
 Unlike `assoc', KEY can also match an entry in LIST consisting of a
 single string, rather than a cons cell whose car is a string.  */)
-  (register Lisp_Object key, Lisp_Object list, Lisp_Object case_fold)
+  (Lisp_Object key, Lisp_Object list, Lisp_Object case_fold)
 {
-  register Lisp_Object tail;
+  Lisp_Object tail;
 
   if (SYMBOLP (key))
     key = Fsymbol_name (key);
 
   for (tail = list; CONSP (tail); tail = XCDR (tail))
     {
-      register Lisp_Object elt, tem, thiscar;
+      Lisp_Object elt, tem, thiscar;
       elt = XCAR (tail);
       thiscar = CONSP (elt) ? XCAR (elt) : elt;
       if (SYMBOLP (thiscar))

=== modified file 'src/print.c'
--- src/print.c	2012-05-26 15:52:27 +0000
+++ src/print.c	2012-06-03 05:53:38 +0000
@@ -488,8 +488,8 @@
 temp_output_buffer_setup (const char *bufname)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
-  register struct buffer *old = current_buffer;
-  register Lisp_Object buf;
+  struct buffer *old = current_buffer;
+  Lisp_Object buf;
 
   record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
 
@@ -517,10 +517,11 @@
   specbind (Qstandard_output, buf);
 }
 
-static void print (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag);
+static void print (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag);
 static void print_preprocess (Lisp_Object obj);
 static void print_preprocess_string (INTERVAL interval, Lisp_Object arg);
-static void print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag);
+static void print_object (Lisp_Object obj, Lisp_Object printcharfun,
+			  int escapeflag);
 
 DEFUN ("terpri", Fterpri, Sterpri, 0, 1, 0,
        doc: /* Output a newline to stream PRINTCHARFUN.
@@ -912,7 +913,7 @@
     for (; CONSP (tail); tail = XCDR (tail), sep = ", ")
       {
 	Lisp_Object obj;
-	
+
 	if (sep)
 	  write_string_1 (sep, 2, stream);
 	obj = XCAR (tail);
@@ -1061,7 +1062,7 @@
 
 
 static void
-print (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag)
+print (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
   new_backquote_output = 0;
 
@@ -1311,7 +1312,7 @@
 }
 
 static void
-print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag)
+print_object (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
   char buf[max (sizeof "from..to..in " + 2 * INT_STRLEN_BOUND (EMACS_INT),
 		max (sizeof " . #" + INT_STRLEN_BOUND (printmax_t),
@@ -1386,7 +1387,7 @@
 	print_string (obj, printcharfun);
       else
 	{
-	  register ptrdiff_t i_byte;
+	  ptrdiff_t i_byte;
 	  struct gcpro gcpro1;
 	  unsigned char *str;
 	  ptrdiff_t size_byte;
@@ -1503,10 +1504,10 @@
 
     case Lisp_Symbol:
       {
-	register int confusing;
-	register unsigned char *p = SDATA (SYMBOL_NAME (obj));
-	register unsigned char *end = p + SBYTES (SYMBOL_NAME (obj));
-	register int c;
+	int confusing;
+	unsigned char *p = SDATA (SYMBOL_NAME (obj));
+	unsigned char *end = p + SBYTES (SYMBOL_NAME (obj));
+	int c;
 	ptrdiff_t i, i_byte;
 	ptrdiff_t size_byte;
 	Lisp_Object name;
@@ -1697,7 +1698,7 @@
       else if (BOOL_VECTOR_P (obj))
 	{
 	  ptrdiff_t i;
-	  register unsigned char c;
+	  unsigned char c;
 	  struct gcpro gcpro1;
 	  ptrdiff_t size_in_chars
 	    = ((XBOOL_VECTOR (obj)->size + BOOL_VECTOR_BITS_PER_CHAR - 1)
@@ -1948,8 +1949,8 @@
 
 	  PRINTCHAR ('[');
 	  {
-	    register int i;
-	    register Lisp_Object tem;
+	    int i;
+	    Lisp_Object tem;
 	    ptrdiff_t real_size = size;
 
 	    /* Don't print more elements than the specified maximum.  */

=== modified file 'src/process.c'
--- src/process.c	2012-04-22 04:48:13 +0000
+++ src/process.c	2012-06-03 05:53:38 +0000
@@ -267,7 +267,7 @@
 #define POLL_FOR_INPUT
 #endif
 
-static Lisp_Object get_process (register Lisp_Object name);
+static Lisp_Object get_process (Lisp_Object name);
 static void exec_sentinel (Lisp_Object proc, Lisp_Object reason);
 
 /* Mask of bits indicating the descriptors that we wait for input on.  */
@@ -552,7 +552,7 @@
 #ifdef PTY_ITERATION
   PTY_ITERATION
 #else
-  register int c, i;
+  int c, i;
   for (c = FIRST_PTY_LETTER; c <= 'z'; c++)
     for (i = 0; i < 16; i++)
 #endif
@@ -621,8 +621,8 @@
 static Lisp_Object
 make_process (Lisp_Object name)
 {
-  register Lisp_Object val, tem, name1;
-  register struct Lisp_Process *p;
+  Lisp_Object val, tem, name1;
+  struct Lisp_Process *p;
   char suffix[sizeof "<>" + INT_STRLEN_BOUND (printmax_t)];
   printmax_t i;
 
@@ -675,9 +675,9 @@
 }
 
 static void
-remove_process (register Lisp_Object proc)
+remove_process (Lisp_Object proc)
 {
-  register Lisp_Object pair;
+  Lisp_Object pair;
 
   pair = Frassq (proc, Vprocess_alist);
   Vprocess_alist = Fdelq (pair, Vprocess_alist);
@@ -695,7 +695,7 @@
 
 DEFUN ("get-process", Fget_process, Sget_process, 1, 1, 0,
        doc: /* Return the process named NAME, or nil if there is none.  */)
-  (register Lisp_Object name)
+  (Lisp_Object name)
 {
   if (PROCESSP (name))
     return name;
@@ -709,9 +709,9 @@
    current buffer.  */
 
 static Lisp_Object
-get_process (register Lisp_Object name)
+get_process (Lisp_Object name)
 {
-  register Lisp_Object proc, obj;
+  Lisp_Object proc, obj;
   if (STRINGP (name))
     {
       obj = Fget_process (name);
@@ -755,9 +755,9 @@
        doc: /* Delete PROCESS: kill it and forget about it immediately.
 PROCESS may be a process, a buffer, the name of a process or buffer, or
 nil, indicating the current buffer's process.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
-  register struct Lisp_Process *p;
+  struct Lisp_Process *p;
 
   process = get_process (process);
   p = XPROCESS (process);
@@ -820,10 +820,10 @@
 nil -- if arg is a process name and no such process exists.
 PROCESS may be a process, a buffer, the name of a process, or
 nil, indicating the current buffer's process.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
-  register struct Lisp_Process *p;
-  register Lisp_Object status;
+  struct Lisp_Process *p;
+  Lisp_Object status;
 
   if (STRINGP (process))
     process = Fget_process (process);
@@ -855,7 +855,7 @@
        1, 1, 0,
        doc: /* Return the exit status of PROCESS or the signal number that killed it.
 If PROCESS has not yet exited or died, return 0.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
   CHECK_PROCESS (process);
   if (XPROCESS (process)->raw_status_new)
@@ -869,7 +869,7 @@
        doc: /* Return the process id of PROCESS.
 This is the pid of the external process which PROCESS uses or talks to.
 For a network connection, this value is nil.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
   pid_t pid;
 
@@ -882,7 +882,7 @@
        doc: /* Return the name of PROCESS, as a string.
 This is the name of the program invoked in PROCESS,
 possibly modified to make it unique among process names.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
   CHECK_PROCESS (process);
   return XPROCESS (process)->name;
@@ -894,7 +894,7 @@
 and the rest of the strings being the arguments given to it.
 For a network or serial process, this is nil (process is running) or t
 \(process is stopped).  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
   CHECK_PROCESS (process);
   return XPROCESS (process)->command;
@@ -904,7 +904,7 @@
        doc: /* Return the name of the terminal PROCESS uses, or nil if none.
 This is the terminal that the process itself reads and writes on,
 not the name of the pty that Emacs uses to talk with that terminal.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
   CHECK_PROCESS (process);
   return XPROCESS (process)->tty_name;
@@ -914,7 +914,7 @@
        2, 2, 0,
        doc: /* Set buffer associated with PROCESS to BUFFER (a buffer, or nil).
 Return BUFFER.  */)
-  (register Lisp_Object process, Lisp_Object buffer)
+  (Lisp_Object process, Lisp_Object buffer)
 {
   struct Lisp_Process *p;
 
@@ -933,7 +933,7 @@
        1, 1, 0,
        doc: /* Return the buffer PROCESS is associated with.
 Output from PROCESS is inserted in this buffer unless PROCESS has a filter.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
   CHECK_PROCESS (process);
   return XPROCESS (process)->buffer;
@@ -942,7 +942,7 @@
 DEFUN ("process-mark", Fprocess_mark, Sprocess_mark,
        1, 1, 0,
        doc: /* Return the marker for the end of the last output from PROCESS.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
   CHECK_PROCESS (process);
   return XPROCESS (process)->mark;
@@ -964,7 +964,7 @@
 - if `default-enable-multibyte-characters' is nil, it is a unibyte
   string (the result of converting the decoded input multibyte
   string to unibyte with `string-make-unibyte').  */)
-  (register Lisp_Object process, Lisp_Object filter)
+  (Lisp_Object process, Lisp_Object filter)
 {
   struct Lisp_Process *p;
 
@@ -1006,7 +1006,7 @@
        1, 1, 0,
        doc: /* Returns the filter function of PROCESS; nil if none.
 See `set-process-filter' for more info on filter functions.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
   CHECK_PROCESS (process);
   return XPROCESS (process)->filter;
@@ -1017,7 +1017,7 @@
        doc: /* Give PROCESS the sentinel SENTINEL; nil for none.
 The sentinel is called as a function when the process changes state.
 It gets two arguments: the process, and a string describing the change.  */)
-  (register Lisp_Object process, Lisp_Object sentinel)
+  (Lisp_Object process, Lisp_Object sentinel)
 {
   struct Lisp_Process *p;
 
@@ -1034,7 +1034,7 @@
        1, 1, 0,
        doc: /* Return the sentinel of PROCESS; nil if none.
 See `set-process-sentinel' for more info on sentinels.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
   CHECK_PROCESS (process);
   return XPROCESS (process)->sentinel;
@@ -1043,7 +1043,7 @@
 DEFUN ("set-process-window-size", Fset_process_window_size,
        Sset_process_window_size, 3, 3, 0,
        doc: /* Tell PROCESS that it has logical window size HEIGHT and WIDTH.  */)
-  (register Lisp_Object process, Lisp_Object height, Lisp_Object width)
+  (Lisp_Object process, Lisp_Object height, Lisp_Object width)
 {
   CHECK_PROCESS (process);
   CHECK_RANGED_INTEGER (0, height, INT_MAX);
@@ -1076,7 +1076,7 @@
 for the process which will run.
 
 This function returns FLAG.  */)
-  (register Lisp_Object process, Lisp_Object flag)
+  (Lisp_Object process, Lisp_Object flag)
 {
   CHECK_PROCESS (process);
   XPROCESS (process)->inherit_coding_system_flag = !NILP (flag);
@@ -1090,7 +1090,7 @@
 If the second argument FLAG is non-nil, Emacs will query the user before
 exiting or killing a buffer if PROCESS is running.  This function
 returns FLAG.  */)
-  (register Lisp_Object process, Lisp_Object flag)
+  (Lisp_Object process, Lisp_Object flag)
 {
   CHECK_PROCESS (process);
   XPROCESS (process)->kill_without_query = NILP (flag);
@@ -1101,7 +1101,7 @@
        Fprocess_query_on_exit_flag, Sprocess_query_on_exit_flag,
        1, 1, 0,
        doc: /* Return the current value of query-on-exit flag for PROCESS.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
   CHECK_PROCESS (process);
   return (XPROCESS (process)->kill_without_query ? Qnil : Qt);
@@ -1121,7 +1121,7 @@
 connection is returned, else the specific value for the keyword KEY is
 returned.  See `make-network-process' or `make-serial-process' for a
 list of keywords.  */)
-  (register Lisp_Object process, Lisp_Object key)
+  (Lisp_Object process, Lisp_Object key)
 {
   Lisp_Object contact;
 
@@ -1149,7 +1149,7 @@
 DEFUN ("process-plist", Fprocess_plist, Sprocess_plist,
        1, 1, 0,
        doc: /* Return the plist of PROCESS.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
   CHECK_PROCESS (process);
   return XPROCESS (process)->plist;
@@ -1158,7 +1158,7 @@
 DEFUN ("set-process-plist", Fset_process_plist, Sset_process_plist,
        2, 2, 0,
        doc: /* Replace the plist of PROCESS with PLIST.  Returns PLIST.  */)
-  (register Lisp_Object process, Lisp_Object plist)
+  (Lisp_Object process, Lisp_Object plist)
 {
   CHECK_PROCESS (process);
   CHECK_LIST (plist);
@@ -1209,7 +1209,7 @@
 
   if (VECTORP (address))  /* AF_INET or AF_INET6 */
     {
-      register struct Lisp_Vector *p = XVECTOR (address);
+      struct Lisp_Vector *p = XVECTOR (address);
       ptrdiff_t size = p->header.size;
       Lisp_Object args[10];
       int nargs, i;
@@ -1297,7 +1297,7 @@
   (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object buffer, name, program, proc, current_dir, tem;
-  register unsigned char **new_argv;
+  unsigned char **new_argv;
   ptrdiff_t i;
   ptrdiff_t count = SPECPDL_INDEX ();
 
@@ -2018,7 +2018,7 @@
   Lisp_Object address;
   int i;
   unsigned char *cp;
-  register struct Lisp_Vector *p;
+  struct Lisp_Vector *p;
 
   /* Workaround for a bug in getsockname on BSD: Names bound to
      sockets in the UNIX domain are inaccessible; getsockname returns
@@ -2084,7 +2084,7 @@
 static int
 get_lisp_to_sockaddr_size (Lisp_Object address, int *familyp)
 {
-  register struct Lisp_Vector *p;
+  struct Lisp_Vector *p;
 
   if (VECTORP (address))
     {
@@ -2130,9 +2130,9 @@
 static void
 conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int len)
 {
-  register struct Lisp_Vector *p;
-  register unsigned char *cp = NULL;
-  register int i;
+  struct Lisp_Vector *p;
+  unsigned char *cp = NULL;
+  int i;
   EMACS_INT hostport;
 
   memset (sa, 0, len);
@@ -3788,7 +3788,7 @@
   if (ioctl (s, SIOCGIFHWADDR, &rq) == 0)
     {
       Lisp_Object hwaddr = Fmake_vector (make_number (6), Qnil);
-      register struct Lisp_Vector *p = XVECTOR (hwaddr);
+      struct Lisp_Vector *p = XVECTOR (hwaddr);
       int n;
 
       any = 1;
@@ -3800,7 +3800,7 @@
   if (getifaddrs (&ifap) != -1)
     {
       Lisp_Object hwaddr = Fmake_vector (make_number (6), Qnil);
-      register struct Lisp_Vector *p = XVECTOR (hwaddr);
+      struct Lisp_Vector *p = XVECTOR (hwaddr);
       struct ifaddrs *it;
 
       for (it = ifap; it != NULL; it = it->ifa_next)
@@ -3876,8 +3876,8 @@
 static void
 deactivate_process (Lisp_Object proc)
 {
-  register int inchannel, outchannel;
-  register struct Lisp_Process *p = XPROCESS (proc);
+  int inchannel, outchannel;
+  struct Lisp_Process *p = XPROCESS (proc);
 
 #ifdef HAVE_GNUTLS
   /* Delete GnuTLS structures in PROC, if any.  */
@@ -3958,7 +3958,8 @@
 from PROCESS, suspending reading output from other processes.
 If JUST-THIS-ONE is an integer, don't run any timers either.
 Return non-nil if we received any output before the timeout expired.  */)
-  (register Lisp_Object process, Lisp_Object seconds, Lisp_Object millisec, Lisp_Object just_this_one)
+  (Lisp_Object process, Lisp_Object seconds, Lisp_Object millisec,
+   Lisp_Object just_this_one)
 {
   int secs = -1, usecs = 0;
 
@@ -4289,7 +4290,7 @@
 			     Lisp_Object wait_for_cell,
 			     struct Lisp_Process *wait_proc, int just_wait_proc)
 {
-  register int channel, nfds;
+  int channel, nfds;
   SELECT_TYPE Available;
   SELECT_TYPE Writeok;
   int check_write;
@@ -5034,13 +5035,13 @@
    for decoding.  */
 
 static int
-read_process_output (Lisp_Object proc, register int channel)
+read_process_output (Lisp_Object proc, int channel)
 {
-  register ssize_t nbytes;
+  ssize_t nbytes;
   char *chars;
-  register Lisp_Object outstream;
-  register struct Lisp_Process *p = XPROCESS (proc);
-  register ptrdiff_t opoint;
+  Lisp_Object outstream;
+  struct Lisp_Process *p = XPROCESS (proc);
+  ptrdiff_t opoint;
   struct coding_system *coding = proc_decode_coding_system[channel];
   int carryover = p->decoding_carryover;
   int readmax = 4096;
@@ -5761,7 +5762,7 @@
 		     int nomsg)
 {
   Lisp_Object proc;
-  register struct Lisp_Process *p;
+  struct Lisp_Process *p;
   pid_t gid;
   int no_pgrp = 0;
 
@@ -6428,7 +6429,7 @@
 exec_sentinel (Lisp_Object proc, Lisp_Object reason)
 {
   Lisp_Object sentinel, odeactivate;
-  register struct Lisp_Process *p = XPROCESS (proc);
+  struct Lisp_Process *p = XPROCESS (proc);
   ptrdiff_t count = SPECPDL_INDEX ();
   int outer_running_asynch_code = running_asynch_code;
   int waiting = waiting_for_user_input_p;
@@ -6515,7 +6516,7 @@
 static void
 status_notify (struct Lisp_Process *deleting_process)
 {
-  register Lisp_Object proc, buffer;
+  Lisp_Object proc, buffer;
   Lisp_Object tail, msg;
   struct gcpro gcpro1, gcpro2;
 
@@ -6534,7 +6535,7 @@
   for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
     {
       Lisp_Object symbol;
-      register struct Lisp_Process *p;
+      struct Lisp_Process *p;
 
       proc = Fcdr (XCAR (tail));
       p = XPROCESS (proc);
@@ -6640,9 +6641,9 @@
        doc: /* Set coding systems of PROCESS to DECODING and ENCODING.
 DECODING will be used to decode subprocess output and ENCODING to
 encode subprocess input.  */)
-  (register Lisp_Object process, Lisp_Object decoding, Lisp_Object encoding)
+  (Lisp_Object process, Lisp_Object decoding, Lisp_Object encoding)
 {
-  register struct Lisp_Process *p;
+  struct Lisp_Process *p;
 
   CHECK_PROCESS (process);
   p = XPROCESS (process);
@@ -6663,7 +6664,7 @@
 DEFUN ("process-coding-system",
        Fprocess_coding_system, Sprocess_coding_system, 1, 1, 0,
        doc: /* Return a cons of coding systems for decoding and encoding of PROCESS.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
   CHECK_PROCESS (process);
   return Fcons (XPROCESS (process)->decode_coding_system,
@@ -6679,7 +6680,7 @@
 suppressed.  */)
   (Lisp_Object process, Lisp_Object flag)
 {
-  register struct Lisp_Process *p;
+  struct Lisp_Process *p;
 
   CHECK_PROCESS (process);
   p = XPROCESS (process);
@@ -6695,7 +6696,7 @@
        doc: /* Return t if a multibyte string is given to PROCESS's filter.*/)
   (Lisp_Object process)
 {
-  register struct Lisp_Process *p;
+  struct Lisp_Process *p;
   struct coding_system *coding;
 
   CHECK_PROCESS (process);
@@ -6778,7 +6779,7 @@
 			     Lisp_Object wait_for_cell,
 			     struct Lisp_Process *wait_proc, int just_wait_proc)
 {
-  register int nfds;
+  int nfds;
   EMACS_TIME end_time, timeout;
   SELECT_TYPE waitchannels;
   int xerrno;
@@ -7064,10 +7065,10 @@
 DEFUN ("get-buffer-process", Fget_buffer_process, Sget_buffer_process, 1, 1, 0,
        doc: /* Return the (or a) process associated with BUFFER.
 BUFFER may be a buffer or the name of one.  */)
-  (register Lisp_Object buffer)
+  (Lisp_Object buffer)
 {
 #ifdef subprocesses
-  register Lisp_Object buf, tail, proc;
+  Lisp_Object buf, tail, proc;
 
   if (NILP (buffer)) return Qnil;
   buf = Fget_buffer (buffer);
@@ -7090,7 +7091,7 @@
 If this flag is t, `buffer-file-coding-system' of the buffer
 associated with PROCESS will inherit the coding system used to decode
 the process output.  */)
-  (register Lisp_Object process)
+  (Lisp_Object process)
 {
 #ifdef subprocesses
   CHECK_PROCESS (process);
@@ -7240,7 +7241,7 @@
 init_process (void)
 {
 #ifdef subprocesses
-  register int i;
+  int i;
 
   inhibit_sentinels = 0;

=== modified file 'src/ralloc.c'
--- src/ralloc.c	2012-05-31 06:06:42 +0000
+++ src/ralloc.c	2012-06-03 05:53:38 +0000
@@ -307,7 +307,7 @@
 static void
 relinquish (void)
 {
-  register heap_ptr h;
+  heap_ptr h;
   long excess = 0;
 
   /* Add the amount of space beyond break_value
@@ -368,7 +368,7 @@
 static bloc_ptr
 find_bloc (POINTER *ptr)
 {
-  register bloc_ptr p = first_bloc;
+  bloc_ptr p = first_bloc;
 
   while (p != NIL_BLOC)
     {
@@ -393,8 +393,8 @@
 static bloc_ptr
 get_bloc (SIZE size)
 {
-  register bloc_ptr new_bloc;
-  register heap_ptr heap;
+  bloc_ptr new_bloc;
+  heap_ptr heap;
 
   if (! (new_bloc = (bloc_ptr) malloc (BLOC_PTR_SIZE))
       || ! (new_bloc->data = obtain (break_value, size)))
@@ -448,7 +448,7 @@
 static int
 relocate_blocs (bloc_ptr bloc, heap_ptr heap, POINTER address)
 {
-  register bloc_ptr b = bloc;
+  bloc_ptr b = bloc;
 
   /* No need to ever call this if arena is frozen, bug somewhere!  */
   if (r_alloc_freeze_level)
@@ -470,8 +470,8 @@
 	 get enough new space to hold BLOC and all following blocs.  */
       if (heap == NIL_HEAP)
 	{
-	  register bloc_ptr tb = b;
-	  register SIZE s = 0;
+	  bloc_ptr tb = b;
+	  SIZE s = 0;
 
 	  /* Add up the size of all the following blocs.  */
 	  while (tb != NIL_BLOC)
@@ -507,7 +507,7 @@
 static void
 update_heap_bloc_correspondence (bloc_ptr bloc, heap_ptr heap)
 {
-  register bloc_ptr b;
+  bloc_ptr b;
 
   /* Initialize HEAP's status to reflect blocs before BLOC.  */
   if (bloc != NIL_BLOC && bloc->prev != NIL_BLOC && bloc->prev->heap == heap)
@@ -569,7 +569,7 @@
 static int
 resize_bloc (bloc_ptr bloc, SIZE size)
 {
-  register bloc_ptr b;
+  bloc_ptr b;
   heap_ptr heap;
   POINTER address;
   SIZE old_size;
@@ -735,7 +735,7 @@
 static POINTER
 r_alloc_sbrk (long int size)
 {
-  register bloc_ptr b;
+  bloc_ptr b;
   POINTER address;
 
   if (! r_alloc_initialized)
@@ -888,7 +888,7 @@
 POINTER
 r_alloc (POINTER *ptr, SIZE size)
 {
-  register bloc_ptr new_bloc;
+  bloc_ptr new_bloc;
 
   if (! r_alloc_initialized)
     r_alloc_init ();
@@ -909,9 +909,9 @@
    Store 0 in *PTR to show there's no block allocated.  */
 
 void
-r_alloc_free (register POINTER *ptr)
+r_alloc_free (POINTER *ptr)
 {
-  register bloc_ptr dead_bloc;
+  bloc_ptr dead_bloc;
 
   if (! r_alloc_initialized)
     r_alloc_init ();
@@ -945,7 +945,7 @@
 POINTER
 r_re_alloc (POINTER *ptr, SIZE size)
 {
-  register bloc_ptr bloc;
+  bloc_ptr bloc;
 
   if (! r_alloc_initialized)
     r_alloc_init ();

=== modified file 'src/scroll.c'
--- src/scroll.c	2012-02-10 18:58:48 +0000
+++ src/scroll.c	2012-06-03 05:53:38 +0000
@@ -93,10 +93,10 @@
 		     int *draw_cost, int *old_hash, int *new_hash,
 		     int free_at_end)
 {
-  register int i, j;
+  int i, j;
   int frame_lines = FRAME_LINES (frame);
-  register struct matrix_elt *p, *p1;
-  register int cost, cost1;
+  struct matrix_elt *p, *p1;
+  int cost, cost1;
 
   int lines_moved = window_size
     + (FRAME_SCROLL_REGION_OK (frame) ? 0 : lines_below);
@@ -431,10 +431,10 @@
 			    int *old_hash, int *new_hash,
 			    int free_at_end)
 {
-  register int i, j;
+  int i, j;
   int frame_lines = FRAME_LINES (frame);
-  register struct matrix_elt *p, *p1;
-  register int cost, cost1, delta;
+  struct matrix_elt *p, *p1;
+  int cost, cost1, delta;
 
   /* first_insert_cost[-I] is the cost of doing the first insert-line
      at a position I lines above the bottom line in the scroll window. */
@@ -838,8 +838,8 @@
                            int *cost)
 {
   struct { int hash; int count; } lines[01000];
-  register int i, h;
-  register int matchcount = 0;
+  int i, h;
+  int matchcount = 0;
   int avg_length = 0;
   int threshold;
 
@@ -887,12 +887,12 @@
 
 static void
 line_ins_del (FRAME_PTR frame, int ov1, int pf1, int ovn, int pfn,
-              register int *ov, register int *mf)
+              int *ov, int *mf)
 {
-  register int i;
-  register int frame_lines = FRAME_LINES (frame);
-  register int insert_overhead = ov1 * 10;
-  register int next_insert_cost = ovn * 10;
+  int i;
+  int frame_lines = FRAME_LINES (frame);
+  int insert_overhead = ov1 * 10;
+  int next_insert_cost = ovn * 10;
 
   for (i = frame_lines-1; i >= 0; i--)
     {

=== modified file 'src/search.c'
--- src/search.c	2012-05-31 06:06:42 +0000
+++ src/search.c	2012-06-03 05:53:38 +0000
@@ -273,7 +273,7 @@
   Lisp_Object val;
   unsigned char *p1, *p2;
   ptrdiff_t s1, s2;
-  register ptrdiff_t i;
+  ptrdiff_t i;
   struct re_pattern_buffer *bufp;
 
   if (running_asynch_code)
@@ -642,7 +642,7 @@
    except when inside redisplay.  */
 
 ptrdiff_t
-scan_buffer (register int target, ptrdiff_t start, ptrdiff_t end,
+scan_buffer (int target, ptrdiff_t start, ptrdiff_t end,
 	     ptrdiff_t count, ptrdiff_t *shortage, int allow_quit)
 {
   struct region_cache *newline_cache;
@@ -708,10 +708,8 @@
 
         {
           /* The termination address of the dumb loop.  */
-          register unsigned char *ceiling_addr
-	    = BYTE_POS_ADDR (ceiling_byte) + 1;
-          register unsigned char *cursor
-	    = BYTE_POS_ADDR (start_byte);
+          unsigned char *ceiling_addr = BYTE_POS_ADDR (ceiling_byte) + 1;
+          unsigned char *cursor = BYTE_POS_ADDR (start_byte);
           unsigned char *base = cursor;
 
           while (cursor < ceiling_addr)
@@ -777,8 +775,8 @@
 
         {
           /* The termination address of the dumb loop.  */
-          register unsigned char *ceiling_addr = BYTE_POS_ADDR (ceiling_byte);
-          register unsigned char *cursor = BYTE_POS_ADDR (start_byte - 1);
+          unsigned char *ceiling_addr = BYTE_POS_ADDR (ceiling_byte);
+          unsigned char *cursor = BYTE_POS_ADDR (start_byte - 1);
           unsigned char *base = cursor;
 
           while (cursor >= ceiling_addr)
@@ -837,15 +835,15 @@
 EMACS_INT
 scan_newline (ptrdiff_t start, ptrdiff_t start_byte,
 	      ptrdiff_t limit, ptrdiff_t limit_byte,
-	      register EMACS_INT count, int allow_quit)
+	      EMACS_INT count, int allow_quit)
 {
   int direction = ((count > 0) ? 1 : -1);
 
-  register unsigned char *cursor;
+  unsigned char *cursor;
   unsigned char *base;
 
   ptrdiff_t ceiling;
-  register unsigned char *ceiling_addr;
+  unsigned char *ceiling_addr;
 
   int old_immediate_quit = immediate_quit;
 
@@ -958,7 +956,7 @@
 search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
 		Lisp_Object count, int direction, int RE, int posix)
 {
-  register EMACS_INT np;
+  EMACS_INT np;
   EMACS_INT lim;
   ptrdiff_t lim_byte;
   EMACS_INT n = direction;
@@ -1106,7 +1104,7 @@
 {
   ptrdiff_t len = SCHARS (string);
   ptrdiff_t len_byte = SBYTES (string);
-  register ptrdiff_t i;
+  ptrdiff_t i;
 
   if (running_asynch_code)
     save_search_regs ();
@@ -1659,13 +1657,13 @@
              int char_base)
 {
   int direction = ((n > 0) ? 1 : -1);
-  register ptrdiff_t dirlen;
+  ptrdiff_t dirlen;
   ptrdiff_t limit;
   int stride_for_teases = 0;
   int BM_tab[0400];
-  register unsigned char *cursor, *p_limit;
-  register ptrdiff_t i;
-  register int j;
+  unsigned char *cursor, *p_limit;
+  ptrdiff_t i;
+  int j;
   unsigned char *pat, *pat_end;
   int multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
 
@@ -2248,12 +2246,12 @@
   (Lisp_Object newtext, Lisp_Object fixedcase, Lisp_Object literal, Lisp_Object string, Lisp_Object subexp)
 {
   enum { nochange, all_caps, cap_initial } case_action;
-  register ptrdiff_t pos, pos_byte;
+  ptrdiff_t pos, pos_byte;
   int some_multiletter_word;
   int some_lowercase;
   int some_uppercase;
   int some_nonuppercase_initial;
-  register int c, prevc;
+  int c, prevc;
   ptrdiff_t sub;
   ptrdiff_t opoint, newpoint;
 
@@ -2822,10 +2820,10 @@
 LIST should have been created by calling `match-data' previously.
 
 If optional arg RESEAT is non-nil, make markers on LIST point nowhere.  */)
-  (register Lisp_Object list, Lisp_Object reseat)
+  (Lisp_Object list, Lisp_Object reseat)
 {
   ptrdiff_t i;
-  register Lisp_Object marker;
+  Lisp_Object marker;
 
   if (running_asynch_code)
     save_search_regs ();
@@ -3002,8 +3000,8 @@
        doc: /* Return a regexp string which matches exactly STRING and nothing else.  */)
   (Lisp_Object string)
 {
-  register char *in, *out, *end;
-  register char *temp;
+  char *in, *out, *end;
+  char *temp;
   int backslashes_added = 0;
 
   CHECK_STRING (string);
@@ -3035,7 +3033,7 @@
 void
 syms_of_search (void)
 {
-  register int i;
+  int i;
 
   for (i = 0; i < REGEXP_CACHE_SIZE; ++i)
     {

=== modified file 'src/syntax.c'
--- src/syntax.c	2012-04-09 22:54:59 +0000
+++ src/syntax.c	2012-06-03 05:53:38 +0000
@@ -341,9 +341,9 @@
 static int
 char_quoted (ptrdiff_t charpos, ptrdiff_t bytepos)
 {
-  register enum syntaxcode code;
-  register ptrdiff_t beg = BEGV;
-  register int quoted = 0;
+  enum syntaxcode code;
+  ptrdiff_t beg = BEGV;
+  int quoted = 0;
   ptrdiff_t orig = charpos;
 
   while (charpos > beg)
@@ -530,7 +530,7 @@
      or 0 if we didn't come across it yet.  */
   ptrdiff_t defun_start = 0;
   ptrdiff_t defun_start_byte = 0;
-  register enum syntaxcode code;
+  enum syntaxcode code;
   int nesting = 1;		/* current comment nesting */
   int c;
   int syntax = 0;
@@ -923,8 +923,8 @@
 text property.  */)
   (Lisp_Object string)
 {
-  register const unsigned char *p;
-  register enum syntaxcode code;
+  const unsigned char *p;
+  enum syntaxcode code;
   int val;
   Lisp_Object match;
 
@@ -1072,7 +1072,7 @@
        doc: /* Insert a description of the internal syntax description SYNTAX at point.  */)
   (Lisp_Object syntax)
 {
-  register enum syntaxcode code;
+  enum syntaxcode code;
   int syntax_code;
   char desc, start1, start2, end1, end2, prefix,
     comstyleb, comstylec, comnested;
@@ -1225,12 +1225,12 @@
    COUNT negative means scan backward and stop at word beginning.  */
 
 ptrdiff_t
-scan_words (register ptrdiff_t from, register EMACS_INT count)
+scan_words (ptrdiff_t from, EMACS_INT count)
 {
-  register ptrdiff_t beg = BEGV;
-  register ptrdiff_t end = ZV;
-  register ptrdiff_t from_byte = CHAR_TO_BYTE (from);
-  register enum syntaxcode code;
+  ptrdiff_t beg = BEGV;
+  ptrdiff_t end = ZV;
+  ptrdiff_t from_byte = CHAR_TO_BYTE (from);
+  enum syntaxcode code;
   int ch0, ch1;
   Lisp_Object func, pos;
 
@@ -1427,13 +1427,13 @@
 static Lisp_Object
 skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_classes)
 {
-  register unsigned int c;
+  unsigned int c;
   unsigned char fastmap[0400];
   /* Store the ranges of non-ASCII characters.  */
   int *char_ranges IF_LINT (= NULL);
   int n_char_ranges = 0;
   int negate = 0;
-  register ptrdiff_t i, i_byte;
+  ptrdiff_t i, i_byte;
   /* Set to 1 if the current buffer is multibyte and the region
      contains non-ASCII chars.  */
   int multibyte;
@@ -1923,10 +1923,10 @@
 static Lisp_Object
 skip_syntaxes (int forwardp, Lisp_Object string, Lisp_Object lim)
 {
-  register unsigned int c;
+  unsigned int c;
   unsigned char fastmap[0400];
   int negate = 0;
-  register ptrdiff_t i, i_byte;
+  ptrdiff_t i, i_byte;
   int multibyte;
   ptrdiff_t size_byte;
   unsigned char *str;
@@ -2141,9 +2141,9 @@
 	      ptrdiff_t *charpos_ptr, ptrdiff_t *bytepos_ptr,
 	      EMACS_INT *incomment_ptr)
 {
-  register int c, c1;
-  register enum syntaxcode code;
-  register int syntax, other_syntax;
+  int c, c1;
+  enum syntaxcode code;
+  int syntax, other_syntax;
 
   if (nesting <= 0) nesting = -1;
 
@@ -2241,11 +2241,11 @@
 between them, return t; otherwise return nil.  */)
   (Lisp_Object count)
 {
-  register ptrdiff_t from;
+  ptrdiff_t from;
   ptrdiff_t from_byte;
-  register ptrdiff_t stop;
-  register int c, c1;
-  register enum syntaxcode code;
+  ptrdiff_t stop;
+  int c, c1;
+  enum syntaxcode code;
   int comstyle = 0;	    /* style of comment encountered */
   int comnested = 0;	    /* whether the comment is nestable or not */
   int found;
@@ -2455,15 +2455,15 @@
    ? SYNTAX (c) : Ssymbol)
 
 static Lisp_Object
-scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpflag)
+scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpflag)
 {
   Lisp_Object val;
-  register ptrdiff_t stop = count > 0 ? ZV : BEGV;
-  register int c, c1;
+  ptrdiff_t stop = count > 0 ? ZV : BEGV;
+  int c, c1;
   int stringterm;
   int quoted;
   int mathexit = 0;
-  register enum syntaxcode code, temp_code;
+  enum syntaxcode code, temp_code;
   EMACS_INT min_depth = depth;    /* Err out if depth gets less than this.  */
   int comstyle = 0;	    /* style of comment encountered */
   int comnested = 0;	    /* whether the comment is nestable or not */
@@ -2948,16 +2948,16 @@
 {
   struct lisp_parse_state state;
 
-  register enum syntaxcode code;
+  enum syntaxcode code;
   int c1;
   int comnested;
   struct level { ptrdiff_t last, prev; };
   struct level levelstart[100];
-  register struct level *curlevel = levelstart;
+  struct level *curlevel = levelstart;
   struct level *endlevel = levelstart + 100;
-  register EMACS_INT depth; /* Paren depth of current scanning location.
-			   level - levelstart equals this except
-			   when the depth becomes negative.  */
+  EMACS_INT depth; /* Paren depth of current scanning location.
+		      level - levelstart equals this except
+		      when the depth becomes negative.  */
   EMACS_INT mindepth;		/* Lowest DEPTH value seen.  */
   int start_quoted = 0;		/* Nonzero means starting after a char quote */
   Lisp_Object tem;
@@ -3372,7 +3372,7 @@
 void
 init_syntax_once (void)
 {
-  register int i, c;
+  int i, c;
   Lisp_Object temp;
 
   /* This has to be done here, before we call Fmake_char_table.  */

=== modified file 'src/sysdep.c'
--- src/sysdep.c	2012-06-02 21:01:07 +0000
+++ src/sysdep.c	2012-06-03 05:55:23 +0000
@@ -1869,7 +1869,7 @@
 int
 emacs_open (const char *path, int oflag, int mode)
 {
-  register int rtnval;
+  int rtnval;
 
   while ((rtnval = open (path, oflag, mode)) == -1
 	 && (errno == EINTR))
@@ -1881,7 +1881,7 @@
 emacs_close (int fd)
 {
   int did_retry = 0;
-  register int rtnval;
+  int rtnval;
 
   while ((rtnval = close (fd)) == -1
 	 && (errno == EINTR))
@@ -1913,7 +1913,7 @@
 ptrdiff_t
 emacs_read (int fildes, char *buf, ptrdiff_t nbyte)
 {
-  register ssize_t rtnval;
+  ssize_t rtnval;
 
   /* There is no need to check against MAX_RW_COUNT, since no caller ever
      passes a size that large to emacs_read.  */
@@ -2513,7 +2513,7 @@
 {
   Lisp_Object procdir, match, proclist, next;
   struct gcpro gcpro1, gcpro2;
-  register Lisp_Object tail;
+  Lisp_Object tail;
 
   GCPRO2 (procdir, match);
   /* For every process on the system, there's a directory in the

=== modified file 'src/term.c'
--- src/term.c	2012-05-25 18:19:24 +0000
+++ src/term.c	2012-06-03 05:53:38 +0000
@@ -409,7 +409,7 @@
 static void
 tty_clear_to_end (struct frame *f)
 {
-  register int i;
+  int i;
   struct tty_display_info *tty = FRAME_TTY (f);
 
   if (tty->TS_clr_to_bottom)
@@ -454,7 +454,7 @@
 static void
 tty_clear_end_of_line (struct frame *f, int first_unused_hpos)
 {
-  register int i;
+  int i;
   struct tty_display_info *tty = FRAME_TTY (f);
 
   /* Detect the case where we are called from reset_sys_modes
@@ -507,7 +507,7 @@
   unsigned char *buf;
   ptrdiff_t nchars, nbytes, required;
   ptrdiff_t tlen = GLYPH_TABLE_LENGTH;
-  register Lisp_Object *tbase = GLYPH_TABLE_BASE;
+  Lisp_Object *tbase = GLYPH_TABLE_BASE;
   Lisp_Object charset_list;
 
   /* Allocate sufficient size of buffer to store all characters in
@@ -777,8 +777,8 @@
 #ifdef HAVE_GPM			/* Only used by GPM code.  */
 
 static void
-tty_write_glyphs_with_face (register struct frame *f, register struct glyph *string,
-			    register int len, register int face_id)
+tty_write_glyphs_with_face (struct frame *f, struct glyph *string,
+			    int len, int face_id)
 {
   unsigned char *conversion_buffer;
   struct coding_system *coding;
@@ -929,7 +929,7 @@
 tty_delete_glyphs (struct frame *f, int n)
 {
   char *buf;
-  register int i;
+  int i;
 
   struct tty_display_info *tty = FRAME_TTY (f);
 
@@ -967,8 +967,8 @@
   const char *single = n > 0 ? tty->TS_ins_line : tty->TS_del_line;
   const char *scroll = n > 0 ? tty->TS_rev_scroll : tty->TS_fwd_scroll;
 
-  register int i = n > 0 ? n : -n;
-  register char *buf;
+  int i = n > 0 ? n : -n;
+  char *buf;
 
   /* If the lines below the insertion are being pushed
      into the end of the window, this is the same as clearing;
@@ -1077,8 +1077,8 @@
   struct tty_display_info *tty = FRAME_TTY (f);
   int ins_startup_cost, del_startup_cost;
   int ins_cost_per_char, del_cost_per_char;
-  register int i;
-  register int *p;
+  int i;
+  int *p;
 
   if (tty->TS_ins_multi_chars)
     {
@@ -1140,9 +1140,9 @@
   if (FRAME_TERMCAP_P (frame))
     {
       struct tty_display_info *tty = FRAME_TTY (frame);
-      register const char *f = (tty->TS_set_scroll_region
-				? tty->TS_set_scroll_region
-				: tty->TS_set_scroll_region_1);
+      const char *f = (tty->TS_set_scroll_region
+		       ? tty->TS_set_scroll_region
+		       : tty->TS_set_scroll_region_1);
 
       FRAME_SCROLL_REGION_COST (frame) = string_cost (f);

=== modified file 'src/termcap.c'
--- src/termcap.c	2012-05-21 15:36:54 +0000
+++ src/termcap.c	2012-06-03 05:53:38 +0000
@@ -65,7 +65,7 @@
    0 if not found.  */
 
 static char *
-find_capability (register char *bp, register const char *cap)
+find_capability (char *bp, const char *cap)
 {
   for (; *bp; bp++)
     if (bp[0] == ':'
@@ -78,7 +78,7 @@
 int
 tgetnum (const char *cap)
 {
-  register char *ptr = find_capability (term_entry, cap);
+  char *ptr = find_capability (term_entry, cap);
   if (!ptr || ptr[-1] != '#')
     return -1;
   return atoi (ptr);
@@ -87,7 +87,7 @@
 int
 tgetflag (const char *cap)
 {
-  register char *ptr = find_capability (term_entry, cap);
+  char *ptr = find_capability (term_entry, cap);
   return ptr && ptr[-1] == ':';
 }
 
@@ -99,7 +99,7 @@
 char *
 tgetstr (const char *cap, char **area)
 {
-  register char *ptr = find_capability (term_entry, cap);
+  char *ptr = find_capability (term_entry, cap);
   if (!ptr || (ptr[-1] != '=' && ptr[-1] != '~'))
     return NULL;
   return tgetst1 (ptr, area);
@@ -137,11 +137,11 @@
 static char *
 tgetst1 (char *ptr, char **area)
 {
-  register char *p, *r;
-  register int c;
-  register int size;
+  char *p, *r;
+  int c;
+  int size;
   char *ret;
-  register int c1;
+  int c1;
 
   if (!ptr)
     return NULL;
@@ -216,7 +216,7 @@
      abbreviation expansion makes that effort a little more hairy than
      its worth; this is cleaner.  */
   {
-    register int last_p_param = 0;
+    int last_p_param = 0;
     int remove_p_params = 1;
     struct { char *beg; int len; } cut[11];
 
@@ -241,7 +241,7 @@
       }
     if (remove_p_params && last_p_param)
       {
-	register int i;
+	int i;
 	char *wp;
 
 	cut[last_p_param].len = r - cut[last_p_param].beg;
@@ -263,10 +263,10 @@
 char PC;
 
 void
-tputs (register const char *str, int nlines, int (*outfun) (int))
+tputs (const char *str, int nlines, int (*outfun) (int))
 {
-  register int padcount = 0;
-  register int speed;
+  int padcount = 0;
+  int speed;
 
   speed = baud_rate;
   /* For quite high speeds, convert to the smaller
@@ -327,9 +327,10 @@
 
 /* Forward declarations of static functions.  */
 
-static int scan_file (char *str, int fd, register struct termcap_buffer *bufp);
-static char *gobble_line (int fd, register struct termcap_buffer *bufp, char *append_end);
-static int compare_contin (register char *str1, register char *str2);
+static int scan_file (char *str, int fd, struct termcap_buffer *bufp);
+static char *gobble_line (int fd, struct termcap_buffer *bufp,
+			  char *append_end);
+static int compare_contin (char *str1, char *str2);
 static int name_match (char *line, char *name);
 
 #ifdef MSDOS /* MW, May 1993 */
@@ -356,14 +357,14 @@
 int
 tgetent (char *bp, const char *name)
 {
-  register char *termcap_name;
-  register int fd;
+  char *termcap_name;
+  int fd;
   struct termcap_buffer buf;
-  register char *bp1;
+  char *bp1;
   char *tc_search_point;
   char *term;
   ptrdiff_t malloc_size = 0;
-  register int c;
+  int c;
   char *tcenv = NULL;		/* TERMCAP value, if it contains :tc=.  */
   char *indirect = NULL;	/* Terminal type in :tc= in TERMCAP value.  */
   int filep;
@@ -518,9 +519,9 @@
    or 0 if no entry is found in the file.  */
 
 static int
-scan_file (char *str, int fd, register struct termcap_buffer *bufp)
+scan_file (char *str, int fd, struct termcap_buffer *bufp)
 {
-  register char *end;
+  char *end;
 
   bufp->ptr = bufp->beg;
   bufp->full = 0;
@@ -557,7 +558,7 @@
 static int
 name_match (char *line, char *name)
 {
-  register char *tem;
+  char *tem;
 
   if (!compare_contin (line, name))
     return 1;
@@ -570,9 +571,9 @@
 }
 
 static int
-compare_contin (register char *str1, register char *str2)
+compare_contin (char *str1, char *str2)
 {
-  register int c1, c2;
+  int c1, c2;
   while (1)
     {
       c1 = *str1++;
@@ -610,11 +611,11 @@
    thing as one line.  The caller decides when a line is continued.  */
 
 static char *
-gobble_line (int fd, register struct termcap_buffer *bufp, char *append_end)
+gobble_line (int fd, struct termcap_buffer *bufp, char *append_end)
 {
-  register char *end;
-  register int nread;
-  register char *buf = bufp->beg;
+  char *end;
+  int nread;
+  char *buf = bufp->beg;
 
   if (!append_end)
     append_end = bufp->ptr;
@@ -663,7 +664,7 @@
 tprint (char *cap)
 {
   char *x = tgetstr (cap, 0);
-  register char *y;
+  char *y;
 
   printf ("%s: ", cap);
   if (x)

=== modified file 'src/textprop.c'
--- src/textprop.c	2012-05-25 18:19:24 +0000
+++ src/textprop.c	2012-06-03 05:53:38 +0000
@@ -119,7 +119,7 @@
 INTERVAL
 validate_interval_range (Lisp_Object object, Lisp_Object *begin, Lisp_Object *end, int force)
 {
-  register INTERVAL i;
+  INTERVAL i;
   ptrdiff_t searchpos;
 
   CHECK_STRING_OR_BUFFER (object);
@@ -141,7 +141,7 @@
 
   if (BUFFERP (object))
     {
-      register struct buffer *b = XBUFFER (object);
+      struct buffer *b = XBUFFER (object);
 
       if (!(BUF_BEGV (b) <= XINT (*begin) && XINT (*begin) <= XINT (*end)
 	    && XINT (*end) <= BUF_ZV (b)))
@@ -190,8 +190,8 @@
 
   if (CONSP (list))
     {
-      register int i;
-      register Lisp_Object tail;
+      int i;
+      Lisp_Object tail;
       for (i = 0, tail = list; CONSP (tail); i++)
 	{
 	  tail = XCDR (tail);
@@ -211,8 +211,8 @@
 static int
 interval_has_all_properties (Lisp_Object plist, INTERVAL i)
 {
-  register Lisp_Object tail1, tail2, sym1;
-  register int found;
+  Lisp_Object tail1, tail2, sym1;
+  int found;
 
   /* Go through each element of PLIST.  */
   for (tail1 = plist; CONSP (tail1); tail1 = Fcdr (XCDR (tail1)))
@@ -247,7 +247,7 @@
 static inline int
 interval_has_some_properties (Lisp_Object plist, INTERVAL i)
 {
-  register Lisp_Object tail1, tail2, sym;
+  Lisp_Object tail1, tail2, sym;
 
   /* Go through each element of PLIST.  */
   for (tail1 = plist; CONSP (tail1); tail1 = Fcdr (XCDR (tail1)))
@@ -269,7 +269,7 @@
 static inline int
 interval_has_some_properties_list (Lisp_Object list, INTERVAL i)
 {
-  register Lisp_Object tail1, tail2, sym;
+  Lisp_Object tail1, tail2, sym;
 
   /* Go through each element of LIST.  */
   for (tail1 = list; CONSP (tail1); tail1 = XCDR (tail1))
@@ -357,8 +357,8 @@
 add_properties (Lisp_Object plist, INTERVAL i, Lisp_Object object)
 {
   Lisp_Object tail1, tail2, sym1, val1;
-  register int changed = 0;
-  register int found;
+  int changed = 0;
+  int found;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
   tail1 = plist;
@@ -382,7 +382,7 @@
 	  {
 	    /* No need to gcpro, because tail2 protects this
 	       and it must be a cons cell (we get an error otherwise).  */
-	    register Lisp_Object this_cdr;
+	    Lisp_Object this_cdr;
 
 	    this_cdr = XCDR (tail2);
 	    /* Found the property.  Now check its value.  */
@@ -432,8 +432,8 @@
 static int
 remove_properties (Lisp_Object plist, Lisp_Object list, INTERVAL i, Lisp_Object object)
 {
-  register Lisp_Object tail1, tail2, sym, current_plist;
-  register int changed = 0;
+  Lisp_Object tail1, tail2, sym, current_plist;
+  int changed = 0;
 
   /* Nonzero means tail1 is a plist, otherwise it is a list.  */
   int use_plist;
@@ -466,7 +466,7 @@
       tail2 = current_plist;
       while (! NILP (tail2))
 	{
-	  register Lisp_Object this;
+	  Lisp_Object this;
 	  this = XCDR (XCDR (tail2));
 	  if (CONSP (this) && EQ (sym, XCAR (this)))
 	    {
@@ -512,7 +512,7 @@
 INTERVAL
 interval_of (ptrdiff_t position, Lisp_Object object)
 {
-  register INTERVAL i;
+  INTERVAL i;
   ptrdiff_t beg, end;
 
   if (NILP (object))
@@ -524,7 +524,7 @@
 
   if (BUFFERP (object))
     {
-      register struct buffer *b = XBUFFER (object);
+      struct buffer *b = XBUFFER (object);
 
       beg = BUF_BEGV (b);
       end = BUF_ZV (b);
@@ -554,7 +554,7 @@
 If POSITION is at the end of OBJECT, the value is nil.  */)
   (Lisp_Object position, Lisp_Object object)
 {
-  register INTERVAL i;
+  INTERVAL i;
 
   if (NILP (object))
     XSETBUFFER (object, current_buffer);
@@ -593,7 +593,8 @@
    window-specific overlays are considered only if they are associated
    with OBJECT. */
 Lisp_Object
-get_char_property_and_overlay (Lisp_Object position, register Lisp_Object prop, Lisp_Object object, Lisp_Object *overlay)
+get_char_property_and_overlay (Lisp_Object position, Lisp_Object prop,
+			       Lisp_Object object, Lisp_Object *overlay)
 {
   struct window *w = 0;
 
@@ -926,7 +927,7 @@
 past position LIMIT; return LIMIT if nothing is found before LIMIT.  */)
   (Lisp_Object position, Lisp_Object object, Lisp_Object limit)
 {
-  register INTERVAL i, next;
+  INTERVAL i, next;
 
   if (NILP (object))
     XSETBUFFER (object, current_buffer);
@@ -991,8 +992,8 @@
 past position LIMIT; return LIMIT if nothing is found before LIMIT.  */)
   (Lisp_Object position, Lisp_Object prop, Lisp_Object object, Lisp_Object limit)
 {
-  register INTERVAL i, next;
-  register Lisp_Object here_val;
+  INTERVAL i, next;
+  Lisp_Object here_val;
 
   if (NILP (object))
     XSETBUFFER (object, current_buffer);
@@ -1038,7 +1039,7 @@
 back past position LIMIT; return LIMIT if nothing is found until LIMIT.  */)
   (Lisp_Object position, Lisp_Object object, Lisp_Object limit)
 {
-  register INTERVAL i, previous;
+  INTERVAL i, previous;
 
   if (NILP (object))
     XSETBUFFER (object, current_buffer);
@@ -1086,8 +1087,8 @@
 back past position LIMIT; return LIMIT if nothing is found until LIMIT.  */)
   (Lisp_Object position, Lisp_Object prop, Lisp_Object object, Lisp_Object limit)
 {
-  register INTERVAL i, previous;
-  register Lisp_Object here_val;
+  INTERVAL i, previous;
+  Lisp_Object here_val;
 
   if (NILP (object))
     XSETBUFFER (object, current_buffer);
@@ -1135,9 +1136,9 @@
 Return t if any property value actually changed, nil otherwise.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object)
 {
-  register INTERVAL i, unchanged;
-  register ptrdiff_t s, len;
-  register int modified = 0;
+  INTERVAL i, unchanged;
+  ptrdiff_t s, len;
+  int modified = 0;
   struct gcpro gcpro1;
 
   properties = validate_plist (properties);
@@ -1276,7 +1277,7 @@
 Lisp_Object
 set_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object, Lisp_Object coherent_change_p)
 {
-  register INTERVAL i;
+  INTERVAL i;
   Lisp_Object ostart, oend;
 
   ostart = start;
@@ -1340,8 +1341,8 @@
 void
 set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object buffer, INTERVAL i)
 {
-  register INTERVAL prev_changed = NULL_INTERVAL;
-  register ptrdiff_t s, len;
+  INTERVAL prev_changed = NULL_INTERVAL;
+  ptrdiff_t s, len;
   INTERVAL unchanged;
 
   if (XINT (start) < XINT (end))
@@ -1433,9 +1434,9 @@
 Use `set-text-properties' if you want to remove all text properties.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object)
 {
-  register INTERVAL i, unchanged;
-  register ptrdiff_t s, len;
-  register int modified = 0;
+  INTERVAL i, unchanged;
+  ptrdiff_t s, len;
+  int modified = 0;
 
   if (NILP (object))
     XSETBUFFER (object, current_buffer);
@@ -1519,9 +1520,9 @@
 Return t if any property was actually removed, nil otherwise.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object list_of_properties, Lisp_Object object)
 {
-  register INTERVAL i, unchanged;
-  register ptrdiff_t s, len;
-  register int modified = 0;
+  INTERVAL i, unchanged;
+  ptrdiff_t s, len;
+  int modified = 0;
   Lisp_Object properties;
   properties = list_of_properties;
 
@@ -1629,8 +1630,8 @@
 markers).  If OBJECT is a string, START and END are 0-based indices into it.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object property, Lisp_Object value, Lisp_Object object)
 {
-  register INTERVAL i;
-  register ptrdiff_t e, pos;
+  INTERVAL i;
+  ptrdiff_t e, pos;
 
   if (NILP (object))
     XSETBUFFER (object, current_buffer);
@@ -1665,8 +1666,8 @@
 markers).  If OBJECT is a string, START and END are 0-based indices into it.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object property, Lisp_Object value, Lisp_Object object)
 {
-  register INTERVAL i;
-  register ptrdiff_t s, e;
+  INTERVAL i;
+  ptrdiff_t s, e;
 
   if (NILP (object))
     XSETBUFFER (object, current_buffer);
@@ -2015,10 +2016,10 @@
 verify_interval_modification (struct buffer *buf,
 			      ptrdiff_t start, ptrdiff_t end)
 {
-  register INTERVAL intervals = BUF_INTERVALS (buf);
-  register INTERVAL i;
+  INTERVAL intervals = BUF_INTERVALS (buf);
+  INTERVAL i;
   Lisp_Object hooks;
-  register Lisp_Object prev_mod_hooks;
+  Lisp_Object prev_mod_hooks;
   Lisp_Object mod_hooks;
   struct gcpro gcpro1;

=== modified file 'src/tparam.c'
--- src/tparam.c	2012-05-21 15:36:54 +0000
+++ src/tparam.c	2012-06-03 05:53:38 +0000
@@ -69,16 +69,16 @@
 
 static char *
 tparam1 (const char *string, char *outstring, int len,
-	 char *up, char *left, register int *argp)
+	 char *up, char *left, int *argp)
 {
-  register int c;
-  register const char *p = string;
-  register char *op = outstring;
+  int c;
+  const char *p = string;
+  char *op = outstring;
   char *outend;
   char *new = 0;
   ptrdiff_t outlen = 0;
 
-  register int tem;
+  int tem;
   int *old_argp = argp;                 /* can move */
   int *fixed_argp = argp;               /* never moves */
   int explicit_param_p = 0;             /* set by %p */

=== modified file 'src/undo.c'
--- src/undo.c	2012-05-25 18:19:24 +0000
+++ src/undo.c	2012-06-03 05:53:38 +0000
@@ -452,7 +452,7 @@
   struct gcpro gcpro1, gcpro2;
   Lisp_Object next;
   ptrdiff_t count = SPECPDL_INDEX ();
-  register EMACS_INT arg;
+  EMACS_INT arg;
   Lisp_Object oldlist;
   int did_apply = 0;

=== modified file 'src/unexcoff.c'
--- src/unexcoff.c	2012-01-19 07:21:25 +0000
+++ src/unexcoff.c	2012-06-03 05:53:38 +0000
@@ -161,7 +161,7 @@
   auto struct scnhdr f_dhdr;		/* Data section header */
   auto struct scnhdr f_bhdr;		/* Bss section header */
   auto struct scnhdr scntemp;		/* Temporary section header */
-  register int scns;
+  int scns;
   unsigned int bss_start;
   unsigned int data_start;
 
@@ -313,7 +313,7 @@
 void
 write_segment (int new, const char *ptr, const char *end)
 {
-  register int i, nwrite, ret;
+  int i, nwrite, ret;
   /* This is the normal amount to write at once.
      It is the size of block that NFS uses.  */
   int writesize = 1 << 13;
@@ -358,8 +358,8 @@
 static int
 copy_text_and_data (int new, int a_out)
 {
-  register char *end;
-  register char *ptr;
+  char *end;
+  char *ptr;
 
 #ifdef MSDOS
   /* Dump the original table of exception handlers, not the one
@@ -479,8 +479,8 @@
 int
 adjust_lnnoptrs (int writedesc, int readdesc, const char *new_name)
 {
-  register int nsyms;
-  register int new;
+  int nsyms;
+  int new;
   struct syment symentry;
   union auxent auxentry;

=== modified file 'src/vm-limit.c'
--- src/vm-limit.c	2012-05-21 15:36:54 +0000
+++ src/vm-limit.c	2012-06-03 05:53:38 +0000
@@ -170,7 +170,7 @@
 #endif
   extern POINTER (*__morecore) (long);
 
-  register POINTER cp;
+  POINTER cp;
   unsigned long five_percent;
   unsigned long data_size;
   enum warnlevel new_warnlevel;

=== modified file 'src/window.c'
--- src/window.c	2012-06-01 03:41:03 +0000
+++ src/window.c	2012-06-03 05:53:38 +0000
@@ -131,7 +131,7 @@
 static EMACS_INT window_scroll_preserve_vpos;
 
 static struct window *
-decode_window (register Lisp_Object window)
+decode_window (Lisp_Object window)
 {
   if (NILP (window))
     return XWINDOW (selected_window);
@@ -141,7 +141,7 @@
 }
 
 static struct window *
-decode_any_window (register Lisp_Object window)
+decode_any_window (Lisp_Object window)
 {
   if (NILP (window))
     return XWINDOW (selected_window);
@@ -319,8 +319,8 @@
 static Lisp_Object
 select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
 {
-  register struct window *w;
-  register struct window *ow;
+  struct window *w;
+  struct window *ow;
   struct frame *sf;
 
   CHECK_LIVE_WINDOW (window);
@@ -378,7 +378,7 @@
      redisplay_window has altered point after scrolling,
      because it makes the change only in the window.  */
   {
-    register ptrdiff_t new_point = marker_position (w->pointm);
+    ptrdiff_t new_point = marker_position (w->pointm);
     if (new_point < BEGV)
       SET_PT (BEGV);
     else if (new_point > ZV)
@@ -402,7 +402,7 @@
 
 Note that the main editor command loop sets the current buffer to the
 buffer of the selected window before each command.  */)
-  (register Lisp_Object window, Lisp_Object norecord)
+  (Lisp_Object window, Lisp_Object norecord)
 {
   return select_window (window, norecord, 0);
 }
@@ -483,7 +483,7 @@
 for future use.  */)
   (Lisp_Object window, Lisp_Object limit)
 {
-  register struct window *w = decode_any_window (window);
+  struct window *w = decode_any_window (window);
 
   w->combination_limit = limit;
 
@@ -711,9 +711,9 @@
 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
 with two arguments: WINDOW, and the end trigger value.
 Afterwards the end-trigger value is reset to nil.  */)
-  (register Lisp_Object window, Lisp_Object value)
+  (Lisp_Object window, Lisp_Object value)
 {
-  register struct window *w;
+  struct window *w;
 
   w = decode_window (window);
   w->redisplay_end_trigger = value;
@@ -733,7 +733,7 @@
 just the text area, use `window-inside-edges'.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_any_window (window);
+  struct window *w = decode_any_window (window);
 
   return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w)),
 	 Fcons (make_number (WINDOW_TOP_EDGE_LINE (w)),
@@ -754,7 +754,7 @@
 of just the text area, use `window-inside-pixel-edges'.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_any_window (window);
+  struct window *w = decode_any_window (window);
 
   return Fcons (make_number (WINDOW_LEFT_EDGE_X (w)),
 	 Fcons (make_number (WINDOW_TOP_EDGE_Y (w)),
@@ -798,7 +798,7 @@
 of just the text area, use `window-inside-absolute-pixel-edges'.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_any_window (window);
+  struct window *w = decode_any_window (window);
   int add_x, add_y;
   calc_absolute_offset (w, &add_x, &add_y);
 
@@ -821,7 +821,7 @@
 bar, display margins, fringes, header line, and/or mode line.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_window (window);
+  struct window *w = decode_window (window);
 
   return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w)
 			     + WINDOW_LEFT_MARGIN_COLS (w)
@@ -846,7 +846,7 @@
 display margins, fringes, header line, and/or mode line.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_window (window);
+  struct window *w = decode_window (window);
 
   return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w)
 			     + WINDOW_LEFT_MARGIN_WIDTH (w)
@@ -873,7 +873,7 @@
 display margins, fringes, header line, and/or mode line.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_window (window);
+  struct window *w = decode_window (window);
   int add_x, add_y;
   calc_absolute_offset (w, &add_x, &add_y);
 
@@ -905,7 +905,7 @@
    X and Y are frame relative pixel coordinates.  */
 
 static enum window_part
-coordinates_in_window (register struct window *w, int x, int y)
+coordinates_in_window (struct window *w, int x, int y)
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
   enum window_part part;
@@ -1067,7 +1067,7 @@
   `vertical-line' is returned.
 If they are in the windows's left or right marginal areas, `left-margin'\n\
   or `right-margin' is returned.  */)
-  (register Lisp_Object coordinates, Lisp_Object window)
+  (Lisp_Object coordinates, Lisp_Object window)
 {
   struct window *w;
   struct frame *f;
@@ -1253,7 +1253,7 @@
 But that is hard to define.  */)
   (Lisp_Object window)
 {
-  register struct window *w = decode_window (window);
+  struct window *w = decode_window (window);
 
   if (w == XWINDOW (selected_window)
       && current_buffer == XBUFFER (w->buffer))
@@ -1364,7 +1364,7 @@
 Return POS.  */)
   (Lisp_Object window, Lisp_Object pos)
 {
-  register struct window *w = decode_window (window);
+  struct window *w = decode_window (window);
 
   CHECK_NUMBER_COERCE_MARKER (pos);
   if (w == XWINDOW (selected_window)
@@ -1388,7 +1388,7 @@
 overriding motion of point in order to display at this exact start.  */)
   (Lisp_Object window, Lisp_Object pos, Lisp_Object noforce)
 {
-  register struct window *w = decode_window (window);
+  struct window *w = decode_window (window);
 
   CHECK_NUMBER_COERCE_MARKER (pos);
   set_marker_restricted (w->start, pos, w->buffer);
@@ -1424,9 +1424,9 @@
 display row, and VPOS is the row number (0-based) containing POS.  */)
   (Lisp_Object pos, Lisp_Object window, Lisp_Object partially)
 {
-  register struct window *w;
-  register EMACS_INT posint;
-  register struct buffer *buf;
+  struct window *w;
+  EMACS_INT posint;
+  struct buffer *buf;
   struct text_pos top;
   Lisp_Object in_window = Qnil;
   int rtop, rbot, rowh, vpos, fully_p = 1;
@@ -1492,8 +1492,8 @@
 `pos-visible-in-window-p' to obtain the information.  */)
   (Lisp_Object line, Lisp_Object window)
 {
-  register struct window *w;
-  register struct buffer *b;
+  struct window *w;
+  struct buffer *b;
   struct glyph_row *row, *end_row;
   int max_y, crop, i;
   EMACS_INT n;
@@ -1624,7 +1624,7 @@
 window, it also makes sure that the window is no more dedicated.  */)
   (Lisp_Object window, Lisp_Object flag)
 {
-  register struct window *w = decode_window (window);
+  struct window *w = decode_window (window);
 
   w->dedicated = flag;
   return w->dedicated;
@@ -1703,7 +1703,7 @@
 WINDOW defaults to the selected window.  Return VALUE.  */)
   (Lisp_Object window, Lisp_Object parameter, Lisp_Object value)
 {
-  register struct window *w = decode_any_window (window);
+  struct window *w = decode_any_window (window);
   Lisp_Object old_alist_elt;
 
   old_alist_elt = Fassq (parameter, w->window_parameters);
@@ -1750,9 +1750,9 @@
 
 DEFUN ("set-window-display-table", Fset_window_display_table, Sset_window_display_table, 2, 2, 0,
        doc: /* Set WINDOW's display-table to TABLE.  */)
-  (register Lisp_Object window, Lisp_Object table)
+  (Lisp_Object window, Lisp_Object table)
 {
-  register struct window *w;
+  struct window *w;
 
   w = decode_window (window);
   w->display_table = table;
@@ -1762,7 +1762,7 @@
 /* Record info on buffer window W is displaying
    when it is about to cease to display that buffer.  */
 static void
-unshow_buffer (register struct window *w)
+unshow_buffer (struct window *w)
 {
   Lisp_Object buf;
   struct buffer *b;
@@ -1814,8 +1814,8 @@
 static void
 replace_window (Lisp_Object old, Lisp_Object new, int setflag)
 {
-  register Lisp_Object tem;
-  register struct window *o = XWINDOW (old), *n = XWINDOW (new);
+  Lisp_Object tem;
+  struct window *o = XWINDOW (old), *n = XWINDOW (new);
 
   /* If OLD is its frame's root window, then NEW is the new
      root window for that frame.  */
@@ -3078,10 +3078,10 @@
 
 This function runs `window-scroll-functions' before running
 `window-configuration-change-hook'.  */)
-  (register Lisp_Object window, Lisp_Object buffer_or_name, Lisp_Object keep_margins)
+  (Lisp_Object window, Lisp_Object buffer_or_name, Lisp_Object keep_margins)
 {
-  register Lisp_Object tem, buffer;
-  register struct window *w = decode_window (window);
+  Lisp_Object tem, buffer;
+  struct window *w = decode_window (window);
 
   XSETWINDOW (window, w);
   buffer = Fget_buffer (buffer_or_name);
@@ -3168,11 +3168,11 @@

 void
-temp_output_buffer_show (register Lisp_Object buf)
+temp_output_buffer_show (Lisp_Object buf)
 {
-  register struct buffer *old = current_buffer;
-  register Lisp_Object window;
-  register struct window *w;
+  struct buffer *old = current_buffer;
+  Lisp_Object window;
+  struct window *w;
 
   BVAR (XBUFFER (buf), directory) = BVAR (current_buffer, directory);
 
@@ -3237,7 +3237,7 @@
 make_parent_window (Lisp_Object window, int horflag)
 {
   Lisp_Object parent;
-  register struct window *o, *p;
+  struct window *o, *p;
   int i;
 
   o = XWINDOW (window);
@@ -3270,7 +3270,7 @@
 make_window (void)
 {
   Lisp_Object window;
-  register struct window *w;
+  struct window *w;
 
   w = allocate_window ();
   /* Initialize all Lisp data.  */
@@ -3677,8 +3677,8 @@
      provided OLD is a leaf window, or to the frame's selected window.
      NEW (*n) is the new window created with some parameters taken from
      REFERENCE (*r).  */
-  register Lisp_Object new, frame, reference;
-  register struct window *o, *p, *n, *r;
+  Lisp_Object new, frame, reference;
+  struct window *o, *p, *n, *r;
   struct frame *f;
   int horflag
     /* HORFLAG is 1 when we split side-by-side, 0 otherwise.  */
@@ -3842,9 +3842,9 @@
        doc: /* Remove WINDOW from its frame.
 WINDOW defaults to the selected window.  Return nil.
 Signal an error when WINDOW is the only window on its frame.  */)
-     (register Lisp_Object window)
+     (Lisp_Object window)
 {
-  register Lisp_Object parent, sibling, frame, root;
+  Lisp_Object parent, sibling, frame, root;
   struct window *w, *p, *s, *r;
   struct frame *f;
   int horflag;
@@ -4577,16 +4577,16 @@
 static void
 window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
 {
-  register struct window *w = XWINDOW (window);
+  struct window *w = XWINDOW (window);
   /* Fvertical_motion enters redisplay, which can trigger
      fontification, which in turn can modify buffer text (e.g., if the
      fontification functions replace escape sequences with faces, as
      in `grep-mode-font-lock-keywords').  So we use a marker to record
      the old point position, to prevent crashes in SET_PT_BOTH.  */
   Lisp_Object opoint_marker = Fpoint_marker ();
-  register ptrdiff_t pos, pos_byte;
-  register int ht = window_internal_height (w);
-  register Lisp_Object tem;
+  ptrdiff_t pos, pos_byte;
+  int ht = window_internal_height (w);
+  Lisp_Object tem;
   int lose;
   Lisp_Object bolp;
   ptrdiff_t startpos;
@@ -4892,7 +4892,7 @@
 lower bound for automatic scrolling, i.e. automatic scrolling
 will not scroll a window to a column less than the value returned
 by this function.  This happens in an interactive call.  */)
-  (register Lisp_Object arg, Lisp_Object set_minimum)
+  (Lisp_Object arg, Lisp_Object set_minimum)
 {
   Lisp_Object result;
   EMACS_INT hscroll;
@@ -4921,7 +4921,7 @@
 lower bound for automatic scrolling, i.e. automatic scrolling
 will not scroll a window to a column less than the value returned
 by this function.  This happens in an interactive call.  */)
-  (register Lisp_Object arg, Lisp_Object set_minimum)
+  (Lisp_Object arg, Lisp_Object set_minimum)
 {
   Lisp_Object result;
   EMACS_INT hscroll;
@@ -5029,7 +5029,7 @@
 
 Just C-u as prefix means put point in the center of the window
 and redisplay normally--don't erase and redraw the frame.  */)
-  (register Lisp_Object arg)
+  (Lisp_Object arg)
 {
   struct window *w = XWINDOW (selected_window);
   struct buffer *buf = XBUFFER (w->buffer);
@@ -5356,7 +5356,7 @@
        doc: /* Return the frame that CONFIG, a window-configuration object, is about.  */)
   (Lisp_Object config)
 {
-  register struct save_window_data *data;
+  struct save_window_data *data;
   struct Lisp_Vector *saved_windows;
 
   CHECK_WINDOW_CONFIGURATION (config);
@@ -5376,7 +5376,7 @@
 the return value is nil.  Otherwise the value is t.  */)
   (Lisp_Object configuration)
 {
-  register struct save_window_data *data;
+  struct save_window_data *data;
   struct Lisp_Vector *saved_windows;
   Lisp_Object new_current_buffer;
   Lisp_Object frame;
@@ -5438,9 +5438,9 @@
     {
       Lisp_Object window;
       Lisp_Object dead_windows = Qnil;
-      register Lisp_Object tem, par, pers;
-      register struct window *w;
-      register struct saved_window *p;
+      Lisp_Object tem, par, pers;
+      struct window *w;
+      struct saved_window *p;
       struct window *root_window;
       struct window **leaf_windows;
       int n_leaf_windows;
@@ -5750,7 +5750,7 @@
 void
 delete_all_child_windows (Lisp_Object window)
 {
-  register struct window *w;
+  struct window *w;
 
   w = XWINDOW (window);
 
@@ -5782,9 +5782,9 @@
 }
 
 static int
-count_windows (register struct window *window)
+count_windows (struct window *window)
 {
-  register int count = 1;
+  int count = 1;
   if (!NILP (window->next))
     count += count_windows (XWINDOW (window->next));
   if (!NILP (window->vchild))
@@ -5858,9 +5858,9 @@
 static int
 save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
 {
-  register struct saved_window *p;
-  register struct window *w;
-  register Lisp_Object tem, pers, par;
+  struct saved_window *p;
+  struct window *w;
+  Lisp_Object tem, pers, par;
 
   for (;!NILP (window); window = w->next)
     {
@@ -6000,10 +6000,10 @@
 saved by this function.  */)
   (Lisp_Object frame)
 {
-  register Lisp_Object tem;
-  register int n_windows;
-  register struct save_window_data *data;
-  register int i;
+  Lisp_Object tem;
+  int n_windows;
+  struct save_window_data *data;
+  int i;
   FRAME_PTR f;
 
   if (NILP (frame))
@@ -6407,7 +6407,7 @@
 int
 compare_window_configurations (Lisp_Object configuration1, Lisp_Object configuration2, int ignore_positions)
 {
-  register struct save_window_data *d1, *d2;
+  struct save_window_data *d1, *d2;
   struct Lisp_Vector *sws1, *sws2;
   ptrdiff_t i;

=== modified file 'src/xdisp.c'
--- src/xdisp.c	2012-06-01 03:41:03 +0000
+++ src/xdisp.c	2012-06-03 05:53:38 +0000
@@ -1756,7 +1756,7 @@
    not force the value into range.  */
 
 void
-pixel_to_glyph_coords (FRAME_PTR f, register int pix_x, register int pix_y,
+pixel_to_glyph_coords (FRAME_PTR f, int pix_x, int pix_y,
 		       int *x, int *y, NativeRectangle *bounds, int noclip)
 {
 
@@ -3235,7 +3235,7 @@
 static void
 compute_stop_pos (struct it *it)
 {
-  register INTERVAL iv, next_iv;
+  INTERVAL iv, next_iv;
   Lisp_Object object, limit, position;
   ptrdiff_t charpos, bytepos;
 
@@ -11135,7 +11135,7 @@
 update_menu_bar (struct frame *f, int save_match_data, int hooks_run)
 {
   Lisp_Object window;
-  register struct window *w;
+  struct window *w;
 
   /* If called recursively during a menu update, do nothing.  This can
      happen when, for instance, an activate-menubar-hook causes a
@@ -20145,8 +20145,8 @@
 static Lisp_Object
 move_elt_to_front (Lisp_Object elt, Lisp_Object list)
 {
-  register Lisp_Object tail, prev;
-  register Lisp_Object tem;
+  Lisp_Object tail, prev;
+  Lisp_Object tem;
 
   tail = list;
   prev = Qnil;
@@ -20463,7 +20463,7 @@
 	 Special case: if value of symbol is a string, output the string
 	 literally.  */
       {
-	register Lisp_Object tem;
+	Lisp_Object tem;
 
 	/* If the variable is not marked as risky to set
 	   then its contents are risky to use.  */
@@ -20491,7 +20491,7 @@
 
     case Lisp_Cons:
       {
-	register Lisp_Object car, tem;
+	Lisp_Object car, tem;
 
 	/* A cons cell: five distinct cases.
 	   If first element is :eval or :propertize, do something special.
@@ -20563,7 +20563,7 @@
 	  }
 	else if (INTEGERP (car))
 	  {
-	    register int lim = XINT (car);
+	    int lim = XINT (car);
 	    elt = XCDR (elt);
 	    if (lim < 0)
 	      {
@@ -20853,9 +20853,9 @@
    the positive integer D to BUF using a minimal field width WIDTH.  */
 
 static void
-pint2str (register char *buf, register int width, register ptrdiff_t d)
+pint2str (char *buf, int width, ptrdiff_t d)
 {
-  register char *p = buf;
+  char *p = buf;
 
   if (d <= 0)
     *p++ = '0';
@@ -20997,7 +20997,7 @@
 static unsigned char invalid_eol_type[] = "(*invalid*)";
 
 static char *
-decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_flag)
+decode_mode_spec_coding (Lisp_Object coding_system, char *buf, int eol_flag)
 {
   Lisp_Object val;
   int multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
@@ -21082,8 +21082,7 @@
 static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
 
 static const char *
-decode_mode_spec (struct window *w, register int c, int field_width,
-		  Lisp_Object *string)
+decode_mode_spec (struct window *w, int c, int field_width, Lisp_Object *string)
 {
   Lisp_Object obj;
   struct frame *f = XFRAME (WINDOW_FRAME (w));
@@ -21149,7 +21148,7 @@
 
     case '-':
       {
-	register int i;
+	int i;
 
 	/* Let lots_of_dashes be a string of infinite length.  */
 	if (mode_line_target == MODE_LINE_NOPROP ||
@@ -21502,11 +21501,11 @@
 		     ptrdiff_t limit_byte, ptrdiff_t count,
 		     ptrdiff_t *byte_pos_ptr)
 {
-  register unsigned char *cursor;
+  unsigned char *cursor;
   unsigned char *base;
 
-  register ptrdiff_t ceiling;
-  register unsigned char *ceiling_addr;
+  ptrdiff_t ceiling;
+  unsigned char *ceiling_addr;
   ptrdiff_t orig_count = count;
 
   /* If we are not in selective display mode,
@@ -21853,13 +21852,13 @@
    and 1 if it's invisible and without an ellipsis.  */
 
 int
-invisible_p (register Lisp_Object propval, Lisp_Object list)
+invisible_p (Lisp_Object propval, Lisp_Object list)
 {
-  register Lisp_Object tail, proptail;
+  Lisp_Object tail, proptail;
 
   for (tail = list; CONSP (tail); tail = XCDR (tail))
     {
-      register Lisp_Object tem;
+      Lisp_Object tem;
       tem = XCAR (tail);
       if (EQ (propval, tem))
 	return 1;
@@ -21875,7 +21874,7 @@
 	  propelt = XCAR (proptail);
 	  for (tail = list; CONSP (tail); tail = XCDR (tail))
 	    {
-	      register Lisp_Object tem;
+	      Lisp_Object tem;
 	      tem = XCAR (tail);
 	      if (EQ (propelt, tem))
 		return 1;

=== modified file 'src/xfns.c'
--- src/xfns.c	2012-06-01 20:49:03 +0000
+++ src/xfns.c	2012-06-03 05:53:38 +0000
@@ -3873,25 +3873,25 @@
 }
 
 int
-x_pixel_width (register struct frame *f)
+x_pixel_width (struct frame *f)
 {
   return FRAME_PIXEL_WIDTH (f);
 }
 
 int
-x_pixel_height (register struct frame *f)
+x_pixel_height (struct frame *f)
 {
   return FRAME_PIXEL_HEIGHT (f);
 }
 
 int
-x_char_width (register struct frame *f)
+x_char_width (struct frame *f)
 {
   return FRAME_COLUMN_WIDTH (f);
 }
 
 int
-x_char_height (register struct frame *f)
+x_char_height (struct frame *f)
 {
   return FRAME_LINE_HEIGHT (f);
 }
@@ -3929,7 +3929,7 @@
 
 int
 XScreenNumberOfScreen (scr)
-    register Screen *scr;
+    Screen *scr;
 {
   Display *dpy = scr->display;
   int i;

=== modified file 'src/xterm.c'
--- src/xterm.c	2012-05-31 06:51:43 +0000
+++ src/xterm.c	2012-06-03 05:53:38 +0000
@@ -2941,7 +2941,7 @@
    for X frames.  */
 
 static void
-x_delete_glyphs (struct frame *f, register int n)
+x_delete_glyphs (struct frame *f, int n)
 {
   abort ();
 }
@@ -8269,7 +8269,7 @@
    which means, do adjust for borders but don't change the gravity.  */
 
 void
-x_set_offset (struct frame *f, register int xoff, register int yoff, int change_gravity)
+x_set_offset (struct frame *f, int xoff, int yoff, int change_gravity)
 {
   int modified_top, modified_left;
 
=== modified file 'lib-src/ChangeLog'
--- lib-src/ChangeLog	2012-05-31 06:08:06 +0000
+++ lib-src/ChangeLog	2012-06-03 05:55:23 +0000
@@ -1,3 +1,8 @@
+2012-06-03  Paul Eggert  <[email-masked]>
+
+	Don't use 'register'; these days it's not needed.
+	* etags.c, hexl.c, make-docfile.c, movemail.c, pop.c: Omit 'register'.
+
 2012-05-31  Eli Zaretskii  <[email-masked]>
 
 	* makefile.w32-in ($(BLD)/emacsclientw.exe): Use $(MWINDOWS)

=== modified file 'lib-src/etags.c'
--- lib-src/etags.c	2012-05-21 15:36:54 +0000
+++ lib-src/etags.c	2012-06-03 05:53:38 +0000
@@ -1706,8 +1706,8 @@
 static void
 init (void)
 {
-  register const char *sp;
-  register int i;
+  const char *sp;
+  int i;
 
   for (i = 0; i < CHARS; i++)
     iswhite (i) = notinname (i) = begtoken (i) = intoken (i) = endtoken (i) = FALSE;
@@ -1901,7 +1901,7 @@
        such that etags.el can guess a name from it. */
     {
       int i;
-      register const char *cp = name;
+      const char *cp = name;
 
       for (i = 0; i < namelen; i++)
 	if (notinname (*cp++))
@@ -1935,7 +1935,7 @@
              			/* line number */
               			/* character number */
 {
-  register node *np;
+  node *np;
 
   assert (name == NULL || name[0] != '\0');
   if (CTAGS && name == NULL)
@@ -1946,7 +1946,7 @@
   /* If ctags mode, change name "main" to M<thisfilename>. */
   if (CTAGS && !cxref_style && streq (name, "main"))
     {
-      register char *fp = etags_strrchr (curfdp->taggedfname, '/');
+      char *fp = etags_strrchr (curfdp->taggedfname, '/');
       np->name = concat ("M", fp == NULL ? curfdp->taggedfname : fp + 1, "");
       fp = etags_strrchr (np->name, '.');
       if (fp != NULL && fp[1] != '\0' && fp[2] == '\0')
@@ -1987,11 +1987,11 @@
  *	recurse on left children, iterate on right children.
  */
 static void
-free_tree (register node *np)
+free_tree (node *np)
 {
   while (np)
     {
-      register node *node_right = np->right;
+      node *node_right = np->right;
       free_tree (np->left);
       free (np->name);
       free (np->regex);
@@ -2005,7 +2005,7 @@
  *	delete a file description
  */
 static void
-free_fdesc (register fdesc *fdp)
+free_fdesc (fdesc *fdp)
 {
   free (fdp->infname);
   free (fdp->infabsname);
@@ -2027,8 +2027,8 @@
 static void
 add_node (node *np, node **cur_node_p)
 {
-  register int dif;
-  register node *cur_node = *cur_node_p;
+  int dif;
+  node *cur_node = *cur_node_p;
 
   if (cur_node == NULL)
     {
@@ -2157,9 +2157,9 @@
  * but is still supplied for backward compatibility.
  */
 static int
-total_size_of_entries (register node *np)
+total_size_of_entries (node *np)
 {
-  register int total = 0;
+  int total = 0;
 
   for (; np != NULL; np = np->right)
     if (np->valid)
@@ -2177,9 +2177,9 @@
 }
 
 static void
-put_entries (register node *np)
+put_entries (node *np)
 {
-  register char *sp;
+  char *sp;
   static fdesc *fdp = NULL;
 
   if (np == NULL)
@@ -2349,7 +2349,7 @@
 /* maximum key range = 33, duplicates = 0 */
 
 static inline unsigned int
-hash (register const char *str, register unsigned int len)
+hash (const char *str, unsigned int len)
 {
   static unsigned char asso_values[] =
     {
@@ -2380,7 +2380,7 @@
       35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
       35, 35, 35, 35, 35, 35
     };
-  register int hval = len;
+  int hval = len;
 
   switch (hval)
     {
@@ -2395,7 +2395,7 @@
 }
 
 static struct C_stab_entry *
-in_word_set (register const char *str, register unsigned int len)
+in_word_set (const char *str, unsigned int len)
 {
   enum
     {
@@ -2446,11 +2446,11 @@
 
   if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
     {
-      register int key = hash (str, len);
+      int key = hash (str, len);
 
       if (key <= MAX_HASH_VALUE && key >= 0)
         {
-          register const char *s = wordlist[key].name;
+          const char *s = wordlist[key].name;
 
           if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
             return &wordlist[key];
@@ -2463,7 +2463,7 @@
 static enum sym_type
 C_symtype (char *str, int len, int c_ext)
 {
-  register struct C_stab_entry *se = in_word_set (str, len);
+  struct C_stab_entry *se = in_word_set (str, len);
 
   if (se == NULL || (se->c_ext && !(c_ext & se->c_ext)))
     return st_none;
@@ -2693,7 +2693,8 @@
  */
 
 static bool
-consider_token (register char *str, register int len, register int c, int *c_extp, int bracelev, int parlev, int *is_func_or_var)
+consider_token (char *str, int len, int c, int *c_extp, int bracelev,
+		int parlev, int *is_func_or_var)
                         	/* IN: token pointer */
                       		/* IN: token length */
                     		/* IN: first char after the token */
@@ -3064,11 +3065,11 @@
                			/* extension of C */
                			/* input file */
 {
-  register char c;		/* latest char read; '\0' for end of line */
-  register char *lp;		/* pointer one beyond the character `c' */
+  char c;			/* latest char read; '\0' for end of line */
+  char *lp;			/* pointer one beyond the character `c' */
   int curndx, newndx;		/* indices for current and new lb */
-  register int tokoff;		/* offset in line of start of current token */
-  register int toklen;		/* length of current token */
+  int tokoff;			/* offset in line of start of current token */
+  int toklen;			/* length of current token */
   const char *qualifier;        /* string used to qualify names */
   int qlen;			/* length of qualifier */
   int bracelev;			/* current brace level */
@@ -4000,7 +4001,7 @@
 static void
 F_getit (FILE *inf)
 {
-  register char *cp;
+  char *cp;
 
   dbp = skip_spaces (dbp);
   if (*dbp == '\0')
@@ -4115,7 +4116,7 @@
 static void
 Ada_getit (FILE *inf, const char *name_qualifier)
 {
-  register char *cp;
+  char *cp;
   char *name;
   char c;
 
@@ -4291,7 +4292,7 @@
 static void
 Asm_labels (FILE *inf)
 {
-  register char *cp;
+  char *cp;
 
   LOOP_ON_INPUT_LINES (inf, lb, cp)
     {
@@ -4324,7 +4325,7 @@
 Perl_functions (FILE *inf)
 {
   char *package = savestr ("main"); /* current package name */
-  register char *cp;
+  char *cp;
 
   LOOP_ON_INPUT_LINES (inf, lb, cp)
     {
@@ -4405,7 +4406,7 @@
 static void
 Python_functions (FILE *inf)
 {
-  register char *cp;
+  char *cp;
 
   LOOP_ON_INPUT_LINES (inf, lb, cp)
     {
@@ -4435,7 +4436,7 @@
 static void
 PHP_functions (FILE *inf)
 {
-  register char *cp, *name;
+  char *cp, *name;
   bool search_identifier = FALSE;
 
   LOOP_ON_INPUT_LINES (inf, lb, cp)
@@ -4514,7 +4515,7 @@
 static void
 Cobol_paragraphs (FILE *inf)
 {
-  register char *bp, *ep;
+  char *bp, *ep;
 
   LOOP_ON_INPUT_LINES (inf, lb, bp)
     {
@@ -4542,7 +4543,7 @@
 static void
 Makefile_targets (FILE *inf)
 {
-  register char *bp;
+  char *bp;
 
   LOOP_ON_INPUT_LINES (inf, lb, bp)
     {
@@ -4817,7 +4818,7 @@
 static void
 Lua_functions (FILE *inf)
 {
-  register char *bp;
+  char *bp;
 
   LOOP_ON_INPUT_LINES (inf, lb, bp)
     {
@@ -4843,7 +4844,7 @@
 static void
 PS_functions (FILE *inf)
 {
-  register char *bp, *ep;
+  char *bp, *ep;
 
   LOOP_ON_INPUT_LINES (inf, lb, bp)
     {
@@ -4873,7 +4874,7 @@
 static void
 Forth_words (FILE *inf)
 {
-  register char *bp;
+  char *bp;
 
   LOOP_ON_INPUT_LINES (inf, lb, bp)
     while ((bp = skip_spaces (bp))[0] != '\0')
@@ -4909,7 +4910,7 @@
 static void
 Scheme_functions (FILE *inf)
 {
-  register char *bp;
+  char *bp;
 
   LOOP_ON_INPUT_LINES (inf, lb, bp)
     {
@@ -4983,7 +4984,7 @@
 	  for (key = TEX_toktab; key->buffer != NULL; key++)
 	    if (strneq (cp, key->buffer, key->len))
 	      {
-		register char *p;
+		char *p;
 		int namelen, linelen;
 		bool opgrp = FALSE;
 
@@ -5058,7 +5059,7 @@
 static void
 TEX_decode_env (const char *evarname, const char *defenv)
 {
-  register const char *env, *p;
+  const char *env, *p;
   int i, len;
 
   /* Append default string to environment. */
@@ -5948,7 +5949,7 @@
 static bool
 nocase_tail (const char *cp)
 {
-  register int len = 0;
+  int len = 0;
 
   while (*cp != '\0' && lowcase (*cp) == lowcase (dbp[len]))
     cp++, len++;
@@ -5961,9 +5962,9 @@
 }
 
 static void
-get_tag (register char *bp, char **namepp)
+get_tag (char *bp, char **namepp)
 {
-  register char *cp = bp;
+  char *cp = bp;
 
   if (*bp != '\0')
     {
@@ -5992,18 +5993,18 @@
  * appended to `filebuf'.
  */
 static long
-readline_internal (linebuffer *lbp, register FILE *stream)
+readline_internal (linebuffer *lbp, FILE *stream)
 {
   char *buffer = lbp->buffer;
-  register char *p = lbp->buffer;
-  register char *pend;
+  char *p = lbp->buffer;
+  char *pend;
   int chars_deleted;
 
   pend = p + lbp->size;		/* Separate to avoid 386/IX compiler bug.  */
 
   for (;;)
     {
-      register int c = getc (stream);
+      int c = getc (stream);
       if (p == pend)
 	{
 	  /* We're at the end of linebuffer: expand it. */
@@ -6275,7 +6276,7 @@
 static char *
 savenstr (const char *cp, int len)
 {
-  register char *dp;
+  char *dp;
 
   dp = xnew (len + 1, char);
   strncpy (dp, cp, len);
@@ -6290,9 +6291,9 @@
  * Identical to POSIX strrchr, included for portability.
  */
 static char *
-etags_strrchr (register const char *sp, register int c)
+etags_strrchr (const char *sp, int c)
 {
-  register const char *r;
+  const char *r;
 
   r = NULL;
   do
@@ -6310,7 +6311,7 @@
  * Identical to POSIX strchr, included for portability.
  */
 static char *
-etags_strchr (register const char *sp, register int c)
+etags_strchr (const char *sp, int c)
 {
   do
     {
@@ -6326,7 +6327,7 @@
  * Same as BSD's strcasecmp, included for portability.
  */
 static int
-etags_strcasecmp (register const char *s1, register const char *s2)
+etags_strcasecmp (const char *s1, const char *s2)
 {
   while (*s1 != '\0'
 	 && (ISALPHA (*s1) && ISALPHA (*s2)
@@ -6346,7 +6347,7 @@
  * Same as BSD's strncasecmp, included for portability.
  */
 static int
-etags_strncasecmp (register const char *s1, register const char *s2, register int n)
+etags_strncasecmp (const char *s1, const char *s2, int n)
 {
   while (*s1 != '\0' && n-- > 0
 	 && (ISALPHA (*s1) && ISALPHA (*s2)
@@ -6619,9 +6620,9 @@
 /* Downcase DOS drive letter and collapse separators into single slashes.
    Works in place. */
 static void
-canonicalize_filename (register char *fn)
+canonicalize_filename (char *fn)
 {
-  register char* cp;
+  char *cp;
   char sep = '/';
 
 #ifdef DOS_NT

=== modified file 'lib-src/hexl.c'
--- lib-src/hexl.c	2012-01-19 07:21:25 +0000
+++ lib-src/hexl.c	2012-06-03 05:53:38 +0000
@@ -53,7 +53,7 @@
 int
 main (int argc, char **argv)
 {
-  register long address;
+  long address;
   char string[18];
   FILE *fp;
 
@@ -174,7 +174,7 @@
 #endif
 	  for (;;)
 	    {
-	      register int i, c = 0, d;
+	      int i, c = 0, d;
 
 #define hexchar(x) (isdigit (x) ? x - '0' : x - 'a' + 10)
 
@@ -230,7 +230,7 @@
 	  string[17] = '\0';
 	  for (;;)
 	    {
-	      register int i, c = 0;
+	      int i, c = 0;
 
 	      for (i=0; i < 16; ++i)
 		{

=== modified file 'lib-src/make-docfile.c'
--- lib-src/make-docfile.c	2012-05-30 03:59:42 +0000
+++ lib-src/make-docfile.c	2012-06-03 05:53:38 +0000
@@ -398,7 +398,7 @@
 static int
 read_c_string_or_comment (FILE *infile, int printflag, int comment, int *saw_usage)
 {
-  register int c;
+  int c;
   struct rcsoc_state state;
 
   state.in_file = infile;
@@ -486,7 +486,7 @@
 static void
 write_c_args (FILE *out, char *func, char *buf, int minargs, int maxargs)
 {
-  register char *p;
+  char *p;
   int in_ident = 0;
   char *ident_start IF_LINT (= NULL);
   size_t ident_length = 0;
@@ -663,8 +663,8 @@
 scan_c_file (char *filename, const char *mode)
 {
   FILE *infile;
-  register int c;
-  register int commas;
+  int c;
+  int commas;
   int minargs, maxargs;
   int extension = filename[strlen (filename) - 1];
 
@@ -1049,7 +1049,7 @@
 scan_lisp_file (const char *filename, const char *mode)
 {
   FILE *infile;
-  register int c;
+  int c;
   char *saved_string = 0;
 
   if (generate_globals)

=== modified file 'lib-src/movemail.c'
--- lib-src/movemail.c	2012-01-19 07:21:25 +0000
+++ lib-src/movemail.c	2012-06-03 05:53:38 +0000
@@ -710,7 +710,7 @@
 popmail (char *mailbox, char *outfile, int preserve, char *password, int reverse_order)
 {
   int nmsgs, nbytes;
-  register int i;
+  int i;
   int mbfi;
   FILE *mbf;
   char *getenv (const char *);

=== modified file 'lib-src/pop.c'
--- lib-src/pop.c	2012-05-02 10:12:13 +0000
+++ lib-src/pop.c	2012-06-03 05:53:38 +0000
@@ -999,7 +999,7 @@
   krb5_ccache ccdef;
   krb5_principal client, server;
   krb5_error *err_ret;
-  register char *cp;
+  char *cp;
 #else
   KTEXT ticket;
   MSG_DAT msg_data;