Mercurial > emacs
annotate src/casefiddle.c @ 19073:215810cb0e44 libc-970802 libc-970803 libc-970804 libc-970805 libc-970806 libc-970807 libc-970808 libc-970809 libc-970810 libc-970811 libc-970812 libc-970813 libc-970814 libc-970815 libc-970816 libc-970817 libc-970818 libc-970819 libc-970820 libc-970821 libc-970822
Translate -svr4 to -sysv4 and -unixware to -sysv4.2uw.
author | Richard M. Stallman <rms@gnu.org> |
---|---|
date | Fri, 01 Aug 1997 18:09:30 +0000 |
parents | 614b916ff5bf |
children | 4dbda4b7c66f |
rev | line source |
---|---|
118 | 1 /* GNU Emacs case conversion functions. |
7307 | 2 Copyright (C) 1985, 1994 Free Software Foundation, Inc. |
118 | 3 |
4 This file is part of GNU Emacs. | |
5 | |
6 GNU Emacs is free software; you can redistribute it and/or modify | |
7 it under the terms of the GNU General Public License as published by | |
12244 | 8 the Free Software Foundation; either version 2, or (at your option) |
118 | 9 any later version. |
10 | |
11 GNU Emacs is distributed in the hope that it will be useful, | |
12 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 GNU General Public License for more details. | |
15 | |
16 You should have received a copy of the GNU General Public License | |
17 along with GNU Emacs; see the file COPYING. If not, write to | |
14186
ee40177f6c68
Update FSF's address in the preamble.
Erik Naggum <erik@naggum.no>
parents:
14063
diff
changeset
|
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
ee40177f6c68
Update FSF's address in the preamble.
Erik Naggum <erik@naggum.no>
parents:
14063
diff
changeset
|
19 Boston, MA 02111-1307, USA. */ |
118 | 20 |
21 | |
4696
1fc792473491
Include <config.h> instead of "config.h".
Roland McGrath <roland@gnu.org>
parents:
2822
diff
changeset
|
22 #include <config.h> |
118 | 23 #include "lisp.h" |
24 #include "buffer.h" | |
17816 | 25 #include "charset.h" |
118 | 26 #include "commands.h" |
27 #include "syntax.h" | |
28 | |
29 enum case_action {CASE_UP, CASE_DOWN, CASE_CAPITALIZE, CASE_CAPITALIZE_UP}; | |
17816 | 30 |
31 Lisp_Object Qidentity; | |
118 | 32 |
33 Lisp_Object | |
34 casify_object (flag, obj) | |
35 enum case_action flag; | |
36 Lisp_Object obj; | |
37 { | |
38 register int i, c, len; | |
39 register int inword = flag == CASE_DOWN; | |
17816 | 40 Lisp_Object tem; |
118 | 41 |
15170
0d698228e98c
(casify_region, casify_object):
Richard M. Stallman <rms@gnu.org>
parents:
14186
diff
changeset
|
42 /* If the case table is flagged as modified, rescan it. */ |
0d698228e98c
(casify_region, casify_object):
Richard M. Stallman <rms@gnu.org>
parents:
14186
diff
changeset
|
43 if (NILP (XCHAR_TABLE (current_buffer->downcase_table)->extras[1])) |
0d698228e98c
(casify_region, casify_object):
Richard M. Stallman <rms@gnu.org>
parents:
14186
diff
changeset
|
44 Fset_case_table (current_buffer->downcase_table); |
0d698228e98c
(casify_region, casify_object):
Richard M. Stallman <rms@gnu.org>
parents:
14186
diff
changeset
|
45 |
118 | 46 while (1) |
47 { | |
9137
412e94c1dbf2
(casify_object): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
9053
diff
changeset
|
48 if (INTEGERP (obj)) |
118 | 49 { |
18613
614b916ff5bf
Fix bugs with inappropriate mixing of Lisp_Object with int.
Richard M. Stallman <rms@gnu.org>
parents:
18136
diff
changeset
|
50 c = DOWNCASE (XFASTINT (obj)); |
18136
015e9e4a90ed
(casify_object): Fix bug on handling a character
Kenichi Handa <handa@m17n.org>
parents:
18005
diff
changeset
|
51 if (inword) |
015e9e4a90ed
(casify_object): Fix bug on handling a character
Kenichi Handa <handa@m17n.org>
parents:
18005
diff
changeset
|
52 XSETFASTINT (obj, c); |
015e9e4a90ed
(casify_object): Fix bug on handling a character
Kenichi Handa <handa@m17n.org>
parents:
18005
diff
changeset
|
53 else if (c == XFASTINT (obj)) |
015e9e4a90ed
(casify_object): Fix bug on handling a character
Kenichi Handa <handa@m17n.org>
parents:
18005
diff
changeset
|
54 { |
18613
614b916ff5bf
Fix bugs with inappropriate mixing of Lisp_Object with int.
Richard M. Stallman <rms@gnu.org>
parents:
18136
diff
changeset
|
55 c = UPCASE1 (XFASTINT (obj)); |
18136
015e9e4a90ed
(casify_object): Fix bug on handling a character
Kenichi Handa <handa@m17n.org>
parents:
18005
diff
changeset
|
56 XSETFASTINT (obj, c); |
015e9e4a90ed
(casify_object): Fix bug on handling a character
Kenichi Handa <handa@m17n.org>
parents:
18005
diff
changeset
|
57 } |
118 | 58 return obj; |
59 } | |
9137
412e94c1dbf2
(casify_object): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
9053
diff
changeset
|
60 if (STRINGP (obj)) |
118 | 61 { |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
62 int multibyte = !NILP (current_buffer->enable_multibyte_characters); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
63 |
118 | 64 obj = Fcopy_sequence (obj); |
65 len = XSTRING (obj)->size; | |
66 for (i = 0; i < len; i++) | |
67 { | |
68 c = XSTRING (obj)->data[i]; | |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
69 if (multibyte && c >= 0x80) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
70 /* A multibyte character can't be handled in this |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
71 simple loop. */ |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
72 break; |
9052
6de22822cf72
(upcase_initials): New function.
Richard M. Stallman <rms@gnu.org>
parents:
7307
diff
changeset
|
73 if (inword && flag != CASE_CAPITALIZE_UP) |
118 | 74 c = DOWNCASE (c); |
9052
6de22822cf72
(upcase_initials): New function.
Richard M. Stallman <rms@gnu.org>
parents:
7307
diff
changeset
|
75 else if (!UPPERCASEP (c) |
6de22822cf72
(upcase_initials): New function.
Richard M. Stallman <rms@gnu.org>
parents:
7307
diff
changeset
|
76 && (!inword || flag != CASE_CAPITALIZE_UP)) |
118 | 77 c = UPCASE1 (c); |
78 XSTRING (obj)->data[i] = c; | |
9052
6de22822cf72
(upcase_initials): New function.
Richard M. Stallman <rms@gnu.org>
parents:
7307
diff
changeset
|
79 if ((int) flag >= (int) CASE_CAPITALIZE) |
118 | 80 inword = SYNTAX (c) == Sword; |
81 } | |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
82 if (i < len) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
83 { |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
84 /* The work is not yet finished because of a multibyte |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
85 character just encountered. */ |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
86 int fromlen, tolen, j = i; |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
87 char *buf |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
88 = (char *) alloca ((len - i) * MAX_LENGTH_OF_MULTI_BYTE_FORM |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
89 + i); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
90 char *str, workbuf[4]; |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
91 |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
92 /* Copy data already handled. */ |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
93 bcopy (XSTRING (obj)->data, buf, i); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
94 |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
95 while (i < len) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
96 { |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
97 c = STRING_CHAR_AND_LENGTH (XSTRING (obj)->data + i, |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
98 len - i, fromlen); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
99 if (inword && flag != CASE_CAPITALIZE_UP) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
100 c = DOWNCASE (c); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
101 else if (!UPPERCASEP (c) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
102 && (!inword || flag != CASE_CAPITALIZE_UP)) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
103 c = UPCASE1 (c); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
104 tolen = CHAR_STRING (c, workbuf, str); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
105 bcopy (str, buf + j, tolen); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
106 i += fromlen; |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
107 j += tolen; |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
108 if ((int) flag >= (int) CASE_CAPITALIZE) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
109 inword = SYNTAX (c) == Sword; |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
110 } |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
111 obj = make_string (buf, j); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
112 } |
118 | 113 return obj; |
114 } | |
1926
952f2a18f83d
* callint.c (Fcall_interactively): Pass the correct number of
Jim Blandy <jimb@redhat.com>
parents:
1505
diff
changeset
|
115 obj = wrong_type_argument (Qchar_or_string_p, obj); |
118 | 116 } |
117 } | |
118 | |
119 DEFUN ("upcase", Fupcase, Supcase, 1, 1, 0, | |
120 "Convert argument to upper case and return that.\n\ | |
121 The argument may be a character or string. The result has the same type.\n\ | |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
122 The argument object is not altered--the value is a copy.\n\ |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
123 See also `capitalize', `downcase' and `upcase-initials'.") |
118 | 124 (obj) |
125 Lisp_Object obj; | |
126 { | |
127 return casify_object (CASE_UP, obj); | |
128 } | |
129 | |
130 DEFUN ("downcase", Fdowncase, Sdowncase, 1, 1, 0, | |
131 "Convert argument to lower case and return that.\n\ | |
132 The argument may be a character or string. The result has the same type.\n\ | |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
133 The argument object is not altered--the value is a copy.") |
118 | 134 (obj) |
135 Lisp_Object obj; | |
136 { | |
137 return casify_object (CASE_DOWN, obj); | |
138 } | |
139 | |
140 DEFUN ("capitalize", Fcapitalize, Scapitalize, 1, 1, 0, | |
141 "Convert argument to capitalized form and return that.\n\ | |
142 This means that each word's first character is upper case\n\ | |
143 and the rest is lower case.\n\ | |
144 The argument may be a character or string. The result has the same type.\n\ | |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
145 The argument object is not altered--the value is a copy.") |
118 | 146 (obj) |
147 Lisp_Object obj; | |
148 { | |
149 return casify_object (CASE_CAPITALIZE, obj); | |
150 } | |
9052
6de22822cf72
(upcase_initials): New function.
Richard M. Stallman <rms@gnu.org>
parents:
7307
diff
changeset
|
151 |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
152 /* Like Fcapitalize but change only the initials. */ |
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
153 |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
154 DEFUN ("upcase-initials", Fupcase_initials, Supcase_initials, 1, 1, 0, |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
155 "Convert the initial of each word in the argument to upper case.\n\ |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
156 Do not change the other letters of each word.\n\ |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
157 The argument may be a character or string. The result has the same type.\n\ |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
158 The argument object is not altered--the value is a copy.") |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
159 (obj) |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
160 Lisp_Object obj; |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
161 { |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
162 return casify_object (CASE_CAPITALIZE_UP, obj); |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
163 } |
118 | 164 |
165 /* flag is CASE_UP, CASE_DOWN or CASE_CAPITALIZE or CASE_CAPITALIZE_UP. | |
166 b and e specify range of buffer to operate on. */ | |
167 | |
168 casify_region (flag, b, e) | |
169 enum case_action flag; | |
170 Lisp_Object b, e; | |
171 { | |
172 register int i; | |
173 register int c; | |
174 register int inword = flag == CASE_DOWN; | |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
175 register int multibyte = !NILP (current_buffer->enable_multibyte_characters); |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
176 int start, end; |
17816 | 177 Lisp_Object ch, downch, val; |
118 | 178 |
179 if (EQ (b, e)) | |
180 /* Not modifying because nothing marked */ | |
181 return; | |
182 | |
15170
0d698228e98c
(casify_region, casify_object):
Richard M. Stallman <rms@gnu.org>
parents:
14186
diff
changeset
|
183 /* If the case table is flagged as modified, rescan it. */ |
0d698228e98c
(casify_region, casify_object):
Richard M. Stallman <rms@gnu.org>
parents:
14186
diff
changeset
|
184 if (NILP (XCHAR_TABLE (current_buffer->downcase_table)->extras[1])) |
0d698228e98c
(casify_region, casify_object):
Richard M. Stallman <rms@gnu.org>
parents:
14186
diff
changeset
|
185 Fset_case_table (current_buffer->downcase_table); |
0d698228e98c
(casify_region, casify_object):
Richard M. Stallman <rms@gnu.org>
parents:
14186
diff
changeset
|
186 |
118 | 187 validate_region (&b, &e); |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
188 start = XFASTINT (b); |
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
189 end = XFASTINT (e); |
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
190 modify_region (current_buffer, start, end); |
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
191 record_change (start, end - start); |
118 | 192 |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
193 for (i = start; i < end; i++) |
17816 | 194 { |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
195 c = FETCH_BYTE (i); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
196 if (multibyte && c >= 0x80) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
197 /* A multibyte character can't be handled in this simple loop. */ |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
198 break; |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
199 if (inword && flag != CASE_CAPITALIZE_UP) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
200 c = DOWNCASE (c); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
201 else if (!UPPERCASEP (c) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
202 && (!inword || flag != CASE_CAPITALIZE_UP)) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
203 c = UPCASE1 (c); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
204 FETCH_BYTE (i) = c; |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
205 if ((int) flag >= (int) CASE_CAPITALIZE) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
206 inword = SYNTAX (c) == Sword; |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
207 } |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
208 if (i < end) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
209 { |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
210 /* The work is not yet finished because of a multibyte character |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
211 just encountered. */ |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
212 int opoint = PT, c2; |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
213 |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
214 while (i < end) |
17816 | 215 { |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
216 if ((c = FETCH_BYTE (i)) >= 0x80) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
217 c = FETCH_MULTIBYTE_CHAR (i); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
218 c2 = c; |
17816 | 219 if (inword && flag != CASE_CAPITALIZE_UP) |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
220 c2 = DOWNCASE (c); |
17816 | 221 else if (!UPPERCASEP (c) |
222 && (!inword || flag != CASE_CAPITALIZE_UP)) | |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
223 c2 = UPCASE1 (c); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
224 if (c != c2) |
17816 | 225 { |
226 int fromlen, tolen, j; | |
227 char workbuf[4], *str; | |
228 | |
229 /* Handle the most likely case */ | |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
230 if (c < 0400 && c2 < 0400) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
231 FETCH_BYTE (i) = c2; |
17816 | 232 else if (fromlen = CHAR_STRING (c, workbuf, str), |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
233 tolen = CHAR_STRING (c2, workbuf, str), |
17816 | 234 fromlen == tolen) |
235 { | |
236 for (j = 0; j < tolen; ++j) | |
237 FETCH_BYTE (i + j) = str[j]; | |
238 } | |
239 else | |
240 { | |
241 error ("Can't casify letters that change length"); | |
242 #if 0 /* This is approximately what we'd like to be able to do here */ | |
243 if (tolen < fromlen) | |
244 del_range_1 (i + tolen, i + fromlen, 0); | |
245 else if (tolen > fromlen) | |
246 { | |
247 TEMP_SET_PT (i + fromlen); | |
248 insert_1 (str + fromlen, tolen - fromlen, 1, 0); | |
249 } | |
250 #endif | |
251 } | |
252 } | |
253 if ((int) flag >= (int) CASE_CAPITALIZE) | |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
254 inword = SYNTAX (c2) == Sword; |
17816 | 255 INC_POS (i); |
256 } | |
257 TEMP_SET_PT (opoint); | |
118 | 258 } |
259 | |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
260 signal_after_change (start, end - start, end - start); |
118 | 261 } |
262 | |
263 DEFUN ("upcase-region", Fupcase_region, Supcase_region, 2, 2, "r", | |
264 "Convert the region to upper case. In programs, wants two arguments.\n\ | |
265 These arguments specify the starting and ending character numbers of\n\ | |
266 the region to operate on. When used as a command, the text between\n\ | |
267 point and the mark is operated on.\n\ | |
268 See also `capitalize-region'.") | |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
269 (beg, end) |
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
270 Lisp_Object beg, end; |
118 | 271 { |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
272 casify_region (CASE_UP, beg, end); |
118 | 273 return Qnil; |
274 } | |
275 | |
276 DEFUN ("downcase-region", Fdowncase_region, Sdowncase_region, 2, 2, "r", | |
277 "Convert the region to lower case. In programs, wants two arguments.\n\ | |
278 These arguments specify the starting and ending character numbers of\n\ | |
279 the region to operate on. When used as a command, the text between\n\ | |
280 point and the mark is operated on.") | |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
281 (beg, end) |
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
282 Lisp_Object beg, end; |
118 | 283 { |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
284 casify_region (CASE_DOWN, beg, end); |
118 | 285 return Qnil; |
286 } | |
287 | |
288 DEFUN ("capitalize-region", Fcapitalize_region, Scapitalize_region, 2, 2, "r", | |
289 "Convert the region to capitalized form.\n\ | |
290 Capitalized form means each word's first character is upper case\n\ | |
291 and the rest of it is lower case.\n\ | |
292 In programs, give two arguments, the starting and ending\n\ | |
293 character positions to operate on.") | |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
294 (beg, end) |
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
295 Lisp_Object beg, end; |
118 | 296 { |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
297 casify_region (CASE_CAPITALIZE, beg, end); |
118 | 298 return Qnil; |
299 } | |
300 | |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
301 /* Like Fcapitalize_region but change only the initials. */ |
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
302 |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
303 DEFUN ("upcase-initials-region", Fupcase_initials_region, |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
304 Supcase_initials_region, 2, 2, "r", |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
305 "Upcase the initial of each word in the region.\n\ |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
306 Subsequent letters of each word are not changed.\n\ |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
307 In programs, give two arguments, the starting and ending\n\ |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
308 character positions to operate on.") |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
309 (beg, end) |
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
310 Lisp_Object beg, end; |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
311 { |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
312 casify_region (CASE_CAPITALIZE_UP, beg, end); |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
313 return Qnil; |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
314 } |
118 | 315 |
316 Lisp_Object | |
6221
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
317 operate_on_word (arg, newpoint) |
118 | 318 Lisp_Object arg; |
6221
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
319 int *newpoint; |
118 | 320 { |
1505
4f138b03e5ab
* casefiddle.c (operate_on_word): Declare end to be an int, not a
Jim Blandy <jimb@redhat.com>
parents:
484
diff
changeset
|
321 Lisp_Object val; |
6221
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
322 int farend; |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
323 int iarg; |
118 | 324 |
325 CHECK_NUMBER (arg, 0); | |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
326 iarg = XINT (arg); |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15170
diff
changeset
|
327 farend = scan_words (PT, iarg); |
118 | 328 if (!farend) |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
329 farend = iarg > 0 ? ZV : BEGV; |
118 | 330 |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15170
diff
changeset
|
331 *newpoint = PT > farend ? PT : farend; |
9299
e8c880f2723e
(casify_object, operate_on_word, Fupcase_word, Fdowncase_word,
Karl Heuer <kwzh@gnu.org>
parents:
9137
diff
changeset
|
332 XSETFASTINT (val, farend); |
118 | 333 |
334 return val; | |
335 } | |
336 | |
337 DEFUN ("upcase-word", Fupcase_word, Supcase_word, 1, 1, "p", | |
338 "Convert following word (or ARG words) to upper case, moving over.\n\ | |
339 With negative argument, convert previous words but do not move.\n\ | |
340 See also `capitalize-word'.") | |
341 (arg) | |
342 Lisp_Object arg; | |
343 { | |
6221
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
344 Lisp_Object beg, end; |
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
345 int newpoint; |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15170
diff
changeset
|
346 XSETFASTINT (beg, PT); |
6221
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
347 end = operate_on_word (arg, &newpoint); |
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
348 casify_region (CASE_UP, beg, end); |
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
349 SET_PT (newpoint); |
118 | 350 return Qnil; |
351 } | |
352 | |
353 DEFUN ("downcase-word", Fdowncase_word, Sdowncase_word, 1, 1, "p", | |
354 "Convert following word (or ARG words) to lower case, moving over.\n\ | |
355 With negative argument, convert previous words but do not move.") | |
356 (arg) | |
357 Lisp_Object arg; | |
358 { | |
6221
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
359 Lisp_Object beg, end; |
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
360 int newpoint; |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15170
diff
changeset
|
361 XSETFASTINT (beg, PT); |
6221
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
362 end = operate_on_word (arg, &newpoint); |
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
363 casify_region (CASE_DOWN, beg, end); |
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
364 SET_PT (newpoint); |
118 | 365 return Qnil; |
366 } | |
367 | |
368 DEFUN ("capitalize-word", Fcapitalize_word, Scapitalize_word, 1, 1, "p", | |
369 "Capitalize the following word (or ARG words), moving over.\n\ | |
370 This gives the word(s) a first character in upper case\n\ | |
371 and the rest lower case.\n\ | |
372 With negative argument, capitalize previous words but do not move.") | |
373 (arg) | |
374 Lisp_Object arg; | |
375 { | |
6221
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
376 Lisp_Object beg, end; |
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
377 int newpoint; |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15170
diff
changeset
|
378 XSETFASTINT (beg, PT); |
6221
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
379 end = operate_on_word (arg, &newpoint); |
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
380 casify_region (CASE_CAPITALIZE, beg, end); |
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
381 SET_PT (newpoint); |
118 | 382 return Qnil; |
383 } | |
384 | |
385 syms_of_casefiddle () | |
386 { | |
17816 | 387 Qidentity = intern ("identity"); |
388 staticpro (&Qidentity); | |
118 | 389 defsubr (&Supcase); |
390 defsubr (&Sdowncase); | |
391 defsubr (&Scapitalize); | |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
392 defsubr (&Supcase_initials); |
118 | 393 defsubr (&Supcase_region); |
394 defsubr (&Sdowncase_region); | |
395 defsubr (&Scapitalize_region); | |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
396 defsubr (&Supcase_initials_region); |
118 | 397 defsubr (&Supcase_word); |
398 defsubr (&Sdowncase_word); | |
399 defsubr (&Scapitalize_word); | |
400 } | |
401 | |
402 keys_of_casefiddle () | |
403 { | |
404 initial_define_key (control_x_map, Ctl('U'), "upcase-region"); | |
484 | 405 Fput (intern ("upcase-region"), Qdisabled, Qt); |
118 | 406 initial_define_key (control_x_map, Ctl('L'), "downcase-region"); |
484 | 407 Fput (intern ("downcase-region"), Qdisabled, Qt); |
408 | |
118 | 409 initial_define_key (meta_map, 'u', "upcase-word"); |
410 initial_define_key (meta_map, 'l', "downcase-word"); | |
411 initial_define_key (meta_map, 'c', "capitalize-word"); | |
412 } |