9 files changed, 104 insertions, 158 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index ff059cf1a3c..d39336f11e6 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,32 @@
+2013-02-20  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * sheap.c (report_sheap_usage): Prefer message1_nolog.
+
+        * keyboard.c (Qcommand_execute): New var.
+        (command_loop_1, read_char): Use it.
+        (Fcommand_execute): Remove, replace by an Elisp implementation.
+        (syms_of_keyboard): Adjust accordingly.
+
+2013-02-19  Daniel Colascione <dancol@dancol.org>
+
+        * sheap.c (report_sheap_usage): Use message, not message1, so
+        that we don't try to create a buffer while we're in the middle
+        of dumping Emacs.  Explain why.
+
+2013-02-20  Dmitry Antipov  <dmantipov@yandex.ru>
+        * search.c (find_newline): Return byte position in bytepos.
+        Adjust comment.
+        (find_next_newline_no_quit, find_before_next_newline):
+        Add bytepos argument.
+        * lisp.h (find_newline, find_next_newline_no_quit)
+        (find_before_next_newline): Adjust prototypes.
+        * bidi.c (bidi_find_paragraph_start):
+        * editfns.c (Fconstrain_to_field, Fline_end_position):
+        * indent.c (compute_motion, vmotion):
+        * xdisp.c (back_to_previous_line_start, forward_to_next_line_start):
+        (get_visually_first_element, move_it_vertically_backward):
+        Adjust users and avoid calls to CHAR_TO_BYTE where appropriate.
+
 2013-02-19  Eli Zaretskii  <eliz@gnu.org>
 
         * w32proc.c (new_child): Avoid leaking handles if the subprocess
diff --git a/src/bidi.c b/src/bidi.c
index db2e48a2ca7..364d7e500ba 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -1104,14 +1104,11 @@ bidi_find_paragraph_start (ptrdiff_t pos, ptrdiff_t pos_byte)
   while (pos_byte > BEGV_BYTE
          && n++ < MAX_PARAGRAPH_SEARCH
          && fast_looking_at (re, pos, pos_byte, limit, limit_byte, Qnil) < 0)
-    {
-      /* FIXME: What if the paragraph beginning is covered by a
-         display string?  And what if a display string covering some
-         of the text over which we scan back includes
-         paragraph_start_re?  */
-      pos = find_next_newline_no_quit (pos - 1, -1);
-      pos_byte = CHAR_TO_BYTE (pos);
-    }
+    /* FIXME: What if the paragraph beginning is covered by a
+       display string?  And what if a display string covering some
+       of the text over which we scan back includes
+       paragraph_start_re?  */
+    pos = find_next_newline_no_quit (pos - 1, -1, &pos_byte);
   if (n >= MAX_PARAGRAPH_SEARCH)
     pos_byte = BEGV_BYTE;
   return pos_byte;
diff --git a/src/editfns.c b/src/editfns.c
index bee0bcc158d..831c8359fab 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -736,7 +736,7 @@ Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.  */)
                  FIELD_BOUND are on the same line by seeing whether
                  there's an intervening newline or not.  */
               || (find_newline (XFASTINT (new_pos), XFASTINT (field_bound),
-                                fwd ? -1 : 1, &shortage, 1),
+                                fwd ? -1 : 1, &shortage, NULL, 1),
                   shortage != 0)))
         /* Constrain NEW_POS to FIELD_BOUND.  */
         new_pos = field_bound;
@@ -821,7 +821,8 @@ This function does not move point.  */)
     CHECK_NUMBER (n);
 
   clipped_n = clip_to_bounds (PTRDIFF_MIN + 1, XINT (n), PTRDIFF_MAX);
