X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/ff2de6d2bb239c5fdcfaba2c8efd5c62610e3b7d..9e1821d3a2350a87de85d19208a63cfcd27d7b50:/src/casefiddle.c
diff --git a/src/casefiddle.c b/src/casefiddle.c
index b6551618b2..e365462757 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -1,6 +1,6 @@
/* GNU Emacs case conversion functions.
- Copyright (C) 1985, 1994, 1997, 1998, 1999, 2001, 2002, 2003, 2004,
- 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+
+Copyright (C) 1985, 1994, 1997-1999, 2001-2012 Free Software Foundation, Inc.
This file is part of GNU Emacs.
@@ -19,10 +19,10 @@ along with GNU Emacs. If not, see . */
#include
-#include
+
#include "lisp.h"
-#include "buffer.h"
#include "character.h"
+#include "buffer.h"
#include "commands.h"
#include "syntax.h"
#include "composite.h"
@@ -32,27 +32,28 @@ 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;
+ int c, c1;
+ bool inword = flag == CASE_DOWN;
/* If the case table is flagged as modified, rescan it. */
- if (NILP (XCHAR_TABLE (current_buffer->downcase_table)->extras[1]))
- Fset_case_table (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 (current_buffer->enable_multibyte_characters);
+ bool 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 +65,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 +83,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 +93,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,38 +112,31 @@ 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;
- SAFE_ALLOCA (dst, void *, o_size);
- o = dst;
+ ptrdiff_t o_size = (size < STRING_BYTES_BOUND / MAX_MULTIBYTE_LENGTH
+ ? size * MAX_MULTIBYTE_LENGTH
+ : STRING_BYTES_BOUND);
+ unsigned char *dst = SAFE_ALLOCA (o_size);
+ unsigned char *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);
}
eassert (o - dst <= o_size);
- obj = make_multibyte_string (dst, size, o - dst);
+ obj = make_multibyte_string ((char *) dst, size, o - dst);
SAFE_FREE ();
return obj;
}
@@ -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 (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;
+ int c;
+ bool inword = flag == CASE_DOWN;
+ bool 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 (current_buffer->downcase_table)->extras[1]))
- Fset_case_table (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)));
@@ -279,7 +275,7 @@ casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e)
keeping text properties the same. */
replace_range_2 (start, start_byte,
start + 1, start_byte + len,
- str, 1, tolen,
+ (char *) str, 1, tolen,
0);
len = tolen;
}
@@ -349,11 +345,11 @@ 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;
- int farend;
- int iarg;
+ ptrdiff_t farend;
+ EMACS_INT iarg;
CHECK_NUMBER (arg);
iarg = XINT (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,15 +428,12 @@ 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");
initial_define_key (meta_map, 'l', "downcase-word");
initial_define_key (meta_map, 'c', "capitalize-word");
}
-
-/* arch-tag: 60a73c66-5489-47e7-a81f-cead4057c526
- (do not change this comment) */