casefiddle.c 20.8 KB
Newer Older
1
/* -*- coding: utf-8 -*- */
Jim Blandy's avatar
Jim Blandy committed
2
/* GNU Emacs case conversion functions.
3

Paul Eggert's avatar
Paul Eggert committed
4
Copyright (C) 1985, 1994, 1997-1999, 2001-2017 Free Software Foundation,
5
Inc.
Jim Blandy's avatar
Jim Blandy committed
6 7 8

This file is part of GNU Emacs.

9
GNU Emacs is free software: you can redistribute it and/or modify
Jim Blandy's avatar
Jim Blandy committed
10
it under the terms of the GNU General Public License as published by
11 12
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
Jim Blandy's avatar
Jim Blandy committed
13 14 15 16 17 18 19

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
20
along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
Jim Blandy's avatar
Jim Blandy committed
21 22


23
#include <config.h>
24

Jim Blandy's avatar
Jim Blandy committed
25
#include "lisp.h"
26
#include "character.h"
27
#include "buffer.h"
Jim Blandy's avatar
Jim Blandy committed
28 29
#include "commands.h"
#include "syntax.h"
Kenichi Handa's avatar
Kenichi Handa committed
30
#include "composite.h"
Stefan Monnier's avatar
Stefan Monnier committed
31
#include "keymap.h"
Jim Blandy's avatar
Jim Blandy committed
32 33

enum case_action {CASE_UP, CASE_DOWN, CASE_CAPITALIZE, CASE_CAPITALIZE_UP};
34 35 36

/* State for casing individual characters.  */
struct casing_context {
37 38 39
  /* A char-table with title-case character mappings or nil.  Non-nil implies
     flag is CASE_CAPITALIZE or CASE_CAPITALIZE_UP.  */
  Lisp_Object titlecase_char_table;
40 41 42
  /* The unconditional special-casing Unicode property char tables for upper
     casing, lower casing and title casing respectively. */
  Lisp_Object specialcase_char_tables[3];
43 44 45 46 47 48
  /* User-requested action. */
  enum case_action flag;
  /* If true, function operates on a buffer as opposed to a string or character.
     When run on a buffer, syntax_prefix_flag_p is taken into account when
     determined inword flag. */
  bool inbuffer;
49
  /* Whether we are inside of a word. */
50 51 52 53 54 55 56 57 58 59
  bool inword;
};

/* Initialise CTX structure for casing characters. */
static void
prepare_casing_context (struct casing_context *ctx,
			enum case_action flag, bool inbuffer)
{
  ctx->flag = flag;
  ctx->inbuffer = inbuffer;
60
  ctx->inword = false;
61 62
  ctx->titlecase_char_table = (int)flag < (int)CASE_CAPITALIZE ? Qnil :
    uniprop_table (intern_c_string ("titlecase"));
63 64 65 66 67 68 69
  ctx->specialcase_char_tables[CASE_UP] = flag == CASE_DOWN ? Qnil :
    uniprop_table (intern_c_string ("special-uppercase"));
  ctx->specialcase_char_tables[CASE_DOWN] = flag == CASE_UP ? Qnil :
    uniprop_table (intern_c_string ("special-lowercase"));
  ctx->specialcase_char_tables[CASE_CAPITALIZE] =
    (int)flag < (int)CASE_CAPITALIZE ? Qnil :
    uniprop_table (intern_c_string ("special-titlecase"));
70 71 72 73 74 75 76 77 78

  /* If the case table is flagged as modified, rescan it.  */
  if (NILP (XCHAR_TABLE (BVAR (current_buffer, downcase_table))->extras[1]))
    Fset_case_table (BVAR (current_buffer, downcase_table));

  if (inbuffer && (int) flag >= (int) CASE_CAPITALIZE)
    SETUP_BUFFER_SYNTAX_TABLE ();	/* For syntax_prefix_flag_p.  */
}

79 80 81 82 83 84 85 86 87 88 89 90
struct casing_str_buf {
  unsigned char data[MAX_MULTIBYTE_LENGTH > 6 ? MAX_MULTIBYTE_LENGTH : 6];
  unsigned char len_chars;
  unsigned char len_bytes;
};

