\f
#ifdef UTF2000
-static void
-decode_char_table_range (Lisp_Object range, struct chartab_range *outrange);
-
#define BT_UINT8_MIN 0
#define BT_UINT8_MAX (UCHAR_MAX - 3)
#define BT_UINT8_t (UCHAR_MAX - 2)
return hash;
}
+static const struct lrecord_description uint8_byte_table_description[] = {
+ { XD_END }
+};
+
DEFINE_LRECORD_IMPLEMENTATION ("uint8-byte-table", uint8_byte_table,
mark_uint8_byte_table,
print_uint8_byte_table,
0, uint8_byte_table_equal,
uint8_byte_table_hash,
- 0 /* uint8_byte_table_description */,
+ uint8_byte_table_description,
Lisp_Uint8_Byte_Table);
static Lisp_Object
static int
map_over_uint8_byte_table (Lisp_Uint8_Byte_Table *ct, Emchar ofs, int place,
- Lisp_Object ccs,
int (*fn) (struct chartab_range *range,
Lisp_Object val, void *arg),
void *arg)
c1 = c + unit;
for (; c < c1 && retval == 0; c++)
{
- if ( NILP (ccs) || charset_code_point (ccs, c) >= 0 )
- {
- rainj.ch = c;
- retval = (fn) (&rainj, UINT8_DECODE (ct->property[i]), arg);
- }
+ rainj.ch = c;
+ retval = (fn) (&rainj, UINT8_DECODE (ct->property[i]), arg);
}
}
else
return hash;
}
+static const struct lrecord_description uint16_byte_table_description[] = {
+ { XD_END }
+};
+
DEFINE_LRECORD_IMPLEMENTATION ("uint16-byte-table", uint16_byte_table,
mark_uint16_byte_table,
print_uint16_byte_table,
0, uint16_byte_table_equal,
uint16_byte_table_hash,
- 0 /* uint16_byte_table_description */,
+ uint16_byte_table_description,
Lisp_Uint16_Byte_Table);
static Lisp_Object
static int
map_over_uint16_byte_table (Lisp_Uint16_Byte_Table *ct, Emchar ofs, int place,
- Lisp_Object ccs,
int (*fn) (struct chartab_range *range,
Lisp_Object val, void *arg),
void *arg)
c1 = c + unit;
for (; c < c1 && retval == 0; c++)
{
- if ( NILP (ccs) || charset_code_point (ccs, c) >= 0 )
- {
- rainj.ch = c;
- retval = (fn) (&rainj, UINT16_DECODE (ct->property[i]),
- arg);
- }
+ rainj.ch = c;
+ retval = (fn) (&rainj, UINT16_DECODE (ct->property[i]), arg);
}
}
else
static int
map_over_byte_table (Lisp_Byte_Table *ct, Emchar ofs, int place,
- Lisp_Object ccs,
int (*fn) (struct chartab_range *range,
Lisp_Object val, void *arg),
void *arg)
{
retval
= map_over_uint8_byte_table (XUINT8_BYTE_TABLE(v),
- c, place - 1, ccs, fn, arg);
+ c, place - 1, fn, arg);
c += unit;
}
else if (UINT16_BYTE_TABLE_P (v))
{
retval
= map_over_uint16_byte_table (XUINT16_BYTE_TABLE(v),
- c, place - 1, ccs, fn, arg);
+ c, place - 1, fn, arg);
c += unit;
}
else if (BYTE_TABLE_P (v))
{
retval = map_over_byte_table (XBYTE_TABLE(v),
- c, place - 1, ccs, fn, arg);
+ c, place - 1, fn, arg);
c += unit;
}
else if (!UNBOUNDP (v))
for (; c < c1 && retval == 0; c++)
{
- if ( NILP (ccs) || charset_code_point (ccs, c) >= 0 )
- {
- rainj.ch = c;
- retval = (fn) (&rainj, v, arg);
- }
+ rainj.ch = c;
+ retval = (fn) (&rainj, v, arg);
}
}
else
return obj;
}
-Lisp_Object
-get_char_id_table (Lisp_Char_Table* cit, Emchar ch)
-{
- Lisp_Object val = get_byte_table (get_byte_table
- (get_byte_table
- (get_byte_table
- (cit->table,
- (unsigned char)(ch >> 24)),
- (unsigned char) (ch >> 16)),
- (unsigned char) (ch >> 8)),
- (unsigned char) ch);
- if (UNBOUNDP (val))
- return cit->default_value;
- else
- return val;
-}
-
-void
-put_char_id_table (Lisp_Char_Table* cit,
- Lisp_Object character, Lisp_Object value)
-{
- struct chartab_range range;
-
- decode_char_table_range (character, &range);
- switch (range.type)
- {
- case CHARTAB_RANGE_ALL:
- cit->table = value;
- break;
- case CHARTAB_RANGE_DEFAULT:
- cit->default_value = value;
- break;
- case CHARTAB_RANGE_CHARSET:
- {
- Emchar c;
- Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (range.charset);
-
- if ( CHAR_TABLEP (encoding_table) )
- {
- for (c = 0; c < 1 << 24; c++)
- {
- if ( INTP (get_char_id_table (XCHAR_TABLE(encoding_table),
- c)) )
- put_char_id_table_0 (cit, c, value);
- }
- }
- else
- {
- for (c = 0; c < 1 << 24; c++)
- {
- if ( charset_code_point (range.charset, c) >= 0 )
- put_char_id_table_0 (cit, c, value);
- }
- }
- }
- break;
- case CHARTAB_RANGE_ROW:
- {
- int cell_min, cell_max, i;
-
- if (XCHARSET_DIMENSION (range.charset) < 2)
- signal_simple_error ("Charset in row vector must be multi-byte",
- range.charset);
- else
- {
- switch (XCHARSET_CHARS (range.charset))
- {
- case 94:
- cell_min = 33; cell_max = 126;
- break;
- case 96:
- cell_min = 32; cell_max = 127;
- break;
- case 128:
- cell_min = 0; cell_max = 127;
- break;
- case 256:
- cell_min = 0; cell_max = 255;
- break;
- default:
- abort ();
- }
- }
- if (XCHARSET_DIMENSION (range.charset) == 2)
- check_int_range (range.row, cell_min, cell_max);
- else if (XCHARSET_DIMENSION (range.charset) == 3)
- {
- check_int_range (range.row >> 8 , cell_min, cell_max);
- check_int_range (range.row & 0xFF, cell_min, cell_max);
- }
- else if (XCHARSET_DIMENSION (range.charset) == 4)
- {
- check_int_range ( range.row >> 16 , cell_min, cell_max);
- check_int_range ((range.row >> 8) & 0xFF, cell_min, cell_max);
- check_int_range ( range.row & 0xFF, cell_min, cell_max);
- }
- else
- abort ();
-
- for (i = cell_min; i <= cell_max; i++)
- {
- Emchar ch = DECODE_CHAR (range.charset, (range.row << 8) | i);
- if ( charset_code_point (range.charset, ch) >= 0 )
- put_char_id_table_0 (cit, ch, value);
- }
- }
- break;
- case CHARTAB_RANGE_CHAR:
- put_char_id_table_0 (cit, range.ch, value);
- break;
- }
-}
-
Lisp_Object Vcharacter_composition_table;
Lisp_Object Vcharacter_variant_table;
return obj;
}
-static void
+INLINE_HEADER int XCHARSET_CELL_RANGE (Lisp_Object ccs);
+INLINE_HEADER int
+XCHARSET_CELL_RANGE (Lisp_Object ccs)
+{
+ switch (XCHARSET_CHARS (ccs))
+ {
+ case 94:
+ return (33 << 8) | 126;
+ case 96:
+ return (32 << 8) | 127;
+#ifdef UTF2000
+ case 128:
+ return (0 << 8) | 127;
+ case 256:
+ return (0 << 8) | 255;
+#endif
+ default:
+ abort ();
+ return 0;
+ }
+}
+
+#ifndef UTF2000
+static
+#endif
+void
decode_char_table_range (Lisp_Object range, struct chartab_range *outrange)
{
if (EQ (range, Qt))
{
Lisp_Vector *vec = XVECTOR (range);
Lisp_Object *elts = vector_data (vec);
- if (vector_length (vec) != 2)
- signal_simple_error ("Length of charset row vector must be 2",
- range);
+ int cell_min, cell_max;
+
outrange->type = CHARTAB_RANGE_ROW;
outrange->charset = Fget_charset (elts[0]);
CHECK_INT (elts[1]);
outrange->row = XINT (elts[1]);
- if (XCHARSET_DIMENSION (outrange->charset) >= 2)
+ if (XCHARSET_DIMENSION (outrange->charset) < 2)
+ signal_simple_error ("Charset in row vector must be multi-byte",
+ outrange->charset);
+ else
{
- switch (XCHARSET_CHARS (outrange->charset))
- {
- case 94:
- check_int_range (outrange->row, 33, 126);
- break;
- case 96:
- check_int_range (outrange->row, 32, 127);
- break;
- default:
- abort ();
- }
+ int ret = XCHARSET_CELL_RANGE (outrange->charset);
+
+ cell_min = ret >> 8;
+ cell_max = ret & 0xFF;
}
+ if (XCHARSET_DIMENSION (outrange->charset) == 2)
+ check_int_range (outrange->row, cell_min, cell_max);
+#ifdef UTF2000
+ else if (XCHARSET_DIMENSION (outrange->charset) == 3)
+ {
+ check_int_range (outrange->row >> 8 , cell_min, cell_max);
+ check_int_range (outrange->row & 0xFF, cell_min, cell_max);
+ }
+ else if (XCHARSET_DIMENSION (outrange->charset) == 4)
+ {
+ check_int_range ( outrange->row >> 16 , cell_min, cell_max);
+ check_int_range ((outrange->row >> 8) & 0xFF, cell_min, cell_max);
+ check_int_range ( outrange->row & 0xFF, cell_min, cell_max);
+ }
+#endif
else
- signal_simple_error ("Charset in row vector must be multi-byte",
- outrange->charset);
+ abort ();
}
else
{
get_char_table (Emchar ch, Lisp_Char_Table *ct)
{
#ifdef UTF2000
- Lisp_Object val = get_byte_table (get_byte_table
- (get_byte_table
- (get_byte_table
- (ct->table,
- (unsigned char)(ch >> 24)),
- (unsigned char) (ch >> 16)),
- (unsigned char) (ch >> 8)),
- (unsigned char) ch);
- if (UNBOUNDP (val))
- return ct->default_value;
- else
- return val;
+ return get_char_id_table (ct, ch);
#elif defined(MULE)
{
Lisp_Object charset;
{
int cell_min, cell_max, i;
- /* printf ("put-char-table: range = charset-row: %d, 0x%x\n",
- XCHARSET_LEADING_BYTE (range->charset), range->row); */
- if (XCHARSET_DIMENSION (range->charset) < 2)
- signal_simple_error ("Charset in row vector must be multi-byte",
- range->charset);
- else
- {
- switch (XCHARSET_CHARS (range->charset))
- {
- case 94:
- cell_min = 33; cell_max = 126;
- break;
- case 96:
- cell_min = 32; cell_max = 127;
- break;
- case 128:
- cell_min = 0; cell_max = 127;
- break;
- case 256:
- cell_min = 0; cell_max = 255;
- break;
- default:
- abort ();
- }
- }
- if (XCHARSET_DIMENSION (range->charset) == 2)
- check_int_range (range->row, cell_min, cell_max);
- else if (XCHARSET_DIMENSION (range->charset) == 3)
- {
- check_int_range (range->row >> 8 , cell_min, cell_max);
- check_int_range (range->row & 0xFF, cell_min, cell_max);
- }
- else if (XCHARSET_DIMENSION (range->charset) == 4)
- {
- check_int_range ( range->row >> 16 , cell_min, cell_max);
- check_int_range ((range->row >> 8) & 0xFF, cell_min, cell_max);
- check_int_range ( range->row & 0xFF, cell_min, cell_max);
- }
- else
- abort ();
-
+ i = XCHARSET_CELL_RANGE (range->charset);
+ cell_min = i >> 8;
+ cell_max = i & 0xFF;
for (i = cell_min; i <= cell_max; i++)
{
Emchar ch = DECODE_CHAR (range->charset, (range->row << 8) | i);
+
if ( charset_code_point (range->charset, ch) >= 0 )
put_char_id_table_0 (ct, ch, val);
}
return retval;
}
if (UINT8_BYTE_TABLE_P (ct->table))
- return map_over_uint8_byte_table (XUINT8_BYTE_TABLE(ct->table), 0, 3,
- Qnil, fn, arg);
+ return map_over_uint8_byte_table (XUINT8_BYTE_TABLE(ct->table),
+ 0, 3, fn, arg);
else if (UINT16_BYTE_TABLE_P (ct->table))
- return map_over_uint16_byte_table (XUINT16_BYTE_TABLE(ct->table), 0, 3,
- Qnil, fn, arg);
+ return map_over_uint16_byte_table (XUINT16_BYTE_TABLE(ct->table),
+ 0, 3, fn, arg);
else if (BYTE_TABLE_P (ct->table))
- return map_over_byte_table (XBYTE_TABLE(ct->table), 0, 3,
- Qnil, fn, arg);
+ return map_over_byte_table (XBYTE_TABLE(ct->table),
+ 0, 3, fn, arg);
else if (!UNBOUNDP (ct->table))
#if 0
{
int retval;
struct chartab_range rainj;
- if (XCHARSET_DIMENSION (range->charset) < 2)
- signal_simple_error ("Charset in row vector must be multi-byte",
- range->charset);
- else
- {
- switch (XCHARSET_CHARS (range->charset))
- {
- case 94:
- cell_min = 33; cell_max = 126;
- break;
- case 96:
- cell_min = 32; cell_max = 127;
- break;
- case 128:
- cell_min = 0; cell_max = 127;
- break;
- case 256:
- cell_min = 0; cell_max = 255;
- break;
- default:
- abort ();
- }
- }
- if (XCHARSET_DIMENSION (range->charset) == 2)
- check_int_range (range->row, cell_min, cell_max);
- else if (XCHARSET_DIMENSION (range->charset) == 3)
- {
- check_int_range (range->row >> 8 , cell_min, cell_max);
- check_int_range (range->row & 0xFF, cell_min, cell_max);
- }
- else if (XCHARSET_DIMENSION (range->charset) == 4)
- {
- check_int_range ( range->row >> 16 , cell_min, cell_max);
- check_int_range ((range->row >> 8) & 0xFF, cell_min, cell_max);
- check_int_range ( range->row & 0xFF, cell_min, cell_max);
- }
- else
- abort ();
-
+ i = XCHARSET_CELL_RANGE (range->charset);
+ cell_min = i >> 8;
+ cell_max = i & 0xFF;
rainj.type = CHARTAB_RANGE_CHAR;
for (retval =0, i = cell_min; i <= cell_max && retval == 0; i++)
{
return slarg.retval;
}
-EXFUN (Fmake_char, 3);
-EXFUN (Fdecode_char, 2);
-
DEFUN ("define-char", Fdefine_char, 1, 1, 0, /*
Store character's ATTRIBUTES.
*/
if (CONSP (cell))
character = Fmake_char (ccs, Fcar (cell), Fcar (Fcdr (cell)));
else
- character = Fdecode_char (ccs, cell);
+ character = Fdecode_char (ccs, cell, Qnil);
if (!NILP (character))
goto setup_attributes;
}
if (CONSP (cell))
return Fmake_char (ccs, Fcar (cell), Fcar (Fcdr (cell)));
else
- return Fdecode_char (ccs, cell);
+ return Fdecode_char (ccs, cell, Qnil);
}
rest = Fcdr (rest);
}