Merge remote-tracking branch 'origin/master' into feature/android

7 files changed, 84 insertions, 54 deletions

diff --git a/src/coding.c b/src/coding.c
index 96c3827c326..b7f4120dc8d 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -11473,7 +11473,18 @@ usage: (define-coding-system-internal ...)  */)
 
 DEFUN ("coding-system-put", Fcoding_system_put, Scoding_system_put,
        3, 3, 0,
-       doc: /* Change value in CODING-SYSTEM's property list PROP to VAL.  */)
+       doc: /* Change value of CODING-SYSTEM's property PROP to VAL.
+
+The following properties, if set by this function, override the values
+of the corresponding attributes set by `define-coding-system':
+
+  `:mnemonic', `:default-char', `:ascii-compatible-p'
+  `:decode-translation-table', `:encode-translation-table',
+  `:post-read-conversion', `:pre-write-conversion'
+
+See `define-coding-system' for the description of these properties.
+See `coding-system-get' and `coding-system-plist' for accessing the
+property list of a coding-system.  */)
   (Lisp_Object coding_system, Lisp_Object prop, Lisp_Object val)
 {
   Lisp_Object spec, attrs;
diff --git a/src/data.c b/src/data.c
index 9d7e7effdcd..6de8e0cf1a1 100644
--- a/src/data.c
+++ b/src/data.c
@@ -269,10 +269,11 @@ for example, (type-of 1) returns `integer'.  */)
           return Qtreesit_compiled_query;
         case PVEC_SQLITE:
           return Qsqlite;
+        case PVEC_SUB_CHAR_TABLE:
+          return Qsub_char_table;
         /* "Impossible" cases.  */
         case PVEC_MISC_PTR:
         case PVEC_OTHER:
-        case PVEC_SUB_CHAR_TABLE:
         case PVEC_FREE: ;
         }
       emacs_abort ();
@@ -4215,6 +4216,7 @@ syms_of_data (void)
   DEFSYM (Qvector, "vector");
   DEFSYM (Qrecord, "record");
   DEFSYM (Qchar_table, "char-table");
+  DEFSYM (Qsub_char_table, "sub-char-table");
   DEFSYM (Qbool_vector, "bool-vector");
   DEFSYM (Qhash_table, "hash-table");
   DEFSYM (Qthread, "thread");
diff --git a/src/indent.c b/src/indent.c
index c3cbc49c81b..eda85f2e94d 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -2149,21 +2149,33 @@ If LINES is negative, this means moving up.
 This function is an ordinary cursor motion function
 which calculates the new position based on how text would be displayed.
 The new position may be the start of a line,
-or just the start of a continuation line.
+or the start of a continuation line,
+or the start of the visible portion of a horizontally-scrolled line.
+
 The function returns number of screen lines moved over;
-that usually equals LINES, but may be closer to zero
-if beginning or end of buffer was reached.
+that usually equals LINES, but may be closer to zero if
+beginning or end of buffer was reached.
 
 The optional second argument WINDOW specifies the window to use for
 parameters such as width, horizontal scrolling, and so on.
 The default is to use the selected window's parameters.
 
+If LINES is zero, point will move to the first visible character on
+the current screen line.
+
 LINES can optionally take the form (COLS . LINES), in which case the
-motion will not stop at the start of a screen line but COLS column
-from the visual start of the line (if such exists on that line, that
-is).  If the line is scrolled horizontally, COLS is interpreted
-visually, i.e., as addition to the columns of text beyond the left
-edge of the window.
+motion will stop at the COLSth column from the visual start of the
+line (if such column exists on that line, that is).  If the line is
+scrolled horizontally, COLS is interpreted visually, i.e., as addition
+to the columns of text beyond the left edge of the window.
+If LINES is a cons cell, its car COLS can be a float, which allows
+specifying an accurate position of point on a screen line that mixes
+fonts or uses variable-pitch font: COLS is interpreted in units of the
+canonical character width, and is internally converted to pixel units;
+point will then stop at the position closest to that pixel coordinate.
+The cdr of the cons, LINES, must be an integer; if it is zero, this
+function moves point horizontally in the current screen line, to the
+position specified by COLS.
 
 The optional third argument CUR-COL specifies the horizontal
 window-relative coordinate of point, in units of frame's canonical
@@ -2171,11 +2183,10 @@ character width, where the function is invoked.  If this argument is
 omitted or nil, the function will determine the point coordinate by
 going back to the beginning of the line.
 
-`vertical-motion' always uses the current buffer,
-regardless of which buffer is displayed in WINDOW.
-This is consistent with other cursor motion functions
-and makes it possible to use `vertical-motion' in any buffer,
-whether or not it is currently displayed in some window.  */)
+`vertical-motion' always uses the current buffer, regardless of which
+buffer is displayed in WINDOW.  This is consistent with other cursor
+motion functions and makes it possible to use `vertical-motion' in any
+buffer, whether or not it is currently displayed in some window.  */)
   (Lisp_Object lines, Lisp_Object window, Lisp_Object cur_col)
 {
   struct it it;
diff --git a/src/lisp.h b/src/lisp.h
index 83029b8a7f0..9a4cdec2815 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2016,9 +2016,7 @@ ASCII_CHAR_P (intmax_t c)
    range of characters.  A sub-char-table is like a vector, but with
    two integer fields between the header and Lisp data, which means
    that it has to be marked with some precautions (see mark_char_table
-   in alloc.c).  A sub-char-table appears only in an element of a
-   char-table, and there's no way to access it directly from a Lisp
-   program.  */
+   in alloc.c).  A sub-char-table appears in an element of a char-table.  */
 
 enum CHARTAB_SIZE_BITS
   {
@@ -4815,7 +4813,7 @@ extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t,
                                            ptrdiff_t, ptrdiff_t *);
 extern EMACS_INT search_buffer (Lisp_Object, ptrdiff_t, ptrdiff_t,
                                 ptrdiff_t, ptrdiff_t, EMACS_INT,
-                                int, Lisp_Object, Lisp_Object, bool);
+                                bool, Lisp_Object, Lisp_Object, bool);
 extern void syms_of_search (void);
 extern void clear_regexp_cache (void);
 
diff --git a/src/minibuf.c b/src/minibuf.c
index 6e54d8c3ba5..58adde1bf66 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -2471,7 +2471,12 @@ The basic completion functions only consider a completion acceptable
 if it matches all regular expressions in this list, with
 `case-fold-search' bound to the value of `completion-ignore-case'.
 See Info node `(elisp)Basic Completion', for a description of these
-functions.  */);
+functions.
+
+Do not set this variable to a non-nil value globally, as that is not
+safe and will probably cause errors in completion commands.  This
+variable should be only let-bound to non-nil values around calls to
+basic completion functions like `try-completion' and `all-completions'.  */);
   Vcompletion_regexp_list = Qnil;
 
   DEFVAR_BOOL ("minibuffer-allow-text-properties",
diff --git a/src/search.c b/src/search.c
index 0bb52c03eef..122d6166637 100644
--- a/src/search.c
+++ b/src/search.c
@@ -1027,7 +1027,7 @@ find_before_next_newline (ptrdiff_t from, ptrdiff_t to,
 
 static Lisp_Object
 search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
-                Lisp_Object count, int direction, int RE, bool posix)
+                Lisp_Object count, int direction, bool RE, bool posix)
 {
   EMACS_INT np;
   EMACS_INT lim;
@@ -1130,21 +1130,6 @@ trivial_regexp_p (Lisp_Object regexp)
   return 1;
 }
 
