Mercurial > hg > xemacs-beta
annotate src/casefiddle.c @ 5750:66d2f63df75f
Correct some spelling and formatting in behavior.el.
Mentioned in tracker issue 826, the third thing mentioned there (the file
name at the bottom of the file) had already been fixed.
lisp/ChangeLog addition:
2013-08-05 Aidan Kehoe <kehoea@parhasard.net>
* behavior.el:
(override-behavior):
Correct some spelling and formatting here, thank you Steven
Mitchell in tracker issue 826.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Mon, 05 Aug 2013 10:05:32 +0100 |
| parents | 56144c8593a8 |
| children |
| rev | line source |
|---|---|
| 428 | 1 /* XEmacs case conversion functions. |
| 2 Copyright (C) 1985, 1992, 1993, 1994, 1997, 1998 Free Software Foundation, Inc. | |
| 826 | 3 Copyright (C) 2002 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
4910
diff
changeset
|
7 XEmacs is free software: you can redistribute it and/or modify it |
| 428 | 8 under the terms of the GNU General Public License as published by the |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
4910
diff
changeset
|
9 Free Software Foundation, either version 3 of the License, or (at your |
|
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
4910
diff
changeset
|
10 option) any later version. |
| 428 | 11 |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
4910
diff
changeset
|
18 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. */ |
| 428 | 19 |
| 20 /* Synched up with: FSF 19.34, but substantially rewritten by Martin. */ | |
| 21 | |
| 22 #include <config.h> | |
| 23 #include "lisp.h" | |
| 24 | |
| 25 #include "buffer.h" | |
| 26 #include "insdel.h" | |
| 27 #include "syntax.h" | |
| 28 | |
|
4910
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
29 enum case_action {CASE_UP, CASE_DOWN, CASE_CAPITALIZE, CASE_CAPITALIZE_UP, |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
30 CASE_CANONICALIZE}; |
| 428 | 31 |
| 32 static Lisp_Object | |
| 444 | 33 casify_object (enum case_action flag, Lisp_Object string_or_char, |
| 34 Lisp_Object buffer) | |
| 428 | 35 { |
| 36 struct buffer *buf = decode_buffer (buffer, 0); | |
| 37 | |
| 38 retry: | |
| 39 | |
| 444 | 40 if (CHAR_OR_CHAR_INTP (string_or_char)) |
| 428 | 41 { |
| 867 | 42 Ichar c; |
| 444 | 43 CHECK_CHAR_COERCE_INT (string_or_char); |
| 44 c = XCHAR (string_or_char); | |
|
4910
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
45 if (flag == CASE_DOWN) |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
46 { |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
47 c = DOWNCASE (buf, c); |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
48 } |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
49 else if (flag == CASE_UP) |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
50 { |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
51 c = UPCASE (buf, c); |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
52 } |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
53 else |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
54 { |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
55 c = CANONCASE (buf, c); |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
56 } |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
57 |
| 428 | 58 return make_char (c); |
| 59 } | |
| 60 | |
| 444 | 61 if (STRINGP (string_or_char)) |
| 428 | 62 { |
| 826 | 63 Lisp_Object syntax_table = buf->mirror_syntax_table; |
| 867 | 64 Ibyte *storage = |
| 2367 | 65 alloca_ibytes (XSTRING_LENGTH (string_or_char) * MAX_ICHAR_LEN); |
| 867 | 66 Ibyte *newp = storage; |
| 67 Ibyte *oldp = XSTRING_DATA (string_or_char); | |
| 68 Ibyte *endp = oldp + XSTRING_LENGTH (string_or_char); | |
| 428 | 69 int wordp = 0, wordp_prev; |
| 70 | |
| 771 | 71 while (oldp < endp) |
| 428 | 72 { |
| 867 | 73 Ichar c = itext_ichar (oldp); |
| 428 | 74 switch (flag) |
| 75 { | |
| 76 case CASE_UP: | |
| 77 c = UPCASE (buf, c); | |
| 78 break; | |
| 79 case CASE_DOWN: | |
| 80 c = DOWNCASE (buf, c); | |
| 81 break; | |
|
4910
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
82 case CASE_CANONICALIZE: |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
83 c = CANONCASE (buf, c); |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
84 break; |
| 428 | 85 case CASE_CAPITALIZE: |
| 86 case CASE_CAPITALIZE_UP: | |
| 87 wordp_prev = wordp; | |
| 88 wordp = WORD_SYNTAX_P (syntax_table, c); | |
| 89 if (!wordp) break; | |
| 90 if (wordp_prev) | |
| 91 { | |
| 92 if (flag == CASE_CAPITALIZE) | |
| 93 c = DOWNCASE (buf, c); | |
| 94 } | |
| 95 else | |
| 96 c = UPCASE (buf, c); | |
| 97 break; | |
| 98 } | |
| 99 | |
| 867 | 100 newp += set_itext_ichar (newp, c); |
| 101 INC_IBYTEPTR (oldp); | |
| 428 | 102 } |
| 103 | |
| 104 return make_string (storage, newp - storage); | |
| 105 } | |
| 106 | |
| 444 | 107 string_or_char = wrong_type_argument (Qchar_or_string_p, string_or_char); |
| 428 | 108 goto retry; |
| 109 } | |
| 110 | |
| 111 DEFUN ("upcase", Fupcase, 1, 2, 0, /* | |
| 444 | 112 Convert STRING-OR-CHAR to upper case and return that. |
| 113 STRING-OR-CHAR may be a character or string. The result has the same type. | |
| 114 STRING-OR-CHAR is not altered--the value is a copy. | |
| 428 | 115 See also `capitalize', `downcase' and `upcase-initials'. |
| 116 Optional second arg BUFFER specifies which buffer's case tables to use, | |
| 117 and defaults to the current buffer. | |
| 118 */ | |
| 444 | 119 (string_or_char, buffer)) |
| 428 | 120 { |
| 444 | 121 return casify_object (CASE_UP, string_or_char, buffer); |
| 428 | 122 } |
| 123 | |
| 124 DEFUN ("downcase", Fdowncase, 1, 2, 0, /* | |
| 444 | 125 Convert STRING-OR-CHAR to lower case and return that. |
| 126 STRING-OR-CHAR may be a character or string. The result has the same type. | |
| 127 STRING-OR-CHAR is not altered--the value is a copy. | |
| 428 | 128 Optional second arg BUFFER specifies which buffer's case tables to use, |
| 129 and defaults to the current buffer. | |
| 130 */ | |
| 444 | 131 (string_or_char, buffer)) |
| 428 | 132 { |
| 444 | 133 return casify_object (CASE_DOWN, string_or_char, buffer); |
| 428 | 134 } |
| 135 | |
|
4910
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
136 DEFUN ("canoncase", Fcanoncase, 1, 2, 0, /* |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
137 Convert STRING-OR-CHAR to its canonical lowercase form and return that. |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
138 |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
139 STRING-OR-CHAR may be a character or string. The result has the same type. |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
140 STRING-OR-CHAR is not altered--the value is a copy. |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
141 |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
142 Optional second arg BUFFER specifies which buffer's case tables to use, |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
143 and defaults to the current buffer. |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
144 |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
145 For any N characters that are equivalent in case-insensitive searching, |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
146 their canonical lowercase character will be the same. |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
147 */ |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
148 (string_or_char, buffer)) |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
149 { |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
150 return casify_object (CASE_CANONICALIZE, string_or_char, buffer); |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
151 } |
|
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
152 |
| 428 | 153 DEFUN ("capitalize", Fcapitalize, 1, 2, 0, /* |
| 444 | 154 Convert STRING-OR-CHAR to capitalized form and return that. |
| 428 | 155 This means that each word's first character is upper case |
| 156 and the rest is lower case. | |
| 444 | 157 STRING-OR-CHAR may be a character or string. The result has the same type. |
| 158 STRING-OR-CHAR is not altered--the value is a copy. | |
| 428 | 159 Optional second arg BUFFER specifies which buffer's case tables to use, |
| 160 and defaults to the current buffer. | |
| 161 */ | |
| 444 | 162 (string_or_char, buffer)) |
| 428 | 163 { |
| 444 | 164 return casify_object (CASE_CAPITALIZE, string_or_char, buffer); |
| 428 | 165 } |
| 166 | |
| 167 /* Like Fcapitalize but change only the initial characters. */ | |
| 168 | |
| 169 DEFUN ("upcase-initials", Fupcase_initials, 1, 2, 0, /* | |
| 444 | 170 Convert the initial of each word in STRING-OR-CHAR to upper case. |
| 428 | 171 Do not change the other letters of each word. |
| 444 | 172 STRING-OR-CHAR may be a character or string. The result has the same type. |
| 173 STRING-OR-CHAR is not altered--the value is a copy. | |
| 428 | 174 Optional second arg BUFFER specifies which buffer's case tables to use, |
| 175 and defaults to the current buffer. | |
| 176 */ | |
| 444 | 177 (string_or_char, buffer)) |
| 428 | 178 { |
| 444 | 179 return casify_object (CASE_CAPITALIZE_UP, string_or_char, buffer); |
| 428 | 180 } |
| 181 | |
| 182 /* flag is CASE_UP, CASE_DOWN or CASE_CAPITALIZE or CASE_CAPITALIZE_UP. | |
| 444 | 183 START and END specify range of buffer to operate on. */ |
| 428 | 184 |
| 185 static void | |
| 444 | 186 casify_region_internal (enum case_action flag, Lisp_Object start, |
| 187 Lisp_Object end, struct buffer *buf) | |
| 428 | 188 { |
| 189 /* This function can GC */ | |
| 665 | 190 Charbpos pos, s, e; |
| 826 | 191 Lisp_Object syntax_table = buf->mirror_syntax_table; |
| 428 | 192 int mccount; |
| 193 int wordp = 0, wordp_prev; | |
| 194 | |
| 444 | 195 if (EQ (start, end)) |
| 428 | 196 /* Not modifying because nothing marked */ |
| 197 return; | |
| 198 | |
| 444 | 199 get_buffer_range_char (buf, start, end, &s, &e, 0); |
| 200 | |
| 201 mccount = begin_multiple_change (buf, s, e); | |
| 202 record_change (buf, s, e - s); | |
| 428 | 203 |
| 444 | 204 for (pos = s; pos < e; pos++) |
| 428 | 205 { |
| 867 | 206 Ichar oldc = BUF_FETCH_CHAR (buf, pos); |
| 207 Ichar c = oldc; | |
| 428 | 208 |
| 209 switch (flag) | |
| 210 { | |
| 211 case CASE_UP: | |
| 212 c = UPCASE (buf, oldc); | |
| 213 break; | |
| 214 case CASE_DOWN: | |
| 215 c = DOWNCASE (buf, oldc); | |
| 216 break; | |
| 217 case CASE_CAPITALIZE: | |
| 218 case CASE_CAPITALIZE_UP: | |
| 219 /* !!#### need to revalidate the start and end pointers in case | |
| 220 the buffer was changed */ | |
| 221 wordp_prev = wordp; | |
| 222 wordp = WORD_SYNTAX_P (syntax_table, c); | |
| 223 if (!wordp) continue; | |
| 224 if (wordp_prev) | |
| 225 { | |
| 226 if (flag == CASE_CAPITALIZE) | |
| 227 c = DOWNCASE (buf, c); | |
| 228 } | |
| 229 else | |
| 230 c = UPCASE (buf, c); | |
| 231 break; | |
| 232 } | |
| 233 | |
| 234 if (oldc == c) continue; | |
| 444 | 235 buffer_replace_char (buf, pos, c, 1, (pos == s)); |
| 428 | 236 BUF_MODIFF (buf)++; |
| 237 } | |
| 238 | |
| 239 end_multiple_change (buf, mccount); | |
| 240 } | |
| 241 | |
| 242 static Lisp_Object | |
| 444 | 243 casify_region (enum case_action flag, Lisp_Object start, Lisp_Object end, |
| 428 | 244 Lisp_Object buffer) |
| 245 { | |
| 444 | 246 casify_region_internal (flag, start, end, decode_buffer (buffer, 1)); |
| 428 | 247 return Qnil; |
| 248 } | |
| 249 | |
| 250 DEFUN ("upcase-region", Fupcase_region, 2, 3, "r", /* | |
| 251 Convert the region to upper case. In programs, wants two arguments. | |
| 252 These arguments specify the starting and ending character numbers of | |
| 253 the region to operate on. When used as a command, the text between | |
| 254 point and the mark is operated on. | |
| 255 See also `capitalize-region'. | |
| 256 Optional third arg BUFFER defaults to the current buffer. | |
| 257 */ | |
| 444 | 258 (start, end, buffer)) |
| 428 | 259 { |
| 260 /* This function can GC */ | |
| 444 | 261 return casify_region (CASE_UP, start, end, buffer); |
| 428 | 262 } |
| 263 | |
| 264 DEFUN ("downcase-region", Fdowncase_region, 2, 3, "r", /* | |
| 265 Convert the region to lower case. In programs, wants two arguments. | |
| 266 These arguments specify the starting and ending character numbers of | |
| 267 the region to operate on. When used as a command, the text between | |
| 268 point and the mark is operated on. | |
| 269 Optional third arg BUFFER defaults to the current buffer. | |
| 270 */ | |
| 444 | 271 (start, end, buffer)) |
| 428 | 272 { |
| 273 /* This function can GC */ | |
| 444 | 274 return casify_region (CASE_DOWN, start, end, buffer); |
| 428 | 275 } |
| 276 | |
| 277 DEFUN ("capitalize-region", Fcapitalize_region, 2, 3, "r", /* | |
| 278 Convert the region to capitalized form. | |
| 279 Capitalized form means each word's first character is upper case | |
| 280 and the rest of it is lower case. | |
| 281 In programs, give two arguments, the starting and ending | |
| 282 character positions to operate on. | |
| 283 Optional third arg BUFFER defaults to the current buffer. | |
| 284 */ | |
| 444 | 285 (start, end, buffer)) |
| 428 | 286 { |
| 287 /* This function can GC */ | |
| 444 | 288 return casify_region (CASE_CAPITALIZE, start, end, buffer); |
| 428 | 289 } |
| 290 | |
| 291 /* Like Fcapitalize_region but change only the initials. */ | |
| 292 | |
| 293 DEFUN ("upcase-initials-region", Fupcase_initials_region, 2, 3, "r", /* | |
| 294 Upcase the initial of each word in the region. | |
| 295 Subsequent letters of each word are not changed. | |
| 296 In programs, give two arguments, the starting and ending | |
| 297 character positions to operate on. | |
| 298 Optional third arg BUFFER defaults to the current buffer. | |
| 299 */ | |
| 444 | 300 (start, end, buffer)) |
| 428 | 301 { |
| 444 | 302 return casify_region (CASE_CAPITALIZE_UP, start, end, buffer); |
| 428 | 303 } |
| 304 | |
| 305 | |
| 306 static Lisp_Object | |
| 307 casify_word (enum case_action flag, Lisp_Object arg, Lisp_Object buffer) | |
| 308 { | |
| 665 | 309 Charbpos farend; |
| 428 | 310 struct buffer *buf = decode_buffer (buffer, 1); |
| 311 | |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
312 CHECK_FIXNUM (arg); |
| 428 | 313 |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
314 farend = scan_words (buf, BUF_PT (buf), XFIXNUM (arg)); |
| 428 | 315 if (!farend) |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
316 farend = XFIXNUM (arg) > 0 ? BUF_ZV (buf) : BUF_BEGV (buf); |
| 428 | 317 |
|
5581
56144c8593a8
Mechanically change INT to FIXNUM in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
318 casify_region_internal (flag, make_fixnum (BUF_PT (buf)), make_fixnum (farend), buf); |
| 428 | 319 BUF_SET_PT (buf, max (BUF_PT (buf), farend)); |
| 320 return Qnil; | |
| 321 } | |
| 322 | |
| 323 DEFUN ("upcase-word", Fupcase_word, 1, 2, "p", /* | |
| 444 | 324 Convert following word (or COUNT words) to upper case, moving over. |
| 428 | 325 With negative argument, convert previous words but do not move. |
| 326 See also `capitalize-word'. | |
| 327 Optional second arg BUFFER defaults to the current buffer. | |
| 328 */ | |
| 444 | 329 (count, buffer)) |
| 428 | 330 { |
| 331 /* This function can GC */ | |
| 444 | 332 return casify_word (CASE_UP, count, buffer); |
| 428 | 333 } |
| 334 | |
| 335 DEFUN ("downcase-word", Fdowncase_word, 1, 2, "p", /* | |
| 444 | 336 Convert following word (or COUNT words) to lower case, moving over. |
| 428 | 337 With negative argument, convert previous words but do not move. |
| 338 Optional second arg BUFFER defaults to the current buffer. | |
| 339 */ | |
| 444 | 340 (count, buffer)) |
| 428 | 341 { |
| 342 /* This function can GC */ | |
| 444 | 343 return casify_word (CASE_DOWN, count, buffer); |
| 428 | 344 } |
| 345 | |
| 346 DEFUN ("capitalize-word", Fcapitalize_word, 1, 2, "p", /* | |
| 444 | 347 Capitalize the following word (or COUNT words), moving over. |
| 428 | 348 This gives the word(s) a first character in upper case |
| 349 and the rest lower case. | |
| 350 With negative argument, capitalize previous words but do not move. | |
| 351 Optional second arg BUFFER defaults to the current buffer. | |
| 352 */ | |
| 444 | 353 (count, buffer)) |
| 428 | 354 { |
| 355 /* This function can GC */ | |
| 444 | 356 return casify_word (CASE_CAPITALIZE, count, buffer); |
| 428 | 357 } |
| 358 | |
| 359 | |
| 360 void | |
| 361 syms_of_casefiddle (void) | |
| 362 { | |
| 363 DEFSUBR (Fupcase); | |
| 364 DEFSUBR (Fdowncase); | |
|
4910
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2367
diff
changeset
|
365 DEFSUBR (Fcanoncase); |
| 428 | 366 DEFSUBR (Fcapitalize); |
| 367 DEFSUBR (Fupcase_initials); | |
| 368 DEFSUBR (Fupcase_region); | |
| 369 DEFSUBR (Fdowncase_region); | |
| 370 DEFSUBR (Fcapitalize_region); | |
| 371 DEFSUBR (Fupcase_initials_region); | |
| 372 DEFSUBR (Fupcase_word); | |
| 373 DEFSUBR (Fdowncase_word); | |
| 374 DEFSUBR (Fcapitalize_word); | |
| 375 } |