/* Based on CTX, case character CH.  If BUF is NULL, return cased character.
   Otherwise, if BUF is non-NULL, save result in it and return whether the
   character has been changed.

   Since meaning of return value depends on arguments, it’s more convenient to
   use case_single_character or case_character instead. */
91
static int
92 93
case_character_impl (struct casing_str_buf *buf,
		     struct casing_context *ctx, int ch)
94
{
95
  enum case_action flag;
96
  Lisp_Object prop;
97 98 99 100 101
  bool was_inword;
  int cased;

  /* Update inword state */
  was_inword = ctx->inword;
102 103
  ctx->inword = SYNTAX (ch) == Sword &&
    (!ctx->inbuffer || was_inword || !syntax_prefix_flag_p (ch));
104 105

  /* Normalise flag so its one of CASE_UP, CASE_DOWN or CASE_CAPITALIZE. */
106 107
  if (ctx->flag == CASE_CAPITALIZE)
    flag = (enum case_action)((int)ctx->flag - was_inword);
108
  else if (ctx->flag != CASE_CAPITALIZE_UP)
109 110 111
    flag = ctx->flag;
  else if (!was_inword)
    flag = CASE_CAPITALIZE;
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
  else
    {
      cased = ch;
      goto done;
    }

  /* Look through the special casing entries. */
  if (buf && !NILP(ctx->specialcase_char_tables[(int)flag]))
    {
      prop = CHAR_TABLE_REF(ctx->specialcase_char_tables[(int)flag], ch);
      if (STRINGP(prop))
        {
          struct Lisp_String *str = XSTRING(prop);
          if (STRING_BYTES(str) <= sizeof buf->data)
	    {
	      buf->len_chars = str->size;
	      buf->len_bytes = STRING_BYTES(str);
	      memcpy(buf->data, str->data, buf->len_bytes);
	      return 1;
	    }
        }
    }
134

135 136 137
  /* Handle simple, one-to-one case. */
  if (flag == CASE_DOWN)
    cased = downcase (ch);
138 139
  else if (!NILP (ctx->titlecase_char_table) &&
	   CHARACTERP (prop = CHAR_TABLE_REF (ctx->titlecase_char_table, ch)))
140
    cased = XFASTINT (prop);
141
  else
142 143 144 145 146 147 148 149 150 151
    cased = upcase(ch);

  /* And we’re done. */
 done:
  if (!buf)
    return cased;
  buf->len_chars = 1;
  buf->len_bytes = CHAR_STRING (cased, buf->data);
  return cased != ch;
}
152 153 154 155 156 157 158

/* In Greek, lower case sigma has two forms: one when used in the middle and one
   when used at the end of a word.  Below is to help handle those cases when
   casing.

   The rule does not conflict with any other casing rules so while it is
   a conditional one, it is independent on language. */
159

160 161 162 163
#define CAPITAL_SIGMA     0x03A3
#define SMALL_SIGMA       0x03C3
#define SMALL_FINAL_SIGMA 0x03C2

164 165 166 167 168 169 170 171 172 173 174 175 176
/* Based on CTX, case character CH accordingly.  Update CTX as necessary.
   Return cased character.

   Special casing rules (such as upcase(fi) = FI) are not handled.  For
   characters whose casing results in multiple code points, the character is
   returned unchanged. */
static inline int
case_single_character (struct casing_context *ctx, int ch)
{
  return case_character_impl (NULL, ctx, ch);
}

/* Save in BUF result of casing character CH.  Return whether casing changed the
177 178 179 180 181 182 183 184 185 186 187
   character.

   If not-NULL, NEXT points to the next character in the cased string.  If NULL,
   it is assumed current character is the last one being cased.  This is used to
   apply some rules which depend on proceeding state.

   This is like case_single_character but also handles one-to-many casing
   rules. */
static bool
case_character (struct casing_str_buf *buf, struct casing_context *ctx,
		int ch, const unsigned char *next)
188
{
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
  bool changed, was_inword;

  was_inword = ctx->inword;
  changed = case_character_impl (buf, ctx, ch);

  /* If we have just down-cased a capital sigma and the next character no longer
     has a word syntax (i.e. current character is end of word), use final
     sigma. */
  if (was_inword && ch == CAPITAL_SIGMA && changed &&
      (!next || SYNTAX (STRING_CHAR (next)) != Sword))
    {
      buf->len_bytes = CHAR_STRING (SMALL_FINAL_SIGMA, buf->data);
      buf->len_chars = 1;
    }

  return changed;
205
}
Jim Blandy's avatar
Jim Blandy committed
206