-/* Search for the n'th occurrence of STRING in the current buffer,
-   starting at position POS and stopping at position LIM,
-   treating STRING as a literal string if RE is false or as
-   a regular expression if RE is true.
-
-   If N is positive, searching is forward and LIM must be greater than POS.
-   If N is negative, searching is backward and LIM must be less than POS.
-
-   Returns -x if x occurrences remain to be found (x > 0),
-   or else the position at the beginning of the Nth occurrence
-   (if searching backward) or the end (if searching forward).
-
-   POSIX is nonzero if we want full backtracking (POSIX style)
-   for this pattern.  0 means backtrack only enough to get a valid match.  */
-
 #define TRANSLATE(out, trt, d)                  \
 do                                              \
   {                                             \
@@ -1308,7 +1293,7 @@ search_buffer_re (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
 static EMACS_INT
 search_buffer_non_re (Lisp_Object string, ptrdiff_t pos,
                       ptrdiff_t pos_byte, ptrdiff_t lim, ptrdiff_t lim_byte,
-                      EMACS_INT n, int RE, Lisp_Object trt, Lisp_Object inverse_trt,
+                      EMACS_INT n, bool RE, Lisp_Object trt, Lisp_Object inverse_trt,
                       bool posix)
 {
   unsigned char *raw_pattern, *pat;
@@ -1507,10 +1492,28 @@ search_buffer_non_re (Lisp_Object string, ptrdiff_t pos,
   return result;
 }
 
+/* Search for the Nth occurrence of STRING in the current buffer,
+   from buffer position POS/POS_BYTE until LIM/LIM_BYTE.
+
+   If RE, look for matches against the regular expression STRING instead;
+   if POSIX, enable POSIX style backtracking within that regular
+   expression.
+
+   If N is positive, search forward; in this case, LIM must be greater
+   than POS.
+
+   If N is negative, search backward; LIM must be less than POS.
+
+   Return -X if there are X remaining occurrences or matches,
+   or else the position at the beginning (if N is negative) or the end
+   (if N is positive) of the Nth occurrence or match against STRING.
+
+   Use TRT and INVERSE_TRT as character translation tables.  */
+
 EMACS_INT
 search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
                ptrdiff_t lim, ptrdiff_t lim_byte, EMACS_INT n,
-               int RE, Lisp_Object trt, Lisp_Object inverse_trt, bool posix)
+               bool RE, Lisp_Object trt, Lisp_Object inverse_trt, bool posix)
 {
   if (running_asynch_code)
     save_search_regs ();
@@ -2219,7 +2222,7 @@ Search case-sensitivity is determined by the value of the variable
 See also the functions `match-beginning', `match-end' and `replace-match'.  */)
   (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
 {
-  return search_command (string, bound, noerror, count, -1, 0, 0);
+  return search_command (string, bound, noerror, count, -1, false, false);
 }
 
 DEFUN ("search-forward", Fsearch_forward, Ssearch_forward, 1, 4, "MSearch: ",
@@ -2244,7 +2247,7 @@ Search case-sensitivity is determined by the value of the variable
 See also the functions `match-beginning', `match-end' and `replace-match'.  */)
   (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
 {
-  return search_command (string, bound, noerror, count, 1, 0, 0);
+  return search_command (string, bound, noerror, count, 1, false, false);
 }
 
 DEFUN ("re-search-backward", Fre_search_backward, Sre_search_backward, 1, 4,
@@ -2260,7 +2263,7 @@ because REGEXP is still matched in the forward direction.  See Info
 anchor `(elisp) re-search-backward' for details.  */)
   (Lisp_Object regexp, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
 {
-  return search_command (regexp, bound, noerror, count, -1, 1, 0);
+  return search_command (regexp, bound, noerror, count, -1, true, false);
 }
 
 DEFUN ("re-search-forward", Fre_search_forward, Sre_search_forward, 1, 4,
@@ -2291,7 +2294,7 @@ See also the functions `match-beginning', `match-end', `match-string',
 and `replace-match'.  */)
   (Lisp_Object regexp, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
 {
-  return search_command (regexp, bound, noerror, count, 1, 1, 0);
+  return search_command (regexp, bound, noerror, count, 1, true, false);
 }
 
 DEFUN ("posix-search-backward", Fposix_search_backward, Sposix_search_backward, 1, 4,
@@ -2319,7 +2322,7 @@ See also the functions `match-beginning', `match-end', `match-string',
 and `replace-match'.  */)
   (Lisp_Object regexp, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
 {
-  return search_command (regexp, bound, noerror, count, -1, 1, 1);
+  return search_command (regexp, bound, noerror, count, -1, true, true);
 }
 
 DEFUN ("posix-search-forward", Fposix_search_forward, Sposix_search_forward, 1, 4,
@@ -2347,7 +2350,7 @@ See also the functions `match-beginning', `match-end', `match-string',
 and `replace-match'.  */)
   (Lisp_Object regexp, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
 {
-  return search_command (regexp, bound, noerror, count, 1, 1, 1);
+  return search_command (regexp, bound, noerror, count, 1, true, true);
 }
 
 DEFUN ("replace-match", Freplace_match, Sreplace_match, 1, 5, 0,
diff --git a/src/treesit.c b/src/treesit.c
index 87aa1eeb377..1f694e47201 100644
--- a/src/treesit.c
+++ b/src/treesit.c
@@ -1649,7 +1649,7 @@ buffer.  */)
       TSRange *treesit_ranges = xmalloc (sizeof (TSRange) * len);
       struct buffer *buffer = XBUFFER (XTS_PARSER (parser)->buffer);
 
-      /* We can use XFUXNUM, XCAR, XCDR freely because we have checked
+      /* We can use XFIXNUM, XCAR, XCDR freely because we have checked
          the input by treesit_check_range_argument.  */
 
       for (int idx = 0; !NILP (ranges); idx++, ranges = XCDR (ranges))
@@ -2546,10 +2546,10 @@ static bool
 treesit_predicate_equal (Lisp_Object args, struct capture_range captures,
                          Lisp_Object *signal_data)
 {
-  if (XFIXNUM (Flength (args)) != 2)
+  if (list_length (args) != 2)
     {
       *signal_data = list2 (build_string ("Predicate `equal' requires "
-                                          "two arguments but only given"),
+                                          "two arguments but got"),
                             Flength (args));
       return false;
     }
@@ -2581,10 +2581,10 @@ static bool
 treesit_predicate_match (Lisp_Object args, struct capture_range captures,
                          Lisp_Object *signal_data)
 {
-  if (XFIXNUM (Flength (args)) != 2)
+  if (list_length (args) != 2)
     {
       *signal_data = list2 (build_string ("Predicate `match' requires two "
-                                          "arguments but only given"),
+                                          "arguments but got"),
                             Flength (args));
       return false;
     }
@@ -2628,7 +2628,7 @@ treesit_predicate_match (Lisp_Object args, struct capture_range captures,
   ZV_BYTE = end_byte;
 
   ptrdiff_t val = search_buffer (regexp, start_pos, start_byte,
-                                 end_pos, end_byte, 1, 1, Qnil, Qnil, false);
+                                 end_pos, end_byte, 1, true, Qnil, Qnil, false);
 
   BEGV = old_begv;
   BEGV_BYTE = old_begv_byte;
@@ -2646,11 +2646,11 @@ static bool
 treesit_predicate_pred (Lisp_Object args, struct capture_range captures,
                         Lisp_Object *signal_data)
 {
-  if (XFIXNUM (Flength (args)) < 2)
+  if (list_length (args) < 2)
     {
       *signal_data = list2 (build_string ("Predicate `pred' requires "
                                           "at least two arguments, "
-                                          "but was only given"),
+                                          "but only got"),
                             Flength (args));
       return false;
     }
@@ -2671,7 +2671,7 @@ treesit_predicate_pred (Lisp_Object args, struct capture_range captures,
   return !NILP (CALLN (Fapply, fn, nodes));
 }
 
-/* If all predicates in PREDICATES passes, return true; otherwise
+/* If all predicates in PREDICATES pass, return true; otherwise
    return false.  If everything goes fine, don't touch SIGNAL_DATA; if
    error occurs, set it to a suitable signal data.  */
 static bool
@@ -2696,7 +2696,7 @@ treesit_eval_predicates (struct capture_range captures, Lisp_Object predicates,
         {
           *signal_data = list3 (build_string ("Invalid predicate"),
                                 fn, build_string ("Currently Emacs only supports"
-                                                  " equal, match, and pred"
+                                                  " `equal', `match', and `pred'"
                                                   " predicates"));
           pass = false;
         }