1 /* Basic character set support.
2 Copyright (C) 1995, 97, 98, 2000, 2001 Electrotechnical Laboratory, JAPAN.
3 Licensed to the Free Software Foundation.
4 Copyright (C) 2001 Free Software Foundation, Inc.
6 National Institute of Advanced Industrial Science and Technology (AIST)
7 Registration Number H13PRO009
9 This file is part of GNU Emacs.
11 GNU Emacs is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2, or (at your option)
16 GNU Emacs is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with GNU Emacs; see the file COPYING. If not, write to
23 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 Boston, MA 02111-1307, USA. */
31 #include <sys/types.h>
33 #include "character.h"
39 /*** GENERAL NOTES on CODED CHARACTER SETS (CHARSETS) ***
41 A coded character set ("charset" hereafter) is a meaningful
42 collection (i.e. language, culture, functionality, etc.) of
43 characters. Emacs handles multiple charsets at once. In Emacs Lisp
44 code, a charset is represented by a symbol. In C code, a charset is
45 represented by its ID number or by a pointer to a struct charset.
47 The actual information about each charset is stored in two places.
48 Lispy information is stored in the hash table Vcharset_hash_table as
49 a vector (charset attributes). The other information is stored in
50 charset_table as a struct charset.
54 /* List of all charsets. This variable is used only from Emacs
56 Lisp_Object Vcharset_list
;
58 /* Hash table that contains attributes of each charset. Keys are
59 charset symbols, and values are vectors of charset attributes. */
60 Lisp_Object Vcharset_hash_table
;
62 /* Table of struct charset. */
63 struct charset
*charset_table
;
65 static int charset_table_size
;
66 int charset_table_used
;
68 Lisp_Object Qcharsetp
;
70 /* Special charset symbols. */
72 Lisp_Object Qeight_bit
;
73 Lisp_Object Qiso_8859_1
;
76 /* The corresponding charsets. */
78 int charset_eight_bit
;
79 int charset_iso_8859_1
;
82 /* The other special charsets. */
83 int charset_jisx0201_roman
;
84 int charset_jisx0208_1978
;
87 /* Value of charset attribute `charset-iso-plane'. */
90 /* Charset of unibyte characters. */
93 /* List of charsets ordered by the priority. */
94 Lisp_Object Vcharset_ordered_list
;
96 /* Incremented everytime we change Vcharset_ordered_list. This is
97 unsigned short so that it fits in Lisp_Int and never matches
99 unsigned short charset_ordered_list_tick
;
101 /* List of iso-2022 charsets. */
102 Lisp_Object Viso_2022_charset_list
;
104 /* List of emacs-mule charsets. */
105 Lisp_Object Vemacs_mule_charset_list
;
107 struct charset
*emacs_mule_charset
[256];
109 /* Mapping table from ISO2022's charset (specified by DIMENSION,
110 CHARS, and FINAL-CHAR) to Emacs' charset. */
111 int iso_charset_table
[ISO_MAX_DIMENSION
][ISO_MAX_CHARS
][ISO_MAX_FINAL
];
113 Lisp_Object Vcharset_map_directory
;
115 Lisp_Object Vchar_unified_charset_table
;
117 /* Defined in chartab.c */
119 map_char_table_for_charset
P_ ((void (*c_function
) (Lisp_Object
, Lisp_Object
),
120 Lisp_Object function
, Lisp_Object table
,
121 Lisp_Object arg
, struct charset
*charset
,
122 unsigned from
, unsigned to
));
124 #define CODE_POINT_TO_INDEX(charset, code) \
125 ((charset)->code_linear_p \
126 ? (code) - (charset)->min_code \
127 : (((charset)->code_space_mask[(code) >> 24] & 0x8) \
128 && ((charset)->code_space_mask[((code) >> 16) & 0xFF] & 0x4) \
129 && ((charset)->code_space_mask[((code) >> 8) & 0xFF] & 0x2) \
130 && ((charset)->code_space_mask[(code) & 0xFF] & 0x1)) \
131 ? (((((code) >> 24) - (charset)->code_space[12]) \
132 * (charset)->code_space[11]) \
133 + (((((code) >> 16) & 0xFF) - (charset)->code_space[8]) \
134 * (charset)->code_space[7]) \
135 + (((((code) >> 8) & 0xFF) - (charset)->code_space[4]) \
136 * (charset)->code_space[3]) \
137 + (((code) & 0xFF) - (charset)->code_space[0]) \
138 - ((charset)->char_index_offset)) \
142 /* Convert the character index IDX to code-point CODE for CHARSET.
143 It is assumed that IDX is in a valid range. */
145 #define INDEX_TO_CODE_POINT(charset, idx) \
146 ((charset)->code_linear_p \
147 ? (idx) + (charset)->min_code \
148 : (idx += (charset)->char_index_offset, \
149 (((charset)->code_space[0] + (idx) % (charset)->code_space[2]) \
150 | (((charset)->code_space[4] \
151 + ((idx) / (charset)->code_space[3] % (charset)->code_space[6])) \
153 | (((charset)->code_space[8] \
154 + ((idx) / (charset)->code_space[7] % (charset)->code_space[10])) \
156 | (((charset)->code_space[12] + ((idx) / (charset)->code_space[11])) \
162 /* Set to 1 to warn that a charset map is loaded and thus a buffer
163 text and a string data may be relocated. */
164 int charset_map_loaded
;
166 struct charset_map_entries
172 struct charset_map_entries
*next
;
175 /* Load the mapping information for CHARSET from ENTRIES.
177 If CONTROL_FLAG is 0, setup CHARSET->min_char and CHARSET->max_char.
179 If CONTROL_FLAG is 1, setup CHARSET->min_char, CHARSET->max_char,
180 CHARSET->decoder, and CHARSET->encoder.
182 If CONTROL_FLAG is 2, setup CHARSET->deunifier and
183 Vchar_unify_table. If Vchar_unified_charset_table is non-nil,
187 load_charset_map (charset
, entries
, n_entries
, control_flag
)
188 struct charset
*charset
;
189 struct charset_map_entries
*entries
;
193 Lisp_Object vec
, table
;
194 unsigned max_code
= CHARSET_MAX_CODE (charset
);
195 int ascii_compatible_p
= charset
->ascii_compatible_p
;
196 int min_char
, max_char
, nonascii_min_char
;
198 unsigned char *fast_map
= charset
->fast_map
;
203 if (control_flag
> 0)
205 int n
= CODE_POINT_TO_INDEX (charset
, max_code
) + 1;
207 table
= Fmake_char_table (Qnil
, Qnil
);
208 if (control_flag
== 1)
209 vec
= Fmake_vector (make_number (n
), make_number (-1));
210 else if (! CHAR_TABLE_P (Vchar_unify_table
))
211 Vchar_unify_table
= Fmake_char_table (Qnil
, Qnil
);
213 charset_map_loaded
= 1;
216 min_char
= max_char
= entries
->entry
[0].c
;
217 nonascii_min_char
= MAX_CHAR
;
218 for (i
= 0; i
< n_entries
; i
++)
221 int from_index
, to_index
;
223 int idx
= i
% 0x10000;
225 if (i
> 0 && idx
== 0)
226 entries
= entries
->next
;
227 from
= entries
->entry
[idx
].from
;
228 to
= entries
->entry
[idx
].to
;
229 from_c
= entries
->entry
[idx
].c
;
230 from_index
= CODE_POINT_TO_INDEX (charset
, from
);
233 to_index
= from_index
;
238 to_index
= CODE_POINT_TO_INDEX (charset
, to
);
239 to_c
= from_c
+ (to_index
- from_index
);
241 if (from_index
< 0 || to_index
< 0)
244 if (control_flag
< 2)
250 else if (from_c
< min_char
)
252 if (ascii_compatible_p
)
254 if (! ASCII_BYTE_P (from_c
))
256 if (from_c
< nonascii_min_char
)
257 nonascii_min_char
= from_c
;
259 else if (! ASCII_BYTE_P (to_c
))
261 nonascii_min_char
= 0x80;
265 for (c
= from_c
; c
<= to_c
; c
++)
266 CHARSET_FAST_MAP_SET (c
, fast_map
);
268 if (control_flag
== 1)
270 unsigned code
= from
;
272 if (CHARSET_COMPACT_CODES_P (charset
))
275 ASET (vec
, from_index
, make_number (from_c
));
276 if (NILP (CHAR_TABLE_REF (table
, from_c
)))
277 CHAR_TABLE_SET (table
, from_c
, make_number (code
));
278 if (from_index
== to_index
)
280 from_index
++, from_c
++;
281 code
= INDEX_TO_CODE_POINT (charset
, from_index
);
284 for (; from_index
<= to_index
; from_index
++, from_c
++)
286 ASET (vec
, from_index
, make_number (from_c
));
287 if (NILP (CHAR_TABLE_REF (table
, from_c
)))
288 CHAR_TABLE_SET (table
, from_c
, make_number (from_index
));
294 unsigned code
= from
;
298 int c1
= DECODE_CHAR (charset
, code
);
302 CHAR_TABLE_SET (table
, from_c
, make_number (c1
));
303 CHAR_TABLE_SET (Vchar_unify_table
, c1
, make_number (from_c
));
304 if (CHAR_TABLE_P (Vchar_unified_charset_table
))
305 CHAR_TABLE_SET (Vchar_unified_charset_table
, c1
,
306 CHARSET_NAME (charset
));
308 if (from_index
== to_index
)
310 from_index
++, from_c
++;
311 code
= INDEX_TO_CODE_POINT (charset
, from_index
);
316 if (control_flag
< 2)
318 CHARSET_MIN_CHAR (charset
) = (ascii_compatible_p
319 ? nonascii_min_char
: min_char
);
320 CHARSET_MAX_CHAR (charset
) = max_char
;
321 if (control_flag
== 1)
323 CHARSET_DECODER (charset
) = vec
;
324 CHARSET_ENCODER (charset
) = table
;
328 CHARSET_DEUNIFIER (charset
) = table
;
332 /* Read a hexadecimal number (preceded by "0x") from the file FP while
333 paying attention to comment charcter '#'. */
335 static INLINE
unsigned
343 while ((c
= getc (fp
)) != EOF
)
347 while ((c
= getc (fp
)) != EOF
&& c
!= '\n');
351 if ((c
= getc (fp
)) == EOF
|| c
== 'x')
363 while ((c
= getc (fp
)) != EOF
&& isxdigit (c
))
365 | (c
<= '9' ? c
- '0' : c
<= 'F' ? c
- 'A' + 10 : c
- 'a' + 10));
367 while ((c
= getc (fp
)) != EOF
&& isdigit (c
))
368 n
= (n
* 10) + c
- '0';
375 /* Return a mapping vector for CHARSET loaded from MAPFILE.
376 Each line of MAPFILE has this form
378 where 0xAAAA is a code-point and 0xCCCC is the corresponding
379 character code, or this form
381 where 0xAAAA and 0xBBBB are code-points specifying a range, and
382 0xCCCC is the first character code of the range.
384 The returned vector has this form:
385 [ CODE1 CHAR1 CODE2 CHAR2 .... ]
386 where CODE1 is a code-point or a cons of code-points specifying a
389 extern void add_to_log
P_ ((char *, Lisp_Object
, Lisp_Object
));
392 load_charset_map_from_file (charset
, mapfile
, control_flag
)
393 struct charset
*charset
;
397 unsigned min_code
= CHARSET_MIN_CODE (charset
);
398 unsigned max_code
= CHARSET_MAX_CODE (charset
);
402 Lisp_Object suffixes
;
403 struct charset_map_entries
*head
, *entries
;
406 suffixes
= Fcons (build_string (".map"),
407 Fcons (build_string (".TXT"), Qnil
));
409 fd
= openp (Fcons (Vcharset_map_directory
, Qnil
), mapfile
, suffixes
,
412 || ! (fp
= fdopen (fd
, "r")))
414 add_to_log ("Failure in loading charset map: %S", mapfile
, Qnil
);
418 head
= entries
= ((struct charset_map_entries
*)
419 alloca (sizeof (struct charset_map_entries
)));
428 from
= read_hex (fp
, &eof
);
431 if (getc (fp
) == '-')
432 to
= read_hex (fp
, &eof
);
435 c
= (int) read_hex (fp
, &eof
);
437 if (from
< min_code
|| to
> max_code
|| from
> to
|| c
> MAX_CHAR
)
440 if (n_entries
> 0 && (n_entries
% 0x10000) == 0)
442 entries
->next
= ((struct charset_map_entries
*)
443 alloca (sizeof (struct charset_map_entries
)));
444 entries
= entries
->next
;
446 idx
= n_entries
% 0x10000;
447 entries
->entry
[idx
].from
= from
;
448 entries
->entry
[idx
].to
= to
;
449 entries
->entry
[idx
].c
= c
;
455 load_charset_map (charset
, head
, n_entries
, control_flag
);
459 load_charset_map_from_vector (charset
, vec
, control_flag
)
460 struct charset
*charset
;
464 unsigned min_code
= CHARSET_MIN_CODE (charset
);
465 unsigned max_code
= CHARSET_MAX_CODE (charset
);
466 struct charset_map_entries
*head
, *entries
;
468 int len
= ASIZE (vec
);
473 add_to_log ("Failure in loading charset map: %V", vec
, Qnil
);
477 head
= entries
= ((struct charset_map_entries
*)
478 alloca (sizeof (struct charset_map_entries
)));
480 for (i
= 0; i
< len
; i
+= 2)
482 Lisp_Object val
, val2
;
494 from
= XFASTINT (val
);
495 to
= XFASTINT (val2
);
500 from
= to
= XFASTINT (val
);
502 val
= AREF (vec
, i
+ 1);
506 if (from
< min_code
|| to
> max_code
|| from
> to
|| c
> MAX_CHAR
)
509 if ((n_entries
% 0x10000) == 0)
511 entries
->next
= ((struct charset_map_entries
*)
512 alloca (sizeof (struct charset_map_entries
)));
513 entries
= entries
->next
;
515 idx
= n_entries
% 0x10000;
516 entries
->entry
[idx
].from
= from
;
517 entries
->entry
[idx
].to
= to
;
518 entries
->entry
[idx
].c
= c
;
522 load_charset_map (charset
, head
, n_entries
, control_flag
);
526 load_charset (charset
)
527 struct charset
*charset
;
529 if (CHARSET_METHOD (charset
) == CHARSET_METHOD_MAP_DEFERRED
)
533 map
= CHARSET_MAP (charset
);
535 load_charset_map_from_file (charset
, map
, 1);
537 load_charset_map_from_vector (charset
, map
, 1);
538 CHARSET_METHOD (charset
) = CHARSET_METHOD_MAP
;
543 DEFUN ("charsetp", Fcharsetp
, Scharsetp
, 1, 1, 0,
544 doc
: /* Return non-nil if and only if OBJECT is a charset.*/)
548 return (CHARSETP (object
) ? Qt
: Qnil
);
553 map_charset_chars (c_function
, function
, arg
,
555 void (*c_function
) P_ ((Lisp_Object
, Lisp_Object
));
556 Lisp_Object function
, arg
;
557 struct charset
*charset
;
563 if (CHARSET_METHOD (charset
) == CHARSET_METHOD_MAP_DEFERRED
)
564 load_charset (charset
);
566 partial
= (from
> CHARSET_MIN_CODE (charset
)
567 || to
< CHARSET_MAX_CODE (charset
));
569 if (CHARSET_UNIFIED_P (charset
)
570 && CHAR_TABLE_P (CHARSET_DEUNIFIER (charset
)))
572 map_char_table_for_charset (c_function
, function
,
573 CHARSET_DEUNIFIER (charset
), arg
,
574 partial
? charset
: NULL
, from
, to
);
577 if (CHARSET_METHOD (charset
) == CHARSET_METHOD_OFFSET
)
579 int from_idx
= CODE_POINT_TO_INDEX (charset
, from
);
580 int to_idx
= CODE_POINT_TO_INDEX (charset
, to
);
581 int from_c
= from_idx
+ CHARSET_CODE_OFFSET (charset
);
582 int to_c
= to_idx
+ CHARSET_CODE_OFFSET (charset
);
584 range
= Fcons (make_number (from_c
), make_number (to_c
));
586 (*c_function
) (range
, arg
);
588 call2 (function
, range
, arg
);
590 else if (CHARSET_METHOD (charset
) == CHARSET_METHOD_MAP
)
592 if (! CHAR_TABLE_P (CHARSET_ENCODER (charset
)))
594 if (CHARSET_ASCII_COMPATIBLE_P (charset
) && from
<= 127)
596 range
= Fcons (make_number (from
), make_number (to
));
598 XSETCAR (range
, make_number (127));
601 (*c_function
) (range
, arg
);
603 call2 (function
, range
, arg
);
605 map_char_table_for_charset (c_function
, function
,
606 CHARSET_ENCODER (charset
), arg
,
607 partial
? charset
: NULL
, from
, to
);
609 else if (CHARSET_METHOD (charset
) == CHARSET_METHOD_SUBSET
)
611 Lisp_Object subset_info
;
614 subset_info
= CHARSET_SUBSET (charset
);
615 charset
= CHARSET_FROM_ID (XFASTINT (AREF (subset_info
, 0)));
616 offset
= XINT (AREF (subset_info
, 3));
618 if (from
< XFASTINT (AREF (subset_info
, 1)))
619 from
= XFASTINT (AREF (subset_info
, 1));
621 if (to
> XFASTINT (AREF (subset_info
, 2)))
622 to
= XFASTINT (AREF (subset_info
, 2));
623 map_charset_chars (c_function
, function
, arg
, charset
, from
, to
);
625 else /* i.e. CHARSET_METHOD_SUPERSET */
629 for (parents
= CHARSET_SUPERSET (charset
); CONSP (parents
);
630 parents
= XCDR (parents
))
633 unsigned this_from
, this_to
;
635 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (XCAR (parents
))));
636 offset
= XINT (XCDR (XCAR (parents
)));
637 this_from
= from
- offset
;
638 this_to
= to
- offset
;
639 if (this_from
< CHARSET_MIN_CODE (charset
))
640 this_from
= CHARSET_MIN_CODE (charset
);
641 if (this_to
> CHARSET_MAX_CODE (charset
))
642 this_to
= CHARSET_MAX_CODE (charset
);
643 map_charset_chars (c_function
, function
, arg
, charset
, from
, to
);
648 DEFUN ("map-charset-chars", Fmap_charset_chars
, Smap_charset_chars
, 2, 5, 0,
649 doc
: /* Call FUNCTION for all characters in CHARSET.
650 FUNCTION is called with an argument RANGE and the optional 3rd
653 RANGE is a cons (FROM . TO), where FROM and TO indicate a range of
654 characters contained in CHARSET.
656 The optional 4th and 5th arguments FROM-CODE and TO-CODE specify the
657 range of code points of target characters. */)
658 (function
, charset
, arg
, from_code
, to_code
)
659 Lisp_Object function
, charset
, arg
, from_code
, to_code
;
664 CHECK_CHARSET_GET_CHARSET (charset
, cs
);
665 if (NILP (from_code
))
666 from
= CHARSET_MIN_CODE (cs
);
669 CHECK_NATNUM (from_code
);
670 from
= XINT (from_code
);
671 if (from
< CHARSET_MIN_CODE (cs
))
672 from
= CHARSET_MIN_CODE (cs
);
675 to
= CHARSET_MAX_CODE (cs
);
678 CHECK_NATNUM (to_code
);
680 if (to
> CHARSET_MAX_CODE (cs
))
681 to
= CHARSET_MAX_CODE (cs
);
683 map_charset_chars (NULL
, function
, arg
, cs
, from
, to
);
688 /* Define a charset according to the arguments. The Nth argument is
689 the Nth attribute of the charset (the last attribute `charset-id'
690 is not included). See the docstring of `define-charset' for the
693 DEFUN ("define-charset-internal", Fdefine_charset_internal
,
694 Sdefine_charset_internal
, charset_arg_max
, MANY
, 0,
695 doc
: /* For internal use only.
696 usage: (define-charset-internal ...) */)
701 /* Charset attr vector. */
705 struct Lisp_Hash_Table
*hash_table
= XHASH_TABLE (Vcharset_hash_table
);
707 struct charset charset
;
710 int new_definition_p
;
713 if (nargs
!= charset_arg_max
)
714 return Fsignal (Qwrong_number_of_arguments
,
715 Fcons (intern ("define-charset-internal"),
716 make_number (nargs
)));
718 attrs
= Fmake_vector (make_number (charset_attr_max
), Qnil
);
720 CHECK_SYMBOL (args
[charset_arg_name
]);
721 ASET (attrs
, charset_name
, args
[charset_arg_name
]);
723 val
= args
[charset_arg_code_space
];
724 for (i
= 0, dimension
= 0, nchars
= 1; i
< 4; i
++)
726 int min_byte
, max_byte
;
728 min_byte
= XINT (Faref (val
, make_number (i
* 2)));
729 max_byte
= XINT (Faref (val
, make_number (i
* 2 + 1)));
730 if (min_byte
< 0 || min_byte
> max_byte
|| max_byte
>= 256)
731 error ("Invalid :code-space value");
732 charset
.code_space
[i
* 4] = min_byte
;
733 charset
.code_space
[i
* 4 + 1] = max_byte
;
734 charset
.code_space
[i
* 4 + 2] = max_byte
- min_byte
+ 1;
735 nchars
*= charset
.code_space
[i
* 4 + 2];
736 charset
.code_space
[i
* 4 + 3] = nchars
;
741 val
= args
[charset_arg_dimension
];
743 charset
.dimension
= dimension
;
747 charset
.dimension
= XINT (val
);
748 if (charset
.dimension
< 1 || charset
.dimension
> 4)
749 args_out_of_range_3 (val
, make_number (1), make_number (4));
752 charset
.code_linear_p
753 = (charset
.dimension
== 1
754 || (charset
.code_space
[2] == 256
755 && (charset
.dimension
== 2
756 || (charset
.code_space
[6] == 256
757 && (charset
.dimension
== 3
758 || charset
.code_space
[10] == 256)))));
760 if (! charset
.code_linear_p
)
762 charset
.code_space_mask
= (unsigned char *) xmalloc (256);
763 bzero (charset
.code_space_mask
, 256);
764 for (i
= 0; i
< 4; i
++)
765 for (j
= charset
.code_space
[i
* 4]; j
<= charset
.code_space
[i
* 4 + 1];
767 charset
.code_space_mask
[j
] |= (1 << i
);
770 charset
.iso_chars_96
= charset
.code_space
[2] == 96;
772 charset
.min_code
= (charset
.code_space
[0]
773 | (charset
.code_space
[4] << 8)
774 | (charset
.code_space
[8] << 16)
775 | (charset
.code_space
[12] << 24));
776 charset
.max_code
= (charset
.code_space
[1]
777 | (charset
.code_space
[5] << 8)
778 | (charset
.code_space
[9] << 16)
779 | (charset
.code_space
[13] << 24));
780 charset
.char_index_offset
= 0;
782 val
= args
[charset_arg_min_code
];
792 CHECK_NUMBER_CAR (val
);
793 CHECK_NUMBER_CDR (val
);
794 code
= (XINT (XCAR (val
)) << 16) | (XINT (XCDR (val
)));
796 if (code
< charset
.min_code
797 || code
> charset
.max_code
)
798 args_out_of_range_3 (make_number (charset
.min_code
),
799 make_number (charset
.max_code
), val
);
800 charset
.char_index_offset
= CODE_POINT_TO_INDEX (&charset
, code
);
801 charset
.min_code
= code
;
804 val
= args
[charset_arg_max_code
];
814 CHECK_NUMBER_CAR (val
);
815 CHECK_NUMBER_CDR (val
);
816 code
= (XINT (XCAR (val
)) << 16) | (XINT (XCDR (val
)));
818 if (code
< charset
.min_code
819 || code
> charset
.max_code
)
820 args_out_of_range_3 (make_number (charset
.min_code
),
821 make_number (charset
.max_code
), val
);
822 charset
.max_code
= code
;
825 charset
.compact_codes_p
= charset
.max_code
< 0x1000000;
827 val
= args
[charset_arg_invalid_code
];
830 if (charset
.min_code
> 0)
831 charset
.invalid_code
= 0;
834 XSETINT (val
, charset
.max_code
+ 1);
835 if (XINT (val
) == charset
.max_code
+ 1)
836 charset
.invalid_code
= charset
.max_code
+ 1;
838 error ("Attribute :invalid-code must be specified");
844 charset
.invalid_code
= XFASTINT (val
);
847 val
= args
[charset_arg_iso_final
];
849 charset
.iso_final
= -1;
853 if (XINT (val
) < '0' || XINT (val
) > 127)
854 error ("Invalid iso-final-char: %d", XINT (val
));
855 charset
.iso_final
= XINT (val
);
858 val
= args
[charset_arg_iso_revision
];
860 charset
.iso_revision
= -1;
865 args_out_of_range (make_number (63), val
);
866 charset
.iso_revision
= XINT (val
);
869 val
= args
[charset_arg_emacs_mule_id
];
871 charset
.emacs_mule_id
= -1;
875 if ((XINT (val
) > 0 && XINT (val
) <= 128) || XINT (val
) >= 256)
876 error ("Invalid emacs-mule-id: %d", XINT (val
));
877 charset
.emacs_mule_id
= XINT (val
);
880 charset
.ascii_compatible_p
= ! NILP (args
[charset_arg_ascii_compatible_p
]);
882 charset
.supplementary_p
= ! NILP (args
[charset_arg_supplementary_p
]);
884 charset
.unified_p
= 0;
886 bzero (charset
.fast_map
, sizeof (charset
.fast_map
));
888 if (! NILP (args
[charset_arg_code_offset
]))
890 val
= args
[charset_arg_code_offset
];
893 charset
.method
= CHARSET_METHOD_OFFSET
;
894 charset
.code_offset
= XINT (val
);
896 i
= CODE_POINT_TO_INDEX (&charset
, charset
.min_code
);
897 charset
.min_char
= i
+ charset
.code_offset
;
898 i
= CODE_POINT_TO_INDEX (&charset
, charset
.max_code
);
899 charset
.max_char
= i
+ charset
.code_offset
;
900 if (charset
.max_char
> MAX_CHAR
)
901 error ("Unsupported max char: %d", charset
.max_char
);
903 i
= (charset
.min_char
>> 7) << 7;
904 for (; i
< 0x10000 && i
<= charset
.max_char
; i
+= 128)
905 CHARSET_FAST_MAP_SET (i
, charset
.fast_map
);
907 for (; i
<= charset
.max_char
; i
+= 0x1000)
908 CHARSET_FAST_MAP_SET (i
, charset
.fast_map
);
910 else if (! NILP (args
[charset_arg_map
]))
912 val
= args
[charset_arg_map
];
913 ASET (attrs
, charset_map
, val
);
915 load_charset_map_from_file (&charset
, val
, 0);
917 load_charset_map_from_vector (&charset
, val
, 0);
918 charset
.method
= CHARSET_METHOD_MAP_DEFERRED
;
920 else if (! NILP (args
[charset_arg_subset
]))
923 Lisp_Object parent_min_code
, parent_max_code
, parent_code_offset
;
924 struct charset
*parent_charset
;
926 val
= args
[charset_arg_subset
];
928 CHECK_CHARSET_GET_CHARSET (parent
, parent_charset
);
929 parent_min_code
= Fnth (make_number (1), val
);
930 CHECK_NATNUM (parent_min_code
);
931 parent_max_code
= Fnth (make_number (2), val
);
932 CHECK_NATNUM (parent_max_code
);
933 parent_code_offset
= Fnth (make_number (3), val
);
934 CHECK_NUMBER (parent_code_offset
);
935 val
= Fmake_vector (make_number (4), Qnil
);
936 ASET (val
, 0, make_number (parent_charset
->id
));
937 ASET (val
, 1, parent_min_code
);
938 ASET (val
, 2, parent_max_code
);
939 ASET (val
, 3, parent_code_offset
);
940 ASET (attrs
, charset_subset
, val
);
942 charset
.method
= CHARSET_METHOD_SUBSET
;
943 /* Here, we just copy the parent's fast_map. It's not accurate,
944 but at least it works for quickly detecting which character
945 DOESN'T belong to this charset. */
946 for (i
= 0; i
< 190; i
++)
947 charset
.fast_map
[i
] = parent_charset
->fast_map
[i
];
949 /* We also copy these for parents. */
950 charset
.min_char
= parent_charset
->min_char
;
951 charset
.max_char
= parent_charset
->max_char
;
953 else if (! NILP (args
[charset_arg_superset
]))
955 val
= args
[charset_arg_superset
];
956 charset
.method
= CHARSET_METHOD_SUPERSET
;
957 val
= Fcopy_sequence (val
);
958 ASET (attrs
, charset_superset
, val
);
960 charset
.min_char
= MAX_CHAR
;
961 charset
.max_char
= 0;
962 for (; ! NILP (val
); val
= Fcdr (val
))
964 Lisp_Object elt
, car_part
, cdr_part
;
966 struct charset
*this_charset
;
971 car_part
= XCAR (elt
);
972 cdr_part
= XCDR (elt
);
973 CHECK_CHARSET_GET_ID (car_part
, this_id
);
974 CHECK_NUMBER (cdr_part
);
975 offset
= XINT (cdr_part
);
979 CHECK_CHARSET_GET_ID (elt
, this_id
);
982 XSETCAR (val
, Fcons (make_number (this_id
), make_number (offset
)));
984 this_charset
= CHARSET_FROM_ID (this_id
);
985 if (charset
.min_char
> this_charset
->min_char
)
986 charset
.min_char
= this_charset
->min_char
;
987 if (charset
.max_char
< this_charset
->max_char
)
988 charset
.max_char
= this_charset
->max_char
;
989 for (i
= 0; i
< 190; i
++)
990 charset
.fast_map
[i
] |= this_charset
->fast_map
[i
];
994 error ("None of :code-offset, :map, :parents are specified");
996 val
= args
[charset_arg_unify_map
];
997 if (! NILP (val
) && !STRINGP (val
))
999 ASET (attrs
, charset_unify_map
, val
);
1001 CHECK_LIST (args
[charset_arg_plist
]);
1002 ASET (attrs
, charset_plist
, args
[charset_arg_plist
]);
1004 charset
.hash_index
= hash_lookup (hash_table
, args
[charset_arg_name
],
1006 if (charset
.hash_index
>= 0)
1008 new_definition_p
= 0;
1009 id
= XFASTINT (CHARSET_SYMBOL_ID (args
[charset_arg_name
]));
1010 HASH_VALUE (hash_table
, charset
.hash_index
) = attrs
;
1014 charset
.hash_index
= hash_put (hash_table
, args
[charset_arg_name
], attrs
,
1016 if (charset_table_used
== charset_table_size
)
1018 struct charset
*new_table
1019 = (struct charset
*) xmalloc (sizeof (struct charset
)
1020 * (charset_table_size
+ 16));
1021 bcopy (charset_table
, new_table
,
1022 sizeof (struct charset
) * charset_table_size
);
1023 charset_table_size
+= 16;
1024 charset_table
= new_table
;
1026 id
= charset_table_used
++;
1027 new_definition_p
= 1;
1030 ASET (attrs
, charset_id
, make_number (id
));
1032 charset_table
[id
] = charset
;
1034 if (charset
.iso_final
>= 0)
1036 ISO_CHARSET_TABLE (charset
.dimension
, charset
.iso_chars_96
,
1037 charset
.iso_final
) = id
;
1038 if (new_definition_p
)
1039 Viso_2022_charset_list
= nconc2 (Viso_2022_charset_list
,
1040 Fcons (make_number (id
), Qnil
));
1041 if (ISO_CHARSET_TABLE (1, 0, 'J') == id
)
1042 charset_jisx0201_roman
= id
;
1043 else if (ISO_CHARSET_TABLE (2, 0, '@') == id
)
1044 charset_jisx0208_1978
= id
;
1045 else if (ISO_CHARSET_TABLE (2, 0, 'B') == id
)
1046 charset_jisx0208
= id
;
1049 if (charset
.emacs_mule_id
>= 0)
1051 emacs_mule_charset
[charset
.emacs_mule_id
] = CHARSET_FROM_ID (id
);
1052 if (charset
.emacs_mule_id
< 0xA0)
1053 emacs_mule_bytes
[charset
.emacs_mule_id
] = charset
.dimension
+ 1;
1054 if (new_definition_p
)
1055 Vemacs_mule_charset_list
= nconc2 (Vemacs_mule_charset_list
,
1056 Fcons (make_number (id
), Qnil
));
1059 if (new_definition_p
)
1061 Vcharset_list
= Fcons (args
[charset_arg_name
], Vcharset_list
);
1062 Vcharset_ordered_list
= nconc2 (Vcharset_ordered_list
,
1063 Fcons (make_number (id
), Qnil
));
1064 charset_ordered_list_tick
++;
1071 /* Same as Fdefine_charset_internal but arguments are more convenient
1072 to call from C (typically in syms_of_charset). This can define a
1073 charset of `offset' method only. Return the ID of the new
1077 define_charset_internal (name
, dimension
, code_space
, min_code
, max_code
,
1078 iso_final
, iso_revision
, emacs_mule_id
,
1079 ascii_compatible
, supplementary
,
1083 unsigned char *code_space
;
1084 unsigned min_code
, max_code
;
1085 int iso_final
, iso_revision
, emacs_mule_id
;
1086 int ascii_compatible
, supplementary
;
1089 Lisp_Object args
[charset_arg_max
];
1090 Lisp_Object plist
[14];
1094 args
[charset_arg_name
] = name
;
1095 args
[charset_arg_dimension
] = make_number (dimension
);
1096 val
= Fmake_vector (make_number (8), make_number (0));
1097 for (i
= 0; i
< 8; i
++)
1098 ASET (val
, i
, make_number (code_space
[i
]));
1099 args
[charset_arg_code_space
] = val
;
1100 args
[charset_arg_min_code
] = make_number (min_code
);
1101 args
[charset_arg_max_code
] = make_number (max_code
);
1102 args
[charset_arg_iso_final
]
1103 = (iso_final
< 0 ? Qnil
: make_number (iso_final
));
1104 args
[charset_arg_iso_revision
] = make_number (iso_revision
);
1105 args
[charset_arg_emacs_mule_id
]
1106 = (emacs_mule_id
< 0 ? Qnil
: make_number (emacs_mule_id
));
1107 args
[charset_arg_ascii_compatible_p
] = ascii_compatible
? Qt
: Qnil
;
1108 args
[charset_arg_supplementary_p
] = supplementary
? Qt
: Qnil
;
1109 args
[charset_arg_invalid_code
] = Qnil
;
1110 args
[charset_arg_code_offset
] = make_number (code_offset
);
1111 args
[charset_arg_map
] = Qnil
;
1112 args
[charset_arg_subset
] = Qnil
;
1113 args
[charset_arg_superset
] = Qnil
;
1114 args
[charset_arg_unify_map
] = Qnil
;
1116 plist
[0] = intern (":name");
1117 plist
[1] = args
[charset_arg_name
];
1118 plist
[2] = intern (":dimension");
1119 plist
[3] = args
[charset_arg_dimension
];
1120 plist
[4] = intern (":code-space");
1121 plist
[5] = args
[charset_arg_code_space
];
1122 plist
[6] = intern (":iso-final-char");
1123 plist
[7] = args
[charset_arg_iso_final
];
1124 plist
[8] = intern (":emacs-mule-id");
1125 plist
[9] = args
[charset_arg_emacs_mule_id
];
1126 plist
[10] = intern (":ascii-compatible-p");
1127 plist
[11] = args
[charset_arg_ascii_compatible_p
];
1128 plist
[12] = intern (":code-offset");
1129 plist
[13] = args
[charset_arg_code_offset
];
1131 args
[charset_arg_plist
] = Flist (14, plist
);
1132 Fdefine_charset_internal (charset_arg_max
, args
);
1134 return XINT (CHARSET_SYMBOL_ID (name
));
1138 DEFUN ("define-charset-alias", Fdefine_charset_alias
,
1139 Sdefine_charset_alias
, 2, 2, 0,
1140 doc
: /* Define ALIAS as an alias for charset CHARSET. */)
1142 Lisp_Object alias
, charset
;
1146 CHECK_CHARSET_GET_ATTR (charset
, attr
);
1147 Fputhash (alias
, attr
, Vcharset_hash_table
);
1148 Vcharset_list
= Fcons (alias
, Vcharset_list
);
1153 DEFUN ("unibyte-charset", Funibyte_charset
, Sunibyte_charset
, 0, 0, 0,
1154 doc
: /* Return the unibyte charset (set by `set-unibyte-charset'). */)
1157 return CHARSET_NAME (CHARSET_FROM_ID (charset_unibyte
));
1161 DEFUN ("set-unibyte-charset", Fset_unibyte_charset
, Sset_unibyte_charset
,
1163 doc
: /* Set the unibyte charset to CHARSET.
1164 This determines how unibyte/multibyte conversion is done. See also
1165 function `unibyte-charset'. */)
1167 Lisp_Object charset
;
1172 CHECK_CHARSET_GET_CHARSET (charset
, cs
);
1173 if (! cs
->ascii_compatible_p
1174 || cs
->dimension
!= 1)
1175 error ("Inappropriate unibyte charset: %s", SDATA (SYMBOL_NAME (charset
)));
1176 charset_unibyte
= cs
->id
;
1177 for (i
= 128; i
< 256; i
++)
1179 c
= DECODE_CHAR (cs
, i
);
1180 unibyte_to_multibyte_table
[i
] = (c
< 0 ? BYTE8_TO_CHAR (i
) : c
);
1187 DEFUN ("charset-plist", Fcharset_plist
, Scharset_plist
, 1, 1, 0,
1188 doc
: /* Return the property list of CHARSET. */)
1190 Lisp_Object charset
;
1194 CHECK_CHARSET_GET_ATTR (charset
, attrs
);
1195 return CHARSET_ATTR_PLIST (attrs
);
1199 DEFUN ("set-charset-plist", Fset_charset_plist
, Sset_charset_plist
, 2, 2, 0,
1200 doc
: /* Set CHARSET's property list to PLIST. */)
1202 Lisp_Object charset
, plist
;
1206 CHECK_CHARSET_GET_ATTR (charset
, attrs
);
1207 CHARSET_ATTR_PLIST (attrs
) = plist
;
1212 DEFUN ("unify-charset", Funify_charset
, Sunify_charset
, 1, 3, 0,
1213 doc
: /* Unify characters of CHARSET with Unicode.
1214 This means reading the relevant file and installing the table defined
1215 by CHARSET's `:unify-map' property.
1217 Optional second arg UNIFY-MAP is a file name string or a vector. It has
1218 the same meaning as the `:unify-map' attribute in the function
1219 `define-charset' (which see).
1221 Optional third argument DEUNIFY, if non-nil, means to de-unify CHARSET. */)
1222 (charset
, unify_map
, deunify
)
1223 Lisp_Object charset
, unify_map
, deunify
;
1228 CHECK_CHARSET_GET_ID (charset
, id
);
1229 cs
= CHARSET_FROM_ID (id
);
1230 if (CHARSET_METHOD (cs
) == CHARSET_METHOD_MAP_DEFERRED
)
1233 ? CHARSET_UNIFIED_P (cs
) && ! NILP (CHARSET_DEUNIFIER (cs
))
1234 : ! CHARSET_UNIFIED_P (cs
))
1237 CHARSET_UNIFIED_P (cs
) = 0;
1240 if (CHARSET_METHOD (cs
) != CHARSET_METHOD_OFFSET
)
1241 error ("Can't unify charset: %s", SDATA (SYMBOL_NAME (charset
)));
1242 if (NILP (unify_map
))
1243 unify_map
= CHARSET_UNIFY_MAP (cs
);
1244 if (STRINGP (unify_map
))
1245 load_charset_map_from_file (cs
, unify_map
, 2);
1246 else if (VECTORP (unify_map
))
1247 load_charset_map_from_vector (cs
, unify_map
, 2);
1248 else if (NILP (unify_map
))
1249 error ("No unify-map for charset");
1251 error ("Bad unify-map arg");
1252 CHARSET_UNIFIED_P (cs
) = 1;
1254 else if (CHAR_TABLE_P (Vchar_unify_table
))
1256 int min_code
= CHARSET_MIN_CODE (cs
);
1257 int max_code
= CHARSET_MAX_CODE (cs
);
1258 int min_char
= DECODE_CHAR (cs
, min_code
);
1259 int max_char
= DECODE_CHAR (cs
, max_code
);
1261 char_table_set_range (Vchar_unify_table
, min_char
, max_char
, Qnil
);
1267 DEFUN ("get-unused-iso-final-char", Fget_unused_iso_final_char
,
1268 Sget_unused_iso_final_char
, 2, 2, 0,
1270 Return an unsed ISO final char for a charset of DIMENISION and CHARS.
1271 DIMENSION is the number of bytes to represent a character: 1 or 2.
1272 CHARS is the number of characters in a dimension: 94 or 96.
1274 This final char is for private use, thus the range is `0' (48) .. `?' (63).
1275 If there's no unused final char for the specified kind of charset,
1278 Lisp_Object dimension
, chars
;
1282 CHECK_NUMBER (dimension
);
1283 CHECK_NUMBER (chars
);
1284 if (XINT (dimension
) != 1 && XINT (dimension
) != 2 && XINT (dimension
) != 3)
1285 args_out_of_range_3 (dimension
, make_number (1), make_number (3));
1286 if (XINT (chars
) != 94 && XINT (chars
) != 96)
1287 args_out_of_range_3 (chars
, make_number (94), make_number (96));
1288 for (final_char
= '0'; final_char
<= '?'; final_char
++)
1289 if (ISO_CHARSET_TABLE (XINT (dimension
), XINT (chars
), final_char
) < 0)
1291 return (final_char
<= '?' ? make_number (final_char
) : Qnil
);
1295 check_iso_charset_parameter (dimension
, chars
, final_char
)
1296 Lisp_Object dimension
, chars
, final_char
;
1298 CHECK_NATNUM (dimension
);
1299 CHECK_NATNUM (chars
);
1300 CHECK_NATNUM (final_char
);
1302 if (XINT (dimension
) > 3)
1303 error ("Invalid DIMENSION %d, it should be 1, 2, or 3", XINT (dimension
));
1304 if (XINT (chars
) != 94 && XINT (chars
) != 96)
1305 error ("Invalid CHARS %d, it should be 94 or 96", XINT (chars
));
1306 if (XINT (final_char
) < '0' || XINT (final_char
) > '~')
1307 error ("Invalid FINAL-CHAR %c, it should be `0'..`~'", XINT (chars
));
1311 DEFUN ("declare-equiv-charset", Fdeclare_equiv_charset
, Sdeclare_equiv_charset
,
1314 Declare a charset of DIMENSION, CHARS, FINAL-CHAR is the same as CHARSET.
1315 CHARSET should be defined by `define-charset' in advance. */)
1316 (dimension
, chars
, final_char
, charset
)
1317 Lisp_Object dimension
, chars
, final_char
, charset
;
1321 CHECK_CHARSET_GET_ID (charset
, id
);
1322 check_iso_charset_parameter (dimension
, chars
, final_char
);
1324 ISO_CHARSET_TABLE (XINT (dimension
), XINT (chars
), XINT (final_char
)) = id
;
1329 /* Return information about charsets in the text at PTR of NBYTES
1330 bytes, which are NCHARS characters. The value is:
1332 0: Each character is represented by one byte. This is always
1333 true for a unibyte string. For a multibyte string, true if
1334 it contains only ASCII characters.
1336 1: No charsets other than ascii, control-1, and latin-1 are
1343 string_xstring_p (string
)
1346 const unsigned char *p
= SDATA (string
);
1347 const unsigned char *endp
= p
+ SBYTES (string
);
1348 struct charset
*charset
;
1350 if (SCHARS (string
) == SBYTES (string
))
1353 charset
= CHARSET_FROM_ID (charset_iso_8859_1
);
1356 int c
= STRING_CHAR_ADVANCE (p
);
1358 /* Fixme: comparison of unsigned expression < 0 is always false */
1359 if (ENCODE_CHAR (charset
, c
) < 0)
1366 /* Find charsets in the string at PTR of NCHARS and NBYTES.
1368 CHARSETS is a vector. Each element is a cons of CHARSET and
1369 FOUND-FLAG. CHARSET is a charset id, and FOUND-FLAG is nil or t.
1370 FOUND-FLAG t (or nil) means that the corresponding charset is
1371 already found (or not yet found).
1373 It may lookup a translation table TABLE if supplied. */
1376 find_charsets_in_text (ptr
, nchars
, nbytes
, charsets
, table
)
1377 const unsigned char *ptr
;
1379 Lisp_Object charsets
, table
;
1381 const unsigned char *pend
= ptr
+ nbytes
;
1382 int ncharsets
= ASIZE (charsets
);
1384 if (nchars
== nbytes
)
1389 int c
= STRING_CHAR_ADVANCE (ptr
);
1395 c
= translate_char (table
, c
);
1396 for (i
= 0; i
< ncharsets
; i
++)
1398 elt
= AREF (charsets
, i
);
1399 if (NILP (XCDR (elt
)))
1401 struct charset
*charset
= CHARSET_FROM_ID (XINT (XCAR (elt
)));
1403 if (ENCODE_CHAR (charset
, c
) != CHARSET_INVALID_CODE (charset
))
1414 /* Fixme: returns nil for unibyte. */
1415 DEFUN ("find-charset-region", Ffind_charset_region
, Sfind_charset_region
,
1417 doc
: /* Return a list of charsets in the region between BEG and END.
1418 BEG and END are buffer positions.
1419 Optional arg TABLE if non-nil is a translation table to look up.
1421 If the current buffer is unibyte, the returned list may contain
1422 only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
1424 Lisp_Object beg
, end
, table
;
1426 Lisp_Object charsets
;
1427 int from
, from_byte
, to
, stop
, stop_byte
, i
;
1430 validate_region (&beg
, &end
);
1431 from
= XFASTINT (beg
);
1432 stop
= to
= XFASTINT (end
);
1434 if (from
< GPT
&& GPT
< to
)
1437 stop_byte
= GPT_BYTE
;
1440 stop_byte
= CHAR_TO_BYTE (stop
);
1442 from_byte
= CHAR_TO_BYTE (from
);
1444 charsets
= Fmake_vector (make_number (charset_table_used
), Qnil
);
1445 for (i
= 0; i
< charset_table_used
; i
++)
1446 ASET (charsets
, i
, Fcons (make_number (i
), Qnil
));
1450 find_charsets_in_text (BYTE_POS_ADDR (from_byte
), stop
- from
,
1451 stop_byte
- from_byte
, charsets
, table
);
1454 from
= stop
, from_byte
= stop_byte
;
1455 stop
= to
, stop_byte
= CHAR_TO_BYTE (stop
);
1462 for (i
= charset_table_used
- 1; i
>= 0; i
--)
1463 if (!NILP (XCDR (AREF (charsets
, i
))))
1464 val
= Fcons (CHARSET_NAME (charset_table
+ i
), val
);
1468 /* Fixme: returns nil for unibyte. */
1469 DEFUN ("find-charset-string", Ffind_charset_string
, Sfind_charset_string
,
1471 doc
: /* Return a list of charsets in STR.
1472 Optional arg TABLE if non-nil is a translation table to look up.
1474 If STR is unibyte, the returned list may contain
1475 only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
1477 Lisp_Object str
, table
;
1479 Lisp_Object charsets
;
1485 charsets
= Fmake_vector (make_number (charset_table_used
), Qnil
);
1486 for (i
= 0; i
< charset_table_used
; i
++)
1487 ASET (charsets
, i
, Fcons (make_number (i
), Qnil
));
1488 find_charsets_in_text (SDATA (str
), SCHARS (str
), SBYTES (str
),
1492 for (i
= charset_table_used
- 1; i
>= 0; i
--)
1493 if (!NILP (XCDR (AREF (charsets
, i
))))
1494 val
= Fcons (CHARSET_NAME (charset_table
+ i
), val
);
1500 /* Return a character correponding to the code-point CODE of
1504 decode_char (charset
, code
)
1505 struct charset
*charset
;
1509 enum charset_method method
= CHARSET_METHOD (charset
);
1511 if (code
< CHARSET_MIN_CODE (charset
) || code
> CHARSET_MAX_CODE (charset
))
1514 if (method
== CHARSET_METHOD_MAP_DEFERRED
)
1516 load_charset (charset
);
1517 method
= CHARSET_METHOD (charset
);
1520 if (method
== CHARSET_METHOD_SUBSET
)
1522 Lisp_Object subset_info
;
1524 subset_info
= CHARSET_SUBSET (charset
);
1525 charset
= CHARSET_FROM_ID (XFASTINT (AREF (subset_info
, 0)));
1526 code
-= XINT (AREF (subset_info
, 3));
1527 if (code
< XFASTINT (AREF (subset_info
, 1))
1528 || code
> XFASTINT (AREF (subset_info
, 2)))
1531 c
= DECODE_CHAR (charset
, code
);
1533 else if (method
== CHARSET_METHOD_SUPERSET
)
1535 Lisp_Object parents
;
1537 parents
= CHARSET_SUPERSET (charset
);
1539 for (; CONSP (parents
); parents
= XCDR (parents
))
1541 int id
= XINT (XCAR (XCAR (parents
)));
1542 int code_offset
= XINT (XCDR (XCAR (parents
)));
1543 unsigned this_code
= code
- code_offset
;
1545 charset
= CHARSET_FROM_ID (id
);
1546 if ((c
= DECODE_CHAR (charset
, this_code
)) >= 0)
1552 char_index
= CODE_POINT_TO_INDEX (charset
, code
);
1556 if (method
== CHARSET_METHOD_MAP
)
1558 Lisp_Object decoder
;
1560 decoder
= CHARSET_DECODER (charset
);
1561 if (! VECTORP (decoder
))
1563 c
= XINT (AREF (decoder
, char_index
));
1567 c
= char_index
+ CHARSET_CODE_OFFSET (charset
);
1571 if (CHARSET_UNIFIED_P (charset
)
1574 MAYBE_UNIFY_CHAR (c
);
1580 /* Variable used temporarily by the macro ENCODE_CHAR. */
1581 Lisp_Object charset_work
;
1583 /* Return a code-point of CHAR in CHARSET. If CHAR doesn't belong to
1584 CHARSET, return CHARSET_INVALID_CODE (CHARSET). If STRICT is true,
1585 use CHARSET's strict_max_char instead of max_char. */
1588 encode_char (charset
, c
)
1589 struct charset
*charset
;
1593 enum charset_method method
= CHARSET_METHOD (charset
);
1595 if (CHARSET_UNIFIED_P (charset
))
1597 Lisp_Object deunifier
, deunified
;
1599 deunifier
= CHARSET_DEUNIFIER (charset
);
1600 if (! CHAR_TABLE_P (deunifier
))
1602 Funify_charset (CHARSET_NAME (charset
), Qnil
, Qnil
);
1603 deunifier
= CHARSET_DEUNIFIER (charset
);
1605 deunified
= CHAR_TABLE_REF (deunifier
, c
);
1606 if (! NILP (deunified
))
1607 c
= XINT (deunified
);
1610 if (method
== CHARSET_METHOD_SUBSET
)
1612 Lisp_Object subset_info
;
1613 struct charset
*this_charset
;
1615 subset_info
= CHARSET_SUBSET (charset
);
1616 this_charset
= CHARSET_FROM_ID (XFASTINT (AREF (subset_info
, 0)));
1617 code
= ENCODE_CHAR (this_charset
, c
);
1618 if (code
== CHARSET_INVALID_CODE (this_charset
)
1619 || code
< XFASTINT (AREF (subset_info
, 1))
1620 || code
> XFASTINT (AREF (subset_info
, 2)))
1621 return CHARSET_INVALID_CODE (charset
);
1622 code
+= XINT (AREF (subset_info
, 3));
1626 if (method
== CHARSET_METHOD_SUPERSET
)
1628 Lisp_Object parents
;
1630 parents
= CHARSET_SUPERSET (charset
);
1631 for (; CONSP (parents
); parents
= XCDR (parents
))
1633 int id
= XINT (XCAR (XCAR (parents
)));
1634 int code_offset
= XINT (XCDR (XCAR (parents
)));
1635 struct charset
*this_charset
= CHARSET_FROM_ID (id
);
1637 code
= ENCODE_CHAR (this_charset
, c
);
1638 if (code
!= CHARSET_INVALID_CODE (this_charset
))
1639 return code
+ code_offset
;
1641 return CHARSET_INVALID_CODE (charset
);
1644 if (! CHARSET_FAST_MAP_REF ((c
), charset
->fast_map
)
1645 || c
< CHARSET_MIN_CHAR (charset
) || c
> CHARSET_MAX_CHAR (charset
))
1646 return CHARSET_INVALID_CODE (charset
);
1648 if (method
== CHARSET_METHOD_MAP_DEFERRED
)
1650 load_charset (charset
);
1651 method
= CHARSET_METHOD (charset
);
1654 if (method
== CHARSET_METHOD_MAP
)
1656 Lisp_Object encoder
;
1659 encoder
= CHARSET_ENCODER (charset
);
1660 if (! CHAR_TABLE_P (CHARSET_ENCODER (charset
)))
1661 return CHARSET_INVALID_CODE (charset
);
1662 val
= CHAR_TABLE_REF (encoder
, c
);
1664 return CHARSET_INVALID_CODE (charset
);
1666 if (! CHARSET_COMPACT_CODES_P (charset
))
1667 code
= INDEX_TO_CODE_POINT (charset
, code
);
1669 else /* method == CHARSET_METHOD_OFFSET */
1671 code
= c
- CHARSET_CODE_OFFSET (charset
);
1672 code
= INDEX_TO_CODE_POINT (charset
, code
);
1679 DEFUN ("decode-char", Fdecode_char
, Sdecode_char
, 2, 3, 0,
1680 doc
: /* Decode the pair of CHARSET and CODE-POINT into a character.
1681 Return nil if CODE-POINT is not valid in CHARSET.
1683 CODE-POINT may be a cons (HIGHER-16-BIT-VALUE . LOWER-16-BIT-VALUE).
1685 Optional argument RESTRICTION specifies a way to map the pair of CCS
1686 and CODE-POINT to a chracter. Currently not supported and just ignored. */)
1687 (charset
, code_point
, restriction
)
1688 Lisp_Object charset
, code_point
, restriction
;
1692 struct charset
*charsetp
;
1694 CHECK_CHARSET_GET_ID (charset
, id
);
1695 if (CONSP (code_point
))
1697 CHECK_NATNUM_CAR (code_point
);
1698 CHECK_NATNUM_CDR (code_point
);
1699 code
= (XINT (XCAR (code_point
)) << 16) | (XINT (XCDR (code_point
)));
1703 CHECK_NATNUM (code_point
);
1704 code
= XINT (code_point
);
1706 charsetp
= CHARSET_FROM_ID (id
);
1707 c
= DECODE_CHAR (charsetp
, code
);
1708 return (c
>= 0 ? make_number (c
) : Qnil
);
1712 DEFUN ("encode-char", Fencode_char
, Sencode_char
, 2, 3, 0,
1713 doc
: /* Encode the character CH into a code-point of CHARSET.
1714 Return nil if CHARSET doesn't include CH.
1716 Optional argument RESTRICTION specifies a way to map CHAR to a
1717 code-point in CCS. Currently not supported and just ignored. */)
1718 (ch
, charset
, restriction
)
1719 Lisp_Object ch
, charset
, restriction
;
1723 struct charset
*charsetp
;
1725 CHECK_CHARSET_GET_ID (charset
, id
);
1727 charsetp
= CHARSET_FROM_ID (id
);
1728 code
= ENCODE_CHAR (charsetp
, XINT (ch
));
1729 if (code
== CHARSET_INVALID_CODE (charsetp
))
1731 if (code
> 0x7FFFFFF)
1732 return Fcons (make_number (code
>> 16), make_number (code
& 0xFFFF));
1733 return make_number (code
);
1737 DEFUN ("make-char", Fmake_char
, Smake_char
, 1, 5, 0,
1739 /* Return a character of CHARSET whose position codes are CODEn.
1741 CODE1 through CODE4 are optional, but if you don't supply sufficient
1742 position codes, it is assumed that the minimum code in each dimension
1744 (charset
, code1
, code2
, code3
, code4
)
1745 Lisp_Object charset
, code1
, code2
, code3
, code4
;
1748 struct charset
*charsetp
;
1752 CHECK_CHARSET_GET_ID (charset
, id
);
1753 charsetp
= CHARSET_FROM_ID (id
);
1755 dimension
= CHARSET_DIMENSION (charsetp
);
1757 code
= (CHARSET_ASCII_COMPATIBLE_P (charsetp
)
1758 ? 0 : CHARSET_MIN_CODE (charsetp
));
1761 CHECK_NATNUM (code1
);
1762 if (XFASTINT (code1
) >= 0x100)
1763 args_out_of_range (make_number (0xFF), code1
);
1764 code
= XFASTINT (code1
);
1770 code
|= charsetp
->code_space
[(dimension
- 2) * 4];
1773 CHECK_NATNUM (code2
);
1774 if (XFASTINT (code2
) >= 0x100)
1775 args_out_of_range (make_number (0xFF), code2
);
1776 code
|= XFASTINT (code2
);
1783 code
|= charsetp
->code_space
[(dimension
- 3) * 4];
1786 CHECK_NATNUM (code3
);
1787 if (XFASTINT (code3
) >= 0x100)
1788 args_out_of_range (make_number (0xFF), code3
);
1789 code
|= XFASTINT (code3
);
1796 code
|= charsetp
->code_space
[0];
1799 CHECK_NATNUM (code4
);
1800 if (XFASTINT (code4
) >= 0x100)
1801 args_out_of_range (make_number (0xFF), code4
);
1802 code
|= XFASTINT (code4
);
1809 if (CHARSET_ISO_FINAL (charsetp
) >= 0)
1811 c
= DECODE_CHAR (charsetp
, code
);
1813 error ("Invalid code(s)");
1814 return make_number (c
);
1818 /* Return the first charset in CHARSET_LIST that contains C.
1819 CHARSET_LIST is a list of charset IDs. If it is nil, use
1820 Vcharset_ordered_list. */
1823 char_charset (c
, charset_list
, code_return
)
1825 Lisp_Object charset_list
;
1826 unsigned *code_return
;
1828 if (NILP (charset_list
))
1829 charset_list
= Vcharset_ordered_list
;
1831 while (CONSP (charset_list
))
1833 struct charset
*charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
1834 unsigned code
= ENCODE_CHAR (charset
, c
);
1836 if (code
!= CHARSET_INVALID_CODE (charset
))
1839 *code_return
= code
;
1842 charset_list
= XCDR (charset_list
);
1848 /* Fixme: `unknown' can't happen now? */
1849 DEFUN ("split-char", Fsplit_char
, Ssplit_char
, 1, 1, 0,
1850 doc
: /*Return list of charset and one to three position-codes of CHAR.
1851 If CHAR is invalid as a character code, return a list `(unknown CHAR)'. */)
1855 struct charset
*charset
;
1860 CHECK_CHARACTER (ch
);
1862 charset
= CHAR_CHARSET (c
);
1864 return Fcons (intern ("unknown"), Fcons (ch
, Qnil
));
1866 code
= ENCODE_CHAR (charset
, c
);
1867 if (code
== CHARSET_INVALID_CODE (charset
))
1869 dimension
= CHARSET_DIMENSION (charset
);
1870 val
= (dimension
== 1 ? Fcons (make_number (code
), Qnil
)
1871 : dimension
== 2 ? Fcons (make_number (code
>> 8),
1872 Fcons (make_number (code
& 0xFF), Qnil
))
1873 : Fcons (make_number (code
>> 16),
1874 Fcons (make_number ((code
>> 8) & 0xFF),
1875 Fcons (make_number (code
& 0xFF), Qnil
))));
1876 return Fcons (CHARSET_NAME (charset
), val
);
1880 DEFUN ("char-charset", Fchar_charset
, Schar_charset
, 1, 1, 0,
1881 doc
: /* Return the charset of highest priority that contains CHAR. */)
1885 struct charset
*charset
;
1887 CHECK_CHARACTER (ch
);
1888 charset
= CHAR_CHARSET (XINT (ch
));
1889 return (CHARSET_NAME (charset
));
1893 DEFUN ("charset-after", Fcharset_after
, Scharset_after
, 0, 1, 0,
1895 Return charset of a character in the current buffer at position POS.
1896 If POS is nil, it defauls to the current point.
1897 If POS is out of range, the value is nil. */)
1902 struct charset
*charset
;
1904 ch
= Fchar_after (pos
);
1905 if (! INTEGERP (ch
))
1907 charset
= CHAR_CHARSET (XINT (ch
));
1908 return (CHARSET_NAME (charset
));
1912 DEFUN ("iso-charset", Fiso_charset
, Siso_charset
, 3, 3, 0,
1914 Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.
1916 ISO 2022's designation sequence (escape sequence) distinguishes charsets
1917 by their DIMENSION, CHARS, and FINAL-CHAR,
1918 where as Emacs distinguishes them by charset symbol.
1919 See the documentation of the function `charset-info' for the meanings of
1920 DIMENSION, CHARS, and FINAL-CHAR. */)
1921 (dimension
, chars
, final_char
)
1922 Lisp_Object dimension
, chars
, final_char
;
1926 check_iso_charset_parameter (dimension
, chars
, final_char
);
1927 id
= ISO_CHARSET_TABLE (XFASTINT (dimension
), XFASTINT (chars
),
1928 XFASTINT (final_char
));
1929 return (id
>= 0 ? CHARSET_NAME (CHARSET_FROM_ID (id
)) : Qnil
);
1933 DEFUN ("clear-charset-maps", Fclear_charset_maps
, Sclear_charset_maps
,
1936 Clear encoder and decoder of charsets that are loaded from mapfiles. */)
1940 struct charset
*charset
;
1943 for (i
= 0; i
< charset_table_used
; i
++)
1945 charset
= CHARSET_FROM_ID (i
);
1946 attrs
= CHARSET_ATTRIBUTES (charset
);
1948 if (CHARSET_METHOD (charset
) == CHARSET_METHOD_MAP
)
1950 CHARSET_ATTR_DECODER (attrs
) = Qnil
;
1951 CHARSET_ATTR_ENCODER (attrs
) = Qnil
;
1952 CHARSET_METHOD (charset
) = CHARSET_METHOD_MAP_DEFERRED
;
1955 if (CHARSET_UNIFIED_P (charset
))
1956 CHARSET_ATTR_DEUNIFIER (attrs
) = Qnil
;
1959 if (CHAR_TABLE_P (Vchar_unified_charset_table
))
1961 Foptimize_char_table (Vchar_unified_charset_table
);
1962 Vchar_unify_table
= Vchar_unified_charset_table
;
1963 Vchar_unified_charset_table
= Qnil
;
1969 DEFUN ("charset-priority-list", Fcharset_priority_list
,
1970 Scharset_priority_list
, 0, 1, 0,
1971 doc
: /* Return the list of charsets ordered by priority.
1972 HIGHESTP non-nil means just return the highest priority one. */)
1974 Lisp_Object highestp
;
1976 Lisp_Object val
= Qnil
, list
= Vcharset_ordered_list
;
1978 if (!NILP (highestp
))
1979 return CHARSET_NAME (CHARSET_FROM_ID (XINT (Fcar (list
))));
1981 while (!NILP (list
))
1983 val
= Fcons (CHARSET_NAME (CHARSET_FROM_ID (XINT (XCAR (list
)))), val
);
1986 return Fnreverse (val
);
1989 DEFUN ("set-charset-priority", Fset_charset_priority
, Sset_charset_priority
,
1991 doc
: /* Assign higher priority to the charsets given as arguments.
1992 usage: (set-charset-priority &rest charsets) */)
1997 Lisp_Object new_head
, old_list
, arglist
[2];
2000 old_list
= Fcopy_sequence (Vcharset_ordered_list
);
2002 for (i
= 0; i
< nargs
; i
++)
2004 CHECK_CHARSET_GET_ID (args
[i
], id
);
2005 if (! NILP (Fmemq (make_number (id
), old_list
)))
2007 old_list
= Fdelq (make_number (id
), old_list
);
2008 new_head
= Fcons (make_number (id
), new_head
);
2011 arglist
[0] = Fnreverse (new_head
);
2012 arglist
[1] = old_list
;
2013 Vcharset_ordered_list
= Fnconc (2, arglist
);
2014 charset_ordered_list_tick
++;
2016 for (old_list
= Vcharset_ordered_list
, new_head
= Qnil
;
2017 CONSP (old_list
); old_list
= XCDR (old_list
))
2019 if (! NILP (Fmemq (XCAR (old_list
), Viso_2022_charset_list
)))
2020 new_head
= Fcons (XCAR (old_list
), new_head
);
2022 Viso_2022_charset_list
= Fnreverse (new_head
);
2027 DEFUN ("charset-id-internal", Fcharset_id_internal
, Scharset_id_internal
,
2029 doc
: /* Internal use only.
2030 Return charset identification number of CHARSET. */)
2032 Lisp_Object charset
;
2036 CHECK_CHARSET_GET_ID (charset
, id
);
2037 return make_number (id
);
2049 init_charset_once ()
2053 for (i
= 0; i
< ISO_MAX_DIMENSION
; i
++)
2054 for (j
= 0; j
< ISO_MAX_CHARS
; j
++)
2055 for (k
= 0; k
< ISO_MAX_FINAL
; k
++)
2056 iso_charset_table
[i
][j
][k
] = -1;
2058 for (i
= 0; i
< 256; i
++)
2059 emacs_mule_charset
[i
] = NULL
;
2061 charset_jisx0201_roman
= -1;
2062 charset_jisx0208_1978
= -1;
2063 charset_jisx0208
= -1;
2065 for (i
= 0; i
< 128; i
++)
2066 unibyte_to_multibyte_table
[i
] = i
;
2067 for (; i
< 256; i
++)
2068 unibyte_to_multibyte_table
[i
] = BYTE8_TO_CHAR (i
);
2078 DEFSYM (Qcharsetp
, "charsetp");
2080 DEFSYM (Qascii
, "ascii");
2081 DEFSYM (Qunicode
, "unicode");
2082 DEFSYM (Qeight_bit
, "eight-bit");
2083 DEFSYM (Qiso_8859_1
, "iso-8859-1");
2088 p
= (char *) xmalloc (30000);
2090 staticpro (&Vcharset_ordered_list
);
2091 Vcharset_ordered_list
= Qnil
;
2093 staticpro (&Viso_2022_charset_list
);
2094 Viso_2022_charset_list
= Qnil
;
2096 staticpro (&Vemacs_mule_charset_list
);
2097 Vemacs_mule_charset_list
= Qnil
;
2099 staticpro (&Vcharset_hash_table
);
2101 Lisp_Object args
[2];
2104 Vcharset_hash_table
= Fmake_hash_table (2, args
);
2107 charset_table_size
= 128;
2108 charset_table
= ((struct charset
*)
2109 xmalloc (sizeof (struct charset
) * charset_table_size
));
2110 charset_table_used
= 0;
2112 staticpro (&Vchar_unified_charset_table
);
2113 Vchar_unified_charset_table
= Fmake_char_table (Qnil
, make_number (-1));
2115 defsubr (&Scharsetp
);
2116 defsubr (&Smap_charset_chars
);
2117 defsubr (&Sdefine_charset_internal
);
2118 defsubr (&Sdefine_charset_alias
);
2119 defsubr (&Sunibyte_charset
);
2120 defsubr (&Sset_unibyte_charset
);
2121 defsubr (&Scharset_plist
);
2122 defsubr (&Sset_charset_plist
);
2123 defsubr (&Sunify_charset
);
2124 defsubr (&Sget_unused_iso_final_char
);
2125 defsubr (&Sdeclare_equiv_charset
);
2126 defsubr (&Sfind_charset_region
);
2127 defsubr (&Sfind_charset_string
);
2128 defsubr (&Sdecode_char
);
2129 defsubr (&Sencode_char
);
2130 defsubr (&Ssplit_char
);
2131 defsubr (&Smake_char
);
2132 defsubr (&Schar_charset
);
2133 defsubr (&Scharset_after
);
2134 defsubr (&Siso_charset
);
2135 defsubr (&Sclear_charset_maps
);
2136 defsubr (&Scharset_priority_list
);
2137 defsubr (&Sset_charset_priority
);
2138 defsubr (&Scharset_id_internal
);
2140 DEFVAR_LISP ("charset-map-directory", &Vcharset_map_directory
,
2141 doc
: /* Directory of charset map files that come with GNU Emacs.
2142 The default value is sub-directory "charsets" of `data-directory'. */);
2143 Vcharset_map_directory
= Fexpand_file_name (build_string ("charsets"),
2146 DEFVAR_LISP ("charset-list", &Vcharset_list
,
2147 doc
: /* List of all charsets ever defined. */);
2148 Vcharset_list
= Qnil
;
2151 = define_charset_internal (Qascii
, 1, "\x00\x7F\x00\x00\x00\x00",
2152 0, 127, 'B', -1, 0, 1, 0, 0);
2154 = define_charset_internal (Qiso_8859_1
, 1, "\x00\xFF\x00\x00\x00\x00",
2155 0, 255, -1, -1, -1, 1, 0, 0);
2157 = define_charset_internal (Qunicode
, 3, "\x00\xFF\x00\xFF\x00\x10",
2158 0, MAX_UNICODE_CHAR
, -1, 0, -1, 1, 0, 0);
2160 = define_charset_internal (Qeight_bit
, 1, "\x80\xFF\x00\x00\x00\x00",
2161 128, 255, -1, 0, -1, 0, 0,
2162 MAX_5_BYTE_CHAR
+ 1);