207
static Lisp_Object
208
do_casify_natnum (struct casing_context *ctx, Lisp_Object obj)
Jim Blandy's avatar
Jim Blandy committed
209
{
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
  int flagbits = (CHAR_ALT | CHAR_SUPER | CHAR_HYPER
		  | CHAR_SHIFT | CHAR_CTL | CHAR_META);
  int flags, ch = XFASTINT (obj), cased;
  bool multibyte;

  /* If the character has higher bits set above the flags, return it unchanged.
     It is not a real character.  */
  if (UNSIGNED_CMP (ch, >, flagbits))
    return obj;

  flags = ch & flagbits;
  ch = ch & ~flagbits;

  /* FIXME: Even if enable-multibyte-characters is nil, we may manipulate
     multibyte chars.  This means we have a bug for latin-1 chars since when we
     receive an int 128-255 we can't tell whether it's an eight-bit byte or
     a latin-1 char.  */
  multibyte = ch >= 256
    || !NILP (BVAR (current_buffer, enable_multibyte_characters));
  if (! multibyte)
    MAKE_CHAR_MULTIBYTE (ch);
231
  cased = case_single_character (ctx, ch);
232 233 234 235 236 237 238 239 240 241
  if (cased == ch)
    return obj;

  if (! multibyte)
    MAKE_CHAR_UNIBYTE (cased);
  XSETFASTINT (obj, cased | flags);
  return obj;
}

static Lisp_Object
242
do_casify_multibyte_string (struct casing_context *ctx, Lisp_Object obj)
243
{
244 245 246 247 248 249 250 251
  /* We assume data is the first member of casing_str_buf structure so that if
     we cast a (char *) into (struct casing_str_buf *) the representation of the
     character is at the beginning of the buffer.  This is why we don’t need
     separate struct casing_str_buf object but rather write directly to o. */
  typedef char static_assertion[offsetof(struct casing_str_buf, data) ? -1 : 1];

  ptrdiff_t size = SCHARS (obj), n;
  int ch;
252
  USE_SAFE_ALLOCA;
253 254 255 256
  if (INT_MULTIPLY_WRAPV (size, MAX_MULTIBYTE_LENGTH, &n) ||
      INT_ADD_WRAPV (n, sizeof(struct casing_str_buf), &n))
    n = PTRDIFF_MAX;
  unsigned char *const dst = SAFE_ALLOCA (n), *const dst_end = dst + n;
257 258
  unsigned char *o = dst;

259 260 261
  const unsigned char *src = SDATA (obj);

  for (n = 0; size; --size)
262
    {
263
      if (dst_end - o < sizeof(struct casing_str_buf))
264
	string_overflow ();
265
      ch = STRING_CHAR_ADVANCE (src);
266
      case_character ((void *)o, ctx, ch, size > 1 ? src : NULL);
267 268
      n += ((struct casing_str_buf *)o)->len_chars;
      o += ((struct casing_str_buf *)o)->len_bytes;
269
    }
270 271
  eassert (o <= dst_end);
  obj = make_multibyte_string ((char *) dst, n, o - dst);
272 273 274 275 276
  SAFE_FREE ();
  return obj;
}

static Lisp_Object
277
do_casify_unibyte_string (struct casing_context *ctx, Lisp_Object obj)
278 279 280 281 282 283 284 285 286
{
  ptrdiff_t i, size = SCHARS (obj);
  int ch, cased;

  obj = Fcopy_sequence (obj);
  for (i = 0; i < size; i++)
    {
      ch = SREF (obj, i);
      MAKE_CHAR_MULTIBYTE (ch);
287
      cased = case_single_character (ctx, ch);
288 289
      if (ch == cased)
	continue;
290
      MAKE_CHAR_UNIBYTE (cased);
291
      /* If the char can't be converted to a valid byte, just don't change it */
292 293
      if (cased >= 0 && cased < 256)
	SSET (obj, i, cased);
294 295 296
    }
  return obj;
}
Jim Blandy's avatar
Jim Blandy committed
297

