X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/5d8ea1203d1e659bc77d953784a85a6e7da0ce95..8d0eb4c275581847990b85dbb350caa3df9e653f:/src/casefiddle.c diff --git a/src/casefiddle.c b/src/casefiddle.c index 6c05aecffe..05d689a9ee 100644 --- a/src/casefiddle.c +++ b/src/casefiddle.c @@ -32,27 +32,27 @@ enum case_action {CASE_UP, CASE_DOWN, CASE_CAPITALIZE, CASE_CAPITALIZE_UP}; Lisp_Object Qidentity; -Lisp_Object +static Lisp_Object casify_object (enum case_action flag, Lisp_Object obj) { register int c, c1; register int inword = flag == CASE_DOWN; /* If the case table is flagged as modified, rescan it. */ - if (NILP (XCHAR_TABLE (B_ (current_buffer, downcase_table))->extras[1])) - Fset_case_table (B_ (current_buffer, downcase_table)); + if (NILP (XCHAR_TABLE (BVAR (current_buffer, downcase_table))->extras[1])) + Fset_case_table (BVAR (current_buffer, downcase_table)); if (INTEGERP (obj)) { int flagbits = (CHAR_ALT | CHAR_SUPER | CHAR_HYPER | CHAR_SHIFT | CHAR_CTL | CHAR_META); int flags = XINT (obj) & flagbits; - int multibyte = ! NILP (B_ (current_buffer, enable_multibyte_characters)); + int multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters)); /* If the character has higher bits set above the flags, return it unchanged. It is not a real character. */ - if ((unsigned) XFASTINT (obj) > (unsigned) flagbits) + if (UNSIGNED_CMP (XFASTINT (obj), >, flagbits)) return obj; c1 = XFASTINT (obj) & ~flagbits; @@ -64,13 +64,13 @@ casify_object (enum case_action flag, Lisp_Object obj) multibyte = 1; if (! multibyte) MAKE_CHAR_MULTIBYTE (c1); - c = DOWNCASE (c1); + c = downcase (c1); if (inword) XSETFASTINT (obj, c | flags); else if (c == (XFASTINT (obj) & ~flagbits)) { if (! inword) - c = UPCASE1 (c1); + c = upcase1 (c1); if (! multibyte) MAKE_CHAR_UNIBYTE (c); XSETFASTINT (obj, c | flags); @@ -82,8 +82,8 @@ casify_object (enum case_action flag, Lisp_Object obj) wrong_type_argument (Qchar_or_string_p, obj); else if (!STRING_MULTIBYTE (obj)) { - EMACS_INT i; - EMACS_INT size = SCHARS (obj); + ptrdiff_t i; + ptrdiff_t size = SCHARS (obj); obj = Fcopy_sequence (obj); for (i = 0; i < size; i++) @@ -92,10 +92,10 @@ casify_object (enum case_action flag, Lisp_Object obj) MAKE_CHAR_MULTIBYTE (c); c1 = c; if (inword && flag != CASE_CAPITALIZE_UP) - c = DOWNCASE (c); - else if (!UPPERCASEP (c) + c = downcase (c); + else if (!uppercasep (c) && (!inword || flag != CASE_CAPITALIZE_UP)) - c = UPCASE1 (c1); + c = upcase1 (c1); if ((int) flag >= (int) CASE_CAPITALIZE) inword = (SYNTAX (c) == Sword); if (c != c1) @@ -111,32 +111,26 @@ casify_object (enum case_action flag, Lisp_Object obj) } else { - EMACS_INT i, i_byte, size = SCHARS (obj); + ptrdiff_t i, i_byte, size = SCHARS (obj); int len; USE_SAFE_ALLOCA; unsigned char *dst, *o; - /* Over-allocate by 12%: this is a minor overhead, but should be - sufficient in 99.999% of the cases to avoid a reallocation. */ - EMACS_INT o_size = SBYTES (obj) + SBYTES (obj) / 8 + MAX_MULTIBYTE_LENGTH; + ptrdiff_t o_size = (size < STRING_BYTES_BOUND / MAX_MULTIBYTE_LENGTH + ? size * MAX_MULTIBYTE_LENGTH + : STRING_BYTES_BOUND); SAFE_ALLOCA (dst, void *, o_size); o = dst; for (i = i_byte = 0; i < size; i++, i_byte += len) { - if ((o - dst) + MAX_MULTIBYTE_LENGTH > o_size) - { /* Not enough space for the next char: grow the destination. */ - unsigned char *old_dst = dst; - o_size += o_size; /* Probably overkill, but extremely rare. */ - SAFE_ALLOCA (dst, void *, o_size); - memcpy (dst, old_dst, o - old_dst); - o = dst + (o - old_dst); - } + if (o_size - (o - dst) < MAX_MULTIBYTE_LENGTH) + string_overflow (); c = STRING_CHAR_AND_LENGTH (SDATA (obj) + i_byte, len); if (inword && flag != CASE_CAPITALIZE_UP) - c = DOWNCASE (c); - else if (!UPPERCASEP (c) + c = downcase (c); + else if (!uppercasep (c) && (!inword || flag != CASE_CAPITALIZE_UP)) - c = UPCASE1 (c); + c = upcase1 (c); if ((int) flag >= (int) CASE_CAPITALIZE) inword = (SYNTAX (c) == Sword); o += CHAR_STRING (c, o); @@ -193,25 +187,28 @@ The argument object is not altered--the value is a copy. */) /* flag is CASE_UP, CASE_DOWN or CASE_CAPITALIZE or CASE_CAPITALIZE_UP. b and e specify range of buffer to operate on. */ -void +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 (B_ (current_buffer, enable_multibyte_characters)); - EMACS_INT start, end; - EMACS_INT start_byte, end_byte; - EMACS_INT first = -1, last; /* Position of first and last changes. */ - EMACS_INT opoint = PT; - EMACS_INT opoint_byte = PT_BYTE; + register int multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters)); + ptrdiff_t start, end; + ptrdiff_t start_byte; + + /* Position of first and last changes. */ + ptrdiff_t first = -1, last IF_LINT (= 0); + + ptrdiff_t opoint = PT; + ptrdiff_t opoint_byte = PT_BYTE; if (EQ (b, e)) /* Not modifying because nothing marked */ return; /* If the case table is flagged as modified, rescan it. */ - if (NILP (XCHAR_TABLE (B_ (current_buffer, downcase_table))->extras[1])) - Fset_case_table (B_ (current_buffer, downcase_table)); + if (NILP (XCHAR_TABLE (BVAR (current_buffer, downcase_table))->extras[1])) + Fset_case_table (BVAR (current_buffer, downcase_table)); validate_region (&b, &e); start = XFASTINT (b); @@ -219,9 +216,8 @@ casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e) modify_region (current_buffer, start, end, 0); record_change (start, end - start); start_byte = CHAR_TO_BYTE (start); - end_byte = CHAR_TO_BYTE (end); - SETUP_BUFFER_SYNTAX_TABLE(); /* For syntax_prefix_flag_p. */ + SETUP_BUFFER_SYNTAX_TABLE (); /* For syntax_prefix_flag_p. */ while (start < end) { @@ -240,10 +236,10 @@ casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e) } c2 = c; if (inword && flag != CASE_CAPITALIZE_UP) - c = DOWNCASE (c); - else if (!UPPERCASEP (c) + c = downcase (c); + else if (!uppercasep (c) && (!inword || flag != CASE_CAPITALIZE_UP)) - c = UPCASE1 (c); + c = upcase1 (c); if ((int) flag >= (int) CASE_CAPITALIZE) inword = ((SYNTAX (c) == Sword) && (inword || !syntax_prefix_flag_p (c))); @@ -349,10 +345,10 @@ character positions to operate on. */) } static Lisp_Object -operate_on_word (Lisp_Object arg, EMACS_INT *newpoint) +operate_on_word (Lisp_Object arg, ptrdiff_t *newpoint) { Lisp_Object val; - EMACS_INT farend; + ptrdiff_t farend; EMACS_INT iarg; CHECK_NUMBER (arg); @@ -374,7 +370,7 @@ See also `capitalize-word'. */) (Lisp_Object arg) { Lisp_Object beg, end; - EMACS_INT newpoint; + ptrdiff_t newpoint; XSETFASTINT (beg, PT); end = operate_on_word (arg, &newpoint); casify_region (CASE_UP, beg, end); @@ -388,7 +384,7 @@ With negative argument, convert previous words but do not move. */) (Lisp_Object arg) { Lisp_Object beg, end; - EMACS_INT newpoint; + ptrdiff_t newpoint; XSETFASTINT (beg, PT); end = operate_on_word (arg, &newpoint); casify_region (CASE_DOWN, beg, end); @@ -404,7 +400,7 @@ With negative argument, capitalize previous words but do not move. */) (Lisp_Object arg) { Lisp_Object beg, end; - EMACS_INT newpoint; + ptrdiff_t newpoint; XSETFASTINT (beg, PT); end = operate_on_word (arg, &newpoint); casify_region (CASE_CAPITALIZE, beg, end); @@ -415,8 +411,7 @@ With negative argument, capitalize previous words but do not move. */) void syms_of_casefiddle (void) { - Qidentity = intern_c_string ("identity"); - staticpro (&Qidentity); + DEFSYM (Qidentity, "identity"); defsubr (&Supcase); defsubr (&Sdowncase); defsubr (&Scapitalize); @@ -433,9 +428,9 @@ syms_of_casefiddle (void) void keys_of_casefiddle (void) { - initial_define_key (control_x_map, Ctl('U'), "upcase-region"); + initial_define_key (control_x_map, Ctl ('U'), "upcase-region"); Fput (intern ("upcase-region"), Qdisabled, Qt); - initial_define_key (control_x_map, Ctl('L'), "downcase-region"); + initial_define_key (control_x_map, Ctl ('L'), "downcase-region"); Fput (intern ("downcase-region"), Qdisabled, Qt); initial_define_key (meta_map, 'u', "upcase-word");