forked from fgeller/emacs-mac-port
/
composite.c
2066 lines (1810 loc) · 62.6 KB
/
composite.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* Composite sequence support.
Copyright (C) 2001-2013 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
National Institute of Advanced Industrial Science and Technology (AIST)
Registration Number H13PRO009
This file is part of GNU Emacs.
GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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
along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include <config.h>
#define COMPOSITE_INLINE EXTERN_INLINE
#include "lisp.h"
#include "character.h"
#include "buffer.h"
#include "coding.h"
#include "intervals.h"
#include "window.h"
#include "frame.h"
#include "dispextern.h"
#include "font.h"
#include "termhooks.h"
/* Emacs uses special text property `composition' to support character
composition. A sequence of characters that have the same (i.e. eq)
`composition' property value is treated as a single composite
sequence (we call it just `composition' here after). Characters in
a composition are all composed somehow on the screen.
The property value has this form when the composition is made:
((LENGTH . COMPONENTS) . MODIFICATION-FUNC)
then turns to this form:
(COMPOSITION-ID . (LENGTH COMPONENTS-VEC . MODIFICATION-FUNC))
when the composition is registered in composition_hash_table and
composition_table. These rather peculiar structures were designed
to make it easy to distinguish them quickly (we can do that by
checking only the first element) and to extract LENGTH (from the
former form) and COMPOSITION-ID (from the latter form).
We register a composition when it is displayed, or when the width
is required (for instance, to calculate columns).
LENGTH -- Length of the composition. This information is used to
check the validity of the composition.
COMPONENTS -- Character, string, vector, list, or nil.
If it is nil, characters in the text are composed relatively
according to their metrics in font glyphs.
If it is a character or a string, the character or characters
in the string are composed relatively.
If it is a vector or list of integers, the element is a
character or an encoded composition rule. The characters are
composed according to the rules. (2N)th elements are
characters to be composed and (2N+1)th elements are
composition rules to tell how to compose (2N+2)th element with
the previously composed 2N glyphs.
COMPONENTS-VEC -- Vector of integers. In a relative composition,
the elements are the characters to be composed. In a rule-base
composition, the elements are characters or encoded
composition rules.
MODIFICATION-FUNC -- If non nil, it is a function to call when the
composition gets invalid after a modification in a buffer. If
it is nil, a function in `composition-function-table' of the
first character in the sequence is called.
COMPOSITION-ID --Identification number of the composition. It is
used as an index to composition_table for the composition.
When Emacs has to display a composition or has to know its
displaying width, the function get_composition_id is called. It
returns COMPOSITION-ID so that the caller can access the
information about the composition through composition_table. If a
COMPOSITION-ID has not yet been assigned to the composition,
get_composition_id checks the validity of `composition' property,
and, if valid, assigns a new ID, registers the information in
composition_hash_table and composition_table, and changes the form
of the property value. If the property is invalid,
get_composition_id returns -1 without changing the property value.
We use two tables to keep the information about composition;
composition_hash_table and composition_table.
The former is a hash table whose keys are COMPONENTS-VECs and
values are the corresponding COMPOSITION-IDs. This hash table is
weak, but as each key (COMPONENTS-VEC) is also kept as a value of the
`composition' property, it won't be collected as garbage until all
bits of text that have the same COMPONENTS-VEC are deleted.
The latter is a table of pointers to `struct composition' indexed
by COMPOSITION-ID. This structure keeps the other information (see
composite.h).
In general, a text property holds information about individual
characters. But, a `composition' property holds information about
a sequence of characters (in this sense, it is like the `intangible'
property). That means that we should not share the property value
in adjacent compositions -- we can't distinguish them if they have the
same property. So, after any changes, we call
`update_compositions' and change a property of one of adjacent
compositions to a copy of it. This function also runs a proper
composition modification function to make a composition that gets
invalid by the change valid again.
As the value of the `composition' property holds information about a
specific range of text, the value gets invalid if we change the
text in the range. We treat the `composition' property as always
rear-nonsticky (currently by setting default-text-properties to
(rear-nonsticky (composition))) and we never make properties of
adjacent compositions identical. Thus, any such changes make the
range just shorter. So, we can check the validity of the `composition'
property by comparing LENGTH information with the actual length of
the composition.
*/
Lisp_Object Qcomposition;
/* Table of pointers to the structure `composition' indexed by
COMPOSITION-ID. This structure is for storing information about
each composition except for COMPONENTS-VEC. */
struct composition **composition_table;
/* The current size of `composition_table'. */
static ptrdiff_t composition_table_size;
/* Number of compositions currently made. */
ptrdiff_t n_compositions;
/* Hash table for compositions. The key is COMPONENTS-VEC of
`composition' property. The value is the corresponding
COMPOSITION-ID. */
Lisp_Object composition_hash_table;
static Lisp_Object Qauto_composed;
static Lisp_Object Qauto_composition_function;
/* Maximum number of characters to look back for
auto-compositions. */
#define MAX_AUTO_COMPOSITION_LOOKBACK 3
/* Temporary variable used in macros COMPOSITION_XXX. */
Lisp_Object composition_temp;
/* Return COMPOSITION-ID of a composition at buffer position
CHARPOS/BYTEPOS and length NCHARS. The `composition' property of
the sequence is PROP. STRING, if non-nil, is a string that
contains the composition instead of the current buffer.
If the composition is invalid, return -1. */
ptrdiff_t
get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
Lisp_Object prop, Lisp_Object string)
{
Lisp_Object id, length, components, key, *key_contents;
ptrdiff_t glyph_len;
struct Lisp_Hash_Table *hash_table = XHASH_TABLE (composition_hash_table);
ptrdiff_t hash_index;
EMACS_UINT hash_code;
enum composition_method method;
struct composition *cmp;
ptrdiff_t i;
int ch;
/* Maximum length of a string of glyphs. XftGlyphExtents limits
this to INT_MAX, and Emacs limits it further. Divide INT_MAX - 1
by 2 because x_produce_glyphs computes glyph_len * 2 + 1. Divide
the size by MAX_MULTIBYTE_LENGTH because encode_terminal_code
multiplies glyph_len by MAX_MULTIBYTE_LENGTH. */
enum {
GLYPH_LEN_MAX = min ((INT_MAX - 1) / 2,
min (PTRDIFF_MAX, SIZE_MAX) / MAX_MULTIBYTE_LENGTH)
};
/* PROP should be
Form-A: ((LENGTH . COMPONENTS) . MODIFICATION-FUNC)
or
Form-B: (COMPOSITION-ID . (LENGTH COMPONENTS-VEC . MODIFICATION-FUNC))
*/
if (nchars == 0 || !CONSP (prop))
goto invalid_composition;
id = XCAR (prop);
if (INTEGERP (id))
{
/* PROP should be Form-B. */
if (XINT (id) < 0 || XINT (id) >= n_compositions)
goto invalid_composition;
return XINT (id);
}
/* PROP should be Form-A.
Thus, ID should be (LENGTH . COMPONENTS). */
if (!CONSP (id))
goto invalid_composition;
length = XCAR (id);
if (!INTEGERP (length) || XINT (length) != nchars)
goto invalid_composition;
components = XCDR (id);
/* Check if the same composition has already been registered or not
by consulting composition_hash_table. The key for this table is
COMPONENTS (converted to a vector COMPONENTS-VEC) or, if it is
nil, vector of characters in the composition range. */
if (INTEGERP (components))
key = Fmake_vector (make_number (1), components);
else if (STRINGP (components) || CONSP (components))
key = Fvconcat (1, &components);
else if (VECTORP (components))
key = components;
else if (NILP (components))
{
key = Fmake_vector (make_number (nchars), Qnil);
if (STRINGP (string))
for (i = 0; i < nchars; i++)
{
FETCH_STRING_CHAR_ADVANCE (ch, string, charpos, bytepos);
ASET (key, i, make_number (ch));
}
else
for (i = 0; i < nchars; i++)
{
FETCH_CHAR_ADVANCE (ch, charpos, bytepos);
ASET (key, i, make_number (ch));
}
}
else
goto invalid_composition;
hash_index = hash_lookup (hash_table, key, &hash_code);
if (hash_index >= 0)
{
/* We have already registered the same composition. Change PROP
from Form-A above to Form-B while replacing COMPONENTS with
COMPONENTS-VEC stored in the hash table. We can directly
modify the cons cell of PROP because it is not shared. */
key = HASH_KEY (hash_table, hash_index);
id = HASH_VALUE (hash_table, hash_index);
XSETCAR (prop, id);
XSETCDR (prop, Fcons (make_number (nchars), Fcons (key, XCDR (prop))));
return XINT (id);
}
/* This composition is a new one. We must register it. */
/* Check if we have sufficient memory to store this information. */
if (composition_table_size <= n_compositions)
composition_table = xpalloc (composition_table, &composition_table_size,
1, -1, sizeof *composition_table);
key_contents = XVECTOR (key)->contents;
/* Check if the contents of COMPONENTS are valid if COMPONENTS is a
vector or a list. It should be a sequence of:
char1 rule1 char2 rule2 char3 ... ruleN charN+1 */
if (VECTORP (components)
&& ASIZE (components) >= 2
&& VECTORP (AREF (components, 0)))
{
/* COMPONENTS is a glyph-string. */
ptrdiff_t len = ASIZE (key);
for (i = 1; i < len; i++)
if (! VECTORP (AREF (key, i)))
goto invalid_composition;
}
else if (VECTORP (components) || CONSP (components))
{
ptrdiff_t len = ASIZE (key);
/* The number of elements should be odd. */
if ((len % 2) == 0)
goto invalid_composition;
/* All elements should be integers (character or encoded
composition rule). */
for (i = 0; i < len; i++)
{
if (!INTEGERP (key_contents[i]))
goto invalid_composition;
}
}
/* Change PROP from Form-A above to Form-B. We can directly modify
the cons cell of PROP because it is not shared. */
XSETFASTINT (id, n_compositions);
XSETCAR (prop, id);
XSETCDR (prop, Fcons (make_number (nchars), Fcons (key, XCDR (prop))));
/* Register the composition in composition_hash_table. */
hash_index = hash_put (hash_table, key, id, hash_code);
method = (NILP (components)
? COMPOSITION_RELATIVE
: ((INTEGERP (components) || STRINGP (components))
? COMPOSITION_WITH_ALTCHARS
: COMPOSITION_WITH_RULE_ALTCHARS));
glyph_len = (method == COMPOSITION_WITH_RULE_ALTCHARS
? (ASIZE (key) + 1) / 2
: ASIZE (key));
if (GLYPH_LEN_MAX < glyph_len)
memory_full (SIZE_MAX);
/* Register the composition in composition_table. */
cmp = xmalloc (sizeof *cmp);
cmp->method = method;
cmp->hash_index = hash_index;
cmp->glyph_len = glyph_len;
cmp->offsets = xnmalloc (glyph_len, 2 * sizeof *cmp->offsets);
cmp->font = NULL;
if (cmp->method != COMPOSITION_WITH_RULE_ALTCHARS)
{
/* Relative composition. */
cmp->width = 0;
for (i = 0; i < glyph_len; i++)
{
int this_width;
ch = XINT (key_contents[i]);
/* TAB in a composition means display glyphs with padding
space on the left or right. */
this_width = (ch == '\t' ? 1 : CHAR_WIDTH (ch));
if (cmp->width < this_width)
cmp->width = this_width;
}
}
else
{
/* Rule-base composition. */
double leftmost = 0.0, rightmost;
ch = XINT (key_contents[0]);
rightmost = ch != '\t' ? CHAR_WIDTH (ch) : 1;
for (i = 1; i < glyph_len; i += 2)
{
int rule, gref, nref;
int this_width;
double this_left;
rule = XINT (key_contents[i]);
ch = XINT (key_contents[i + 1]);
this_width = ch != '\t' ? CHAR_WIDTH (ch) : 1;
/* A composition rule is specified by an integer value
that encodes global and new reference points (GREF and
NREF). GREF and NREF are specified by numbers as
below:
0---1---2 -- ascent
| |
| |
| |
9--10--11 -- center
| |
---3---4---5--- baseline
| |
6---7---8 -- descent
*/
COMPOSITION_DECODE_REFS (rule, gref, nref);
this_left = (leftmost
+ (gref % 3) * (rightmost - leftmost) / 2.0
- (nref % 3) * this_width / 2.0);
if (this_left < leftmost)
leftmost = this_left;
if (this_left + this_width > rightmost)
rightmost = this_left + this_width;
}
cmp->width = rightmost - leftmost;
if (cmp->width < (rightmost - leftmost))
/* To get a ceiling integer value. */
cmp->width++;
}
composition_table[n_compositions] = cmp;
return n_compositions++;
invalid_composition:
/* Would it be better to remove this `composition' property? */
return -1;
}
/* Find a static composition at or nearest to position POS of OBJECT
(buffer or string).
OBJECT defaults to the current buffer. If there's a composition at
POS, set *START and *END to the start and end of the sequence,
*PROP to the `composition' property, and return 1.
If there's no composition at POS and LIMIT is negative, return 0.
Otherwise, search for a composition forward (LIMIT > POS) or
backward (LIMIT < POS). In this case, LIMIT bounds the search.
If a composition is found, set *START, *END, and *PROP as above,
and return 1, else return 0.
This doesn't check the validity of composition. */
bool
find_composition (ptrdiff_t pos, ptrdiff_t limit,
ptrdiff_t *start, ptrdiff_t *end,
Lisp_Object *prop, Lisp_Object object)
{
Lisp_Object val;
if (get_property_and_range (pos, Qcomposition, prop, start, end, object))
return 1;
if (limit < 0 || limit == pos)
return 0;
if (limit > pos) /* search forward */
{
val = Fnext_single_property_change (make_number (pos), Qcomposition,
object, make_number (limit));
pos = XINT (val);
if (pos == limit)
return 0;
}
else /* search backward */
{
if (get_property_and_range (pos - 1, Qcomposition, prop, start, end,
object))
return 1;
val = Fprevious_single_property_change (make_number (pos), Qcomposition,
object, make_number (limit));
pos = XINT (val);
if (pos == limit)
return 0;
pos--;
}
get_property_and_range (pos, Qcomposition, prop, start, end, object);
return 1;
}
/* Run a proper function to adjust the composition sitting between
FROM and TO with property PROP. */
static void
run_composition_function (ptrdiff_t from, ptrdiff_t to, Lisp_Object prop)
{
Lisp_Object func;
ptrdiff_t start, end;
func = COMPOSITION_MODIFICATION_FUNC (prop);
/* If an invalid composition precedes or follows, try to make them
valid too. */
if (from > BEGV
&& find_composition (from - 1, -1, &start, &end, &prop, Qnil)
&& !COMPOSITION_VALID_P (start, end, prop))
from = start;
if (to < ZV
&& find_composition (to, -1, &start, &end, &prop, Qnil)
&& !COMPOSITION_VALID_P (start, end, prop))
to = end;
if (!NILP (Ffboundp (func)))
call2 (func, make_number (from), make_number (to));
}
/* Make invalid compositions adjacent to or inside FROM and TO valid.
CHECK_MASK is bitwise `or' of mask bits defined by macros
CHECK_XXX (see the comment in composite.h).
It also resets the text-property `auto-composed' to a proper region
so that automatic character composition works correctly later while
displaying the region.
This function is called when a buffer text is changed. If the
change is deletion, FROM == TO. Otherwise, FROM < TO. */
void
update_compositions (ptrdiff_t from, ptrdiff_t to, int check_mask)
{
Lisp_Object prop;
ptrdiff_t start, end;
/* The beginning and end of the region to set the property
`auto-composed' to nil. */
ptrdiff_t min_pos = from, max_pos = to;
if (inhibit_modification_hooks)
return;
/* If FROM and TO are not in a valid range, do nothing. */
if (! (BEGV <= from && from <= to && to <= ZV))
return;
if (check_mask & CHECK_HEAD)
{
/* FROM should be at composition boundary. But, insertion or
deletion will make two compositions adjacent and
indistinguishable when they have same (eq) property. To
avoid it, in such a case, we change the property of the
latter to the copy of it. */
if (from > BEGV
&& find_composition (from - 1, -1, &start, &end, &prop, Qnil)
&& COMPOSITION_VALID_P (start, end, prop))
{
min_pos = start;
if (end > to)
max_pos = end;
if (from < end)
Fput_text_property (make_number (from), make_number (end),
Qcomposition,
Fcons (XCAR (prop), XCDR (prop)), Qnil);
run_composition_function (start, end, prop);
from = end;
}
else if (from < ZV
&& find_composition (from, -1, &start, &from, &prop, Qnil)
&& COMPOSITION_VALID_P (start, from, prop))
{
if (from > to)
max_pos = from;
run_composition_function (start, from, prop);
}
}
if (check_mask & CHECK_INSIDE)
{
/* In this case, we are sure that (check & CHECK_TAIL) is also
nonzero. Thus, here we should check only compositions before
(to - 1). */
while (from < to - 1
&& find_composition (from, to, &start, &from, &prop, Qnil)
&& COMPOSITION_VALID_P (start, from, prop)
&& from < to - 1)
run_composition_function (start, from, prop);
}
if (check_mask & CHECK_TAIL)
{
if (from < to
&& find_composition (to - 1, -1, &start, &end, &prop, Qnil)
&& COMPOSITION_VALID_P (start, end, prop))
{
/* TO should be also at composition boundary. But,
insertion or deletion will make two compositions adjacent
and indistinguishable when they have same (eq) property.
To avoid it, in such a case, we change the property of
the former to the copy of it. */
if (to < end)
{
Fput_text_property (make_number (start), make_number (to),
Qcomposition,
Fcons (XCAR (prop), XCDR (prop)), Qnil);
max_pos = end;
}
run_composition_function (start, end, prop);
}
else if (to < ZV
&& find_composition (to, -1, &start, &end, &prop, Qnil)
&& COMPOSITION_VALID_P (start, end, prop))
{
run_composition_function (start, end, prop);
max_pos = end;
}
}
if (min_pos < max_pos)
{
ptrdiff_t count = SPECPDL_INDEX ();
specbind (Qinhibit_read_only, Qt);
specbind (Qinhibit_modification_hooks, Qt);
specbind (Qinhibit_point_motion_hooks, Qt);
Fremove_list_of_text_properties (make_number (min_pos),
make_number (max_pos),
Fcons (Qauto_composed, Qnil), Qnil);
unbind_to (count, Qnil);
}
}
/* Modify composition property values in LIST destructively. LIST is
a list as returned from text_property_list. Change values to the
top-level copies of them so that none of them are `eq'. */
void
make_composition_value_copy (Lisp_Object list)
{
Lisp_Object plist, val;
for (; CONSP (list); list = XCDR (list))
{
plist = XCAR (XCDR (XCDR (XCAR (list))));
while (CONSP (plist) && CONSP (XCDR (plist)))
{
if (EQ (XCAR (plist), Qcomposition)
&& (val = XCAR (XCDR (plist)), CONSP (val)))
XSETCAR (XCDR (plist), Fcons (XCAR (val), XCDR (val)));
plist = XCDR (XCDR (plist));
}
}
}
/* Make text in the region between START and END a composition that
has COMPONENTS and MODIFICATION-FUNC.
If STRING is non-nil, then operate on characters contained between
indices START and END in STRING. */
void
compose_text (ptrdiff_t start, ptrdiff_t end, Lisp_Object components,
Lisp_Object modification_func, Lisp_Object string)
{
Lisp_Object prop;
prop = Fcons (Fcons (make_number (end - start), components),
modification_func);
Fput_text_property (make_number (start), make_number (end),
Qcomposition, prop, string);
}
static Lisp_Object autocmp_chars (Lisp_Object, ptrdiff_t, ptrdiff_t,
ptrdiff_t, struct window *,
struct face *, Lisp_Object);
/* Lisp glyph-string handlers */
/* Hash table for automatic composition. The key is a header of a
lgstring (Lispy glyph-string), and the value is a body of a
lgstring. */
static Lisp_Object gstring_hash_table;
static Lisp_Object gstring_lookup_cache (Lisp_Object);
static Lisp_Object
gstring_lookup_cache (Lisp_Object header)
{
struct Lisp_Hash_Table *h = XHASH_TABLE (gstring_hash_table);
ptrdiff_t i = hash_lookup (h, header, NULL);
return (i >= 0 ? HASH_VALUE (h, i) : Qnil);
}
Lisp_Object
composition_gstring_put_cache (Lisp_Object gstring, ptrdiff_t len)
{
struct Lisp_Hash_Table *h = XHASH_TABLE (gstring_hash_table);
EMACS_UINT hash;
Lisp_Object header, copy;
ptrdiff_t i;
header = LGSTRING_HEADER (gstring);
hash = h->hashfn (h, header);
if (len < 0)
{
ptrdiff_t j, glyph_len = LGSTRING_GLYPH_LEN (gstring);
for (j = 0; j < glyph_len; j++)
if (NILP (LGSTRING_GLYPH (gstring, j)))
break;
len = j;
}
lint_assume (len <= TYPE_MAXIMUM (ptrdiff_t) - 2);
copy = Fmake_vector (make_number (len + 2), Qnil);
LGSTRING_SET_HEADER (copy, Fcopy_sequence (header));
for (i = 0; i < len; i++)
LGSTRING_SET_GLYPH (copy, i, Fcopy_sequence (LGSTRING_GLYPH (gstring, i)));
i = hash_put (h, LGSTRING_HEADER (copy), copy, hash);
LGSTRING_SET_ID (copy, make_number (i));
return copy;
}
Lisp_Object
composition_gstring_from_id (ptrdiff_t id)
{
struct Lisp_Hash_Table *h = XHASH_TABLE (gstring_hash_table);
return HASH_VALUE (h, id);
}
static Lisp_Object fill_gstring_header (Lisp_Object, Lisp_Object,
Lisp_Object, Lisp_Object,
Lisp_Object);
bool
composition_gstring_p (Lisp_Object gstring)
{
Lisp_Object header;
ptrdiff_t i;
if (! VECTORP (gstring) || ASIZE (gstring) < 2)
return 0;
header = LGSTRING_HEADER (gstring);
if (! VECTORP (header) || ASIZE (header) < 2)
return 0;
if (! NILP (LGSTRING_FONT (gstring))
&& (! FONT_OBJECT_P (LGSTRING_FONT (gstring))
&& ! CODING_SYSTEM_P (LGSTRING_FONT (gstring))))
return 0;
for (i = 1; i < ASIZE (LGSTRING_HEADER (gstring)); i++)
if (! NATNUMP (AREF (LGSTRING_HEADER (gstring), i)))
return 0;
if (! NILP (LGSTRING_ID (gstring)) && ! NATNUMP (LGSTRING_ID (gstring)))
return 0;
for (i = 0; i < LGSTRING_GLYPH_LEN (gstring); i++)
{
Lisp_Object glyph = LGSTRING_GLYPH (gstring, i);
if (NILP (glyph))
break;
if (! VECTORP (glyph) || ASIZE (glyph) != LGLYPH_SIZE)
return 0;
}
return 1;
}
int
composition_gstring_width (Lisp_Object gstring, ptrdiff_t from, ptrdiff_t to,
struct font_metrics *metrics)
{
Lisp_Object *glyph;
int width = 0;
if (metrics)
{
Lisp_Object font_object = LGSTRING_FONT (gstring);
if (FONT_OBJECT_P (font_object))
{
struct font *font = XFONT_OBJECT (font_object);
metrics->ascent = font->ascent;
metrics->descent = font->descent;
}
else
{
metrics->ascent = 1;
metrics->descent = 0;
}
metrics->width = metrics->lbearing = metrics->rbearing = 0;
}
for (glyph = lgstring_glyph_addr (gstring, from); from < to; from++, glyph++)
{
int x;
if (NILP (LGLYPH_ADJUSTMENT (*glyph)))
width += LGLYPH_WIDTH (*glyph);
else
width += LGLYPH_WADJUST (*glyph);
if (metrics)
{
x = metrics->width + LGLYPH_LBEARING (*glyph) + LGLYPH_XOFF (*glyph);
if (metrics->lbearing > x)
metrics->lbearing = x;
x = metrics->width + LGLYPH_RBEARING (*glyph) + LGLYPH_XOFF (*glyph);
if (metrics->rbearing < x)
metrics->rbearing = x;
metrics->width = width;
x = LGLYPH_ASCENT (*glyph) - LGLYPH_YOFF (*glyph);
if (metrics->ascent < x)
metrics->ascent = x;
x = LGLYPH_DESCENT (*glyph) + LGLYPH_YOFF (*glyph);
if (metrics->descent < x)
metrics->descent = x;
}
}
return width;
}
static Lisp_Object gstring_work;
static Lisp_Object gstring_work_headers;
static Lisp_Object
fill_gstring_header (Lisp_Object header, Lisp_Object start, Lisp_Object end, Lisp_Object font_object, Lisp_Object string)
{
ptrdiff_t from, to, from_byte;
ptrdiff_t len, i;
if (NILP (string))
{
if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
error ("Attempt to shape unibyte text");
validate_region (&start, &end);
from = XFASTINT (start);
to = XFASTINT (end);
from_byte = CHAR_TO_BYTE (from);
}
else
{
CHECK_STRING (string);
if (! STRING_MULTIBYTE (string))
error ("Attempt to shape unibyte text");
/* The caller checks that START and END are nonnegative integers. */
if (! (XINT (start) <= XINT (end) && XINT (end) <= SCHARS (string)))
args_out_of_range_3 (string, start, end);
from = XINT (start);
to = XINT (end);
from_byte = string_char_to_byte (string, from);
}
len = to - from;
if (len == 0)
error ("Attempt to shape zero-length text");
if (VECTORP (header))
{
if (ASIZE (header) != len + 1)
args_out_of_range (header, make_number (len + 1));
}
else
{
if (len <= 8)
header = AREF (gstring_work_headers, len - 1);
else
header = Fmake_vector (make_number (len + 1), Qnil);
}
ASET (header, 0, font_object);
for (i = 0; i < len; i++)
{
int c;
if (NILP (string))
FETCH_CHAR_ADVANCE_NO_CHECK (c, from, from_byte);
else
FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, string, from, from_byte);
ASET (header, i + 1, make_number (c));
}
return header;
}
static void
fill_gstring_body (Lisp_Object gstring)
{
Lisp_Object font_object = LGSTRING_FONT (gstring);
Lisp_Object header = AREF (gstring, 0);
ptrdiff_t len = LGSTRING_CHAR_LEN (gstring);
ptrdiff_t i;
for (i = 0; i < len; i++)
{
Lisp_Object g = LGSTRING_GLYPH (gstring, i);
int c = XFASTINT (AREF (header, i + 1));
if (NILP (g))
{
g = LGLYPH_NEW ();
LGSTRING_SET_GLYPH (gstring, i, g);
}
LGLYPH_SET_FROM (g, i);
LGLYPH_SET_TO (g, i);
LGLYPH_SET_CHAR (g, c);
if (FONT_OBJECT_P (font_object))
{
font_fill_lglyph_metrics (g, font_object);
}
else
{
int width = XFASTINT (CHAR_TABLE_REF (Vchar_width_table, c));
LGLYPH_SET_CODE (g, c);
LGLYPH_SET_LBEARING (g, 0);
LGLYPH_SET_RBEARING (g, width);
LGLYPH_SET_WIDTH (g, width);
LGLYPH_SET_ASCENT (g, 1);
LGLYPH_SET_DESCENT (g, 0);
}
LGLYPH_SET_ADJUSTMENT (g, Qnil);
}
if (i < LGSTRING_GLYPH_LEN (gstring))
LGSTRING_SET_GLYPH (gstring, i, Qnil);
}
/* Try to compose the characters at CHARPOS according to composition
rule RULE (either [PATTERN PREV-CHARS FUNC] or [PATTERN PREV-CHARS
FUNC FONT-POS]). LIMIT limits the characters to compose. STRING,
if not nil, is a target string. WIN is a window where the
characters are being displayed. If characters are successfully
composed, return the composition as a glyph-string object.
Otherwise return nil. */
static Lisp_Object
autocmp_chars (Lisp_Object rule, ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t limit, struct window *win, struct face *face, Lisp_Object string)
{
ptrdiff_t count = SPECPDL_INDEX ();
FRAME_PTR f = XFRAME (win->frame);
Lisp_Object pos = make_number (charpos);
ptrdiff_t to;
ptrdiff_t pt = PT, pt_byte = PT_BYTE;
Lisp_Object re, font_object, lgstring;
ptrdiff_t len;
record_unwind_save_match_data ();
re = AREF (rule, 0);
if (NILP (re))
len = 1;
else if (! STRINGP (re))
return unbind_to (count, Qnil);
else if ((len = fast_looking_at (re, charpos, bytepos, limit, -1, string))
> 0)
{
if (NILP (string))
len = BYTE_TO_CHAR (bytepos + len) - charpos;
else
len = string_byte_to_char (string, bytepos + len) - charpos;
}
if (len <= 0)
return unbind_to (count, Qnil);
to = limit = charpos + len;
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
{
bool use_font_pos = 0;
if (ASIZE (rule) == 4 && INTEGERP (AREF (rule, 3)))
{
ptrdiff_t offset = XINT (AREF (rule, 1)) + XINT (AREF (rule, 3));
if (offset >= 0 && offset < len)
{
charpos += offset;
to = charpos + 1;
use_font_pos = 1;
}
}
font_object = font_range (charpos, &to, win, face, string);
if (! FONT_OBJECT_P (font_object)
|| (! use_font_pos
&& ! NILP (re)
&& to < limit
&& (fast_looking_at (re, charpos, bytepos, to, -1, string) <= 0)))
return unbind_to (count, Qnil);
if (use_font_pos)
to = limit;
}
else
#endif /* not HAVE_WINDOW_SYSTEM */
font_object = win->frame;
lgstring = Fcomposition_get_gstring (pos, make_number (to), font_object,
string);
if (NILP (LGSTRING_ID (lgstring)))
{
/* Save point as marker before calling out to lisp. */
if (NILP (string))
record_unwind_protect (restore_point_unwind,
build_marker (current_buffer, pt, pt_byte));
lgstring = safe_call (6, Vauto_composition_function, AREF (rule, 2),
pos, make_number (to), font_object, string);
}
return unbind_to (count, lgstring);
}
static Lisp_Object _work_val;
/* 1 iff the character C is composable. Characters of general
category Z? or C? are not composable except for ZWNJ and ZWJ. */
#define CHAR_COMPOSABLE_P(C) \
((C) > ' ' \
&& ((C) == 0x200C || (C) == 0x200D \
|| (_work_val = CHAR_TABLE_REF (Vunicode_category_table, (C)), \
(INTEGERP (_work_val) \
&& (XINT (_work_val) <= UNICODE_CATEGORY_So)))))
/* Update cmp_it->stop_pos to the next position after CHARPOS (and
BYTEPOS) where character composition may happen. If BYTEPOS is
negative, compute it. ENDPOS is a limit of searching. If it is
less than CHARPOS, search backward to ENDPOS+1 assuming that
set_iterator_to_next works in reverse order. In this case, if a
composition closest to CHARPOS is found, set cmp_it->stop_pos to
the last character of the composition.
If no composition is found, set cmp_it->ch to -2. If a static
composition is found, set cmp_it->ch to -1. Otherwise, set