298 299 300
static Lisp_Object
casify_object (enum case_action flag, Lisp_Object obj)
{
301 302
  struct casing_context ctx;
  prepare_casing_context (&ctx, flag, false);
303

304
  if (NATNUMP (obj))
305
    return do_casify_natnum (&ctx, obj);
306
  else if (!STRINGP (obj))
307
    wrong_type_argument (Qchar_or_string_p, obj);
308 309 310
  else if (!SCHARS (obj))
    return obj;
  else if (STRING_MULTIBYTE (obj))
311
    return do_casify_multibyte_string (&ctx, obj);
312
  else
313
    return do_casify_unibyte_string (&ctx, obj);
Jim Blandy's avatar
Jim Blandy committed
314 315
}

Paul Eggert's avatar
Paul Eggert committed
316
DEFUN ("upcase", Fupcase, Supcase, 1, 1, 0,
317 318
       doc: /* Convert argument to upper case and return that.
The argument may be a character or string.  The result has the same type.
319 320 321
The argument object is not altered--the value is a copy.  If argument
is a character, characters which map to multiple code points when
cased, e.g. fi, are returned unchanged.
322
See also `capitalize', `downcase' and `upcase-initials'.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
323
  (Lisp_Object obj)
Jim Blandy's avatar
Jim Blandy committed
324 325 326 327
{
  return casify_object (CASE_UP, obj);
}

Paul Eggert's avatar
Paul Eggert committed
328
DEFUN ("downcase", Fdowncase, Sdowncase, 1, 1, 0,
329 330 331
       doc: /* Convert argument to lower case and return that.
The argument may be a character or string.  The result has the same type.
The argument object is not altered--the value is a copy.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
332
  (Lisp_Object obj)
Jim Blandy's avatar
Jim Blandy committed
333 334 335 336 337
{
  return casify_object (CASE_DOWN, obj);
}

DEFUN ("capitalize", Fcapitalize, Scapitalize, 1, 1, 0,
338
       doc: /* Convert argument to capitalized form and return that.
339 340
This means that each word's first character is converted to either
title case or upper case, and the rest to lower case.
341
The argument may be a character or string.  The result has the same type.
342 343 344
The argument object is not altered--the value is a copy.  If argument
is a character, characters which map to multiple code points when
cased, e.g. fi, are returned unchanged.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
345
  (Lisp_Object obj)
Jim Blandy's avatar
Jim Blandy committed
346 347 348
{
  return casify_object (CASE_CAPITALIZE, obj);
}
349

350 351
/* Like Fcapitalize but change only the initials.  */

Paul Eggert's avatar
Paul Eggert committed
352
DEFUN ("upcase-initials", Fupcase_initials, Supcase_initials, 1, 1, 0,
353
       doc: /* Convert the initial of each word in the argument to upper case.
354 355
This means that each word's first character is converted to either
title case or upper case, and the rest are left unchanged.
356
The argument may be a character or string.  The result has the same type.
357 358 359
The argument object is not altered--the value is a copy.  If argument
is a character, characters which map to multiple code points when
cased, e.g. fi, are returned unchanged.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
360
  (Lisp_Object obj)
361 362 363
{
  return casify_object (CASE_CAPITALIZE_UP, obj);
}
Jim Blandy's avatar
Jim Blandy committed
364

365 366 367 368 369 370 371 372
/* Based on CTX, case region in a unibyte buffer from *STARTP to *ENDP.

   Save first and last positions that has changed in *STARTP and *ENDP
   respectively.  If no characters were changed, save -1 to *STARTP and leave
   *ENDP unspecified.

   Always return 0.  This is so that interface of this function is the same as
   do_casify_multibyte_region. */
373 374
static ptrdiff_t
do_casify_unibyte_region (struct casing_context *ctx,
375
			  ptrdiff_t *startp, ptrdiff_t *endp)
Jim Blandy's avatar
Jim Blandy committed
376
{
377
  ptrdiff_t first = -1, last = -1;  /* Position of first and last changes. */
378
  ptrdiff_t pos = *startp, end = *endp;
379
  int ch, cased;
380

381 382 383 384
  for (; pos < end; ++pos)
    {
      ch = FETCH_BYTE (pos);
      MAKE_CHAR_MULTIBYTE (ch);
385

386
      cased = case_single_character (ctx, ch);
387 388
      if (cased == ch)
	continue;
Jim Blandy's avatar
Jim Blandy committed
389

390
      last = pos + 1;
391 392
      if (first < 0)
	first = pos;
393

394 395 396
      MAKE_CHAR_UNIBYTE (cased);
      FETCH_BYTE (pos) = cased;
    }
Jim Blandy's avatar
Jim Blandy committed
397

398 399 400
  *startp = first;
  *endp = last;
  return 0;
401
}
Jim Blandy's avatar
Jim Blandy committed
402

403 404 405 406 407 408
/* Based on CTX, case region in a multibyte buffer from *STARTP to *ENDP.

   Return number of added characters (may be negative if more characters were
   deleted then inserted), save first and last positions that has changed in
   *STARTP and *ENDP respectively.  If no characters were changed, return 0,
   save -1 to *STARTP and leave *ENDP unspecified. */
409 410
static ptrdiff_t
do_casify_multibyte_region (struct casing_context *ctx,
411
			    ptrdiff_t *startp, ptrdiff_t *endp)
412 413
{
  ptrdiff_t first = -1, last = -1;  /* Position of first and last changes. */
414 415 416
  ptrdiff_t pos = *startp, pos_byte = CHAR_TO_BYTE (pos), size = *endp - pos;
  ptrdiff_t opoint = PT, added = 0;
  struct casing_str_buf buf;
417 418
  bool changed;
  int ch, len;
419

420
  for (; size; --size)
Karl Heuer's avatar
Karl Heuer committed
421
    {
422
      ch = STRING_CHAR_AND_LENGTH (BYTE_POS_ADDR (pos_byte), len);
423 424 425 426 427
      changed = case_character (
	  &buf, ctx, ch,
	  size > 1 ? BYTE_POS_ADDR (pos_byte + len) : NULL);

      if (!changed)
Karl Heuer's avatar
Karl Heuer committed
428
	{
429 430 431 432
	  pos_byte += len;
	  ++pos;
	  continue;
	}
433

434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
      last = pos + buf.len_chars;
      if (first < 0)
	first = pos;

      if (buf.len_chars == 1 && buf.len_bytes == len)
	memcpy (BYTE_POS_ADDR (pos_byte), buf.data, len);
      else
	{
	  /* Replace one character with the other(s), keeping text
	     properties the same.  */
	  replace_range_2 (pos, pos_byte, pos + 1, pos_byte + len,
			   (const char *) buf.data, buf.len_chars,
			   buf.len_bytes,
			   0);
	  added += (ptrdiff_t) buf.len_chars - 1;
	  if (opoint > pos)
	    opoint += (ptrdiff_t) buf.len_chars - 1;
Karl Heuer's avatar
Karl Heuer committed
451
	}
452 453 454

      pos_byte += buf.len_bytes;
      pos += buf.len_chars;
Jim Blandy's avatar
Jim Blandy committed
455 456
    }

Kenichi Handa's avatar
Kenichi Handa committed
457
  if (PT != opoint)
458 459
    TEMP_SET_PT_BOTH (opoint, CHAR_TO_BYTE (opoint));

460
  *startp = first;
461
  *endp = last;
462
  return added;
463 464
}

465 466 467 468
/* flag is CASE_UP, CASE_DOWN or CASE_CAPITALIZE or CASE_CAPITALIZE_UP.  b and
   e specify range of buffer to operate on.  Return character position of the
   end of the region after changes.  */
static ptrdiff_t
469 470
casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e)
{
471
  ptrdiff_t start, end, orig_end, added;
472 473 474 475 476
  struct casing_context ctx;

  validate_region (&b, &e);
  start = XFASTINT (b);
  end = XFASTINT (e);
477 478 479
  if (start == end)
    /* Not modifying because nothing marked */
    return end;
480 481 482
  modify_text (start, end);
  prepare_casing_context (&ctx, flag, true);

483 484
  orig_end = end;
  record_delete (start, make_buffer_string (start, end, true), false);
485
  if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
486 487 488 489
    {
      record_insert (start, end - start);
      added = do_casify_unibyte_region (&ctx, &start, &end);
    }
490
  else
491 492 493 494 495
    {
      ptrdiff_t len = end - start, ostart = start;
      added = do_casify_multibyte_region (&ctx, &start, &end);
      record_insert (ostart, len + added);
    }
Kenichi Handa's avatar
Kenichi Handa committed
496

497
  if (start >= 0)
Kenichi Handa's avatar
Kenichi Handa committed
498
    {
499 500
      signal_after_change (start, end - start - added, end - start);
      update_compositions (start, end, CHECK_ALL);
Kenichi Handa's avatar
Kenichi Handa committed
501
    }
502 503

  return orig_end + added;
Jim Blandy's avatar
Jim Blandy committed
504 505
}

506 507
DEFUN ("upcase-region", Fupcase_region, Supcase_region, 2, 3,
       "(list (region-beginning) (region-end) (region-noncontiguous-p))",
508 509 510 511 512
       doc: /* Convert the region to upper case.  In programs, wants two arguments.
These arguments specify the starting and ending character numbers of
the region to operate on.  When used as a command, the text between
point and the mark is operated on.
See also `capitalize-region'.  */)
513
  (Lisp_Object beg, Lisp_Object end, Lisp_Object region_noncontiguous_p)
Jim Blandy's avatar
Jim Blandy committed
514
{
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
  Lisp_Object bounds = Qnil;

  if (!NILP (region_noncontiguous_p))
    {
      bounds = call1 (Fsymbol_value (intern ("region-extract-function")),
		      intern ("bounds"));

      while (CONSP (bounds))
	{
	  casify_region (CASE_UP, XCAR (XCAR (bounds)), XCDR (XCAR (bounds)));
	  bounds = XCDR (bounds);
	}
    }
  else
    casify_region (CASE_UP, beg, end);

Jim Blandy's avatar
Jim Blandy committed
531 532 533
  return Qnil;
}

534 535
DEFUN ("downcase-region", Fdowncase_region, Sdowncase_region, 2, 3,
       "(list (region-beginning) (region-end) (region-noncontiguous-p))",
536 537 538 539
       doc: /* Convert the region to lower case.  In programs, wants two arguments.
These arguments specify the starting and ending character numbers of
the region to operate on.  When used as a command, the text between
point and the mark is operated on.  */)
540
  (Lisp_Object beg, Lisp_Object end, Lisp_Object region_noncontiguous_p)
Jim Blandy's avatar
Jim Blandy committed
541
{
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557
  Lisp_Object bounds = Qnil;

  if (!NILP (region_noncontiguous_p))
    {
      bounds = call1 (Fsymbol_value (intern ("region-extract-function")),
		      intern ("bounds"));

      while (CONSP (bounds))
	{
	  casify_region (CASE_DOWN, XCAR (XCAR (bounds)), XCDR (XCAR (bounds)));
	  bounds = XCDR (bounds);
	}
    }
  else
    casify_region (CASE_DOWN, beg, end);

Jim Blandy's avatar
Jim Blandy committed
558 559 560 561
  return Qnil;
}

DEFUN ("capitalize-region", Fcapitalize_region, Scapitalize_region, 2, 2, "r",
562
       doc: /* Convert the region to capitalized form.
563 564
This means that each word's first character is converted to either
title case or upper case, and the rest to lower case.
565 566
In programs, give two arguments, the starting and ending
character positions to operate on.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
567
  (Lisp_Object beg, Lisp_Object end)
Jim Blandy's avatar
Jim Blandy committed
568
{
569
  casify_region (CASE_CAPITALIZE, beg, end);
Jim Blandy's avatar
Jim Blandy committed
570 571 572
  return Qnil;
}

573 574
/* Like Fcapitalize_region but change only the initials.  */

Paul Eggert's avatar
Paul Eggert committed
575
DEFUN ("upcase-initials-region", Fupcase_initials_region,
576
       Supcase_initials_region, 2, 2, "r",
577
       doc: /* Upcase the initial of each word in the region.
578 579
This means that each word's first character is converted to either
title case or upper case, and the rest are left unchanged.
580 581
In programs, give two arguments, the starting and ending
character positions to operate on.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
582
  (Lisp_Object beg, Lisp_Object end)
583
{
584
  casify_region (CASE_CAPITALIZE_UP, beg, end);
585 586
  return Qnil;
}
Jim Blandy's avatar
Jim Blandy committed
587

588
static Lisp_Object
589
casify_word (enum case_action flag, Lisp_Object arg)
Jim Blandy's avatar
Jim Blandy committed
590
{
591
  CHECK_NUMBER (arg);
592 593 594
  ptrdiff_t farend = scan_words (PT, XINT (arg));
  if (!farend)
    farend = XINT (arg) <= 0 ? BEGV : ZV;
595
  SET_PT (casify_region (flag, make_number (PT), make_number (farend)));
596
  return Qnil;
Jim Blandy's avatar
Jim Blandy committed
597 598 599
}

DEFUN ("upcase-word", Fupcase_word, Supcase_word, 1, 1, "p",
600 601 602 603 604
       doc: /* Convert to upper case from point to end of word, moving over.

If point is in the middle of a word, the part of that word before point
is ignored when moving forward.

605 606
With negative argument, convert previous words but do not move.
See also `capitalize-word'.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
607
  (Lisp_Object arg)
Jim Blandy's avatar
Jim Blandy committed
608
{
609
  return casify_word (CASE_UP, arg);
Jim Blandy's avatar
Jim Blandy committed
610 611 612
}

DEFUN ("downcase-word", Fdowncase_word, Sdowncase_word, 1, 1, "p",
613 614 615 616 617
       doc: /* Convert to lower case from point to end of word, moving over.

If point is in the middle of a word, the part of that word before point
is ignored when moving forward.

618
With negative argument, convert previous words but do not move.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
619
  (Lisp_Object arg)
Jim Blandy's avatar
Jim Blandy committed
620
{
621
  return casify_word (CASE_DOWN, arg);
Jim Blandy's avatar
Jim Blandy committed
622 623 624
}

DEFUN ("capitalize-word", Fcapitalize_word, Scapitalize_word, 1, 1, "p",
625 626
       doc: /* Capitalize from point to the end of word, moving over.
With numerical argument ARG, capitalize the next ARG-1 words as well.
627 628
This gives the word(s) a first character in upper case
and the rest lower case.
629 630 631 632

If point is in the middle of a word, the part of that word before point
is ignored when moving forward.

633
With negative argument, capitalize previous words but do not move.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
634
  (Lisp_Object arg)
Jim Blandy's avatar
Jim Blandy committed
635
{
636
  return casify_word (CASE_CAPITALIZE, arg);
Jim Blandy's avatar
Jim Blandy committed
637 638
}

Andreas Schwab's avatar
Andreas Schwab committed
639
void
640
syms_of_casefiddle (void)
Jim Blandy's avatar
Jim Blandy committed
641
{
642
  DEFSYM (Qidentity, "identity");
Jim Blandy's avatar
Jim Blandy committed
643 644 645
  defsubr (&Supcase);
  defsubr (&Sdowncase);
  defsubr (&Scapitalize);
646
  defsubr (&Supcase_initials);
Jim Blandy's avatar
Jim Blandy committed
647 648 649
  defsubr (&Supcase_region);
  defsubr (&Sdowncase_region);
  defsubr (&Scapitalize_region);
650
  defsubr (&Supcase_initials_region);
Jim Blandy's avatar
Jim Blandy committed
651 652 653 654 655
  defsubr (&Supcase_word);
  defsubr (&Sdowncase_word);
  defsubr (&Scapitalize_word);
}

Andreas Schwab's avatar
Andreas Schwab committed
656
void
657
keys_of_casefiddle (void)
Jim Blandy's avatar
Jim Blandy committed
658
{
Juanma Barranquero's avatar
Juanma Barranquero committed
659
  initial_define_key (control_x_map, Ctl ('U'), "upcase-region");
Jim Blandy's avatar
Jim Blandy committed
660
  Fput (intern ("upcase-region"), Qdisabled, Qt);
Juanma Barranquero's avatar
Juanma Barranquero committed
661
  initial_define_key (control_x_map, Ctl ('L'), "downcase-region");
Jim Blandy's avatar
Jim Blandy committed
662 663
  Fput (intern ("downcase-region"), Qdisabled, Qt);

Jim Blandy's avatar
Jim Blandy committed
664 665 666 667
  initial_define_key (meta_map, 'u', "upcase-word");
  initial_define_key (meta_map, 'l', "downcase-word");
  initial_define_key (meta_map, 'c', "capitalize-word");
}