the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-/* Synched up with: FSF 20.3. Not in FSF. */
+/* Synched up with: Mule 2.3. Not in FSF. */
/* Rewritten by Ben Wing <ben@xemacs.org>. */
#include "lstream.h"
#include "device.h"
#include "faces.h"
-#include "mule-ccl.h"
/* The various pre-defined charsets. */
Lisp_Object Vcharset_latin_iso8859_2;
Lisp_Object Vcharset_latin_iso8859_3;
Lisp_Object Vcharset_latin_iso8859_4;
-Lisp_Object Vcharset_thai_tis620;
-Lisp_Object Vcharset_greek_iso8859_7;
+Lisp_Object Vcharset_cyrillic_iso8859_5;
Lisp_Object Vcharset_arabic_iso8859_6;
+Lisp_Object Vcharset_greek_iso8859_7;
Lisp_Object Vcharset_hebrew_iso8859_8;
+Lisp_Object Vcharset_latin_iso8859_9;
+Lisp_Object Vcharset_thai_tis620;
Lisp_Object Vcharset_katakana_jisx0201;
Lisp_Object Vcharset_latin_jisx0201;
-Lisp_Object Vcharset_cyrillic_iso8859_5;
-Lisp_Object Vcharset_latin_iso8859_9;
Lisp_Object Vcharset_japanese_jisx0208_1978;
-Lisp_Object Vcharset_chinese_gb2312;
Lisp_Object Vcharset_japanese_jisx0208;
-Lisp_Object Vcharset_korean_ksc5601;
Lisp_Object Vcharset_japanese_jisx0212;
-Lisp_Object Vcharset_chinese_cns11643_1;
-Lisp_Object Vcharset_chinese_cns11643_2;
+Lisp_Object Vcharset_chinese_gb2312;
Lisp_Object Vcharset_chinese_big5_1;
Lisp_Object Vcharset_chinese_big5_2;
-
-#ifdef ENABLE_COMPOSITE_CHARS
+Lisp_Object Vcharset_chinese_cns11643_1;
+Lisp_Object Vcharset_chinese_cns11643_2;
+Lisp_Object Vcharset_korean_ksc5601;
Lisp_Object Vcharset_composite;
-/* Hash tables for composite chars. One maps string representing
+/* Hashtables for composite chars. One maps string representing
composed chars to their equivalent chars; one goes the
other way. */
-Lisp_Object Vcomposite_char_char2string_hash_table;
-Lisp_Object Vcomposite_char_string2char_hash_table;
+Lisp_Object Vcomposite_char_char2string_hashtable;
+Lisp_Object Vcomposite_char_string2char_hashtable;
-static int composite_char_row_next;
-static int composite_char_col_next;
-
-#endif /* ENABLE_COMPOSITE_CHARS */
+/* Table of charsets indexed by leading byte. */
+Lisp_Object charset_by_leading_byte[128];
-struct charset_lookup *chlook;
-
-static const struct lrecord_description charset_lookup_description_1[] = {
- { XD_LISP_OBJECT_ARRAY, offsetof (struct charset_lookup, charset_by_leading_byte), 128+4*128*2 },
- { XD_END }
-};
+/* Table of charsets indexed by type/final-byte/direction. */
+Lisp_Object charset_by_attributes[4][128][2];
-static const struct struct_description charset_lookup_description = {
- sizeof (struct charset_lookup),
- charset_lookup_description_1
-};
+static int composite_char_row_next;
+static int composite_char_col_next;
/* Table of number of bytes in the string representation of a character
indexed by the first byte of that representation.
rep_bytes_by_first_byte(c) is more efficient than the equivalent
canonical computation:
- XCHARSET_REP_BYTES (CHARSET_BY_LEADING_BYTE (c)) */
+ (BYTE_ASCII_P (c) ? 1 : XCHARSET_REP_BYTES (CHARSET_BY_LEADING_BYTE (c))) */
-const Bytecount rep_bytes_by_first_byte[0xA0] =
+Bytecount rep_bytes_by_first_byte[0xA0] =
{ /* 0x00 - 0x7f are for straight ASCII */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
Lisp_Object Qregistry, Qfinal, Qgraphic;
Lisp_Object Qdirection;
Lisp_Object Qreverse_direction_charset;
-Lisp_Object Qleading_byte;
-Lisp_Object Qshort_name, Qlong_name;
+Lisp_Object Qccl_program;
+
+Lisp_Object Qascii, Qcontrol_1,
-Lisp_Object Qascii,
- Qcontrol_1,
Qlatin_iso8859_1,
Qlatin_iso8859_2,
Qlatin_iso8859_3,
Qlatin_iso8859_4,
- Qthai_tis620,
- Qgreek_iso8859_7,
+ Qcyrillic_iso8859_5,
Qarabic_iso8859_6,
+ Qgreek_iso8859_7,
Qhebrew_iso8859_8,
- Qkatakana_jisx0201,
- Qlatin_jisx0201,
- Qcyrillic_iso8859_5,
Qlatin_iso8859_9,
+
+ Qthai_tis620,
+
+ Qkatakana_jisx0201, Qlatin_jisx0201,
Qjapanese_jisx0208_1978,
- Qchinese_gb2312,
Qjapanese_jisx0208,
- Qkorean_ksc5601,
Qjapanese_jisx0212,
- Qchinese_cns11643_1,
- Qchinese_cns11643_2,
- Qchinese_big5_1,
- Qchinese_big5_2,
- Qcomposite;
+
+ Qchinese_gb2312,
+ Qchinese_big5_1, Qchinese_big5_2,
+ Qchinese_cns11643_1, Qchinese_cns11643_2,
+
+ Qkorean_ksc5601, Qcomposite;
Lisp_Object Ql2r, Qr2l;
-Lisp_Object Vcharset_hash_table;
+Lisp_Object Vcharset_hashtable;
+
+static Bufbyte next_allocated_1_byte_leading_byte;
+static Bufbyte next_allocated_2_byte_leading_byte;
/* Composite characters are characters constructed by overstriking two
or more regular characters.
Use the macro charptr_emchar() instead. */
Emchar
-non_ascii_charptr_emchar (const Bufbyte *str)
+non_ascii_charptr_emchar (CONST Bufbyte *str)
{
Bufbyte i0 = *str, i1, i2 = 0;
Lisp_Object charset;
if (f3 < 0x20)
return 0;
- if (f3 != 0x20 && f3 != 0x7F && !(f2 >= MIN_CHAR_FIELD2_PRIVATE &&
- f2 <= MAX_CHAR_FIELD2_PRIVATE))
+ if (f3 != 0x20 && f3 != 0x7F)
return 1;
/*
FIELD2_TO_PRIVATE_LEADING_BYTE are the same.
*/
charset = CHARSET_BY_LEADING_BYTE (f2 + FIELD2_TO_OFFICIAL_LEADING_BYTE);
- if (EQ (charset, Qnil))
- return 0;
return (XCHARSET_CHARS (charset) == 96);
}
else
if (f2 < 0x20 || f3 < 0x20)
return 0;
-#ifdef ENABLE_COMPOSITE_CHARS
if (f1 + FIELD1_TO_OFFICIAL_LEADING_BYTE == LEADING_BYTE_COMPOSITE)
{
if (UNBOUNDP (Fgethash (make_int (ch),
- Vcomposite_char_char2string_hash_table,
+ Vcomposite_char_char2string_hashtable,
Qunbound)))
return 0;
return 1;
}
-#endif /* ENABLE_COMPOSITE_CHARS */
- if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F
- && !(f1 >= MIN_CHAR_FIELD1_PRIVATE && f1 <= MAX_CHAR_FIELD1_PRIVATE))
+ if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F)
return 1;
if (f1 <= MAX_CHAR_FIELD1_OFFICIAL)
charset =
CHARSET_BY_LEADING_BYTE (f1 + FIELD1_TO_PRIVATE_LEADING_BYTE);
- if (EQ (charset, Qnil))
- return 0;
return (XCHARSET_CHARS (charset) == 96);
}
}
charptr_copy_char() instead. */
Bytecount
-non_ascii_charptr_copy_char (const Bufbyte *ptr, Bufbyte *str)
+non_ascii_charptr_copy_char (CONST Bufbyte *ptr, Bufbyte *str)
{
Bufbyte *strptr = str;
*strptr = *ptr++;
/************************************************************************/
static Lisp_Object
-mark_charset (Lisp_Object obj)
+mark_charset (Lisp_Object obj, void (*markobj) (Lisp_Object))
{
- Lisp_Charset *cs = XCHARSET (obj);
+ struct Lisp_Charset *cs = XCHARSET (obj);
- mark_object (cs->short_name);
- mark_object (cs->long_name);
- mark_object (cs->doc_string);
- mark_object (cs->registry);
- mark_object (cs->ccl_program);
+ (markobj) (cs->doc_string);
+ (markobj) (cs->registry);
+ (markobj) (cs->ccl_program);
return cs->name;
}
static void
print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
{
- Lisp_Charset *cs = XCHARSET (obj);
+ struct Lisp_Charset *cs = XCHARSET (obj);
char buf[200];
if (print_readably)
write_c_string ("#<charset ", printcharfun);
print_internal (CHARSET_NAME (cs), printcharfun, 0);
write_c_string (" ", printcharfun);
- print_internal (CHARSET_SHORT_NAME (cs), printcharfun, 1);
- write_c_string (" ", printcharfun);
- print_internal (CHARSET_LONG_NAME (cs), printcharfun, 1);
- write_c_string (" ", printcharfun);
print_internal (CHARSET_DOC_STRING (cs), printcharfun, 1);
sprintf (buf, " %s %s cols=%d g%d final='%c' reg=",
CHARSET_TYPE (cs) == CHARSET_TYPE_94 ? "94" :
write_c_string (buf, printcharfun);
}
-static const struct lrecord_description charset_description[] = {
- { XD_LISP_OBJECT, offsetof (Lisp_Charset, name) },
- { XD_LISP_OBJECT, offsetof (Lisp_Charset, doc_string) },
- { XD_LISP_OBJECT, offsetof (Lisp_Charset, registry) },
- { XD_LISP_OBJECT, offsetof (Lisp_Charset, short_name) },
- { XD_LISP_OBJECT, offsetof (Lisp_Charset, long_name) },
- { XD_LISP_OBJECT, offsetof (Lisp_Charset, reverse_direction_charset) },
- { XD_LISP_OBJECT, offsetof (Lisp_Charset, ccl_program) },
- { XD_END }
-};
-
DEFINE_LRECORD_IMPLEMENTATION ("charset", charset,
- mark_charset, print_charset, 0, 0, 0, charset_description,
- Lisp_Charset);
+ mark_charset, print_charset, 0, 0, 0,
+ struct Lisp_Charset);
/* Make a new charset. */
static Lisp_Object
-make_charset (int id, Lisp_Object name, unsigned char rep_bytes,
+make_charset (int id, Lisp_Object name, Bufbyte leading_byte, unsigned char rep_bytes,
unsigned char type, unsigned char columns, unsigned char graphic,
- Bufbyte final, unsigned char direction, Lisp_Object short_name,
- Lisp_Object long_name, Lisp_Object doc,
+ Bufbyte final, unsigned char direction, Lisp_Object doc,
Lisp_Object reg)
{
Lisp_Object obj;
- Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset);
-
- zero_lcrecord (cs);
-
+ struct Lisp_Charset *cs =
+ alloc_lcrecord_type (struct Lisp_Charset, lrecord_charset);
XSETCHARSET (obj, cs);
CHARSET_ID (cs) = id;
CHARSET_NAME (cs) = name;
- CHARSET_SHORT_NAME (cs) = short_name;
- CHARSET_LONG_NAME (cs) = long_name;
+ CHARSET_LEADING_BYTE (cs) = leading_byte;
CHARSET_REP_BYTES (cs) = rep_bytes;
CHARSET_DIRECTION (cs) = direction;
CHARSET_TYPE (cs) = type;
CHARSET_TYPE (cs) == CHARSET_TYPE_96) ? 1 : 2;
CHARSET_CHARS (cs) = (CHARSET_TYPE (cs) == CHARSET_TYPE_94 ||
CHARSET_TYPE (cs) == CHARSET_TYPE_94X94) ? 94 : 96;
-
+
if (final)
{
/* some charsets do not have final characters. This includes
ASCII, Control-1, Composite, and the two faux private
charsets. */
- assert (NILP (chlook->charset_by_attributes[type][final][direction]));
- chlook->charset_by_attributes[type][final][direction] = obj;
+ assert (NILP (charset_by_attributes[type][final][direction]));
+ charset_by_attributes[type][final][direction] = obj;
}
- assert (NILP (chlook->charset_by_leading_byte[id - 128]));
- chlook->charset_by_leading_byte[id - 128] = obj;
+ assert (NILP (charset_by_leading_byte[leading_byte - 128]));
+ charset_by_leading_byte[leading_byte - 128] = obj;
+ if (leading_byte < 0xA0)
+ /* official leading byte */
+ rep_bytes_by_first_byte[leading_byte] = rep_bytes;
/* Some charsets are "faux" and don't have names or really exist at
all except in the leading-byte table. */
if (!NILP (name))
- Fputhash (name, obj, Vcharset_hash_table);
+ Fputhash (name, obj, Vcharset_hashtable);
return obj;
}
if (dimension == 1)
{
- if (chlook->next_allocated_1_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_1)
+ if (next_allocated_1_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_1)
lb = 0;
else
- lb = chlook->next_allocated_1_byte_leading_byte++;
+ lb = next_allocated_1_byte_leading_byte++;
}
else
{
- if (chlook->next_allocated_2_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_2)
+ if (next_allocated_2_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_2)
lb = 0;
else
- lb = chlook->next_allocated_2_byte_leading_byte++;
+ lb = next_allocated_2_byte_leading_byte++;
}
if (!lb)
return charset_or_name;
CHECK_SYMBOL (charset_or_name);
- return Fgethash (charset_or_name, Vcharset_hash_table, Qnil);
+ return Fgethash (charset_or_name, Vcharset_hashtable, Qnil);
}
DEFUN ("get-charset", Fget_charset, 1, 1, 0, /*
};
static int
-add_charset_to_list_mapper (Lisp_Object key, Lisp_Object value,
+add_charset_to_list_mapper (CONST void *hash_key, void *hash_contents,
void *charset_list_closure)
{
/* This function can GC */
+ Lisp_Object key, contents;
+ Lisp_Object *charset_list;
struct charset_list_closure *chcl =
(struct charset_list_closure*) charset_list_closure;
- Lisp_Object *charset_list = chcl->charset_list;
+ CVOID_TO_LISP (key, hash_key);
+ VOID_TO_LISP (contents, hash_contents);
+ charset_list = chcl->charset_list;
- *charset_list = Fcons (XCHARSET_NAME (value), *charset_list);
+ *charset_list = Fcons (XCHARSET_NAME (contents), *charset_list);
return 0;
}
GCPRO1 (charset_list);
charset_list_closure.charset_list = &charset_list;
- elisp_maphash (add_charset_to_list_mapper, Vcharset_hash_table,
+ elisp_maphash (add_charset_to_list_mapper, Vcharset_hashtable,
&charset_list_closure);
UNGCPRO;
PROPS is a property list, describing the specific nature of the
character set. Recognized properties are:
-'short-name Short version of the charset name (ex: Latin-1)
-'long-name Long version of the charset name (ex: ISO8859-1 (Latin-1))
'registry A regular expression matching the font registry field for
this character set.
'dimension Number of octets used to index a character in this charset.
*/
(name, doc_string, props))
{
- int id, dimension = 1, chars = 94, graphic = 0, final = 0, columns = -1;
+ int lb, dimension = 1, chars = 94, graphic = 0, final = 0, columns = -1;
int direction = CHARSET_LEFT_TO_RIGHT;
int type;
Lisp_Object registry = Qnil;
Lisp_Object charset;
+ Lisp_Object rest, keyword, value;
Lisp_Object ccl_program = Qnil;
- Lisp_Object short_name = Qnil, long_name = Qnil;
CHECK_SYMBOL (name);
if (!NILP (doc_string))
if (!NILP (charset))
signal_simple_error ("Cannot redefine existing charset", name);
- {
- EXTERNAL_PROPERTY_LIST_LOOP_3 (keyword, value, props)
- {
- if (EQ (keyword, Qshort_name))
- {
- CHECK_STRING (value);
- short_name = value;
- }
-
- if (EQ (keyword, Qlong_name))
- {
- CHECK_STRING (value);
- long_name = value;
- }
-
- else if (EQ (keyword, Qdimension))
- {
- CHECK_INT (value);
- dimension = XINT (value);
- if (dimension < 1 || dimension > 2)
- signal_simple_error ("Invalid value for 'dimension", value);
- }
-
- else if (EQ (keyword, Qchars))
- {
- CHECK_INT (value);
- chars = XINT (value);
- if (chars != 94 && chars != 96)
- signal_simple_error ("Invalid value for 'chars", value);
- }
-
- else if (EQ (keyword, Qcolumns))
- {
- CHECK_INT (value);
- columns = XINT (value);
- if (columns != 1 && columns != 2)
- signal_simple_error ("Invalid value for 'columns", value);
- }
-
- else if (EQ (keyword, Qgraphic))
- {
- CHECK_INT (value);
- graphic = XINT (value);
- if (graphic < 0 || graphic > 1)
- signal_simple_error ("Invalid value for 'graphic", value);
- }
-
- else if (EQ (keyword, Qregistry))
- {
- CHECK_STRING (value);
- registry = value;
- }
-
- else if (EQ (keyword, Qdirection))
- {
- if (EQ (value, Ql2r))
- direction = CHARSET_LEFT_TO_RIGHT;
- else if (EQ (value, Qr2l))
- direction = CHARSET_RIGHT_TO_LEFT;
- else
- signal_simple_error ("Invalid value for 'direction", value);
- }
-
- else if (EQ (keyword, Qfinal))
- {
- CHECK_CHAR_COERCE_INT (value);
- final = XCHAR (value);
- if (final < '0' || final > '~')
- signal_simple_error ("Invalid value for 'final", value);
- }
-
- else if (EQ (keyword, Qccl_program))
- {
- CHECK_VECTOR (value);
- ccl_program = value;
- }
-
- else
- signal_simple_error ("Unrecognized property", keyword);
- }
- }
+ EXTERNAL_PROPERTY_LIST_LOOP (rest, keyword, value, props)
+ {
+ if (EQ (keyword, Qdimension))
+ {
+ CHECK_INT (value);
+ dimension = XINT (value);
+ if (dimension < 1 || dimension > 2)
+ signal_simple_error ("Invalid value for 'dimension", value);
+ }
+
+ else if (EQ (keyword, Qchars))
+ {
+ CHECK_INT (value);
+ chars = XINT (value);
+ if (chars != 94 && chars != 96)
+ signal_simple_error ("Invalid value for 'chars", value);
+ }
+
+ else if (EQ (keyword, Qcolumns))
+ {
+ CHECK_INT (value);
+ columns = XINT (value);
+ if (columns != 1 && columns != 2)
+ signal_simple_error ("Invalid value for 'columns", value);
+ }
+
+ else if (EQ (keyword, Qgraphic))
+ {
+ CHECK_INT (value);
+ graphic = XINT (value);
+ if (graphic < 0 || graphic > 1)
+ signal_simple_error ("Invalid value for 'graphic", value);
+ }
+
+ else if (EQ (keyword, Qregistry))
+ {
+ CHECK_STRING (value);
+ registry = value;
+ }
+
+ else if (EQ (keyword, Qdirection))
+ {
+ if (EQ (value, Ql2r))
+ direction = CHARSET_LEFT_TO_RIGHT;
+ else if (EQ (value, Qr2l))
+ direction = CHARSET_RIGHT_TO_LEFT;
+ else
+ signal_simple_error ("Invalid value for 'direction", value);
+ }
+
+ else if (EQ (keyword, Qfinal))
+ {
+ CHECK_CHAR_COERCE_INT (value);
+ final = XCHAR (value);
+ if (final < '0' || final > '~')
+ signal_simple_error ("Invalid value for 'final", value);
+ }
+
+ else if (EQ (keyword, Qccl_program))
+ {
+ CHECK_VECTOR (value);
+ ccl_program = value;
+ }
+
+ else
+ signal_simple_error ("Unrecognized property", keyword);
+ }
if (!final)
error ("'final must be specified");
error
("Character set already defined for this DIMENSION/CHARS/FINAL combo");
- id = get_unallocated_leading_byte (dimension);
+ lb = get_unallocated_leading_byte (dimension);
if (NILP (doc_string))
doc_string = build_string ("");
if (NILP (registry))
registry = build_string ("");
- if (NILP (short_name))
- XSETSTRING (short_name, XSYMBOL (name)->name);
-
- if (NILP (long_name))
- long_name = doc_string;
-
if (columns == -1)
columns = dimension;
- charset = make_charset (id, name, dimension + 2, type, columns, graphic,
- final, direction, short_name, long_name, doc_string, registry);
+ charset = make_charset (-1, name, lb, dimension + 2, type, columns, graphic,
+ final, direction, doc_string, registry);
if (!NILP (ccl_program))
XCHARSET_CCL_PROGRAM (charset) = ccl_program;
return charset;
(charset, new_name))
{
Lisp_Object new_charset = Qnil;
- int id, dimension, columns, graphic, final;
+ int lb, dimension, columns, graphic, final;
int direction, type;
- Lisp_Object registry, doc_string, short_name, long_name;
- Lisp_Charset *cs;
+ Lisp_Object registry, doc_string;
+ struct Lisp_Charset *cs;
charset = Fget_charset (charset);
if (!NILP (XCHARSET_REVERSE_DIRECTION_CHARSET (charset)))
type = CHARSET_TYPE (cs);
columns = CHARSET_COLUMNS (cs);
dimension = CHARSET_DIMENSION (cs);
- id = get_unallocated_leading_byte (dimension);
+ lb = get_unallocated_leading_byte (dimension);
graphic = CHARSET_GRAPHIC (cs);
final = CHARSET_FINAL (cs);
if (CHARSET_DIRECTION (cs) == CHARSET_RIGHT_TO_LEFT)
direction = CHARSET_LEFT_TO_RIGHT;
doc_string = CHARSET_DOC_STRING (cs);
- short_name = CHARSET_SHORT_NAME (cs);
- long_name = CHARSET_LONG_NAME (cs);
registry = CHARSET_REGISTRY (cs);
- new_charset = make_charset (id, new_name, dimension + 2, type, columns,
- graphic, final, direction, short_name, long_name,
- doc_string, registry);
+ new_charset = make_charset (-1, new_name, lb, dimension + 2, type, columns,
+ graphic, final, direction, doc_string, registry);
CHARSET_REVERSE_DIRECTION_CHARSET (cs) = new_charset;
XCHARSET_REVERSE_DIRECTION_CHARSET (new_charset) = charset;
return obj;
}
-DEFUN ("charset-short-name", Fcharset_short_name, 1, 1, 0, /*
-Return short name of CHARSET.
-*/
- (charset))
-{
- return XCHARSET_SHORT_NAME (Fget_charset (charset));
-}
-
-DEFUN ("charset-long-name", Fcharset_long_name, 1, 1, 0, /*
-Return long name of CHARSET.
-*/
- (charset))
-{
- return XCHARSET_LONG_NAME (Fget_charset (charset));
-}
-
-DEFUN ("charset-description", Fcharset_description, 1, 1, 0, /*
-Return description of CHARSET.
+DEFUN ("charset-doc-string", Fcharset_doc_string, 1, 1, 0, /*
+Return doc string of CHARSET.
*/
(charset))
{
*/
(charset, prop))
{
- Lisp_Charset *cs;
+ struct Lisp_Charset *cs;
charset = Fget_charset (charset);
cs = XCHARSET (charset);
CHECK_SYMBOL (prop);
if (EQ (prop, Qname)) return CHARSET_NAME (cs);
- if (EQ (prop, Qshort_name)) return CHARSET_SHORT_NAME (cs);
- if (EQ (prop, Qlong_name)) return CHARSET_LONG_NAME (cs);
if (EQ (prop, Qdoc_string)) return CHARSET_DOC_STRING (cs);
if (EQ (prop, Qdimension)) return make_int (CHARSET_DIMENSION (cs));
if (EQ (prop, Qcolumns)) return make_int (CHARSET_COLUMNS (cs));
*/
(charset))
{
- return make_int(XCHARSET_LEADING_BYTE (Fget_charset (charset)));
+ return make_int(XCHARSET_ID (Fget_charset (charset)));
}
/* #### We need to figure out which properties we really want to
invalidate_charset_font_caches (Lisp_Object charset)
{
/* Invalidate font cache entries for charset on all devices. */
- Lisp_Object devcons, concons, hash_table;
+ Lisp_Object devcons, concons, hashtab;
DEVICE_LOOP_NO_BREAK (devcons, concons)
{
struct device *d = XDEVICE (XCAR (devcons));
- hash_table = Fgethash (charset, d->charset_font_cache, Qunbound);
- if (!UNBOUNDP (hash_table))
- Fclrhash (hash_table);
+ hashtab = Fgethash (charset, d->charset_font_cache, Qunbound);
+ if (!UNBOUNDP (hashtab))
+ Fclrhash (hashtab);
}
}
/************************************************************************/
DEFUN ("make-char", Fmake_char, 2, 3, 0, /*
-Make a character from CHARSET and octets ARG1 and ARG2.
-ARG2 is required only for characters from two-dimensional charsets.
-For example, (make-char 'latin-iso8859-2 185) will return the Latin 2
-character s with caron.
+Make a multi-byte character from CHARSET and octets ARG1 and ARG2.
*/
(charset, arg1, arg2))
{
- Lisp_Charset *cs;
+ struct Lisp_Charset *cs;
int a1, a2;
int lowlim, highlim;
else /* CHARSET_CHARS (cs) == 96) */ lowlim = 32, highlim = 127;
CHECK_INT (arg1);
- /* It is useful (and safe, according to Olivier Galibert) to strip
- the 8th bit off ARG1 and ARG2 because it allows programmers to
- write (make-char 'latin-iso8859-2 CODE) where code is the actual
- Latin 2 code of the character. */
- a1 = XINT (arg1) & 0x7f;
+ a1 = XINT (arg1);
if (a1 < lowlim || a1 > highlim)
args_out_of_range_3 (arg1, make_int (lowlim), make_int (highlim));
}
CHECK_INT (arg2);
- a2 = XINT (arg2) & 0x7f;
+ a2 = XINT (arg2);
if (a2 < lowlim || a2 > highlim)
args_out_of_range_3 (arg2, make_int (lowlim), make_int (highlim));
(ch, n))
{
Lisp_Object charset;
- int octet0, octet1;
+ int c1, c2, int_n;
CHECK_CHAR_COERCE_INT (ch);
-
- BREAKUP_CHAR (XCHAR (ch), charset, octet0, octet1);
-
- if (NILP (n) || EQ (n, Qzero))
- return make_int (octet0);
- else if (EQ (n, make_int (1)))
- return make_int (octet1);
- else
- signal_simple_error ("Octet number must be 0 or 1", n);
-}
-
-DEFUN ("split-char", Fsplit_char, 1, 1, 0, /*
-Return list of charset and one or two position-codes of CHAR.
-*/
- (character))
-{
- /* This function can GC */
- struct gcpro gcpro1, gcpro2;
- Lisp_Object charset = Qnil;
- Lisp_Object rc = Qnil;
- int c1, c2;
-
- GCPRO2 (charset, rc);
- CHECK_CHAR_COERCE_INT (character);
-
- BREAKUP_CHAR (XCHAR (character), charset, c1, c2);
-
- if (XCHARSET_DIMENSION (Fget_charset (charset)) == 2)
- {
- rc = list3 (XCHARSET_NAME (charset), make_int (c1), make_int (c2));
- }
+ if (NILP (n))
+ int_n = 0;
else
{
- rc = list2 (XCHARSET_NAME (charset), make_int (c1));
+ CHECK_INT (n);
+ int_n = XINT (n);
+ if (int_n != 0 && int_n != 1)
+ signal_simple_error ("Octet number must be 0 or 1", n);
}
- UNGCPRO;
-
- return rc;
+ BREAKUP_CHAR (XCHAR (ch), charset, c1, c2);
+ return make_int (int_n == 0 ? c1 : c2);
}
\f
-#ifdef ENABLE_COMPOSITE_CHARS
/************************************************************************/
/* composite character functions */
/************************************************************************/
{
Lisp_Object lispstr = make_string (str, len);
Lisp_Object ch = Fgethash (lispstr,
- Vcomposite_char_string2char_hash_table,
+ Vcomposite_char_string2char_hashtable,
Qunbound);
Emchar emch;
emch = MAKE_CHAR (Vcharset_composite, composite_char_row_next,
composite_char_col_next);
Fputhash (make_char (emch), lispstr,
- Vcomposite_char_char2string_hash_table);
+ Vcomposite_char_char2string_hashtable);
Fputhash (lispstr, make_char (emch),
- Vcomposite_char_string2char_hash_table);
+ Vcomposite_char_string2char_hashtable);
composite_char_col_next++;
if (composite_char_col_next >= 128)
{
composite_char_string (Emchar ch)
{
Lisp_Object str = Fgethash (make_char (ch),
- Vcomposite_char_char2string_hash_table,
+ Vcomposite_char_char2string_hashtable,
Qunbound);
assert (!UNBOUNDP (str));
return str;
}
-xxDEFUN ("make-composite-char", Fmake_composite_char, 1, 1, 0, /*
+DEFUN ("make-composite-char", Fmake_composite_char, 1, 1, 0, /*
Convert a string into a single composite character.
The character is the result of overstriking all the characters in
the string.
XSTRING_LENGTH (string)));
}
-xxDEFUN ("composite-char-string", Fcomposite_char_string, 1, 1, 0, /*
+DEFUN ("composite-char-string", Fcomposite_char_string, 1, 1, 0, /*
Return a string of the characters comprising a composite character.
*/
(ch))
signal_simple_error ("Must be composite char", ch);
return composite_char_string (emch);
}
-#endif /* ENABLE_COMPOSITE_CHARS */
\f
/************************************************************************/
void
syms_of_mule_charset (void)
{
- INIT_LRECORD_IMPLEMENTATION (charset);
-
DEFSUBR (Fcharsetp);
DEFSUBR (Ffind_charset);
DEFSUBR (Fget_charset);
DEFSUBR (Fmake_reverse_direction_charset);
/* DEFSUBR (Freverse_direction_charset); */
DEFSUBR (Fcharset_from_attributes);
- DEFSUBR (Fcharset_short_name);
- DEFSUBR (Fcharset_long_name);
- DEFSUBR (Fcharset_description);
+ DEFSUBR (Fcharset_doc_string);
DEFSUBR (Fcharset_dimension);
DEFSUBR (Fcharset_property);
DEFSUBR (Fcharset_id);
DEFSUBR (Fmake_char);
DEFSUBR (Fchar_charset);
DEFSUBR (Fchar_octet);
- DEFSUBR (Fsplit_char);
-#ifdef ENABLE_COMPOSITE_CHARS
DEFSUBR (Fmake_composite_char);
DEFSUBR (Fcomposite_char_string);
-#endif
defsymbol (&Qcharsetp, "charsetp");
defsymbol (&Qregistry, "registry");
defsymbol (&Qgraphic, "graphic");
defsymbol (&Qdirection, "direction");
defsymbol (&Qreverse_direction_charset, "reverse-direction-charset");
- defsymbol (&Qshort_name, "short-name");
- defsymbol (&Qlong_name, "long-name");
+ defsymbol (&Qccl_program, "ccl-program");
defsymbol (&Ql2r, "l2r");
defsymbol (&Qr2l, "r2l");
- /* Charsets, compatible with FSF 20.3
+ /* Charsets, compatible with Emacs/Mule 19.33-delta
Naming convention is Script-Charset[-Edition] */
defsymbol (&Qascii, "ascii");
defsymbol (&Qcontrol_1, "control-1");
defsymbol (&Qlatin_iso8859_2, "latin-iso8859-2");
defsymbol (&Qlatin_iso8859_3, "latin-iso8859-3");
defsymbol (&Qlatin_iso8859_4, "latin-iso8859-4");
- defsymbol (&Qthai_tis620, "thai-tis620");
- defsymbol (&Qgreek_iso8859_7, "greek-iso8859-7");
+ defsymbol (&Qcyrillic_iso8859_5, "cyrillic-iso8859-5");
defsymbol (&Qarabic_iso8859_6, "arabic-iso8859-6");
+ defsymbol (&Qgreek_iso8859_7, "greek-iso8859-7");
defsymbol (&Qhebrew_iso8859_8, "hebrew-iso8859-8");
+ defsymbol (&Qlatin_iso8859_9, "latin-iso8859-9");
+ defsymbol (&Qthai_tis620, "thai-tis620");
+
defsymbol (&Qkatakana_jisx0201, "katakana-jisx0201");
defsymbol (&Qlatin_jisx0201, "latin-jisx0201");
- defsymbol (&Qcyrillic_iso8859_5, "cyrillic-iso8859-5");
- defsymbol (&Qlatin_iso8859_9, "latin-iso8859-9");
defsymbol (&Qjapanese_jisx0208_1978, "japanese-jisx0208-1978");
- defsymbol (&Qchinese_gb2312, "chinese-gb2312");
defsymbol (&Qjapanese_jisx0208, "japanese-jisx0208");
- defsymbol (&Qkorean_ksc5601, "korean-ksc5601");
defsymbol (&Qjapanese_jisx0212, "japanese-jisx0212");
- defsymbol (&Qchinese_cns11643_1, "chinese-cns11643-1");
- defsymbol (&Qchinese_cns11643_2, "chinese-cns11643-2");
+
+ defsymbol (&Qchinese_gb2312, "chinese-gb2312");
defsymbol (&Qchinese_big5_1, "chinese-big5-1");
defsymbol (&Qchinese_big5_2, "chinese-big5-2");
+ defsymbol (&Qchinese_cns11643_1, "chinese-cns11643-1");
+ defsymbol (&Qchinese_cns11643_2, "chinese-cns11643-2");
+ defsymbol (&Qkorean_ksc5601, "korean-ksc5601");
defsymbol (&Qcomposite, "composite");
}
{
int i, j, k;
- chlook = xnew (struct charset_lookup);
- dumpstruct (&chlook, &charset_lookup_description);
-
/* Table of charsets indexed by leading byte. */
- for (i = 0; i < countof (chlook->charset_by_leading_byte); i++)
- chlook->charset_by_leading_byte[i] = Qnil;
+ for (i = 0; i < countof (charset_by_leading_byte); i++)
+ charset_by_leading_byte[i] = Qnil;
/* Table of charsets indexed by type/final-byte/direction. */
- for (i = 0; i < countof (chlook->charset_by_attributes); i++)
- for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++)
- for (k = 0; k < countof (chlook->charset_by_attributes[0][0]); k++)
- chlook->charset_by_attributes[i][j][k] = Qnil;
+ for (i = 0; i < countof (charset_by_attributes); i++)
+ for (j = 0; j < countof (charset_by_attributes[0]); j++)
+ for (k = 0; k < countof (charset_by_attributes[0][0]); k++)
+ charset_by_attributes[i][j][k] = Qnil;
- chlook->next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1;
- chlook->next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2;
+ next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1;
+ next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2;
}
void
complex_vars_of_mule_charset (void)
{
- staticpro (&Vcharset_hash_table);
- Vcharset_hash_table =
- make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);
+ staticpro (&Vcharset_hashtable);
+ Vcharset_hashtable = make_lisp_hashtable (50, HASHTABLE_NONWEAK,
+ HASHTABLE_EQ);
/* Predefined character sets. We store them into variables for
ease of access. */
- staticpro (&Vcharset_ascii);
Vcharset_ascii =
- make_charset (LEADING_BYTE_ASCII, Qascii, 1,
+ make_charset (0, Qascii, LEADING_BYTE_ASCII, 1,
CHARSET_TYPE_94, 1, 0, 'B',
CHARSET_LEFT_TO_RIGHT,
- build_string ("ASCII"),
- build_string ("ASCII)"),
- build_string ("ASCII (ISO646 IRV)"),
- build_string ("\\(iso8859-[0-9]*\\|-ascii\\)"));
- staticpro (&Vcharset_control_1);
+ build_string ("ASCII (ISO 646 IRV)"),
+ build_string ("iso8859-1"));
Vcharset_control_1 =
- make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 2,
- CHARSET_TYPE_94, 1, 1, 0,
+ make_charset (-1, Qcontrol_1, LEADING_BYTE_CONTROL_1, 2,
+ CHARSET_TYPE_94, 1, 0, 0,
CHARSET_LEFT_TO_RIGHT,
- build_string ("C1"),
build_string ("Control characters"),
- build_string ("Control characters 128-191"),
build_string (""));
- staticpro (&Vcharset_latin_iso8859_1);
Vcharset_latin_iso8859_1 =
- make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 2,
+ make_charset (129, Qlatin_iso8859_1, LEADING_BYTE_LATIN_ISO8859_1, 2,
CHARSET_TYPE_96, 1, 1, 'A',
CHARSET_LEFT_TO_RIGHT,
- build_string ("Latin-1"),
- build_string ("ISO8859-1 (Latin-1)"),
- build_string ("ISO8859-1 (Latin-1)"),
+ build_string ("ISO 8859-1 (Latin-1)"),
build_string ("iso8859-1"));
- staticpro (&Vcharset_latin_iso8859_2);
Vcharset_latin_iso8859_2 =
- make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 2,
+ make_charset (130, Qlatin_iso8859_2, LEADING_BYTE_LATIN_ISO8859_2, 2,
CHARSET_TYPE_96, 1, 1, 'B',
CHARSET_LEFT_TO_RIGHT,
- build_string ("Latin-2"),
- build_string ("ISO8859-2 (Latin-2)"),
- build_string ("ISO8859-2 (Latin-2)"),
+ build_string ("ISO 8859-2 (Latin-2)"),
build_string ("iso8859-2"));
- staticpro (&Vcharset_latin_iso8859_3);
Vcharset_latin_iso8859_3 =
- make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 2,
+ make_charset (131, Qlatin_iso8859_3, LEADING_BYTE_LATIN_ISO8859_3, 2,
CHARSET_TYPE_96, 1, 1, 'C',
CHARSET_LEFT_TO_RIGHT,
- build_string ("Latin-3"),
- build_string ("ISO8859-3 (Latin-3)"),
- build_string ("ISO8859-3 (Latin-3)"),
+ build_string ("ISO 8859-3 (Latin-3)"),
build_string ("iso8859-3"));
- staticpro (&Vcharset_latin_iso8859_4);
Vcharset_latin_iso8859_4 =
- make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 2,
+ make_charset (132, Qlatin_iso8859_4, LEADING_BYTE_LATIN_ISO8859_4, 2,
CHARSET_TYPE_96, 1, 1, 'D',
CHARSET_LEFT_TO_RIGHT,
- build_string ("Latin-4"),
- build_string ("ISO8859-4 (Latin-4)"),
- build_string ("ISO8859-4 (Latin-4)"),
+ build_string ("ISO 8859-4 (Latin-4)"),
build_string ("iso8859-4"));
- staticpro (&Vcharset_thai_tis620);
- Vcharset_thai_tis620 =
- make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 2,
- CHARSET_TYPE_96, 1, 1, 'T',
- CHARSET_LEFT_TO_RIGHT,
- build_string ("TIS620"),
- build_string ("TIS620 (Thai)"),
- build_string ("TIS620.2529 (Thai)"),
- build_string ("tis620"));
- staticpro (&Vcharset_greek_iso8859_7);
- Vcharset_greek_iso8859_7 =
- make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 2,
- CHARSET_TYPE_96, 1, 1, 'F',
+ Vcharset_cyrillic_iso8859_5 =
+ make_charset (140, Qcyrillic_iso8859_5, LEADING_BYTE_CYRILLIC_ISO8859_5, 2,
+ CHARSET_TYPE_96, 1, 1, 'L',
CHARSET_LEFT_TO_RIGHT,
- build_string ("ISO8859-7"),
- build_string ("ISO8859-7 (Greek)"),
- build_string ("ISO8859-7 (Greek)"),
- build_string ("iso8859-7"));
- staticpro (&Vcharset_arabic_iso8859_6);
+ build_string ("ISO 8859-5 (Cyrillic)"),
+ build_string ("iso8859-5"));
Vcharset_arabic_iso8859_6 =
- make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 2,
+ make_charset (135, Qarabic_iso8859_6, LEADING_BYTE_ARABIC_ISO8859_6, 2,
CHARSET_TYPE_96, 1, 1, 'G',
CHARSET_RIGHT_TO_LEFT,
- build_string ("ISO8859-6"),
- build_string ("ISO8859-6 (Arabic)"),
- build_string ("ISO8859-6 (Arabic)"),
+ build_string ("ISO 8859-6 (Arabic)"),
build_string ("iso8859-6"));
- staticpro (&Vcharset_hebrew_iso8859_8);
+ Vcharset_greek_iso8859_7 =
+ make_charset (134, Qgreek_iso8859_7, LEADING_BYTE_GREEK_ISO8859_7, 2,
+ CHARSET_TYPE_96, 1, 1, 'F',
+ CHARSET_LEFT_TO_RIGHT,
+ build_string ("ISO 8859-7 (Greek)"),
+ build_string ("iso8859-7"));
Vcharset_hebrew_iso8859_8 =
- make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 2,
+ make_charset (136, Qhebrew_iso8859_8, LEADING_BYTE_HEBREW_ISO8859_8, 2,
CHARSET_TYPE_96, 1, 1, 'H',
CHARSET_RIGHT_TO_LEFT,
- build_string ("ISO8859-8"),
- build_string ("ISO8859-8 (Hebrew)"),
- build_string ("ISO8859-8 (Hebrew)"),
+ build_string ("ISO 8859-8 (Hebrew)"),
build_string ("iso8859-8"));
- staticpro (&Vcharset_katakana_jisx0201);
+ Vcharset_latin_iso8859_9 =
+ make_charset (141, Qlatin_iso8859_9, LEADING_BYTE_LATIN_ISO8859_9, 2,
+ CHARSET_TYPE_96, 1, 1, 'M',
+ CHARSET_LEFT_TO_RIGHT,
+ build_string ("ISO 8859-9 (Latin-5)"),
+ build_string ("iso8859-9"));
+ Vcharset_thai_tis620 =
+ make_charset (133, Qthai_tis620, LEADING_BYTE_THAI_TIS620, 2,
+ CHARSET_TYPE_96, 1, 1, 'T',
+ CHARSET_LEFT_TO_RIGHT,
+ build_string ("TIS 620.2529 (Thai)"),
+ build_string ("tis620"));
+
+ /* Japanese */
Vcharset_katakana_jisx0201 =
- make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 2,
+ make_charset (137, Qkatakana_jisx0201,
+ LEADING_BYTE_KATAKANA_JISX0201, 2,
CHARSET_TYPE_94, 1, 1, 'I',
CHARSET_LEFT_TO_RIGHT,
- build_string ("JISX0201 Kana"),
- build_string ("JISX0201.1976 (Japanese Kana)"),
- build_string ("JISX0201.1976 Japanese Kana"),
+ build_string ("JIS X0201-Katakana"),
build_string ("jisx0201.1976"));
- staticpro (&Vcharset_latin_jisx0201);
Vcharset_latin_jisx0201 =
- make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 2,
+ make_charset (138, Qlatin_jisx0201,
+ LEADING_BYTE_LATIN_JISX0201, 2,
CHARSET_TYPE_94, 1, 0, 'J',
CHARSET_LEFT_TO_RIGHT,
- build_string ("JISX0201 Roman"),
- build_string ("JISX0201.1976 (Japanese Roman)"),
- build_string ("JISX0201.1976 Japanese Roman"),
+ build_string ("JIS X0201-Latin"),
build_string ("jisx0201.1976"));
- staticpro (&Vcharset_cyrillic_iso8859_5);
- Vcharset_cyrillic_iso8859_5 =
- make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 2,
- CHARSET_TYPE_96, 1, 1, 'L',
- CHARSET_LEFT_TO_RIGHT,
- build_string ("ISO8859-5"),
- build_string ("ISO8859-5 (Cyrillic)"),
- build_string ("ISO8859-5 (Cyrillic)"),
- build_string ("iso8859-5"));
- staticpro (&Vcharset_latin_iso8859_9);
- Vcharset_latin_iso8859_9 =
- make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 2,
- CHARSET_TYPE_96, 1, 1, 'M',
- CHARSET_LEFT_TO_RIGHT,
- build_string ("Latin-5"),
- build_string ("ISO8859-9 (Latin-5)"),
- build_string ("ISO8859-9 (Latin-5)"),
- build_string ("iso8859-9"));
- staticpro (&Vcharset_japanese_jisx0208_1978);
Vcharset_japanese_jisx0208_1978 =
- make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978, Qjapanese_jisx0208_1978, 3,
+ make_charset (144, Qjapanese_jisx0208_1978,
+ LEADING_BYTE_JAPANESE_JISX0208_1978, 3,
CHARSET_TYPE_94X94, 2, 0, '@',
CHARSET_LEFT_TO_RIGHT,
- build_string ("JISX0208.1978"),
- build_string ("JISX0208.1978 (Japanese)"),
build_string
- ("JISX0208.1978 Japanese Kanji (so called \"old JIS\")"),
- build_string ("\\(jisx0208\\|jisc6226\\)\\.1978"));
- staticpro (&Vcharset_chinese_gb2312);
- Vcharset_chinese_gb2312 =
- make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 3,
- CHARSET_TYPE_94X94, 2, 0, 'A',
- CHARSET_LEFT_TO_RIGHT,
- build_string ("GB2312"),
- build_string ("GB2312)"),
- build_string ("GB2312 Chinese simplified"),
- build_string ("gb2312"));
- staticpro (&Vcharset_japanese_jisx0208);
+ ("JIS X0208-1978 (Japanese Kanji; Old Version)"),
+ build_string ("\\(jisx0208\\|jisc6226\\).19"));
Vcharset_japanese_jisx0208 =
- make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 3,
+ make_charset (146, Qjapanese_jisx0208,
+ LEADING_BYTE_JAPANESE_JISX0208, 3,
CHARSET_TYPE_94X94, 2, 0, 'B',
CHARSET_LEFT_TO_RIGHT,
- build_string ("JISX0208"),
- build_string ("JISX0208.1983/1990 (Japanese)"),
- build_string ("JISX0208.1983/1990 Japanese Kanji"),
+ build_string ("JIS X0208-1983 (Japanese Kanji)"),
build_string ("jisx0208.19\\(83\\|90\\)"));
- staticpro (&Vcharset_korean_ksc5601);
- Vcharset_korean_ksc5601 =
- make_charset (LEADING_BYTE_KOREAN_KSC5601, Qkorean_ksc5601, 3,
- CHARSET_TYPE_94X94, 2, 0, 'C',
- CHARSET_LEFT_TO_RIGHT,
- build_string ("KSC5601"),
- build_string ("KSC5601 (Korean"),
- build_string ("KSC5601 Korean Hangul and Hanja"),
- build_string ("ksc5601"));
- staticpro (&Vcharset_japanese_jisx0212);
Vcharset_japanese_jisx0212 =
- make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 3,
+ make_charset (148, Qjapanese_jisx0212,
+ LEADING_BYTE_JAPANESE_JISX0212, 3,
CHARSET_TYPE_94X94, 2, 0, 'D',
CHARSET_LEFT_TO_RIGHT,
- build_string ("JISX0212"),
- build_string ("JISX0212 (Japanese)"),
- build_string ("JISX0212 Japanese Supplement"),
+ build_string ("JIS X0212 (Japanese Supplement)"),
build_string ("jisx0212"));
+ /* Chinese */
+ Vcharset_chinese_gb2312 =
+ make_charset (145, Qchinese_gb2312, LEADING_BYTE_CHINESE_GB2312, 3,
+ CHARSET_TYPE_94X94, 2, 0, 'A',
+ CHARSET_LEFT_TO_RIGHT,
+ build_string ("GB 2312 (Simplified Chinese)"),
+ build_string ("gb2312"));
#define CHINESE_CNS_PLANE_RE(n) "cns11643[.-]\\(.*[.-]\\)?" n "$"
- staticpro (&Vcharset_chinese_cns11643_1);
Vcharset_chinese_cns11643_1 =
- make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qchinese_cns11643_1, 3,
+ make_charset (149, Qchinese_cns11643_1,
+ LEADING_BYTE_CHINESE_CNS11643_1, 3,
CHARSET_TYPE_94X94, 2, 0, 'G',
CHARSET_LEFT_TO_RIGHT,
- build_string ("CNS11643-1"),
- build_string ("CNS11643-1 (Chinese traditional)"),
build_string
- ("CNS 11643 Plane 1 Chinese traditional"),
+ ("CNS 11643 Plane 1 (Traditional Chinese for daily use)"),
build_string (CHINESE_CNS_PLANE_RE("1")));
- staticpro (&Vcharset_chinese_cns11643_2);
Vcharset_chinese_cns11643_2 =
- make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, 3,
+ make_charset (150, Qchinese_cns11643_2,
+ LEADING_BYTE_CHINESE_CNS11643_2, 3,
CHARSET_TYPE_94X94, 2, 0, 'H',
CHARSET_LEFT_TO_RIGHT,
- build_string ("CNS11643-2"),
- build_string ("CNS11643-2 (Chinese traditional)"),
build_string
- ("CNS 11643 Plane 2 Chinese traditional"),
+ ("CNS 11643 Plane 2 (Traditional Chinese for daily use)"),
build_string (CHINESE_CNS_PLANE_RE("2")));
- staticpro (&Vcharset_chinese_big5_1);
Vcharset_chinese_big5_1 =
- make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1, 3,
+ make_charset (152, Qchinese_big5_1, LEADING_BYTE_CHINESE_BIG5_1, 3,
CHARSET_TYPE_94X94, 2, 0, '0',
CHARSET_LEFT_TO_RIGHT,
- build_string ("Big5"),
- build_string ("Big5 (Level-1)"),
build_string
- ("Big5 Level-1 Chinese traditional"),
+ ("Big5 Level 1 (Traditional Chinese for daily use)"),
build_string ("big5"));
- staticpro (&Vcharset_chinese_big5_2);
Vcharset_chinese_big5_2 =
- make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 3,
+ make_charset (153, Qchinese_big5_2, LEADING_BYTE_CHINESE_BIG5_2, 3,
CHARSET_TYPE_94X94, 2, 0, '1',
CHARSET_LEFT_TO_RIGHT,
- build_string ("Big5"),
- build_string ("Big5 (Level-2)"),
build_string
- ("Big5 Level-2 Chinese traditional"),
+ ("Big5 Level 2 (Traditional Chinese for daily use)"),
build_string ("big5"));
-
-#ifdef ENABLE_COMPOSITE_CHARS
+ Vcharset_korean_ksc5601 =
+ make_charset (147, Qkorean_ksc5601, LEADING_BYTE_KOREAN_KSC5601, 3,
+ CHARSET_TYPE_94X94, 2, 0, 'C',
+ CHARSET_LEFT_TO_RIGHT,
+ build_string ("KS C5601 (Hangul and Korean Hanja)"),
+ build_string ("ksc5601"));
/* #### For simplicity, we put composite chars into a 96x96 charset.
This is going to lead to problems because you can run out of
room, esp. as we don't yet recycle numbers. */
- staticpro (&Vcharset_composite);
Vcharset_composite =
- make_charset (LEADING_BYTE_COMPOSITE, Qcomposite, 3,
+ make_charset (-1, Qcomposite, LEADING_BYTE_COMPOSITE, 3,
CHARSET_TYPE_96X96, 2, 0, 0,
CHARSET_LEFT_TO_RIGHT,
- build_string ("Composite"),
- build_string ("Composite characters"),
build_string ("Composite characters"),
build_string (""));
- /* #### not dumped properly */
composite_char_row_next = 32;
composite_char_col_next = 32;
- Vcomposite_char_string2char_hash_table =
- make_lisp_hash_table (500, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
- Vcomposite_char_char2string_hash_table =
- make_lisp_hash_table (500, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);
- staticpro (&Vcomposite_char_string2char_hash_table);
- staticpro (&Vcomposite_char_char2string_hash_table);
-#endif /* ENABLE_COMPOSITE_CHARS */
+ Vcomposite_char_string2char_hashtable =
+ make_lisp_hashtable (500, HASHTABLE_NONWEAK, HASHTABLE_EQUAL);
+ Vcomposite_char_char2string_hashtable =
+ make_lisp_hashtable (500, HASHTABLE_NONWEAK, HASHTABLE_EQ);
+ staticpro (&Vcomposite_char_string2char_hashtable);
+ staticpro (&Vcomposite_char_char2string_hashtable);
}