/* Composite sequence support.
Copyright (C) 2001, 2002, 2003, 2004, 2005,
- 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
- Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+ 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
National Institute of Advanced Industrial Science and Technology (AIST)
Registration Number H14PRO021
Copyright (C) 2003, 2006
Lisp_Object Vcompose_chars_after_function;
Lisp_Object Qauto_composed;
+Lisp_Object Vauto_composition_mode;
Lisp_Object Vauto_composition_function;
Lisp_Object Qauto_composition_function;
Lisp_Object Vcomposition_function_table;
}
else if (VECTORP (components) || CONSP (components))
{
- int len = XVECTOR (key)->size;
+ EMACS_UINT len = XVECTOR_SIZE (key);
/* The number of elements should be odd. */
if ((len % 2) == 0)
: COMPOSITION_WITH_RULE_ALTCHARS));
cmp->hash_index = hash_index;
glyph_len = (cmp->method == COMPOSITION_WITH_RULE_ALTCHARS
- ? (XVECTOR (key)->size + 1) / 2
- : XVECTOR (key)->size);
+ ? (XVECTOR_SIZE (key) + 1) / 2
+ : XVECTOR_SIZE (key));
cmp->glyph_len = glyph_len;
cmp->offsets = (short *) xmalloc (sizeof (short) * glyph_len * 2);
cmp->font = NULL;
{
Lisp_Object args[6];
+ /* Save point as marker before calling out to lisp. */
+ if (NILP (string))
+ {
+ Lisp_Object m = Fmake_marker ();
+ set_marker_both (m, Qnil, pt, pt_byte);
+ record_unwind_protect (restore_point_unwind, m);
+ }
+
args[0] = Vauto_composition_function;
args[1] = AREF (elt, 2);
args[2] = pos;
args[5] = string;
gstring = safe_call (6, args);
}
- if (NILP (string))
- TEMP_SET_PT_BOTH (pt, pt_byte);
+ else if (NILP (string))
+ {
+ TEMP_SET_PT_BOTH (pt, pt_byte);
+ }
return unbind_to (count, gstring);
}
}
cmp_it->id = -1;
cmp_it->ch = -2;
if (find_composition (charpos, endpos, &start, &end, &prop, string)
+ && start >= charpos
&& COMPOSITION_VALID_P (start, end, prop))
{
cmp_it->stop_pos = endpos = start;
if (NILP (string) && PT > charpos && PT < endpos)
cmp_it->stop_pos = PT;
if (NILP (current_buffer->enable_multibyte_characters)
- || ! FUNCTIONP (Vauto_composition_function))
+ || NILP (Vauto_composition_mode))
return;
if (bytepos < 0)
{
struct face *face;
Lisp_Object string;
{
+ if (NILP (string) && charpos < PT && PT < endpos)
+ endpos = PT;
+
if (cmp_it->ch == -2)
{
composition_compute_stop_pos (cmp_it, charpos, bytepos, endpos, string);
static int _work_char;
/* 1 iff the character C is composable. */
-#define CHAR_COMPOSABLE_P(C) \
- (_work_val = CHAR_TABLE_REF (Vunicode_category_table, (C)), \
- (SYMBOLP (_work_val) \
- && (_work_char = SDATA (SYMBOL_NAME (_work_val))[0]) != 'C' \
- && _work_char != 'Z'))
+#define CHAR_COMPOSABLE_P(C) \
+ ((C) == 0x200C || (C) == 0x200D \
+ || (_work_val = CHAR_TABLE_REF (Vunicode_category_table, (C)), \
+ (SYMBOLP (_work_val) \
+ && (_work_char = SDATA (SYMBOL_NAME (_work_val))[0]) != 'C' \
+ && _work_char != 'Z')))
/* This is like find_composition, but find an automatic composition
instead. If found, set *GSTRING to the glyph-string representing
retry:
check_val = Qnil;
/* At first, check if POS is composable. */
- c = STRING_CHAR (cur.p, 0);
+ c = STRING_CHAR (cur.p);
if (! CHAR_COMPOSABLE_P (c))
{
if (limit < 0)
fore_check_limit = cur.pos;
break;
}
- c = STRING_CHAR (cur.p, 0);
+ c = STRING_CHAR (cur.p);
if (! CHAR_COMPOSABLE_P (c))
break;
val = CHAR_TABLE_REF (Vcomposition_function_table, c);
if (get_property_and_range (cur.pos, Qcomposition, &val, &b, &e, Qnil)
&& COMPOSITION_VALID_P (b, e, val))
break;
- c = STRING_CHAR (cur.p, 0);
+ c = STRING_CHAR (cur.p);
if (! CHAR_COMPOSABLE_P (c))
break;
val = CHAR_TABLE_REF (Vcomposition_function_table, c);
if (NILP (check_val))
{
- c = STRING_CHAR (cur.p, 0);
+ c = STRING_CHAR (cur.p);
check_val = CHAR_TABLE_REF (Vcomposition_function_table, c);
}
for (; CONSP (check_val); check_val = XCDR (check_val))
return 0;
}
+/* Return the adjusted point provided that point is moved from LAST_PT
+ to NEW_PT. */
+
int
-composition_adjust_point (last_pt)
- EMACS_INT last_pt;
+composition_adjust_point (last_pt, new_pt)
+ EMACS_INT last_pt, new_pt;
{
EMACS_INT charpos, bytepos, startpos, beg, end, pos;
Lisp_Object val;
int i;
- if (PT == BEGV || PT == ZV)
- return PT;
+ if (new_pt == BEGV || new_pt == ZV)
+ return new_pt;
/* At first check the static composition. */
- if (get_property_and_range (PT, Qcomposition, &val, &beg, &end, Qnil)
+ if (get_property_and_range (new_pt, Qcomposition, &val, &beg, &end, Qnil)
&& COMPOSITION_VALID_P (beg, end, val))
{
- if (beg < PT /* && end > PT <- It's always the case. */
+ if (beg < new_pt /* && end > new_pt <- It's always the case. */
&& (last_pt <= beg || last_pt >= end))
- return (PT < last_pt ? beg : end);
- return PT;
+ return (new_pt < last_pt ? beg : end);
+ return new_pt;
}
if (NILP (current_buffer->enable_multibyte_characters)
- || ! FUNCTIONP (Vauto_composition_function))
- return PT;
+ || NILP (Vauto_composition_mode))
+ return new_pt;
/* Next check the automatic composition. */
- if (! find_automatic_composition (PT, (EMACS_INT) -1, &beg, &end, &val, Qnil)
- || beg == PT)
- return PT;
+ if (! find_automatic_composition (new_pt, (EMACS_INT) -1, &beg, &end, &val,
+ Qnil)
+ || beg == new_pt)
+ return new_pt;
for (i = 0; i < LGSTRING_GLYPH_LEN (val); i++)
{
Lisp_Object glyph = LGSTRING_GLYPH (val, i);
if (NILP (glyph))
break;
- if (beg + LGLYPH_FROM (glyph) == PT)
- return PT;
- if (beg + LGLYPH_TO (glyph) >= PT)
- return (PT < last_pt
+ if (beg + LGLYPH_FROM (glyph) == new_pt)
+ return new_pt;
+ if (beg + LGLYPH_TO (glyph) >= new_pt)
+ return (new_pt < last_pt
? beg + LGLYPH_FROM (glyph)
: beg + LGLYPH_TO (glyph) + 1);
}
- return PT;
+ return new_pt;
}
DEFUN ("composition-get-gstring", Fcomposition_get_gstring,
if (!find_composition (from, to, &start, &end, &prop, string))
{
if (!NILP (current_buffer->enable_multibyte_characters)
- && FUNCTIONP (Vauto_composition_function)
+ && ! NILP (Vauto_composition_mode)
&& find_automatic_composition (from, to, &start, &end, &gstring,
string))
return list3 (make_number (start), make_number (end), gstring);
Qauto_composition_function = intern_c_string ("auto-composition-function");
staticpro (&Qauto_composition_function);
+ DEFVAR_LISP ("auto-composition-mode", &Vauto_composition_mode,
+ doc: /* Non-nil if Auto-Composition mode is enabled.
+Use the command `auto-composition-mode' to change this variable. */);
+ Vauto_composition_mode = Qt;
+
DEFVAR_LISP ("auto-composition-function", &Vauto_composition_function,
doc: /* Function to call to compose characters automatically.
This function is called from the display routine with four arguments: