/* GNU Emacs case conversion functions.
- Copyright (C) 1985, 1994, 1997, 1998, 1999, 2001, 2002, 2003, 2004,
- 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+
+Copyright (C) 1985, 1994, 1997-1999, 2001-2011 Free Software Foundation, Inc.
This file is part of GNU Emacs.
register int inword = flag == CASE_DOWN;
/* If the case table is flagged as modified, rescan it. */
- if (NILP (XCHAR_TABLE (current_buffer->downcase_table)->extras[1]))
- Fset_case_table (current_buffer->downcase_table);
+ if (NILP (XCHAR_TABLE (BVAR (current_buffer, downcase_table))->extras[1]))
+ Fset_case_table (BVAR (current_buffer, downcase_table));
if (INTEGERP (obj))
{
int flagbits = (CHAR_ALT | CHAR_SUPER | CHAR_HYPER
| CHAR_SHIFT | CHAR_CTL | CHAR_META);
int flags = XINT (obj) & flagbits;
- int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
+ int multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
/* If the character has higher bits set
above the flags, return it unchanged.
o += CHAR_STRING (c, o);
}
eassert (o - dst <= o_size);
- obj = make_multibyte_string (dst, size, o - dst);
+ obj = make_multibyte_string ((char *) dst, size, o - dst);
SAFE_FREE ();
return obj;
}
The argument may be a character or string. The result has the same type.
The argument object is not altered--the value is a copy.
See also `capitalize', `downcase' and `upcase-initials'. */)
- (obj)
- Lisp_Object obj;
+ (Lisp_Object obj)
{
return casify_object (CASE_UP, obj);
}
doc: /* Convert argument to lower case and return that.
The argument may be a character or string. The result has the same type.
The argument object is not altered--the value is a copy. */)
- (obj)
- Lisp_Object obj;
+ (Lisp_Object obj)
{
return casify_object (CASE_DOWN, obj);
}
and the rest is lower case.
The argument may be a character or string. The result has the same type.
The argument object is not altered--the value is a copy. */)
- (obj)
- Lisp_Object obj;
+ (Lisp_Object obj)
{
return casify_object (CASE_CAPITALIZE, obj);
}
Do not change the other letters of each word.
The argument may be a character or string. The result has the same type.
The argument object is not altered--the value is a copy. */)
- (obj)
- Lisp_Object obj;
+ (Lisp_Object obj)
{
return casify_object (CASE_CAPITALIZE_UP, obj);
}
{
register int c;
register int inword = flag == CASE_DOWN;
- register int multibyte = !NILP (current_buffer->enable_multibyte_characters);
+ register int multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
EMACS_INT start, end;
EMACS_INT start_byte, end_byte;
EMACS_INT first = -1, last; /* Position of first and last changes. */
return;
/* If the case table is flagged as modified, rescan it. */
- if (NILP (XCHAR_TABLE (current_buffer->downcase_table)->extras[1]))
- Fset_case_table (current_buffer->downcase_table);
+ if (NILP (XCHAR_TABLE (BVAR (current_buffer, downcase_table))->extras[1]))
+ Fset_case_table (BVAR (current_buffer, downcase_table));
validate_region (&b, &e);
start = XFASTINT (b);
start_byte = CHAR_TO_BYTE (start);
end_byte = CHAR_TO_BYTE (end);
+ SETUP_BUFFER_SYNTAX_TABLE(); /* For syntax_prefix_flag_p. */
+
while (start < end)
{
int c2, len;
&& (!inword || flag != CASE_CAPITALIZE_UP))
c = UPCASE1 (c);
if ((int) flag >= (int) CASE_CAPITALIZE)
- inword = ((SYNTAX (c) == Sword) && (inword || !SYNTAX_PREFIX (c)));
+ inword = ((SYNTAX (c) == Sword)
+ && (inword || !syntax_prefix_flag_p (c)));
if (c != c2)
{
last = start;
keeping text properties the same. */
replace_range_2 (start, start_byte,
start + 1, start_byte + len,
- str, 1, tolen,
+ (char *) str, 1, tolen,
0);
len = tolen;
}
the region to operate on. When used as a command, the text between
point and the mark is operated on.
See also `capitalize-region'. */)
- (beg, end)
- Lisp_Object beg, end;
+ (Lisp_Object beg, Lisp_Object end)
{
casify_region (CASE_UP, beg, end);
return Qnil;
These arguments specify the starting and ending character numbers of
the region to operate on. When used as a command, the text between
point and the mark is operated on. */)
- (beg, end)
- Lisp_Object beg, end;
+ (Lisp_Object beg, Lisp_Object end)
{
casify_region (CASE_DOWN, beg, end);
return Qnil;
and the rest of it is lower case.
In programs, give two arguments, the starting and ending
character positions to operate on. */)
- (beg, end)
- Lisp_Object beg, end;
+ (Lisp_Object beg, Lisp_Object end)
{
casify_region (CASE_CAPITALIZE, beg, end);
return Qnil;
Subsequent letters of each word are not changed.
In programs, give two arguments, the starting and ending
character positions to operate on. */)
- (beg, end)
- Lisp_Object beg, end;
+ (Lisp_Object beg, Lisp_Object end)
{
casify_region (CASE_CAPITALIZE_UP, beg, end);
return Qnil;
operate_on_word (Lisp_Object arg, EMACS_INT *newpoint)
{
Lisp_Object val;
- int farend;
- int iarg;
+ EMACS_INT farend;
+ EMACS_INT iarg;
CHECK_NUMBER (arg);
iarg = XINT (arg);
doc: /* Convert following word (or ARG words) to upper case, moving over.
With negative argument, convert previous words but do not move.
See also `capitalize-word'. */)
- (arg)
- Lisp_Object arg;
+ (Lisp_Object arg)
{
Lisp_Object beg, end;
EMACS_INT newpoint;
DEFUN ("downcase-word", Fdowncase_word, Sdowncase_word, 1, 1, "p",
doc: /* Convert following word (or ARG words) to lower case, moving over.
With negative argument, convert previous words but do not move. */)
- (arg)
- Lisp_Object arg;
+ (Lisp_Object arg)
{
Lisp_Object beg, end;
EMACS_INT newpoint;
This gives the word(s) a first character in upper case
and the rest lower case.
With negative argument, capitalize previous words but do not move. */)
- (arg)
- Lisp_Object arg;
+ (Lisp_Object arg)
{
Lisp_Object beg, end;
EMACS_INT newpoint;
initial_define_key (meta_map, 'l', "downcase-word");
initial_define_key (meta_map, 'c', "capitalize-word");
}
-
-/* arch-tag: 60a73c66-5489-47e7-a81f-cead4057c526
- (do not change this comment) */