WWWWWW

Current Directory: /usr/share/emacs/24.3/lisp
Viewing File: /usr/share/emacs/24.3/lisp/composite.elc
;ELC
;;; Compiled by mockbuild@buildfarm01-new.corp.cloudlinux.com on Tue Nov 11 13:00:11 2025
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/composite.el
;;; in Emacs version 24.3
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


#@1691 Alist of symbols vs integer codes of glyph reference points.
A glyph reference point symbol is to be used to specify a composition
rule in COMPONENTS argument to such functions as `compose-region'.

The meaning of glyph reference point codes is as follows:

    0----1----2 <---- ascent	0:tl or top-left
    |         |			1:tc or top-center
    |         |			2:tr or top-right
    |         |			3:Bl or base-left     9:cl or center-left
    9   10   11 <---- center	4:Bc or base-center  10:cc or center-center
    |         |			5:Br or base-right   11:cr or center-right
  --3----4----5-- <-- baseline	6:bl or bottom-left
    |         |			7:bc or bottom-center
    6----7----8 <---- descent	8:br or bottom-right

Glyph reference point symbols are to be used to specify composition
rule of the form (GLOBAL-REF-POINT . NEW-REF-POINT), where
GLOBAL-REF-POINT is a reference point in the overall glyphs already
composed, and NEW-REF-POINT is a reference point in the new glyph to
be added.

For instance, if GLOBAL-REF-POINT is `br' (bottom-right) and
NEW-REF-POINT is `tc' (top-center), the overall glyph is updated as
follows (the point `*' corresponds to both reference points):

    +-------+--+ <--- new ascent
    |       |  |
    | global|  |
    | glyph |  |
 -- |       |  |-- <--- baseline (doesn't change)
    +----+--*--+
    |    | new |
    |    |glyph|
    +----+-----+ <--- new descent

A composition rule may have the form (GLOBAL-REF-POINT
NEW-REF-POINT XOFF YOFF), where XOFF and YOFF specify how much
to shift NEW-REF-POINT from GLOBAL-REF-POINT.  In this case, XOFF
and YOFF are integers in the range -100..100 representing the
shifting percentage against the font size.
(defconst reference-point-alist '((tl . 0) (tc . 1) (tr . 2) (Bl . 3) (Bc . 4) (Br . 5) (bl . 6) (bc . 7) (br . 8) (cl . 9) (cc . 10) (cr . 11) (top-left . 0) (top-center . 1) (top-right . 2) (base-left . 3) (base-center . 4) (base-right . 5) (bottom-left . 6) (bottom-center . 7) (bottom-right . 8) (center-left . 9) (center-center . 10) (center-right . 11) (ml . 3) (mc . 10) (mr . 5) (mid-left . 3) (mid-center . 10) (mid-right . 5)) (#$ . 552))
#@141 Encode composition rule RULE into an integer value.
RULE is a cons of global and new reference point symbols
(see `reference-point-alist').
(defalias 'encode-composition-rule #[(rule) "\250\203
\306W\203
\207:\203\232@A\307\211:\203TA@\3108@\n\311Y\203D\n\312X\203D	\311Y\203D	\312X\204I\313\314\"\210\n\315\\	\315\\\202X\316\211\f\250\204b\f
\236A\250\204l
\236A\f\316Y\203\204\f\317W\203\204\316Y\203\204\317W\204\211\313\320\"\210\321\322\n\323\"\322	\324\"\f\317_\\#,\207\313\320\"\207" [rule yoff xoff nref gref reference-point-alist 144 nil 2 -100 100 error "Invalid composition rule: %s" 128 0 12 "Invalid composition rule: %S" logior lsh 16 8] 6 (#$ . 2698)])
(defalias 'decode-composition-rule #[(rule-code) "\306!\203\f\307W\204\310\311\"\210\312\313\"\314\312\315\"\316\"\317\211\314\316\"\320\321\245
\"@\320\321\246
\"@\n\203I\n9\203I	\203I	9\204N\310\322\"\210\f\323U\203`\323U\203`\n	B\202m\f\324Z\324Z\n\f	F,\207" [rule-code nref gref yoff xoff reference-point-alist natnump 16777216 error "Invalid encoded composition rule: %S" lsh -16 logand -8 255 nil rassq 12 "Invalid composition rule code: %S" 0 128] 5])
(defalias 'encode-composition-components #[(components &optional nocopy) "\204\305	!\306	!\203.	G\307\nW\203*	\n\310	\nH!I\210\n\311\\\211\202*\202E	A\211\203D\f\310\f@!\240\210\fAA\211\2045)	\207" [nocopy components i len tail copy-sequence vectorp 1 encode-composition-rule 2] 6])
(defalias 'decode-composition-components #[(components &optional nocopy) "\204\304	!	G\305\nW\203$	\n\306	\nH!I\210\n\307\\\211\202*	\207" [nocopy components i len copy-sequence 1 decode-composition-rule 2] 6])
#@1827 Compose characters in the current region.

Characters are composed relatively, i.e. composed by overstriking
or stacking depending on ascent, descent and other metrics of
glyphs.

For instance, if the region has three characters "XYZ", X is
regarded as BASE glyph, and Y is displayed:
  (1) above BASE if Y's descent value is not positive
  (2) below BASE if Y's ascent value is not positive
  (3) on BASE (i.e. at the BASE position) otherwise
and Z is displayed with the same rule while regarding the whole
XY glyphs as BASE.

When called from a program, expects these four arguments.

First two arguments START and END are positions (integers or markers)
specifying the region.

Optional 3rd argument COMPONENTS, if non-nil, is a character, a string
or a vector or list of integers and rules.

If it is a character, it is an alternate character to display instead
of the text in the region.

If it is a string, the elements are alternate characters.  In
this case, TAB element has a special meaning.  If the first
character is TAB, the glyphs are displayed with left padding space
so that no pixel overlaps with the previous column.  If the last
character is TAB, the glyphs are displayed with right padding
space so that no pixel overlaps with the following column.

If it is a vector or list, it is a sequence of alternate characters and
composition rules, where (2N)th elements are characters and (2N+1)th
elements are composition rules to specify how to compose (2N+2)th
elements with previously composed N glyphs.

A composition rule is a cons of global and new glyph reference point
symbols.  See the documentation of `reference-point-alist' for more
details.

Optional 4th argument MODIFICATION-FUNC is a function to call to
adjust the composition when it gets invalid because of a change of
text in the composition.
(defalias 'compose-region #[(start end &optional components modification-func) "\306 \307\310\n!\204\n<\203\311\n!\312\f\n
$\210\313	!*\207" [inhibit-read-only modified-p components start end modification-func buffer-modified-p t vectorp encode-composition-components compose-region-internal restore-buffer-modified-p] 5 (#$ . 4432) "r"])
#@146 Decompose text in the current region.

When called from a program, expects two arguments,
positions (integers or markers) specifying the region.
(defalias 'decompose-region #[(start end) "\304 \305\306\n\307#\210\310	!*\207" [inhibit-read-only modified-p start end buffer-modified-p t remove-text-properties (composition nil) restore-buffer-modified-p] 4 (#$ . 6612) "r"])
#@613 Compose characters in string STRING.

The return value is STRING with the `composition' property put on all
the characters in it.

Optional 2nd and 3rd arguments START and END specify the range of
STRING to be composed.  They default to the beginning and the end of
STRING respectively.

Optional 4th argument COMPONENTS, if non-nil, is a character or a
sequence (vector, list, or string) of integers.  See the function
`compose-region' for more detail.

Optional 5th argument MODIFICATION-FUNC is a function to call to
adjust the composition when it gets invalid because of a change of
text in the composition.
(defalias 'compose-string #[(string &optional start end components modification-func) "\305!\204<\203\306!	\204\307\n\204G\310	\n\f%\210\207" [components start end string modification-func vectorp encode-composition-components 0 compose-string-internal] 6 (#$ . 6995)])
#@56 Return STRING where `composition' property is removed.
(defalias 'decompose-string #[(string) "\301\302G\303$\210\207" [string remove-text-properties 0 (composition nil)] 5 (#$ . 7901)])
#@426 Return a string from arguments in which all characters are composed.
For relative composition, arguments are characters.
For rule-based composition, Mth (where M is odd) arguments are
characters, and Nth (where N is even) arguments are composition rules.
A composition rule is a cons of glyph reference points of the form
(GLOBAL-REF-POINT . NEW-REF-POINT).  See the documentation of
`reference-point-alist' for more detail.
(defalias 'compose-chars #[(&rest args) "\304\211\nA@:\203,\305\n\306\"\211\203!@	BAA\211\204	\237\260\n)\2020\n\260\307	\310	G$*\207" [components str args tail nil encode-composition-components nocopy compose-string-internal 0] 6 (#$ . 8098)])
#@1617 Return information about a composition at or near buffer position POS.

If the character at POS has `composition' property, the value is a list
(FROM TO VALID-P).

FROM and TO specify the range of text that has the same `composition'
property, VALID-P is t if this composition is valid, and nil if not.

If there's no composition at POS, and the optional 2nd argument LIMIT
is non-nil, search for a composition toward the position given by LIMIT.

If no composition is found, return nil.

Optional 3rd argument STRING, if non-nil, is a string to look for a
composition in; nil means the current buffer.

If a valid composition is found and the optional 4th argument DETAIL-P
is non-nil, the return value is a list of the form

   (FROM TO COMPONENTS RELATIVE-P MOD-FUNC WIDTH)

COMPONENTS is a vector of integers, the meaning depends on RELATIVE-P.

RELATIVE-P is t if the composition method is relative, else nil.

If RELATIVE-P is t, COMPONENTS is a vector of characters to be
composed.  If RELATIVE-P is nil, COMPONENTS is a vector of characters
and composition rules as described in `compose-region'.

MOD-FUNC is a modification function of the composition.

WIDTH is a number of columns the composition occupies on the screen.

When Automatic Composition mode is on, this function also finds a
chunk of text that is automatically composed.  If such a chunk is
found closer to POS than the position that has `composition'
property, the value is a list of FROM, TO, and a glyph-string
that specifies how the chunk is to be composed.  See the function
`composition-get-gstring' for the format of the glyph-string.
(defalias 'find-composition #[(pos &optional limit string detail-p) "\305	\n$\203%\fG\306V\203%\307\f8\203%\306\f8\204%\310\307\f8\311\"\210\f)\207" [pos limit string detail-p result find-composition-internal 3 2 decode-composition-components nocopy] 5 (#$ . 8794)])
#@517 Compose characters in current buffer after position POS.

It looks up the char-table `composition-function-table' (which
see) by a character at POS, and compose characters after POS
according to the contents of `composition-function-table'.

Optional 2nd arg LIMIT, if non-nil, limits characters to compose.

Optional 3rd arg OBJECT, if non-nil, is a string that contains the
text to compose.  In that case, POS and LIMIT index into the string.

This function is the default value of `compose-chars-after-function'.
(defalias 'compose-chars-after #[(pos &optional limit object) "	fH\306 \205\n;?\205\307	\310 \"\311\211\211\2040\n;\203-\nG\202.d\203\245\203\245\312 \313\216\212\203\244\314@!\203W\311@\202a@@@A	b\210
\203\220\n;\203v\315
\n\"\316=\202y\317
!\203\231\316\225X\203\231\f	\316\225\n$\202\231\f	\n$\203A\311\211\204F+-\207" [composition-function-table pos object result func pattern display-multi-font-p font-at selected-window nil match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) functionp string-match 0 looking-at font-obj tail limit save-match-data-internal] 6 (#$ . 10692)])
#@620 Compose last characters.
The argument is a parameterized event of the form
	(compose-last-chars N COMPONENTS),
where N is the number of characters before point to compose,
COMPONENTS, if non-nil, is the same as the argument to `compose-region'
(which see).  If it is nil, `compose-chars-after' is called,
and that function finds a proper rule to compose the target characters.
This function is intended to be used from input methods.
The global keymap binds special event `compose-last-chars' to this
function.  Input method may generate an event (compose-last-chars N COMPONENTS)
after a sequence of character events.
(defalias 'compose-last-chars #[(args) "A@\211\247\205)`eZ	Y\205)\3028\203#\303`	Z`\3028#\202)\304`	Z`\")\207" [args chars 2 compose-region compose-chars-after] 6 (#$ . 11907) "e"])
(global-set-key [compose-last-chars] 'compose-last-chars)
(defalias 'lgstring-header #[(gstring) "\301H\207" [gstring 0] 2])
(put 'lgstring-header 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lgstring-set-header #[(gstring header) "\302	I\207" [gstring header 0] 3])
(put 'lgstring-set-header 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lgstring-font #[(gstring) "\211\301H)\301H\207" [gstring 0] 3])
(put 'lgstring-font 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lgstring-char #[(gstring i) "\211\302H)	TH\207" [gstring i 0] 3])
(put 'lgstring-char 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lgstring-char-len #[(gstring) "\211\301H)GS\207" [gstring 0] 3])
(put 'lgstring-char-len 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lgstring-shaped-p #[(gstring) "\301H\207" [gstring 1] 2])
(put 'lgstring-shaped-p 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lgstring-set-id #[(gstring id) "\302	I\207" [gstring id 1] 3])
(put 'lgstring-set-id 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lgstring-glyph #[(gstring i) "	\302\\H\207" [gstring i 2] 3])
(put 'lgstring-glyph 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lgstring-glyph-len #[(gstring) "G\301Z\207" [gstring 2] 2])
(put 'lgstring-glyph-len 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lgstring-set-glyph #[(gstring i glyph) "	\303\\\nI\207" [gstring i glyph 2] 3])
(put 'lgstring-set-glyph 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-from #[(glyph) "\301H\207" [glyph 0] 2])
(put 'lglyph-from 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-to #[(glyph) "\301H\207" [glyph 1] 2])
(put 'lglyph-to 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-char #[(glyph) "\301H\207" [glyph 2] 2])
(put 'lglyph-char 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-code #[(glyph) "\301H\207" [glyph 3] 2])
(put 'lglyph-code 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-width #[(glyph) "\301H\207" [glyph 4] 2])
(put 'lglyph-width 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-lbearing #[(glyph) "\301H\207" [glyph 5] 2])
(put 'lglyph-lbearing 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-rbearing #[(glyph) "\301H\207" [glyph 6] 2])
(put 'lglyph-rbearing 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-ascent #[(glyph) "\301H\207" [glyph 7] 2])
(put 'lglyph-ascent 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-descent #[(glyph) "\301H\207" [glyph 8] 2])
(put 'lglyph-descent 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-adjustment #[(glyph) "\301H\207" [glyph 9] 2])
(put 'lglyph-adjustment 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-set-from-to #[(glyph from to) "\303	I\210\304\nI\207" [glyph from to 0 1] 3])
(put 'lglyph-set-from-to 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-set-char #[(glyph char) "\302	I\207" [glyph char 2] 3])
(put 'lglyph-set-char 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-set-code #[(glyph code) "\302	I\207" [glyph code 3] 3])
(put 'lglyph-set-code 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-set-width #[(glyph width) "\302	I\207" [glyph width 4] 3])
(put 'lglyph-set-width 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-set-adjustment #[(glyph &optional xoff yoff wadjust) "\304\305	\206\306\n\206
\306\206\306#I\207" [glyph xoff yoff wadjust 9 vector 0] 6])
(put 'lglyph-set-adjustment 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lglyph-copy #[(glyph) "\301!\207" [glyph copy-sequence] 2])
(put 'lglyph-copy 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'lgstring-insert-glyph #[(gstring idx glyph) "\211G\305Z)	\nW\203$\n\211\n\305\\H*\203$\nT\211\202\nU\2034\306\307\f!\"\202J\nTW\203J\nT\310\211\n\305\\\fI+\210\n	V\203o\n\nS\211\n\305\\H*\211\n\305\\\fI+\210\nS\211\202K\n\f\211\n\305\\\fI+\210*\207" [gstring idx i nglyphs glyph 2 vconcat vector nil] 6])
(defalias 'compose-glyph-string #[(gstring from to) "	\211\n\306\\H*\307\211\211\211\310H)S\211\n\306\\H*\211\311H)
\f\211\310	I\210
\311I+\210	T\211W\203\254	\211\n\306\\H*\211\203\254
\f\211\310	I\210
\311I+\210
\211\312H)\310X\203v\310\202}
\211\313H)[
\310\211\211\314\315\206\224\310\206\232\310\206\240\310#I,\210)	T\211\202?+\207" [gstring from i to-pos from-pos glyph 2 nil 0 1 6 4 9 vector to xoff wadjust yoff] 7])
(defalias 'compose-glyph-string-relative #[(gstring from to &optional gap) "\211\211\306H)\306H)	\211\n\307\\H*\310\211\211\211\2036\311\312\313\"_!\2029\306\211\306H)S\211\n\307\\H*\211\314H)\211\315H)\211\316H)
\211\306	I\210\314I+\210	T\211W\203]	\211\n\307\\H*\211
\211\306	I\210\314I+\210\211\315H)\211\316H)\310\211\211\317H)\306X\203\326\306\202\337\211\320H)[\306V\203\f\306W\203\321\306\f$\322\f$\202\306\202\322#\322$\306U\203-\306U\204U\306\211\323\324\206E\306\206K\306\206Q\306#I,\210,	T\211\202\203.\207" [gstring from i descent ascent to-pos 0 2 nil floor font-get :size 1 7 8 6 4 - + 9 vector from-pos glyph font-object gap to yoff xoff this-descent this-ascent wadjust] 7])
#@386 Compose glyph-string GSTRING for graphic display.
Combining characters are composed with the preceding base
character.  If the preceding character is not a base character,
each combining character is composed as a spacing character by
a padding space before and/or after the character.

All non-spacing characters have this function in
`composition-function-table' unless overwritten.
(defalias 'compose-gstring-for-graphic #[(gstring) "\211\211\306H)GS)\211G\307Z)\306\211	\307\\H*\211\310U\203\210\n\211\311H)\n\211\312H)\n\211\313H)\314-.\211/\306W\203L/[\202Q\306\211/.-W\203]-.\n
\306./Z01\211\315\316
\206s\3061\206y\3060\206\306#I,\210,\202\317\306\211\211\306H)	TH*\320\"\321>\203\242\314\202\322!\2112\203\3052\306\211	\307\\H*\211\310H)\306V\203\3052\202\3143\211\3103I*\210\n\211\313H)-\n\211\323H)4\n\211\324H)5\n\211\312H).\n\211\311H)\211/.\\\307\2456\325\326\211\211\306H)\306H)\327\"\330_!7\f\3068	8W\203\343	\211	\307\\H*	\306V\203\334\317\n\211\307H)\331\"9\n\211\311H):\n\211\312H);\n\211\323H)<\n\211\324H)=:;\\\307\245>\314\21119\203\3029\332Y\203\3029\333X\203\302\306\21119\332U\203\245/>Z<\306V\203\233\306\202\2405<\\1\202\2039\334U\203\321<\306V\203\266\306<6>Z<\306V\203\307\306\202\3145<\\1\202\2039\335U\203\375<\306V\203\342\306<.>Z<\306V\203\363\306\202\3705<\\1\202\2039\336U\203
/;Z\202\2039\337U\203.:Z\202\2039\340U\203@/>Z=\306Y\2035\306\202;4[=Z1\202\2039\341U\203c6>Z=\306Y\203X\306\202^4[=Z1\202\2039\342U\203\206.>Z=\306Y\203{\306\202\2014[=Z1\202\2039\343U\203\253/>Z<\306V\203\236\306\202\246\3445<7#1\202\2039\345U\203\3206>Z<\306V\203\303\306\202\313\3445<7#1\202\2039\346U\203\365.>Z<\306V\203\350\306\202\360\3445<7#1\202\2039\347U\203/;Z\202\2039\350U\203.:Z\202\2039\351U\203;/>Z=\306Y\203-\306\2026\3524[=7#1\202\2039\353U\203a6>Z=\306Y\203S\306\202\\\3524[=7#1\202\2039\354U\203\203.>Z=\306Y\203y\306\202\2014=\\7Z1\n
-Z1\31401\211\315\316
\206\231\3061\206\237\3060\206\245\306#I,\210:
\\\211:
\\;<1Z<=1\\=4<W\203\316<45=W\203\332=5.	T\211\202.	\306\211W\203	\211	\307\\H*\211\203\n\306\fS?@\211\306@I\210\n\310?I+\210	T\211\202\350))+\207" [gstring i glyph nglyphs nchars xoff 0 2 1 5 6 4 nil 9 vector get-char-code-property general-category (Mn Mc Me Zs Zl Zp Cc Cf Cs) font-shape-gstring 7 8 round font-get :size 0.1 canonical-combining-class 200 240 202 204 208 210 212 214 216 218 + 220 222 224 226 228 - 230 232 width rbearing lbearing wadjust yoff gstr id ascent descent center gap --dotimes-limit-- class lb rb as de ce to from] 7 (#$ . 18190)])
(byte-code "\302\303\304\305!\306B\"\307B\310\311	\"\210)\302\207" [elt unicode-category-table apply vector purecopy "\\c.\\c^+" (1 compose-gstring-for-graphic) ([nil 0 compose-gstring-for-graphic]) map-char-table #[(key val) "\304>\205\305	\n#\207" [val composition-function-table key elt (Mn Mc Me) set-char-table-range] 4]] 4)
#@271 Compose glyph string GSTRING for terminal display.
Non-spacing characters are composed with the preceding base
character.  If the preceding character is not a base character,
each non-spacing character is composed as a spacing character by
prepending a space before it.
(defalias 'compose-gstring-for-terminal #[(gstring) "\211G\306Z)\307\211\211\307H)\307H)\310\fW\203x\211\306\\H*\211\203x\311	\211\306H)\n\"\204\201\307\211\fW\203\211\306\\H*\211\203	\211\312H)\313W\203e	\313\211\312
I*\210	\211\211\307I\210	\313I+\210T\211\202<	\211\312H)\307U\203\361\314	\211\306H)\315\"\316=\203\267	\317\211\306I*\210	\313\211\312
I*\210T\211\202\320	\321	!)#\211\211G\306Z)\211\306\\H*\211\317\211\306I*\210	\313\211\312
I*\210\306\211\202	\211\307H)	\211\313H)T\fW\203D\211\306\\H*\211\203D\311	\211\306H)\n\"\203D	\211\312H)\307U\203D	\211\313H)T\211\202W\203t\211\306\\H*\211\211\307I\210	\313I+\210T\211\202E+\202,\207" [gstring glyph coding i nglyphs width 2 0 nil char-charset 4 1 get-char-code-property general-category Cf 32 lgstring-insert-glyph copy-sequence to from char j] 6 (#$ . 21386)])
#@639 Compose the characters at FROM by FUNC.
FUNC is called with one argument GSTRING which is built for characters
in the region FROM (inclusive) and TO (exclusive).

If the character are composed on a graphic display, FONT-OBJECT
is a font to use.  Otherwise, FONT-OBJECT is nil, and the function
`compose-gstring-for-terminal' is used instead of FUNC.

If STRING is non-nil, it is a string, and FROM and TO are indices
into the string.  In that case, compose characters in the string.

The value is a gstring containing information for shaping the characters.

This function is the default value of `auto-composition-function' (which see).
(defalias 'auto-compose-chars #[(func from to font-object string) "\306	\n$\211\211\307H)\203\f\202 \310\n\302\"\204\311
\f!)\207" [from to font-object string gstring func composition-get-gstring 1 fontp compose-gstring-for-terminal] 6 (#$ . 22636)])
(byte-code "\300\301\302\303#\210\304\305!\210\306\305\307\"\207" [put auto-composition-mode permanent-local t make-variable-buffer-local auto-composition-function set-default auto-compose-chars] 4)
#@453 Toggle Auto Composition mode.
With a prefix argument ARG, enable Auto Composition mode if ARG
is positive, and disable it otherwise.  If called from Lisp,
enable the mode if ARG is omitted or nil.

When Auto Composition mode is enabled, text characters are
automatically composed by functions registered in
`composition-function-table'.

You can use `global-auto-composition-mode' to turn on
Auto Composition mode in all buffers (this is the default).
(defalias 'auto-composition-mode #[(&optional arg) "\303 	\304=\203\n?\202\305	!\306V\307\310\n\203\311\202\312\"\210\313\314!\203@\303 \2033\303 \232\203@\315\316\n\203=\317\202>\320\"\210)\321 \210\n\207" [#1=#:last-message arg auto-composition-mode current-message toggle prefix-numeric-value 0 run-hooks auto-composition-mode-hook auto-composition-mode-on-hook auto-composition-mode-off-hook called-interactively-p any message "Auto-Composition mode %sabled" "en" "dis" force-mode-line-update] 3 (#$ . 23741) (list (or current-prefix-arg 'toggle))])
(byte-code "\301\302\303\304\300!\205\n\303\211%\210\305\302!\207" [auto-composition-mode-map add-minor-mode auto-composition-mode nil boundp make-variable-buffer-local] 6)
#@266 Toggle Auto Composition mode in all buffers.
With a prefix argument ARG, enable it if ARG is positive, and
disable it otherwise.  If called from Lisp, enable it if ARG is
omitted or nil.

For more information on Auto Composition mode, see
`auto-composition-mode' .
(defalias 'global-auto-composition-mode #[(&optional arg) "\302 \303\304	\305=\203\306\304!?\202\307	!\310V\"\210\311\312\306\304!\203%\313\202&\314\"\210\315\316!\203I\302 \203:\302 \232\203I\317\320\306\304!\203F\321\202G\322\"\210)\323 \210\306\304!\207" [#1=#:last-message arg current-message set-default auto-composition-mode toggle default-value prefix-numeric-value 0 run-hooks global-auto-composition-mode-hook global-auto-composition-mode-on-hook global-auto-composition-mode-off-hook called-interactively-p any message "Global-Auto-Composition mode %sabled" "en" "dis" force-mode-line-update] 4 (#$ . 24945) (list (or current-prefix-arg 'toggle))])
(defalias 'toggle-auto-composition 'auto-composition-mode)
F1l3 Manager