-  end_pos = find_before_next_newline (orig, 0, clipped_n - (clipped_n <= 0));
+  end_pos = find_before_next_newline (orig, 0, clipped_n - (clipped_n <= 0),
+                                      NULL);
 
   /* Return END_POS constrained to the current input field.  */
   return Fconstrain_to_field (make_number (end_pos), make_number (orig),
diff --git a/src/indent.c b/src/indent.c
index ce1639eae1e..9bf75bc6d95 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -1328,8 +1328,7 @@ compute_motion (ptrdiff_t from, EMACS_INT fromvpos, EMACS_INT fromhpos,
                  TO (we need to go back below).  */
               if (pos <= to)
                 {
-                  pos = find_before_next_newline (pos, to, 1);
-                  pos_byte = CHAR_TO_BYTE (pos);
+                  pos = find_before_next_newline (pos, to, 1, &pos_byte);
                   hpos = width;
                   /* If we just skipped next_boundary,
                      loop around in the main while
@@ -1583,10 +1582,9 @@ compute_motion (ptrdiff_t from, EMACS_INT fromvpos, EMACS_INT fromhpos,
                           /* Skip any number of invisible lines all at once */
                           do
                             {
-                              pos = find_before_next_newline (pos, to, 1);
+                              pos = find_before_next_newline (pos, to, 1, &pos_byte);
                               if (pos < to)
-                                pos++;
-                              pos_byte = CHAR_TO_BYTE (pos);
+                                INC_BOTH (pos, pos_byte);
                             }
                           while (pos < to
                                  && indented_beyond_p (pos, pos_byte,
@@ -1622,10 +1620,7 @@ compute_motion (ptrdiff_t from, EMACS_INT fromvpos, EMACS_INT fromhpos,
                      everything from a ^M to the end of the line is invisible.
                      Stop *before* the real newline.  */
                   if (pos < to)
-                    {
-                      pos = find_before_next_newline (pos, to, 1);
-                      pos_byte = CHAR_TO_BYTE (pos);
-                    }
+                    pos = find_before_next_newline (pos, to, 1, &pos_byte);
                   /* If we just skipped next_boundary,
                      loop around in the main while
                      and handle it.  */
@@ -1845,21 +1840,20 @@ vmotion (register ptrdiff_t from, register EMACS_INT vtarget, struct window *w)
 
       while ((vpos > vtarget || first) && from > BEGV)
         {
+          ptrdiff_t bytepos;
           Lisp_Object propval;
 
-          prevline = find_next_newline_no_quit (from - 1, -1);
+          prevline = find_next_newline_no_quit (from - 1, -1, &bytepos);
           while (prevline > BEGV
                  && ((selective > 0
-                      && indented_beyond_p (prevline,
-                                            CHAR_TO_BYTE (prevline),
-                                            selective))
+                      && indented_beyond_p (prevline, bytepos, selective))
                      /* Watch out for newlines with `invisible' property.
                         When moving upward, check the newline before.  */
                      || (propval = Fget_char_property (make_number (prevline - 1),
                                                        Qinvisible,
                                                        text_prop_object),
                          TEXT_PROP_MEANS_INVISIBLE (propval))))
-            prevline = find_next_newline_no_quit (prevline - 1, -1);
+            prevline = find_next_newline_no_quit (prevline - 1, -1, &bytepos);
           pos = *compute_motion (prevline, 0,
                                  lmargin,
                                  0,
@@ -1897,21 +1891,20 @@ vmotion (register ptrdiff_t from, register EMACS_INT vtarget, struct window *w)
   from_byte = CHAR_TO_BYTE (from);
   if (from > BEGV && FETCH_BYTE (from_byte - 1) != '\n')
     {
+      ptrdiff_t bytepos;
       Lisp_Object propval;
 
-      prevline = find_next_newline_no_quit (from, -1);
+      prevline = find_next_newline_no_quit (from, -1, &bytepos);
       while (prevline > BEGV
              && ((selective > 0
-                  && indented_beyond_p (prevline,
-                                        CHAR_TO_BYTE (prevline),
-                                        selective))
+                  && indented_beyond_p (prevline, bytepos, selective))
                  /* Watch out for newlines with `invisible' property.
                     When moving downward, check the newline after.  */
                  || (propval = Fget_char_property (make_number (prevline),
                                                    Qinvisible,
                                                    text_prop_object),
                      TEXT_PROP_MEANS_INVISIBLE (propval))))
-        prevline = find_next_newline_no_quit (prevline - 1, -1);
+        prevline = find_next_newline_no_quit (prevline - 1, -1, &bytepos);
       pos = *compute_motion (prevline, 0,
                              lmargin,
                              0,
diff --git a/src/keyboard.c b/src/keyboard.c
index 3c00e017498..38136b57b4b 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -370,7 +370,7 @@ Lisp_Object Qmenu_bar;
 
 static Lisp_Object recursive_edit_unwind (Lisp_Object buffer);
 static Lisp_Object command_loop (void);
-static Lisp_Object Qextended_command_history;
+static Lisp_Object Qcommand_execute;
 EMACS_TIME timer_check (void);
 
 static void echo_now (void);
@@ -1586,11 +1586,11 @@ command_loop_1 (void)
                   = (EQ (undo, BVAR (current_buffer, undo_list))
                      ? Qnil : BVAR (current_buffer, undo_list));
               }
-            Fcommand_execute (Vthis_command, Qnil, Qnil, Qnil);
+            call1 (Qcommand_execute, Vthis_command);
 
 #ifdef HAVE_WINDOW_SYSTEM
           /* Do not check display_hourglass_p here, because
-             Fcommand_execute could change it, but we should cancel
+             `command-execute' could change it, but we should cancel
              hourglass cursor anyway.
              But don't cancel the hourglass within a macro
              just because a command in the macro finishes.  */
@@ -2845,7 +2845,7 @@ read_char (int commandflag, Lisp_Object map,
     {
       struct buffer *prev_buffer = current_buffer;
       last_input_event = c;
-      Fcommand_execute (tem, Qnil, Fvector (1, &last_input_event), Qt);
+      call4 (Qcommand_execute, tem, Qnil, Fvector (1, &last_input_event), Qt);
 
       if (CONSP (c) && EQ (XCAR (c), Qselect_window) && !end_time)
         /* We stopped being idle for this event; undo that.  This
@@ -9895,95 +9895,6 @@ DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector,
   return unbind_to (count, Fvector (i, keybuf));
 }
 
-DEFUN ("command-execute", Fcommand_execute, Scommand_execute, 1, 4, 0,
-       doc: /* Execute CMD as an editor command.
-CMD must be a symbol that satisfies the `commandp' predicate.
-Optional second arg RECORD-FLAG non-nil
-means unconditionally put this command in the variable `command-history'.
-Otherwise, that is done only if an arg is read using the minibuffer.
-The argument KEYS specifies the value to use instead of (this-command-keys)
-when reading the arguments; if it is nil, (this-command-keys) is used.
-The argument SPECIAL, if non-nil, means that this command is executing
-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 prefixarg;
-
-  debug_on_next_call = 0;
-
-  if (NILP (special))
-    {
-      prefixarg = KVAR (current_kboard, Vprefix_arg);
-      Vcurrent_prefix_arg = prefixarg;
-      kset_prefix_arg (current_kboard, Qnil);
-    }
-  else
-    prefixarg = Qnil;
-
-  if (SYMBOLP (cmd))
-    {
-      tem = Fget (cmd, Qdisabled);
-      if (!NILP (tem))
-        {
-          tem = Fsymbol_value (Qdisabled_command_function);
-          if (!NILP (tem))
-            return Frun_hooks (1, &Qdisabled_command_function);
-        }
-    }
-
-  while (1)
-    {
-      final = Findirect_function (cmd, Qnil);
-
-      if (CONSP (final) && (tem = Fcar (final), EQ (tem, Qautoload)))
-        {
-          struct gcpro gcpro1, gcpro2;
-
-          GCPRO2 (cmd, prefixarg);
-          Fautoload_do_load (final, cmd, Qnil);
-          UNGCPRO;
-        }
-      else
-        break;
-    }
-
-  if (STRINGP (final) || VECTORP (final))
-    {
-      /* If requested, place the macro in the command history.  For
-         other sorts of commands, call-interactively takes care of
-         this.  */
-      if (!NILP (record_flag))
-        {
-          Vcommand_history
-            = Fcons (Fcons (Qexecute_kbd_macro,
-                            Fcons (final, Fcons (prefixarg, Qnil))),
-                     Vcommand_history);
-
-          /* Don't keep command history around forever.  */
-          if (NUMBERP (Vhistory_length) && XINT (Vhistory_length) > 0)
-            {
-              tem = Fnthcdr (Vhistory_length, Vcommand_history);
-              if (CONSP (tem))
-                XSETCDR (tem, Qnil);
-            }
-        }
-
-      return Fexecute_kbd_macro (final, prefixarg, Qnil);
-    }
-
-  if (CONSP (final) || SUBRP (final) || COMPILEDP (final))
-    /* Don't call Fcall_interactively directly because we want to make
-       sure the backtrace has an entry for `call-interactively'.
-       For the same reason, pass `cmd' rather than `final'.  */
-      return call3 (Qcall_interactively, cmd, record_flag, keys);
-
-  return Qnil;
-}
-
-
-
 /* Return true if input events are pending.  */
 
 bool
@@ -11218,8 +11129,7 @@ syms_of_keyboard (void)
   raw_keybuf = Fmake_vector (make_number (30), Qnil);
   staticpro (&raw_keybuf);
 
-  DEFSYM (Qextended_command_history, "extended-command-history");
-  Fset (Qextended_command_history, Qnil);
+  DEFSYM (Qcommand_execute, "command-execute");
 
   accent_key_syms = Qnil;
   staticpro (&accent_key_syms);
@@ -11258,7 +11168,6 @@ syms_of_keyboard (void)
   defsubr (&Srecursive_edit);
   defsubr (&Strack_mouse);
   defsubr (&Sinput_pending_p);
-  defsubr (&Scommand_execute);
   defsubr (&Srecent_keys);
   defsubr (&Sthis_command_keys);
   defsubr (&Sthis_command_keys_vector);
diff --git a/src/lisp.h b/src/lisp.h
index e7a86892908..7b36878c0c5 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3348,12 +3348,13 @@ extern ptrdiff_t fast_string_match_ignore_case (Lisp_Object, Lisp_Object);
 extern ptrdiff_t fast_looking_at (Lisp_Object, ptrdiff_t, ptrdiff_t,
                                   ptrdiff_t, ptrdiff_t, Lisp_Object);
 extern ptrdiff_t find_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t,
-                               ptrdiff_t *, bool);
+                               ptrdiff_t *, ptrdiff_t *, bool);
 extern EMACS_INT scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
                                EMACS_INT, bool);
 extern ptrdiff_t find_next_newline (ptrdiff_t, int);
-extern ptrdiff_t find_next_newline_no_quit (ptrdiff_t, ptrdiff_t);
-extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t);
+extern ptrdiff_t find_next_newline_no_quit (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
+extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t,
+                                           ptrdiff_t, ptrdiff_t *);
 extern void syms_of_search (void);
 extern void clear_regexp_cache (void);
 
diff --git a/src/search.c b/src/search.c
index d4508004bf6..1c0f57487f9 100644
--- a/src/search.c
+++ b/src/search.c
@@ -638,15 +638,18 @@ newline_cache_on_off (struct buffer *buf)
    If we don't find COUNT instances before reaching END, set *SHORTAGE
    to the number of newlines left unfound, and return END.
 
+   If BYTEPOS is not NULL, set *BYTEPOS to the byte position corresponding
+   to the returned character position.
+
    If ALLOW_QUIT, set immediate_quit.  That's good to do
    except when inside redisplay.  */
 
 ptrdiff_t
-find_newline (ptrdiff_t start, ptrdiff_t end,
-              ptrdiff_t count, ptrdiff_t *shortage, bool allow_quit)
+find_newline (ptrdiff_t start, ptrdiff_t end, ptrdiff_t count,
+              ptrdiff_t *shortage, ptrdiff_t *bytepos, bool allow_quit)
 {
   struct region_cache *newline_cache;
-  ptrdiff_t end_byte = -1;
+  ptrdiff_t start_byte = -1, end_byte = -1;
   int direction;
 
   if (count > 0)
@@ -680,9 +683,7 @@ find_newline (ptrdiff_t start, ptrdiff_t end,
            the position of the last character before the next such
            obstacle --- the last character the dumb search loop should
            examine.  */
-        ptrdiff_t ceiling_byte = end_byte - 1;
-        ptrdiff_t start_byte;
-        ptrdiff_t tem;
+        ptrdiff_t tem, ceiling_byte = end_byte - 1;
 
         /* If we're looking for a newline, consult the newline cache
            to see where we can avoid some scanning.  */
@@ -745,21 +746,22 @@ find_newline (ptrdiff_t start, ptrdiff_t end,
               if (--count == 0)
                 {
                   immediate_quit = 0;
+                  if (bytepos)
+                    *bytepos = nl + 1 - base + start_byte;
                   return BYTE_TO_CHAR (nl + 1 - base + start_byte);
                 }
               cursor = nl + 1;
             }
 
-          start = BYTE_TO_CHAR (ceiling_addr - base + start_byte);
+          start_byte += ceiling_addr - base;
+          start = BYTE_TO_CHAR (start_byte);
         }
       }
   else
     while (start > end)
       {
         /* The last character to check before the next obstacle.  */
-        ptrdiff_t ceiling_byte = end_byte;
-        ptrdiff_t start_byte;
-        ptrdiff_t tem;
+        ptrdiff_t tem, ceiling_byte = end_byte;
 
         /* Consult the newline cache, if appropriate.  */
         if (newline_cache)
@@ -816,18 +818,26 @@ find_newline (ptrdiff_t start, ptrdiff_t end,
               if (++count >= 0)
                 {
                   immediate_quit = 0;
+                  if (bytepos)
+                    *bytepos = nl - base + start_byte;
                   return BYTE_TO_CHAR (nl - base + start_byte);
                 }
               cursor = nl - 1;
             }
 
-          start = BYTE_TO_CHAR (ceiling_addr - 1 - base + start_byte);
+          start_byte += ceiling_addr - 1 - base;
+          start = BYTE_TO_CHAR (start_byte);
         }
       }
 
   immediate_quit = 0;
-  if (shortage != 0)
+  if (shortage)
     *shortage = count * direction;
+  if (bytepos)
+    {
+      *bytepos = start_byte == -1 ? CHAR_TO_BYTE (start) : start_byte;
+      eassert (*bytepos == CHAR_TO_BYTE (start));
+    }
   return start;
 }
 
@@ -932,9 +942,9 @@ scan_newline (ptrdiff_t start, ptrdiff_t start_byte,
 }
 
 ptrdiff_t
-find_next_newline_no_quit (ptrdiff_t from, ptrdiff_t cnt)
+find_next_newline_no_quit (ptrdiff_t from, ptrdiff_t cnt, ptrdiff_t *bytepos)
 {
-  return find_newline (from, 0, cnt, (ptrdiff_t *) 0, 0);
+  return find_newline (from, 0, cnt, NULL, bytepos, 0);
 }
 
 /* Like find_next_newline, but returns position before the newline,
@@ -942,14 +952,19 @@ find_next_newline_no_quit (ptrdiff_t from, ptrdiff_t cnt)
    find_next_newline (...)-1, because you might hit TO.  */
 
 ptrdiff_t
-find_before_next_newline (ptrdiff_t from, ptrdiff_t to, ptrdiff_t cnt)
+find_before_next_newline (ptrdiff_t from, ptrdiff_t to,
+                          ptrdiff_t cnt, ptrdiff_t *bytepos)
 {
   ptrdiff_t shortage;
-  ptrdiff_t pos = find_newline (from, to, cnt, &shortage, 1);
+  ptrdiff_t pos = find_newline (from, to, cnt, &shortage, bytepos, 1);
 
   if (shortage == 0)
-    pos--;
-
+    {
+      if (bytepos)
+        DEC_BOTH (pos, *bytepos);
+      else
+        pos--;
+    }
   return pos;
 }
 
diff --git a/src/sheap.c b/src/sheap.c
index 06e205bc0e5..28597ec9b65 100644
--- a/src/sheap.c
+++ b/src/sheap.c
@@ -91,5 +91,7 @@ report_sheap_usage (int die_if_pure_storage_exceeded)
   char buf[200];
   sprintf (buf, "Static heap usage: %d of %d bytes",
            bss_sbrk_ptr - bss_sbrk_buffer, STATIC_HEAP_SIZE);
-  message1 (buf);
+  /* Don't log messages, cause at this point, we're not allowed to create
+     buffers.  */
+  message1_nolog ("%s", buf);
 }
diff --git a/src/xdisp.c b/src/xdisp.c
index 9207355bc09..7a329c5421b 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -5940,8 +5940,9 @@ pop_it (struct it *it)
 static void
 back_to_previous_line_start (struct it *it)
 {
-  IT_CHARPOS (*it) = find_next_newline_no_quit (IT_CHARPOS (*it) - 1, -1);
-  IT_BYTEPOS (*it) = CHAR_TO_BYTE (IT_CHARPOS (*it));
+  IT_CHARPOS (*it)
+    = find_next_newline_no_quit (IT_CHARPOS (*it) - 1,
+                                 -1, &IT_BYTEPOS (*it));
 }
 
 
@@ -6012,8 +6013,8 @@ forward_to_next_line_start (struct it *it, int *skipped_p,
      short-cut.  */
   if (!newline_found_p)
     {
-      ptrdiff_t start = IT_CHARPOS (*it);
-      ptrdiff_t limit = find_next_newline_no_quit (start, 1);
+      ptrdiff_t bytepos, start = IT_CHARPOS (*it);
+      ptrdiff_t limit = find_next_newline_no_quit (start, 1, &bytepos);
       Lisp_Object pos;
 
       eassert (!STRINGP (it->string));
@@ -6031,7 +6032,7 @@ forward_to_next_line_start (struct it *it, int *skipped_p,
           if (!it->bidi_p)
             {
               IT_CHARPOS (*it) = limit;
-              IT_BYTEPOS (*it) = CHAR_TO_BYTE (limit);
+              IT_BYTEPOS (*it) = bytepos;
             }
           else
             {
@@ -7473,11 +7474,9 @@ get_visually_first_element (struct it *it)
       if (string_p)
         it->bidi_it.charpos = it->bidi_it.bytepos = 0;
       else
-        {
-          it->bidi_it.charpos = find_next_newline_no_quit (IT_CHARPOS (*it),
-                                                           -1);
-          it->bidi_it.bytepos = CHAR_TO_BYTE (it->bidi_it.charpos);
-        }
+        it->bidi_it.charpos
+          = find_next_newline_no_quit (IT_CHARPOS (*it), -1,
+                                       &it->bidi_it.bytepos);
       bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 1);
       do
         {
@@ -9125,7 +9124,7 @@ move_it_vertically_backward (struct it *it, int dy)
           && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n')
         {
           ptrdiff_t nl_pos =
-            find_next_newline_no_quit (IT_CHARPOS (*it) - 1, -1);
+            find_next_newline_no_quit (IT_CHARPOS (*it) - 1, -1, NULL);
 
           move_it_to (it, nl_pos, -1, -1, -1, MOVE_TO_POS);
         }