Lisp_Object Vcharset_chinese_cns11643_2;
#ifdef UTF2000
Lisp_Object Vcharset_ucs_bmp;
+Lisp_Object Vcharset_latin_viscii;
Lisp_Object Vcharset_latin_viscii_lower;
Lisp_Object Vcharset_latin_viscii_upper;
Lisp_Object Vcharset_hiragana_jisx0208;
#endif
#ifdef UTF2000
-Emchar_to_byte_table*
-make_byte_from_character_table ()
+static Lisp_Object
+mark_char_byte_table (Lisp_Object obj, void (*markobj) (Lisp_Object))
{
- Emchar_to_byte_table* table
- = (Emchar_to_byte_table*) xmalloc (sizeof (Emchar_to_byte_table));
+ struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_TABLE (obj);
+ int i;
- table->base = NULL;
- return table;
+ for (i = 0; i < 256; i++)
+ {
+ markobj (cte->property[i]);
+ }
+ return Qnil;
+}
+
+static int
+char_byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
+{
+ struct Lisp_Char_Byte_Table *cte1 = XCHAR_BYTE_TABLE (obj1);
+ struct Lisp_Char_Byte_Table *cte2 = XCHAR_BYTE_TABLE (obj2);
+ int i;
+
+ for (i = 0; i < 256; i++)
+ if (CHAR_BYTE_TABLE_P (cte1->property[i]))
+ {
+ if (CHAR_BYTE_TABLE_P (cte2->property[i]))
+ {
+ if (!char_byte_table_equal (cte1->property[i],
+ cte2->property[i], depth + 1))
+ return 0;
+ }
+ else
+ return 0;
+ }
+ else
+ if (!internal_equal (cte1->property[i], cte2->property[i], depth + 1))
+ return 0;
+ return 1;
}
-#define destroy_byte_from_character_table(table) xfree(table)
+static unsigned long
+char_byte_table_hash (Lisp_Object obj, int depth)
+{
+ struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_TABLE (obj);
-void
-put_byte_from_character_table (Emchar ch, unsigned char val,
- Emchar_to_byte_table* table)
+ return internal_array_hash (cte->property, 256, depth);
+}
+
+static const struct lrecord_description char_byte_table_description[] = {
+ { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Byte_Table, property), 256 },
+ { XD_END }
+};
+
+DEFINE_LRECORD_IMPLEMENTATION ("char-code-table", char_byte_table,
+ mark_char_byte_table,
+ internal_object_printer,
+ 0, char_byte_table_equal,
+ char_byte_table_hash,
+ char_byte_table_description,
+ struct Lisp_Char_Byte_Table);
+
+
+static Lisp_Object
+make_char_byte_table (Lisp_Object initval)
+{
+ Lisp_Object obj;
+ int i;
+ struct Lisp_Char_Byte_Table *cte =
+ alloc_lcrecord_type (struct Lisp_Char_Byte_Table,
+ &lrecord_char_byte_table);
+
+ for (i = 0; i < 256; i++)
+ cte->property[i] = initval;
+
+ XSETCHAR_BYTE_TABLE (obj, cte);
+ return obj;
+}
+
+static Lisp_Object
+copy_char_byte_table (Lisp_Object entry)
{
- if (table->base == NULL)
+ struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_TABLE (entry);
+ Lisp_Object obj;
+ int i;
+ struct Lisp_Char_Byte_Table *ctenew =
+ alloc_lcrecord_type (struct Lisp_Char_Byte_Table,
+ &lrecord_char_byte_table);
+
+ for (i = 0; i < 256; i++)
{
- table->base = xmalloc (256);
- table->offset = ch - (ch % 256);
- table->size = 256;
- table->base[ch - table->offset] = val;
+ Lisp_Object new = cte->property[i];
+ if (CHAR_BYTE_TABLE_P (new))
+ ctenew->property[i] = copy_char_byte_table (new);
+ else
+ ctenew->property[i] = new;
}
+
+ XSETCHAR_BYTE_TABLE (obj, ctenew);
+ return obj;
+}
+
+#define make_char_code_table(initval) make_char_byte_table(initval)
+
+Lisp_Object
+get_char_code_table (Emchar ch, Lisp_Object table)
+{
+ struct Lisp_Char_Byte_Table* cpt = XCHAR_BYTE_TABLE (table);
+ Lisp_Object ret = cpt->property [ch >> 24];
+
+ if (CHAR_BYTE_TABLE_P (ret))
+ cpt = XCHAR_BYTE_TABLE (ret);
else
- {
- int i = ch - table->offset;
+ return ret;
- if (i < 0)
- {
- size_t new_size = table->size - i;
- size_t j;
-
- new_size += 256 - (new_size % 256);
- table->base = xrealloc (table->base, new_size);
- memmove (table->base + (new_size - table->size), table->base,
- table->size);
- for (j = 0; j < (new_size - table->size); j++)
- table->base[j] = 0;
- table->offset -= (new_size - table->size);
- table->base[ch - table->offset] = val;
- table->size = new_size;
- }
- else if (i >= table->size)
+ ret = cpt->property [(unsigned char) (ch >> 16)];
+ if (CHAR_BYTE_TABLE_P (ret))
+ cpt = XCHAR_BYTE_TABLE (ret);
+ else
+ return ret;
+
+ ret = cpt->property [(unsigned char) (ch >> 8)];
+ if (CHAR_BYTE_TABLE_P (ret))
+ cpt = XCHAR_BYTE_TABLE (ret);
+ else
+ return ret;
+
+ return cpt->property [(unsigned char) ch];
+}
+
+void
+put_char_code_table (Emchar ch, Lisp_Object value, Lisp_Object table)
+{
+ struct Lisp_Char_Byte_Table* cpt1 = XCHAR_BYTE_TABLE (table);
+ Lisp_Object ret = cpt1->property[ch >> 24];
+
+ if (CHAR_BYTE_TABLE_P (ret))
+ {
+ struct Lisp_Char_Byte_Table* cpt2 = XCHAR_BYTE_TABLE (ret);
+
+ ret = cpt2->property[(unsigned char)(ch >> 16)];
+ if (CHAR_BYTE_TABLE_P (ret))
{
- size_t new_size = i + 1;
- size_t j;
-
- new_size += 256 - (new_size % 256);
- table->base = xrealloc (table->base, new_size);
- for (j = table->size; j < new_size; j++)
- table->base[j] = 0;
- table->base[i] = val;
- table->size = new_size;
+ struct Lisp_Char_Byte_Table* cpt3 = XCHAR_BYTE_TABLE (ret);
+
+ ret = cpt3->property[(unsigned char)(ch >> 8)];
+ if (CHAR_BYTE_TABLE_P (ret))
+ {
+ struct Lisp_Char_Byte_Table* cpt4
+ = XCHAR_BYTE_TABLE (ret);
+
+ cpt4->property[(unsigned char)ch] = value;
+ }
+ else if (!EQ (ret, value))
+ {
+ Lisp_Object cpt4 = make_char_byte_table (ret);
+
+ XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)ch] = value;
+ cpt3->property[(unsigned char)(ch >> 8)] = cpt4;
+ }
}
- else
+ else if (!EQ (ret, value))
{
- table->base[i] = val;
+ Lisp_Object cpt3 = make_char_byte_table (ret);
+ Lisp_Object cpt4 = make_char_byte_table (ret);
+
+ XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)ch] = value;
+ XCHAR_BYTE_TABLE(cpt3)->property[(unsigned char)(ch >> 8)]
+ = cpt4;
+ cpt2->property[(unsigned char)(ch >> 16)] = cpt3;
}
}
-}
-
-unsigned char
-get_byte_from_character_table (Emchar ch, Emchar_to_byte_table* table)
-{
- size_t i = ch - table->offset;
- if (i < table->size)
- return table->base[i];
- else
- return 0;
+ else if (!EQ (ret, value))
+ {
+ Lisp_Object cpt2 = make_char_byte_table (ret);
+ Lisp_Object cpt3 = make_char_byte_table (ret);
+ Lisp_Object cpt4 = make_char_byte_table (ret);
+
+ XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)ch] = value;
+ XCHAR_BYTE_TABLE(cpt3)->property[(unsigned char)(ch >> 8)] = cpt4;
+ XCHAR_BYTE_TABLE(cpt2)->property[(unsigned char)(ch >> 16)] = cpt3;
+ cpt1->property[(unsigned char)(ch >> 24)] = cpt2;
+ }
}
Qchinese_cns11643_2,
#ifdef UTF2000
Qucs_bmp,
+ Qlatin_viscii,
Qlatin_viscii_lower,
Qlatin_viscii_upper,
+ Qvietnamese_viscii_lower,
+ Qvietnamese_viscii_upper,
Qhiragana_jisx0208,
Qkatakana_jisx0208,
#endif
Lisp_Object Vcharset_hash_table;
+#ifdef UTF2000
+static Charset_ID next_allocated_leading_byte;
+#else
static Charset_ID next_allocated_1_byte_leading_byte;
static Charset_ID next_allocated_2_byte_leading_byte;
+#endif
/* Composite characters are characters constructed by overstriking two
or more regular characters.
markobj (cs->ccl_program);
#ifdef UTF2000
markobj (cs->decoding_table);
+ markobj (cs->encoding_table);
#endif
return cs->name;
}
static const struct lrecord_description charset_description[] = {
{ XD_LISP_OBJECT, offsetof(struct Lisp_Charset, name), 7 },
+#ifdef UTF2000
+ { XD_LISP_OBJECT, offsetof(struct Lisp_Charset, decoding_table), 2 },
+#endif
{ XD_END }
};
mark_charset, print_charset, 0, 0, 0,
charset_description,
struct Lisp_Charset);
+
/* Make a new charset. */
static Lisp_Object
CHARSET_CCL_PROGRAM (cs) = Qnil;
CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil;
#ifdef UTF2000
- CHARSET_DECODING_TABLE(cs) = decoding_table;
+ CHARSET_DECODING_TABLE(cs) = Qnil;
+ CHARSET_ENCODING_TABLE(cs) = Qnil;
CHARSET_UCS_MIN(cs) = ucs_min;
CHARSET_UCS_MAX(cs) = ucs_max;
CHARSET_CODE_OFFSET(cs) = code_offset;
CHARSET_BYTE_OFFSET(cs) = byte_offset;
#endif
-
- switch ( CHARSET_TYPE (cs) )
+
+ switch (CHARSET_TYPE (cs))
{
case CHARSET_TYPE_94:
CHARSET_DIMENSION (cs) = 1;
CHARSET_CHARS (cs) = 94;
-#ifdef UTF2000
- if (!EQ (decoding_table, Qnil))
- {
- size_t i;
- CHARSET_TO_BYTE1_TABLE(cs) = make_byte_from_character_table();
- for (i = 0; i < 94; i++)
- {
- Lisp_Object c = XVECTOR_DATA(decoding_table)[i];
-
- if (!EQ (c, Qnil))
- put_byte_from_character_table (XCHAR (c), i + 33,
- CHARSET_TO_BYTE1_TABLE(cs));
- }
- }
- else
- CHARSET_TO_BYTE1_TABLE(cs) = NULL;
- CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-#endif
break;
case CHARSET_TYPE_96:
CHARSET_DIMENSION (cs) = 1;
CHARSET_CHARS (cs) = 96;
-#ifdef UTF2000
- if (!EQ (decoding_table, Qnil))
- {
- size_t i;
- CHARSET_TO_BYTE1_TABLE(cs) = make_byte_from_character_table();
- for (i = 0; i < 96; i++)
- {
- Lisp_Object c = XVECTOR_DATA(decoding_table)[i];
-
- if (!EQ (c, Qnil))
- put_byte_from_character_table (XCHAR (c), i + 32,
- CHARSET_TO_BYTE1_TABLE(cs));
- }
- }
- else
- CHARSET_TO_BYTE1_TABLE(cs) = NULL;
- CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-#endif
break;
case CHARSET_TYPE_94X94:
CHARSET_DIMENSION (cs) = 2;
CHARSET_CHARS (cs) = 94;
-#ifdef UTF2000
- CHARSET_TO_BYTE1_TABLE(cs) = NULL;
- CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-#endif
break;
case CHARSET_TYPE_96X96:
CHARSET_DIMENSION (cs) = 2;
CHARSET_CHARS (cs) = 96;
-#ifdef UTF2000
- CHARSET_TO_BYTE1_TABLE(cs) = NULL;
- CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-#endif
break;
#ifdef UTF2000
+ case CHARSET_TYPE_128:
+ CHARSET_DIMENSION (cs) = 1;
+ CHARSET_CHARS (cs) = 128;
+ break;
case CHARSET_TYPE_128X128:
CHARSET_DIMENSION (cs) = 2;
CHARSET_CHARS (cs) = 128;
-#ifdef UTF2000
- CHARSET_TO_BYTE1_TABLE(cs) = NULL;
- CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-#endif
+ break;
+ case CHARSET_TYPE_256:
+ CHARSET_DIMENSION (cs) = 1;
+ CHARSET_CHARS (cs) = 256;
break;
case CHARSET_TYPE_256X256:
CHARSET_DIMENSION (cs) = 2;
CHARSET_CHARS (cs) = 256;
-#ifdef UTF2000
- CHARSET_TO_BYTE1_TABLE(cs) = NULL;
- CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-#endif
break;
#endif
}
{
Charset_ID lb;
+#ifdef UTF2000
+ if (next_allocated_leading_byte > MAX_LEADING_BYTE_PRIVATE)
+ lb = 0;
+ else
+ lb = next_allocated_leading_byte++;
+#else
if (dimension == 1)
{
if (next_allocated_1_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_1)
else
lb = next_allocated_2_byte_leading_byte++;
}
+#endif
if (!lb)
signal_simple_error
unsigned char
charset_get_byte1 (Lisp_Object charset, Emchar ch)
{
- Emchar_to_byte_table* table;
+ Lisp_Object table;
int d;
- if ((table = XCHARSET_TO_BYTE1_TABLE (charset)) != NULL)
- return get_byte_from_character_table (ch, table);
- else if ((XCHARSET_UCS_MIN (charset) <= ch)
- && (ch <= XCHARSET_UCS_MAX (charset)))
+ if (!EQ (table = XCHARSET_ENCODING_TABLE (charset), Qnil))
+ {
+ Lisp_Object value = get_char_code_table (ch, table);
+
+ if (INTP (value))
+ {
+ Emchar code = XINT (value);
+
+ if (code < (1 << 8))
+ return code;
+ else if (code < (1 << 16))
+ return code >> 8;
+ else if (code < (1 << 24))
+ return code >> 16;
+ else
+ return code >> 24;
+ }
+ }
+ if ((XCHARSET_UCS_MIN (charset) <= ch)
+ && (ch <= XCHARSET_UCS_MAX (charset)))
return (ch - XCHARSET_UCS_MIN (charset)
+ XCHARSET_CODE_OFFSET (charset))
/ (XCHARSET_DIMENSION (charset) == 1 ?
return 0;
else
{
- Emchar_to_byte_table* table;
+ Lisp_Object table;
- if ((table = XCHARSET_TO_BYTE2_TABLE (charset)) != NULL)
- return get_byte_from_character_table (ch, table);
- else if ((XCHARSET_UCS_MIN (charset) <= ch)
- && (ch <= XCHARSET_UCS_MAX (charset)))
+ if (!EQ (table = XCHARSET_ENCODING_TABLE (charset), Qnil))
+ {
+ Lisp_Object value = get_char_code_table (ch, table);
+
+ if (INTP (value))
+ {
+ Emchar code = XINT (value);
+
+ if (code < (1 << 16))
+ return (unsigned char)code;
+ else if (code < (1 << 24))
+ return (unsigned char)(code >> 16);
+ else
+ return (unsigned char)(code >> 24);
+ }
+ }
+ if ((XCHARSET_UCS_MIN (charset) <= ch)
+ && (ch <= XCHARSET_UCS_MAX (charset)))
return ((ch - XCHARSET_UCS_MIN (charset)
+ XCHARSET_CODE_OFFSET (charset))
/ (XCHARSET_DIMENSION (charset) == 2 ?
Lisp_Object rest, keyword, value;
Lisp_Object ccl_program = Qnil;
Lisp_Object short_name = Qnil, long_name = Qnil;
+#ifdef UTF2000
+ Emchar code_offset = 0;
+ unsigned char byte_offset = 0;
+#endif
CHECK_SYMBOL (name);
if (!NILP (doc_string))
{
CHECK_INT (value);
graphic = XINT (value);
+#ifdef UTF2000
+ if (graphic < 0 || graphic > 2)
+#else
if (graphic < 0 || graphic > 1)
+#endif
signal_simple_error ("Invalid value for 'graphic", value);
}
{
if (chars == 94)
{
- /* id = CHARSET_ID_OFFSET_94 + final; */
- id = get_unallocated_leading_byte (dimension);
+ if (code_offset == 0)
+ id = CHARSET_ID_OFFSET_94 + final;
+ else
+ id = get_unallocated_leading_byte (dimension);
}
else if (chars == 96)
{
- id = get_unallocated_leading_byte (dimension);
+ if (code_offset == 0)
+ id = CHARSET_ID_OFFSET_96 + final;
+ else
+ id = get_unallocated_leading_byte (dimension);
}
else
{
{
if (chars == 94)
{
- id = get_unallocated_leading_byte (dimension);
+ if (code_offset == 0)
+ id = CHARSET_ID_OFFSET_94x94 + final;
+ else
+ id = get_unallocated_leading_byte (dimension);
}
else if (chars == 96)
{
{
abort ();
}
+ if (final)
+ {
+ if (chars == 94)
+ byte_offset = 33;
+ else if (chars == 96)
+ byte_offset = 32;
+ }
#else
id = get_unallocated_leading_byte (dimension);
#endif
charset = make_charset (id, name, type, columns, graphic,
final, direction, short_name, long_name,
doc_string, registry,
- Qnil, 0, 0, 0, 0);
+ Qnil, 0, 0, 0, byte_offset);
if (!NILP (ccl_program))
XCHARSET_CCL_PROGRAM (charset) = ccl_program;
return charset;
return new_charset;
}
+DEFUN ("define-charset-alias", Fdefine_charset_alias, 2, 2, 0, /*
+Define symbol ALIAS as an alias for CHARSET.
+*/
+ (alias, charset))
+{
+ CHECK_SYMBOL (alias);
+ charset = Fget_charset (charset);
+ return Fputhash (alias, charset, Vcharset_hash_table);
+}
+
/* #### Reverse direction charsets not yet implemented. */
#if 0
DEFUN ("charset-reverse-direction-charset", Fcharset_reverse_direction_charset,
(charset, table))
{
struct Lisp_Charset *cs;
- Emchar_to_byte_table* old_byte1_table;
- Emchar_to_byte_table* old_byte2_table;
+ Lisp_Object old_table;
+ size_t i;
charset = Fget_charset (charset);
- CHECK_VECTOR (table);
-
cs = XCHARSET (charset);
- CHARSET_DECODING_TABLE(cs) = table;
- old_byte1_table = CHARSET_TO_BYTE1_TABLE(cs);
- old_byte2_table = CHARSET_TO_BYTE2_TABLE(cs);
- switch (CHARSET_TYPE (cs))
+
+ if (EQ (table, Qnil))
{
- case CHARSET_TYPE_94:
- if (!EQ (table, Qnil))
- {
- size_t i;
- CHARSET_TO_BYTE1_TABLE(cs) = make_byte_from_character_table();
- for (i = 0; i < 94; i++)
- {
- Lisp_Object c = XVECTOR_DATA(table)[i];
+ CHARSET_DECODING_TABLE(cs) = table;
+ CHARSET_ENCODING_TABLE(cs) = Qnil;
+ return table;
+ }
+ else if (VECTORP (table))
+ {
+ if (XVECTOR_LENGTH (table) > CHARSET_CHARS (cs))
+ args_out_of_range (table, make_int (CHARSET_CHARS (cs)));
+ old_table = CHARSET_ENCODING_TABLE(cs);
+ CHARSET_DECODING_TABLE(cs) = table;
+ }
+ else
+ signal_error (Qwrong_type_argument,
+ list2 (build_translated_string ("vector-or-nil-p"),
+ table));
+ /* signal_simple_error ("Wrong type argument: vector-or-nil-p", table); */
- if (!EQ (c, Qnil))
- put_byte_from_character_table (XCHAR (c), i + 33,
- CHARSET_TO_BYTE1_TABLE(cs));
- }
- }
- else
- CHARSET_TO_BYTE1_TABLE(cs) = NULL;
- CHARSET_TO_BYTE2_TABLE(cs) = NULL;
- break;
- case CHARSET_TYPE_96:
- if (!EQ (table, Qnil))
+ switch (CHARSET_DIMENSION (cs))
+ {
+ case 1:
+ CHARSET_ENCODING_TABLE(cs) = make_char_code_table (Qnil);
+ for (i = 0; i < XVECTOR_LENGTH (table); i++)
{
- size_t i;
- CHARSET_TO_BYTE1_TABLE(cs) = make_byte_from_character_table();
- for (i = 0; i < 96; i++)
- {
- Lisp_Object c = XVECTOR_DATA(table)[i];
+ Lisp_Object c = XVECTOR_DATA(table)[i];
- if (!EQ (c, Qnil))
- put_byte_from_character_table (XCHAR (c), i + 32,
- CHARSET_TO_BYTE1_TABLE(cs));
- }
+ if (CHARP (c))
+ put_char_code_table (XCHAR (c),
+ make_int (i + CHARSET_BYTE_OFFSET (cs)),
+ CHARSET_ENCODING_TABLE(cs));
}
- else
- CHARSET_TO_BYTE1_TABLE(cs) = NULL;
- CHARSET_TO_BYTE2_TABLE(cs) = NULL;
break;
- case CHARSET_TYPE_94X94:
- if (!EQ (table, Qnil))
+ case 2:
+ CHARSET_ENCODING_TABLE(cs) = make_char_code_table (Qnil);
+ for (i = 0; i < XVECTOR_LENGTH (table); i++)
{
- size_t i;
+ Lisp_Object v = XVECTOR_DATA(table)[i];
- CHARSET_TO_BYTE1_TABLE(cs) = make_byte_from_character_table();
- CHARSET_TO_BYTE2_TABLE(cs) = make_byte_from_character_table();
- for (i = 0; i < XVECTOR_LENGTH (table); i++)
+ if (VECTORP (v))
{
- Lisp_Object v = XVECTOR_DATA(table)[i];
+ size_t j;
- if (VECTORP (v))
+ if (XVECTOR_LENGTH (v) > CHARSET_CHARS (cs))
{
- size_t j;
-
- for (j = 0; j < XVECTOR_LENGTH (v); j++)
- {
- Lisp_Object c = XVECTOR_DATA(v)[j];
-
- if (!EQ (c, Qnil))
- {
- put_byte_from_character_table
- (XCHAR (c), i + 33, CHARSET_TO_BYTE1_TABLE(cs));
- put_byte_from_character_table
- (XCHAR (c), j + 33, CHARSET_TO_BYTE2_TABLE(cs));
- }
- }
+ CHARSET_DECODING_TABLE(cs) = old_table;
+ args_out_of_range (v, make_int (CHARSET_CHARS (cs)));
+ }
+ for (j = 0; j < XVECTOR_LENGTH (v); j++)
+ {
+ Lisp_Object c = XVECTOR_DATA(v)[j];
+
+ if (CHARP (c))
+ put_char_code_table
+ (XCHAR (c),
+ make_int (( (i + CHARSET_BYTE_OFFSET (cs)) << 8)
+ | (j + CHARSET_BYTE_OFFSET (cs))),
+ CHARSET_ENCODING_TABLE(cs));
}
- else if (CHARP (v))
- put_byte_from_character_table
- (XCHAR (v), i + 33, CHARSET_TO_BYTE1_TABLE(cs));
}
+ else if (CHARP (v))
+ put_char_code_table (XCHAR (v),
+ make_int (i + CHARSET_BYTE_OFFSET (cs)),
+ CHARSET_ENCODING_TABLE(cs));
}
- else
- {
- CHARSET_TO_BYTE1_TABLE(cs) = NULL;
- CHARSET_TO_BYTE2_TABLE(cs) = NULL;
- }
- break;
- case CHARSET_TYPE_96X96:
- CHARSET_TO_BYTE1_TABLE(cs) = NULL;
- CHARSET_TO_BYTE2_TABLE(cs) = NULL;
- break;
- case CHARSET_TYPE_128X128:
- CHARSET_DIMENSION (cs) = 2;
- CHARSET_CHARS (cs) = 128;
- CHARSET_TO_BYTE1_TABLE(cs) = NULL;
- CHARSET_TO_BYTE2_TABLE(cs) = NULL;
- break;
- case CHARSET_TYPE_256X256:
- CHARSET_DIMENSION (cs) = 2;
- CHARSET_CHARS (cs) = 256;
- CHARSET_TO_BYTE1_TABLE(cs) = NULL;
- CHARSET_TO_BYTE2_TABLE(cs) = NULL;
break;
}
- if (old_byte1_table != NULL)
- destroy_byte_from_character_table (old_byte1_table);
- if (old_byte2_table != NULL)
- destroy_byte_from_character_table (old_byte2_table);
return table;
}
#endif
DEFSUBR (Fmake_charset);
DEFSUBR (Fmake_reverse_direction_charset);
/* DEFSUBR (Freverse_direction_charset); */
+ DEFSUBR (Fdefine_charset_alias);
DEFSUBR (Fcharset_from_attributes);
DEFSUBR (Fcharset_short_name);
DEFSUBR (Fcharset_long_name);
defsymbol (&Qchinese_cns11643_2, "chinese-cns11643-2");
#ifdef UTF2000
defsymbol (&Qucs_bmp, "ucs-bmp");
- defsymbol (&Qlatin_viscii_lower, "vietnamese-viscii-lower");
- defsymbol (&Qlatin_viscii_upper, "vietnamese-viscii-upper");
+ defsymbol (&Qlatin_viscii, "latin-viscii");
+ defsymbol (&Qlatin_viscii_lower, "latin-viscii-lower");
+ defsymbol (&Qlatin_viscii_upper, "latin-viscii-upper");
+ defsymbol (&Qvietnamese_viscii_lower, "vietnamese-viscii-lower");
+ defsymbol (&Qvietnamese_viscii_upper, "vietnamese-viscii-upper");
defsymbol (&Qhiragana_jisx0208, "hiragana-jisx0208");
defsymbol (&Qkatakana_jisx0208, "katakana-jisx0208");
#endif
charset_by_attributes[i][j][k] = Qnil;
#endif
- next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1;
#ifdef UTF2000
- next_allocated_2_byte_leading_byte = LEADING_BYTE_CHINESE_BIG5_2 + 1;
+ next_allocated_leading_byte = MIN_LEADING_BYTE_PRIVATE;
#else
+ next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1;
next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2;
#endif
#endif
#ifdef UTF2000
- Vutf_2000_version = build_string("0.8 (Kami)");
+ Vutf_2000_version = build_string("0.9 (Kyūhōji)");
DEFVAR_LISP ("utf-2000-version", &Vutf_2000_version /*
Version number of UTF-2000.
*/ );
Vdefault_coded_charset_priority_list = Qnil;
DEFVAR_LISP ("default-coded-charset-priority-list",
&Vdefault_coded_charset_priority_list /*
-Default order of preferred coded-character-set.
+Default order of preferred coded-character-sets.
*/ );
#endif
}
#ifdef UTF2000
Vcharset_ucs_bmp =
make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp,
- CHARSET_TYPE_256X256, 1, 0, 0,
+ CHARSET_TYPE_256X256, 1, 2, 0,
CHARSET_LEFT_TO_RIGHT,
build_string ("BMP"),
build_string ("BMP"),
- build_string ("BMP"),
- build_string (""),
+ build_string ("ISO/IEC 10646 Group 0 Plane 0 (BMP)"),
+ build_string ("\\(ISO10646.*-1\\|UNICODE[23]?-0\\)"),
Qnil, 0, 0xFFFF, 0, 0);
#else
# define MIN_CHAR_THAI 0
build_string ("VISCII lower"),
build_string ("VISCII lower (Vietnamese)"),
build_string ("VISCII lower (Vietnamese)"),
- build_string ("VISCII1\\.1"),
+ build_string ("MULEVISCII-LOWER"),
Qnil, 0, 0, 0, 32);
Vcharset_latin_viscii_upper =
make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper,
build_string ("VISCII upper"),
build_string ("VISCII upper (Vietnamese)"),
build_string ("VISCII upper (Vietnamese)"),
- build_string ("VISCII1\\.1"),
+ build_string ("MULEVISCII-UPPER"),
Qnil, 0, 0, 0, 32);
+ Vcharset_latin_viscii =
+ make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii,
+ CHARSET_TYPE_256, 1, 2, 0,
+ CHARSET_LEFT_TO_RIGHT,
+ build_string ("VISCII"),
+ build_string ("VISCII 1.1 (Vietnamese)"),
+ build_string ("VISCII 1.1 (Vietnamese)"),
+ build_string ("VISCII1\\.1"),
+ Qnil, 0, 0, 0, 0);
Vcharset_hiragana_jisx0208 =
make_charset (LEADING_BYTE_HIRAGANA_JISX0208, Qhiragana_jisx0208,
CHARSET_TYPE_94X94, 2, 0, 'B',
projects / chise / xemacs-chise.git- / blobdiff