Mercurial > emacs
annotate src/casefiddle.c @ 111373:45e5b5974ddb
* net/trampver.el: Update release number.
This shall not be merged into the trunk.
author | Michael Albinus <michael.albinus@gmx.de> |
---|---|
date | Fri, 05 Nov 2010 21:52:50 +0100 |
parents | 1d1d5d9bd884 |
children | aec1143e8d85 376148b31b5e |
rev | line source |
---|---|
118 | 1 /* GNU Emacs case conversion functions. |
64770
a0d1312ede66
Update years in copyright notice; nfc.
Thien-Thi Nguyen <ttn@gnuvola.org>
parents:
64084
diff
changeset
|
2 Copyright (C) 1985, 1994, 1997, 1998, 1999, 2001, 2002, 2003, 2004, |
106815 | 3 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
118 | 4 |
5 This file is part of GNU Emacs. | |
6 | |
94963
8971ddf55736
Switch to recommended form of GPLv3 permissions notice.
Glenn Morris <rgm@gnu.org>
parents:
93509
diff
changeset
|
7 GNU Emacs is free software: you can redistribute it and/or modify |
118 | 8 it under the terms of the GNU General Public License as published by |
94963
8971ddf55736
Switch to recommended form of GPLv3 permissions notice.
Glenn Morris <rgm@gnu.org>
parents:
93509
diff
changeset
|
9 the Free Software Foundation, either version 3 of the License, or |
8971ddf55736
Switch to recommended form of GPLv3 permissions notice.
Glenn Morris <rgm@gnu.org>
parents:
93509
diff
changeset
|
10 (at your option) any later version. |
118 | 11 |
12 GNU Emacs is distributed in the hope that it will be useful, | |
13 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 GNU General Public License for more details. | |
16 | |
17 You should have received a copy of the GNU General Public License | |
94963
8971ddf55736
Switch to recommended form of GPLv3 permissions notice.
Glenn Morris <rgm@gnu.org>
parents:
93509
diff
changeset
|
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */ |
118 | 19 |
20 | |
4696
1fc792473491
Include <config.h> instead of "config.h".
Roland McGrath <roland@gnu.org>
parents:
2822
diff
changeset
|
21 #include <config.h> |
105669
68dd71358159
* alloc.c: Do not define struct catchtag.
Dan Nicolaescu <dann@ics.uci.edu>
parents:
105661
diff
changeset
|
22 #include <setjmp.h> |
118 | 23 #include "lisp.h" |
24 #include "buffer.h" | |
88351
aac41b50c875
Include "character.h" instead of "charset.h".
Kenichi Handa <handa@m17n.org>
parents:
40656
diff
changeset
|
25 #include "character.h" |
118 | 26 #include "commands.h" |
27 #include "syntax.h" | |
26839 | 28 #include "composite.h" |
39748
42b7a798ff79
Include keymap.h.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
34969
diff
changeset
|
29 #include "keymap.h" |
118 | 30 |
31 enum case_action {CASE_UP, CASE_DOWN, CASE_CAPITALIZE, CASE_CAPITALIZE_UP}; | |
17816 | 32 |
33 Lisp_Object Qidentity; | |
118 | 34 |
35 Lisp_Object | |
36 casify_object (flag, obj) | |
37 enum case_action flag; | |
38 Lisp_Object obj; | |
39 { | |
89017
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
40 register int c, c1; |
118 | 41 register int inword = flag == CASE_DOWN; |
42 | |
15170
0d698228e98c
(casify_region, casify_object):
Richard M. Stallman <rms@gnu.org>
parents:
14186
diff
changeset
|
43 /* 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
|
44 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
|
45 Fset_case_table (current_buffer->downcase_table); |
0d698228e98c
(casify_region, casify_object):
Richard M. Stallman <rms@gnu.org>
parents:
14186
diff
changeset
|
46 |
71827
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
47 if (INTEGERP (obj)) |
118 | 48 { |
71827
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
49 int flagbits = (CHAR_ALT | CHAR_SUPER | CHAR_HYPER |
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
50 | CHAR_SHIFT | CHAR_CTL | CHAR_META); |
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
51 int flags = XINT (obj) & flagbits; |
90534
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
52 int multibyte = ! NILP (current_buffer->enable_multibyte_characters); |
22506
2107e25fa56f
(casify_object): Cope with modifier bits in character.
Karl Heuer <kwzh@gnu.org>
parents:
21514
diff
changeset
|
53 |
71827
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
54 /* If the character has higher bits set |
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
55 above the flags, return it unchanged. |
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
56 It is not a real character. */ |
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
57 if ((unsigned) XFASTINT (obj) > (unsigned) flagbits) |
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
58 return obj; |
55743
4f33fa491183
(casify_object): Return OBJ unchanged if not real char.
Richard M. Stallman <rms@gnu.org>
parents:
52401
diff
changeset
|
59 |
90534
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
60 c1 = XFASTINT (obj) & ~flagbits; |
95328
44c693827736
(casify_object): Try to guess better whether the argument is a byte or a char.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
94963
diff
changeset
|
61 /* FIXME: Even if enable-multibyte-characters is nil, we may |
44c693827736
(casify_object): Try to guess better whether the argument is a byte or a char.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
94963
diff
changeset
|
62 manipulate multibyte chars. This means we have a bug for latin-1 |
44c693827736
(casify_object): Try to guess better whether the argument is a byte or a char.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
94963
diff
changeset
|
63 chars since when we receive an int 128-255 we can't tell whether |
44c693827736
(casify_object): Try to guess better whether the argument is a byte or a char.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
94963
diff
changeset
|
64 it's an eight-bit byte or a latin-1 char. */ |
44c693827736
(casify_object): Try to guess better whether the argument is a byte or a char.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
94963
diff
changeset
|
65 if (c1 >= 256) |
44c693827736
(casify_object): Try to guess better whether the argument is a byte or a char.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
94963
diff
changeset
|
66 multibyte = 1; |
90534
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
67 if (! multibyte) |
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
68 MAKE_CHAR_MULTIBYTE (c1); |
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
69 c = DOWNCASE (c1); |
71827
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
70 if (inword) |
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
71 XSETFASTINT (obj, c | flags); |
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
72 else if (c == (XFASTINT (obj) & ~flagbits)) |
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
73 { |
90534
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
74 if (! inword) |
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
75 c = UPCASE1 (c1); |
89017
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
76 if (! multibyte) |
90534
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
77 MAKE_CHAR_UNIBYTE (c); |
71827
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
78 XSETFASTINT (obj, c | flags); |
118 | 79 } |
71827
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
80 return obj; |
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
81 } |
20611
e351676e5044
(casify_object): Scan string by bytes and chars.
Richard M. Stallman <rms@gnu.org>
parents:
20543
diff
changeset
|
82 |
93179
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
83 if (!STRINGP (obj)) |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
84 wrong_type_argument (Qchar_or_string_p, obj); |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
85 else if (!STRING_MULTIBYTE (obj)) |
71827
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
86 { |
93179
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
87 EMACS_INT i; |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
88 EMACS_INT size = SCHARS (obj); |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
89 |
71827
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
90 obj = Fcopy_sequence (obj); |
93179
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
91 for (i = 0; i < size; i++) |
71827
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
92 { |
93179
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
93 c = SREF (obj, i); |
105661
bac26aa40069
Remove leftover table unibyte_to_multibyte_table.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
100951
diff
changeset
|
94 MAKE_CHAR_MULTIBYTE (c); |
90534
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
95 c1 = c; |
71827
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
96 if (inword && flag != CASE_CAPITALIZE_UP) |
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
97 c = DOWNCASE (c); |
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
98 else if (!UPPERCASEP (c) |
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
99 && (!inword || flag != CASE_CAPITALIZE_UP)) |
90534
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
100 c = UPCASE1 (c1); |
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
101 if ((int) flag >= (int) CASE_CAPITALIZE) |
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
102 inword = (SYNTAX (c) == Sword); |
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
103 if (c != c1) |
71827
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
104 { |
90534
2811bff46a36
(casify_object): Sync with HEAD.
Kenichi Handa <handa@m17n.org>
parents:
90294
diff
changeset
|
105 MAKE_CHAR_UNIBYTE (c); |
93179
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
106 /* If the char can't be converted to a valid byte, just don't |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
107 change it. */ |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
108 if (c >= 0 && c < 256) |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
109 SSET (obj, i, c); |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
110 } |
118 | 111 } |
71827
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
112 return obj; |
93509
367250b2af54
(casify_object): Fix up int/EMACS_INT mixup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
93179
diff
changeset
|
113 } |
367250b2af54
(casify_object): Fix up int/EMACS_INT mixup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
93179
diff
changeset
|
114 else |
367250b2af54
(casify_object): Fix up int/EMACS_INT mixup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
93179
diff
changeset
|
115 { |
367250b2af54
(casify_object): Fix up int/EMACS_INT mixup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
93179
diff
changeset
|
116 EMACS_INT i, i_byte, size = SCHARS (obj); |
367250b2af54
(casify_object): Fix up int/EMACS_INT mixup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
93179
diff
changeset
|
117 int len; |
93179
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
118 USE_SAFE_ALLOCA; |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
119 unsigned char *dst, *o; |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
120 /* Over-allocate by 12%: this is a minor overhead, but should be |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
121 sufficient in 99.999% of the cases to avoid a reallocation. */ |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
122 EMACS_INT o_size = SBYTES (obj) + SBYTES (obj) / 8 + MAX_MULTIBYTE_LENGTH; |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
123 SAFE_ALLOCA (dst, void *, o_size); |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
124 o = dst; |
71827
5e4428007299
(casify_object): Remove loop around wrong_type_argument.
Kim F. Storm <storm@cua.dk>
parents:
68651
diff
changeset
|
125 |
93179
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
126 for (i = i_byte = 0; i < size; i++, i_byte += len) |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
127 { |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
128 if ((o - dst) + MAX_MULTIBYTE_LENGTH > o_size) |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
129 { /* Not enough space for the next char: grow the destination. */ |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
130 unsigned char *old_dst = dst; |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
131 o_size += o_size; /* Probably overkill, but extremely rare. */ |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
132 SAFE_ALLOCA (dst, void *, o_size); |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
133 bcopy (old_dst, dst, o - old_dst); |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
134 o = dst + (o - old_dst); |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
135 } |
106185
f2cea199b0c4
* character.h (STRING_CHAR, STRING_CHAR_AND_LENGTH): Remove
Andreas Schwab <schwab@linux-m68k.org>
parents:
105877
diff
changeset
|
136 c = STRING_CHAR_AND_LENGTH (SDATA (obj) + i_byte, len); |
93179
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
137 if (inword && flag != CASE_CAPITALIZE_UP) |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
138 c = DOWNCASE (c); |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
139 else if (!UPPERCASEP (c) |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
140 && (!inword || flag != CASE_CAPITALIZE_UP)) |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
141 c = UPCASE1 (c); |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
142 if ((int) flag >= (int) CASE_CAPITALIZE) |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
143 inword = (SYNTAX (c) == Sword); |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
144 o += CHAR_STRING (c, o); |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
145 } |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
146 eassert (o - dst <= o_size); |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
147 obj = make_multibyte_string (dst, size, o - dst); |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
148 SAFE_FREE (); |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
149 return obj; |
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
150 } |
118 | 151 } |
152 | |
153 DEFUN ("upcase", Fupcase, Supcase, 1, 1, 0, | |
40103
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
154 doc: /* Convert argument to upper case and return that. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
155 The argument may be a character or string. The result has the same type. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
156 The argument object is not altered--the value is a copy. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
157 See also `capitalize', `downcase' and `upcase-initials'. */) |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
158 (obj) |
118 | 159 Lisp_Object obj; |
160 { | |
161 return casify_object (CASE_UP, obj); | |
162 } | |
163 | |
164 DEFUN ("downcase", Fdowncase, Sdowncase, 1, 1, 0, | |
40103
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
165 doc: /* Convert argument to lower case and return that. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
166 The argument may be a character or string. The result has the same type. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
167 The argument object is not altered--the value is a copy. */) |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
168 (obj) |
118 | 169 Lisp_Object obj; |
170 { | |
171 return casify_object (CASE_DOWN, obj); | |
172 } | |
173 | |
174 DEFUN ("capitalize", Fcapitalize, Scapitalize, 1, 1, 0, | |
40103
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
175 doc: /* Convert argument to capitalized form and return that. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
176 This means that each word's first character is upper case |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
177 and the rest is lower case. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
178 The argument may be a character or string. The result has the same type. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
179 The argument object is not altered--the value is a copy. */) |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
180 (obj) |
118 | 181 Lisp_Object obj; |
182 { | |
183 return casify_object (CASE_CAPITALIZE, obj); | |
184 } | |
9052
6de22822cf72
(upcase_initials): New function.
Richard M. Stallman <rms@gnu.org>
parents:
7307
diff
changeset
|
185 |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
186 /* 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
|
187 |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
188 DEFUN ("upcase-initials", Fupcase_initials, Supcase_initials, 1, 1, 0, |
40103
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
189 doc: /* Convert the initial of each word in the argument to upper case. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
190 Do not change the other letters of each word. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
191 The argument may be a character or string. The result has the same type. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
192 The argument object is not altered--the value is a copy. */) |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
193 (obj) |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
194 Lisp_Object obj; |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
195 { |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
196 return casify_object (CASE_CAPITALIZE_UP, obj); |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
197 } |
118 | 198 |
199 /* flag is CASE_UP, CASE_DOWN or CASE_CAPITALIZE or CASE_CAPITALIZE_UP. | |
200 b and e specify range of buffer to operate on. */ | |
201 | |
21514 | 202 void |
118 | 203 casify_region (flag, b, e) |
204 enum case_action flag; | |
205 Lisp_Object b, e; | |
206 { | |
207 register int c; | |
208 register int inword = flag == CASE_DOWN; | |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
209 register int multibyte = !NILP (current_buffer->enable_multibyte_characters); |
91803
78fbdbd37286
(casify_region): Only call after-change and composition
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91327
diff
changeset
|
210 EMACS_INT start, end; |
78fbdbd37286
(casify_region): Only call after-change and composition
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91327
diff
changeset
|
211 EMACS_INT start_byte, end_byte; |
78fbdbd37286
(casify_region): Only call after-change and composition
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91327
diff
changeset
|
212 EMACS_INT first = -1, last; /* Position of first and last changes. */ |
78fbdbd37286
(casify_region): Only call after-change and composition
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91327
diff
changeset
|
213 EMACS_INT opoint = PT; |
78fbdbd37286
(casify_region): Only call after-change and composition
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91327
diff
changeset
|
214 EMACS_INT opoint_byte = PT_BYTE; |
118 | 215 |
216 if (EQ (b, e)) | |
217 /* Not modifying because nothing marked */ | |
218 return; | |
219 | |
15170
0d698228e98c
(casify_region, casify_object):
Richard M. Stallman <rms@gnu.org>
parents:
14186
diff
changeset
|
220 /* 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
|
221 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
|
222 Fset_case_table (current_buffer->downcase_table); |
0d698228e98c
(casify_region, casify_object):
Richard M. Stallman <rms@gnu.org>
parents:
14186
diff
changeset
|
223 |
118 | 224 validate_region (&b, &e); |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
225 start = XFASTINT (b); |
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
226 end = XFASTINT (e); |
72592
f6de516bbb4b
* buffer.h (struct buffer_text): New field chars_modiff.
Chong Yidong <cyd@stupidchicken.com>
parents:
71970
diff
changeset
|
227 modify_region (current_buffer, start, end, 0); |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
228 record_change (start, end - start); |
20543
4dbda4b7c66f
(casify_region): Scan in bytes and chars.
Richard M. Stallman <rms@gnu.org>
parents:
18613
diff
changeset
|
229 start_byte = CHAR_TO_BYTE (start); |
4dbda4b7c66f
(casify_region): Scan in bytes and chars.
Richard M. Stallman <rms@gnu.org>
parents:
18613
diff
changeset
|
230 end_byte = CHAR_TO_BYTE (end); |
118 | 231 |
89017
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
232 while (start < end) |
17816 | 233 { |
89017
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
234 int c2, len; |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
235 |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
236 if (multibyte) |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
237 { |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
238 c = FETCH_MULTIBYTE_CHAR (start_byte); |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
239 len = CHAR_BYTES (c); |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
240 } |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
241 else |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
242 { |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
243 c = FETCH_BYTE (start_byte); |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
244 MAKE_CHAR_MULTIBYTE (c); |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
245 len = 1; |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
246 } |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
247 c2 = c; |
18005
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
248 if (inword && flag != CASE_CAPITALIZE_UP) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
249 c = DOWNCASE (c); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
250 else if (!UPPERCASEP (c) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
251 && (!inword || flag != CASE_CAPITALIZE_UP)) |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
252 c = UPCASE1 (c); |
ad95aa134d60
(casify_object): Handle multibyte characters.
Kenichi Handa <handa@m17n.org>
parents:
17816
diff
changeset
|
253 if ((int) flag >= (int) CASE_CAPITALIZE) |
89483 | 254 inword = ((SYNTAX (c) == Sword) && (inword || !SYNTAX_PREFIX (c))); |
26839 | 255 if (c != c2) |
17816 | 256 { |
91803
78fbdbd37286
(casify_region): Only call after-change and composition
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91327
diff
changeset
|
257 last = start; |
78fbdbd37286
(casify_region): Only call after-change and composition
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91327
diff
changeset
|
258 if (first < 0) |
78fbdbd37286
(casify_region): Only call after-change and composition
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91327
diff
changeset
|
259 first = start; |
78fbdbd37286
(casify_region): Only call after-change and composition
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91327
diff
changeset
|
260 |
89017
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
261 if (! multibyte) |
17816 | 262 { |
89017
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
263 MAKE_CHAR_UNIBYTE (c); |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
264 FETCH_BYTE (start_byte) = c; |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
265 } |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
266 else if (ASCII_CHAR_P (c2) && ASCII_CHAR_P (c)) |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
267 FETCH_BYTE (start_byte) = c; |
90049
73c7169fe4ff
(casify_region): Handle changes in byte-length
Kenichi Handa <handa@m17n.org>
parents:
89943
diff
changeset
|
268 else |
89017
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
269 { |
90049
73c7169fe4ff
(casify_region): Handle changes in byte-length
Kenichi Handa <handa@m17n.org>
parents:
89943
diff
changeset
|
270 int tolen = CHAR_BYTES (c); |
89017
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
271 int j; |
26839 | 272 unsigned char str[MAX_MULTIBYTE_LENGTH]; |
17816 | 273 |
89017
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
274 CHAR_STRING (c, str); |
90049
73c7169fe4ff
(casify_region): Handle changes in byte-length
Kenichi Handa <handa@m17n.org>
parents:
89943
diff
changeset
|
275 if (len == tolen) |
17816 | 276 { |
57877
194fa92926e4
(casify_region): Handle changes in byte-length using replace_range_2.
Richard M. Stallman <rms@gnu.org>
parents:
57726
diff
changeset
|
277 /* Length is unchanged. */ |
90049
73c7169fe4ff
(casify_region): Handle changes in byte-length
Kenichi Handa <handa@m17n.org>
parents:
89943
diff
changeset
|
278 for (j = 0; j < len; ++j) |
73c7169fe4ff
(casify_region): Handle changes in byte-length
Kenichi Handa <handa@m17n.org>
parents:
89943
diff
changeset
|
279 FETCH_BYTE (start_byte + j) = str[j]; |
17816 | 280 } |
281 else | |
59854
75a481e7d8f1
(casify_object): Enable changing characters of
Kenichi Handa <handa@m17n.org>
parents:
57877
diff
changeset
|
282 { |
75a481e7d8f1
(casify_object): Enable changing characters of
Kenichi Handa <handa@m17n.org>
parents:
57877
diff
changeset
|
283 /* Replace one character with the other, |
75a481e7d8f1
(casify_object): Enable changing characters of
Kenichi Handa <handa@m17n.org>
parents:
57877
diff
changeset
|
284 keeping text properties the same. */ |
90049
73c7169fe4ff
(casify_region): Handle changes in byte-length
Kenichi Handa <handa@m17n.org>
parents:
89943
diff
changeset
|
285 replace_range_2 (start, start_byte, |
73c7169fe4ff
(casify_region): Handle changes in byte-length
Kenichi Handa <handa@m17n.org>
parents:
89943
diff
changeset
|
286 start + 1, start_byte + len, |
59854
75a481e7d8f1
(casify_object): Enable changing characters of
Kenichi Handa <handa@m17n.org>
parents:
57877
diff
changeset
|
287 str, 1, tolen, |
90049
73c7169fe4ff
(casify_region): Handle changes in byte-length
Kenichi Handa <handa@m17n.org>
parents:
89943
diff
changeset
|
288 0); |
73c7169fe4ff
(casify_region): Handle changes in byte-length
Kenichi Handa <handa@m17n.org>
parents:
89943
diff
changeset
|
289 len = tolen; |
59854
75a481e7d8f1
(casify_object): Enable changing characters of
Kenichi Handa <handa@m17n.org>
parents:
57877
diff
changeset
|
290 } |
17816 | 291 } |
292 } | |
89017
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
293 start++; |
6a9e0cb7368b
(casify_object): Simplified. Handle the case that
Kenichi Handa <handa@m17n.org>
parents:
88426
diff
changeset
|
294 start_byte += len; |
118 | 295 } |
296 | |
89483 | 297 if (PT != opoint) |
298 TEMP_SET_PT_BOTH (opoint, opoint_byte); | |
299 | |
91803
78fbdbd37286
(casify_region): Only call after-change and composition
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91327
diff
changeset
|
300 if (first >= 0) |
26839 | 301 { |
91803
78fbdbd37286
(casify_region): Only call after-change and composition
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91327
diff
changeset
|
302 signal_after_change (first, last + 1 - first, last + 1 - first); |
78fbdbd37286
(casify_region): Only call after-change and composition
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91327
diff
changeset
|
303 update_compositions (first, last + 1, CHECK_ALL); |
26839 | 304 } |
118 | 305 } |
306 | |
307 DEFUN ("upcase-region", Fupcase_region, Supcase_region, 2, 2, "r", | |
40103
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
308 doc: /* Convert the region to upper case. In programs, wants two arguments. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
309 These arguments specify the starting and ending character numbers of |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
310 the region to operate on. When used as a command, the text between |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
311 point and the mark is operated on. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
312 See also `capitalize-region'. */) |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
313 (beg, end) |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
314 Lisp_Object beg, end; |
118 | 315 { |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
316 casify_region (CASE_UP, beg, end); |
118 | 317 return Qnil; |
318 } | |
319 | |
320 DEFUN ("downcase-region", Fdowncase_region, Sdowncase_region, 2, 2, "r", | |
40103
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
321 doc: /* Convert the region to lower case. In programs, wants two arguments. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
322 These arguments specify the starting and ending character numbers of |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
323 the region to operate on. When used as a command, the text between |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
324 point and the mark is operated on. */) |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
325 (beg, end) |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
326 Lisp_Object beg, end; |
118 | 327 { |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
328 casify_region (CASE_DOWN, beg, end); |
118 | 329 return Qnil; |
330 } | |
331 | |
332 DEFUN ("capitalize-region", Fcapitalize_region, Scapitalize_region, 2, 2, "r", | |
40103
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
333 doc: /* Convert the region to capitalized form. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
334 Capitalized form means each word's first character is upper case |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
335 and the rest of it is lower case. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
336 In programs, give two arguments, the starting and ending |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
337 character positions to operate on. */) |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
338 (beg, end) |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
339 Lisp_Object beg, end; |
118 | 340 { |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
341 casify_region (CASE_CAPITALIZE, beg, end); |
118 | 342 return Qnil; |
343 } | |
344 | |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
345 /* 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
|
346 |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
347 DEFUN ("upcase-initials-region", Fupcase_initials_region, |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
348 Supcase_initials_region, 2, 2, "r", |
40103
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
349 doc: /* Upcase the initial of each word in the region. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
350 Subsequent letters of each word are not changed. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
351 In programs, give two arguments, the starting and ending |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
352 character positions to operate on. */) |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
353 (beg, end) |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
354 Lisp_Object beg, end; |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
355 { |
14063
ef7d4117c601
(Fupcase_region, Fdowncase_region, Fcapitalize_region,
Erik Naggum <erik@naggum.no>
parents:
12244
diff
changeset
|
356 casify_region (CASE_CAPITALIZE_UP, beg, end); |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
357 return Qnil; |
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
358 } |
118 | 359 |
93179
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
360 static Lisp_Object |
6221
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
361 operate_on_word (arg, newpoint) |
118 | 362 Lisp_Object arg; |
93179
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
363 EMACS_INT *newpoint; |
118 | 364 { |
1505
4f138b03e5ab
* casefiddle.c (operate_on_word): Declare end to be an int, not a
Jim Blandy <jimb@redhat.com>
parents:
484
diff
changeset
|
365 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
|
366 int farend; |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
367 int iarg; |
118 | 368 |
40656
cdfd4d09b79a
Update usage of CHECK_ macros (remove unused second argument).
Pavel Janík <Pavel@Janik.cz>
parents:
40103
diff
changeset
|
369 CHECK_NUMBER (arg); |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
370 iarg = XINT (arg); |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15170
diff
changeset
|
371 farend = scan_words (PT, iarg); |
118 | 372 if (!farend) |
12089
f7cb17ca1815
(casify_region): Use explicit local vars for start
Karl Heuer <kwzh@gnu.org>
parents:
9299
diff
changeset
|
373 farend = iarg > 0 ? ZV : BEGV; |
118 | 374 |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15170
diff
changeset
|
375 *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
|
376 XSETFASTINT (val, farend); |
118 | 377 |
378 return val; | |
379 } | |
380 | |
381 DEFUN ("upcase-word", Fupcase_word, Supcase_word, 1, 1, "p", | |
40103
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
382 doc: /* Convert following word (or ARG words) to upper case, moving over. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
383 With negative argument, convert previous words but do not move. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
384 See also `capitalize-word'. */) |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
385 (arg) |
118 | 386 Lisp_Object arg; |
387 { | |
6221
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
388 Lisp_Object beg, end; |
93179
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
389 EMACS_INT newpoint; |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15170
diff
changeset
|
390 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
|
391 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
|
392 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
|
393 SET_PT (newpoint); |
118 | 394 return Qnil; |
395 } | |
396 | |
397 DEFUN ("downcase-word", Fdowncase_word, Sdowncase_word, 1, 1, "p", | |
40103
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
398 doc: /* Convert following word (or ARG words) to lower case, moving over. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
399 With negative argument, convert previous words but do not move. */) |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
400 (arg) |
118 | 401 Lisp_Object arg; |
402 { | |
6221
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
403 Lisp_Object beg, end; |
93179
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
404 EMACS_INT newpoint; |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15170
diff
changeset
|
405 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
|
406 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
|
407 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
|
408 SET_PT (newpoint); |
118 | 409 return Qnil; |
410 } | |
411 | |
412 DEFUN ("capitalize-word", Fcapitalize_word, Scapitalize_word, 1, 1, "p", | |
40103
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
413 doc: /* Capitalize the following word (or ARG words), moving over. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
414 This gives the word(s) a first character in upper case |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
415 and the rest lower case. |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
416 With negative argument, capitalize previous words but do not move. */) |
6b389fb978bc
Change doc-string comments to `new style' [w/`doc:' keyword].
Pavel Janík <Pavel@Janik.cz>
parents:
39748
diff
changeset
|
417 (arg) |
118 | 418 Lisp_Object arg; |
419 { | |
6221
c2d29681d218
(operate_on_word): Don't move point; store in *NEWPOINT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
420 Lisp_Object beg, end; |
93179
139d0b227fdc
(casify_object): Avoid pathological N^2 worst case if
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
91803
diff
changeset
|
421 EMACS_INT newpoint; |
16039
855c8d8ba0f0
Change all references from point to PT.
Karl Heuer <kwzh@gnu.org>
parents:
15170
diff
changeset
|
422 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
|
423 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
|
424 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
|
425 SET_PT (newpoint); |
118 | 426 return Qnil; |
427 } | |
428 | |
21514 | 429 void |
118 | 430 syms_of_casefiddle () |
431 { | |
105877
21bdda3ded62
* xterm.c (syms_of_xterm):
Dan Nicolaescu <dann@ics.uci.edu>
parents:
105669
diff
changeset
|
432 Qidentity = intern_c_string ("identity"); |
17816 | 433 staticpro (&Qidentity); |
118 | 434 defsubr (&Supcase); |
435 defsubr (&Sdowncase); | |
436 defsubr (&Scapitalize); | |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
437 defsubr (&Supcase_initials); |
118 | 438 defsubr (&Supcase_region); |
439 defsubr (&Sdowncase_region); | |
440 defsubr (&Scapitalize_region); | |
9053
4887fc1a2dda
(Fupcase_initials_region): New function.
Richard M. Stallman <rms@gnu.org>
parents:
9052
diff
changeset
|
441 defsubr (&Supcase_initials_region); |
118 | 442 defsubr (&Supcase_word); |
443 defsubr (&Sdowncase_word); | |
444 defsubr (&Scapitalize_word); | |
445 } | |
446 | |
21514 | 447 void |
118 | 448 keys_of_casefiddle () |
449 { | |
450 initial_define_key (control_x_map, Ctl('U'), "upcase-region"); | |
484 | 451 Fput (intern ("upcase-region"), Qdisabled, Qt); |
118 | 452 initial_define_key (control_x_map, Ctl('L'), "downcase-region"); |
484 | 453 Fput (intern ("downcase-region"), Qdisabled, Qt); |
454 | |
118 | 455 initial_define_key (meta_map, 'u', "upcase-word"); |
456 initial_define_key (meta_map, 'l', "downcase-word"); | |
457 initial_define_key (meta_map, 'c', "capitalize-word"); | |
458 } | |
52401 | 459 |
460 /* arch-tag: 60a73c66-5489-47e7-a81f-cead4057c526 | |
461 (do not change this comment) */ |