/* GNU Emacs case conversion functions.
- Copyright (C) 1985, 1994, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1985,94,97,98,99, 2001, 2002, 2004, 2005
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
#include <config.h>
#include "lisp.h"
#include "buffer.h"
-#include "charset.h"
+#include "character.h"
#include "commands.h"
#include "syntax.h"
#include "composite.h"
+#include "keymap.h"
enum case_action {CASE_UP, CASE_DOWN, CASE_CAPITALIZE, CASE_CAPITALIZE_UP};
enum case_action flag;
Lisp_Object obj;
{
- register int i, c, len;
+ register int c, c1;
register int inword = flag == CASE_DOWN;
/* If the case table is flagged as modified, rescan it. */
int flagbits = (CHAR_ALT | CHAR_SUPER | CHAR_HYPER
| CHAR_SHIFT | CHAR_CTL | CHAR_META);
int flags = XINT (obj) & flagbits;
-
- c = DOWNCASE (XFASTINT (obj) & ~flagbits);
+ int multibyte = ! NILP (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)
+ return obj;
+
+ c1 = XFASTINT (obj) & ~flagbits;
+ if (! multibyte)
+ MAKE_CHAR_MULTIBYTE (c1);
+ c = DOWNCASE (c1);
if (inword)
XSETFASTINT (obj, c | flags);
else if (c == (XFASTINT (obj) & ~flagbits))
{
- c = UPCASE1 ((XFASTINT (obj) & ~flagbits));
+ if (! inword)
+ c = UPCASE1 (c1);
+ if (! multibyte)
+ MAKE_CHAR_UNIBYTE (c);
XSETFASTINT (obj, c | flags);
}
return obj;
if (STRINGP (obj))
{
int multibyte = STRING_MULTIBYTE (obj);
+ int i, i_byte, len;
+ int size = SCHARS (obj);
obj = Fcopy_sequence (obj);
- len = STRING_BYTES (XSTRING (obj));
-
- /* Scan all single-byte characters from start of string. */
- for (i = 0; i < len;)
+ for (i = i_byte = 0; i < size; i++, i_byte += len)
{
- c = XSTRING (obj)->data[i];
-
- if (multibyte && c >= 0x80)
- /* A multibyte character can't be handled in this
- simple loop. */
- break;
+ if (multibyte)
+ c = STRING_CHAR_AND_LENGTH (SDATA (obj) + i_byte, 0, len);
+ else
+ {
+ c = SREF (obj, i_byte);
+ len = 1;
+ MAKE_CHAR_MULTIBYTE (c);
+ }
+ c1 = c;
if (inword && flag != CASE_CAPITALIZE_UP)
c = DOWNCASE (c);
else if (!UPPERCASEP (c)
&& (!inword || flag != CASE_CAPITALIZE_UP))
- c = UPCASE1 (c);
- /* If this char won't fit in a single-byte string.
- fall out to the multibyte case. */
- if (multibyte ? ! ASCII_BYTE_P (c)
- : ! SINGLE_BYTE_CHAR_P (c))
- break;
-
- XSTRING (obj)->data[i] = c;
+ c = UPCASE1 (c1);
if ((int) flag >= (int) CASE_CAPITALIZE)
- inword = SYNTAX (c) == Sword;
- i++;
- }
-
- /* If we didn't do the whole string as single-byte,
- scan the rest in a more complex way. */
- if (i < len)
- {
- /* The work is not yet finished because of a multibyte
- character just encountered. */
- int fromlen, tolen, j_byte = i;
- char *buf
- = (char *) alloca ((len - i) * MAX_MULTIBYTE_LENGTH + i);
-
- /* Copy data already handled. */
- bcopy (XSTRING (obj)->data, buf, i);
-
- /* From now on, I counts bytes. */
- while (i < len)
+ inword = (SYNTAX (c) == Sword);
+ if (c != c1)
{
- c = STRING_CHAR_AND_LENGTH (XSTRING (obj)->data + i,
- len - i, fromlen);
- if (inword && flag != CASE_CAPITALIZE_UP)
- c = DOWNCASE (c);
- else if (!UPPERCASEP (c)
- && (!inword || flag != CASE_CAPITALIZE_UP))
- c = UPCASE1 (c);
- i += fromlen;
- j_byte += CHAR_STRING (c, buf + j_byte);
- if ((int) flag >= (int) CASE_CAPITALIZE)
- inword = SYNTAX (c) == Sword;
+ if (! multibyte)
+ {
+ MAKE_CHAR_UNIBYTE (c);
+ SSET (obj, i_byte, c);
+ }
+ else if (ASCII_CHAR_P (c1) && ASCII_CHAR_P (c))
+ SSET (obj, i_byte, c);
+ else
+ {
+ Faset (obj, make_number (i), make_number (c));
+ i_byte += CHAR_BYTES (c) - len;
+ }
}
- obj = make_multibyte_string (buf, XSTRING (obj)->size,
- j_byte);
}
return obj;
}
}
DEFUN ("upcase", Fupcase, Supcase, 1, 1, 0,
- "Convert argument to upper case and return that.\n\
-The argument may be a character or string. The result has the same type.\n\
-The argument object is not altered--the value is a copy.\n\
-See also `capitalize', `downcase' and `upcase-initials'.")
- (obj)
+ doc: /* Convert argument to upper case and return that.
+The argument may be a character or string. The result has the same type.
+The argument object is not altered--the value is a copy.
+See also `capitalize', `downcase' and `upcase-initials'. */)
+ (obj)
Lisp_Object obj;
{
return casify_object (CASE_UP, obj);
}
DEFUN ("downcase", Fdowncase, Sdowncase, 1, 1, 0,
- "Convert argument to lower case and return that.\n\
-The argument may be a character or string. The result has the same type.\n\
-The argument object is not altered--the value is a copy.")
- (obj)
+ doc: /* Convert argument to lower case and return that.
+The argument may be a character or string. The result has the same type.
+The argument object is not altered--the value is a copy. */)
+ (obj)
Lisp_Object obj;
{
return casify_object (CASE_DOWN, obj);
}
DEFUN ("capitalize", Fcapitalize, Scapitalize, 1, 1, 0,
- "Convert argument to capitalized form and return that.\n\
-This means that each word's first character is upper case\n\
-and the rest is lower case.\n\
-The argument may be a character or string. The result has the same type.\n\
-The argument object is not altered--the value is a copy.")
- (obj)
+ doc: /* Convert argument to capitalized form and return that.
+This means that each word's first character is upper case
+and the rest is lower case.
+The argument may be a character or string. The result has the same type.
+The argument object is not altered--the value is a copy. */)
+ (obj)
Lisp_Object obj;
{
return casify_object (CASE_CAPITALIZE, obj);
/* Like Fcapitalize but change only the initials. */
DEFUN ("upcase-initials", Fupcase_initials, Supcase_initials, 1, 1, 0,
- "Convert the initial of each word in the argument to upper case.\n\
-Do not change the other letters of each word.\n\
-The argument may be a character or string. The result has the same type.\n\
-The argument object is not altered--the value is a copy.")
- (obj)
+ doc: /* Convert the initial of each word in the argument to upper case.
+Do not change the other letters of each word.
+The argument may be a character or string. The result has the same type.
+The argument object is not altered--the value is a copy. */)
+ (obj)
Lisp_Object obj;
{
return casify_object (CASE_CAPITALIZE_UP, obj);
enum case_action flag;
Lisp_Object b, e;
{
- register int i;
register int c;
register int inword = flag == CASE_DOWN;
register int multibyte = !NILP (current_buffer->enable_multibyte_characters);
int start, end;
int start_byte, end_byte;
int changed = 0;
+ int opoint = PT;
+ int opoint_byte = PT_BYTE;
if (EQ (b, e))
/* Not modifying because nothing marked */
start_byte = CHAR_TO_BYTE (start);
end_byte = CHAR_TO_BYTE (end);
- for (i = start_byte; i < end_byte; i++, start++)
+ while (start < end)
{
- int c2;
- c = c2 = FETCH_BYTE (i);
- if (multibyte && c >= 0x80)
- /* A multibyte character can't be handled in this simple loop. */
- break;
+ int c2, len;
+
+ if (multibyte)
+ {
+ c = FETCH_MULTIBYTE_CHAR (start_byte);
+ len = CHAR_BYTES (c);
+ }
+ else
+ {
+ c = FETCH_BYTE (start_byte);
+ MAKE_CHAR_MULTIBYTE (c);
+ len = 1;
+ }
+ c2 = c;
if (inword && flag != CASE_CAPITALIZE_UP)
c = DOWNCASE (c);
else if (!UPPERCASEP (c)
&& (!inword || flag != CASE_CAPITALIZE_UP))
c = UPCASE1 (c);
- FETCH_BYTE (i) = c;
- if (c != c2)
- changed = 1;
if ((int) flag >= (int) CASE_CAPITALIZE)
- inword = SYNTAX (c) == Sword;
- }
- if (i < end_byte)
- {
- /* The work is not yet finished because of a multibyte character
- just encountered. */
- int opoint = PT;
- int opoint_byte = PT_BYTE;
- int c2;
-
- while (i < end_byte)
+ inword = ((SYNTAX (c) == Sword) && (inword || !SYNTAX_PREFIX (c)));
+ if (c != c2)
{
- if ((c = FETCH_BYTE (i)) >= 0x80)
- c = FETCH_MULTIBYTE_CHAR (i);
- c2 = c;
- if (inword && flag != CASE_CAPITALIZE_UP)
- c2 = DOWNCASE (c);
- else if (!UPPERCASEP (c)
- && (!inword || flag != CASE_CAPITALIZE_UP))
- c2 = UPCASE1 (c);
- if (c != c2)
+ changed = 1;
+ if (! multibyte)
+ {
+ MAKE_CHAR_UNIBYTE (c);
+ FETCH_BYTE (start_byte) = c;
+ }
+ else if (ASCII_CHAR_P (c2) && ASCII_CHAR_P (c))
+ FETCH_BYTE (start_byte) = c;
+ else
{
- int fromlen, tolen, j;
+ int tolen = CHAR_BYTES (c);
+ int j;
unsigned char str[MAX_MULTIBYTE_LENGTH];
- changed = 1;
- /* Handle the most likely case */
- if (c < 0400 && c2 < 0400)
- FETCH_BYTE (i) = c2;
- else if (fromlen = CHAR_STRING (c, str),
- tolen = CHAR_STRING (c2, str),
- fromlen == tolen)
+ CHAR_STRING (c, str);
+ if (len == tolen)
{
- for (j = 0; j < tolen; ++j)
- FETCH_BYTE (i + j) = str[j];
+ /* Length is unchanged. */
+ for (j = 0; j < len; ++j)
+ FETCH_BYTE (start_byte + j) = str[j];
}
else
{
- error ("Can't casify letters that change length");
-#if 0 /* This is approximately what we'd like to be able to do here */
- if (tolen < fromlen)
- del_range_1 (i + tolen, i + fromlen, 0, 0);
- else if (tolen > fromlen)
- {
- TEMP_SET_PT (i + fromlen);
- insert_1 (str + fromlen, tolen - fromlen, 1, 0, 0);
- }
-#endif
+ /* Replace one character with the other,
+ keeping text properties the same. */
+ replace_range_2 (start, start_byte,
+ start + 1, start_byte + len,
+ str, 1, tolen,
+ 0);
+ len = tolen;
}
}
- if ((int) flag >= (int) CASE_CAPITALIZE)
- inword = SYNTAX (c2) == Sword;
- INC_BOTH (start, i);
}
- TEMP_SET_PT_BOTH (opoint, opoint_byte);
+ start++;
+ start_byte += len;
}
- start = XFASTINT (b);
+ if (PT != opoint)
+ TEMP_SET_PT_BOTH (opoint, opoint_byte);
+
if (changed)
{
+ start = XFASTINT (b);
signal_after_change (start, end - start, end - start);
update_compositions (start, end, CHECK_ALL);
}
}
DEFUN ("upcase-region", Fupcase_region, Supcase_region, 2, 2, "r",
- "Convert the region to upper case. In programs, wants two arguments.\n\
-These arguments specify the starting and ending character numbers of\n\
-the region to operate on. When used as a command, the text between\n\
-point and the mark is operated on.\n\
-See also `capitalize-region'.")
- (beg, end)
+ doc: /* Convert the region to upper case. In programs, wants two arguments.
+These arguments specify the starting and ending character numbers of
+the region to operate on. When used as a command, the text between
+point and the mark is operated on.
+See also `capitalize-region'. */)
+ (beg, end)
Lisp_Object beg, end;
{
casify_region (CASE_UP, beg, end);
}
DEFUN ("downcase-region", Fdowncase_region, Sdowncase_region, 2, 2, "r",
- "Convert the region to lower case. In programs, wants two arguments.\n\
-These arguments specify the starting and ending character numbers of\n\
-the region to operate on. When used as a command, the text between\n\
-point and the mark is operated on.")
- (beg, end)
+ doc: /* Convert the region to lower case. In programs, wants two arguments.
+These arguments specify the starting and ending character numbers of
+the region to operate on. When used as a command, the text between
+point and the mark is operated on. */)
+ (beg, end)
Lisp_Object beg, end;
{
casify_region (CASE_DOWN, beg, end);
}
DEFUN ("capitalize-region", Fcapitalize_region, Scapitalize_region, 2, 2, "r",
- "Convert the region to capitalized form.\n\
-Capitalized form means each word's first character is upper case\n\
-and the rest of it is lower case.\n\
-In programs, give two arguments, the starting and ending\n\
-character positions to operate on.")
- (beg, end)
+ doc: /* Convert the region to capitalized form.
+Capitalized form means each word's first character is upper case
+and the rest of it is lower case.
+In programs, give two arguments, the starting and ending
+character positions to operate on. */)
+ (beg, end)
Lisp_Object beg, end;
{
casify_region (CASE_CAPITALIZE, beg, end);
DEFUN ("upcase-initials-region", Fupcase_initials_region,
Supcase_initials_region, 2, 2, "r",
- "Upcase the initial of each word in the region.\n\
-Subsequent letters of each word are not changed.\n\
-In programs, give two arguments, the starting and ending\n\
-character positions to operate on.")
- (beg, end)
+ doc: /* Upcase the initial of each word in the region.
+Subsequent letters of each word are not changed.
+In programs, give two arguments, the starting and ending
+character positions to operate on. */)
+ (beg, end)
Lisp_Object beg, end;
{
casify_region (CASE_CAPITALIZE_UP, beg, end);
int farend;
int iarg;
- CHECK_NUMBER (arg, 0);
+ CHECK_NUMBER (arg);
iarg = XINT (arg);
farend = scan_words (PT, iarg);
if (!farend)
}
DEFUN ("upcase-word", Fupcase_word, Supcase_word, 1, 1, "p",
- "Convert following word (or ARG words) to upper case, moving over.\n\
-With negative argument, convert previous words but do not move.\n\
-See also `capitalize-word'.")
- (arg)
+ doc: /* Convert following word (or ARG words) to upper case, moving over.
+With negative argument, convert previous words but do not move.
+See also `capitalize-word'. */)
+ (arg)
Lisp_Object arg;
{
Lisp_Object beg, end;
}
DEFUN ("downcase-word", Fdowncase_word, Sdowncase_word, 1, 1, "p",
- "Convert following word (or ARG words) to lower case, moving over.\n\
-With negative argument, convert previous words but do not move.")
- (arg)
+ doc: /* Convert following word (or ARG words) to lower case, moving over.
+With negative argument, convert previous words but do not move. */)
+ (arg)
Lisp_Object arg;
{
Lisp_Object beg, end;
}
DEFUN ("capitalize-word", Fcapitalize_word, Scapitalize_word, 1, 1, "p",
- "Capitalize the following word (or ARG words), moving over.\n\
-This gives the word(s) a first character in upper case\n\
-and the rest lower case.\n\
-With negative argument, capitalize previous words but do not move.")
- (arg)
+ doc: /* Capitalize the following word (or ARG words), moving over.
+This gives the word(s) a first character in upper case
+and the rest lower case.
+With negative argument, capitalize previous words but do not move. */)
+ (arg)
Lisp_Object arg;
{
Lisp_Object beg, end;
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) */
HCoop / bpt / emacs.git / blobdiff