else
{
CHECK_NATNUM (n);
- n_extras = XINT (n);
- if (n_extras > 10)
+ if (XINT (n) > 10)
args_out_of_range (n, Qnil);
+ n_extras = XINT (n);
}
size = VECSIZE (struct Lisp_Char_Table) - 1 + n_extras;
(Lisp_Object char_table, Lisp_Object n, Lisp_Object value)
{
CHECK_CHAR_TABLE (char_table);
- if (EQ (XCHAR_TABLE (char_table)->purpose, Qchar_code_property_table))
- error ("Can't change extra-slot of char-code-property-table");
CHECK_NUMBER (n);
if (XINT (n) < 0
|| XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
}
else if (EQ (range, Qnil))
XCHAR_TABLE (char_table)->defalt = value;
- else if (INTEGERP (range))
+ else if (CHARACTERP (range))
char_table_set (char_table, XINT (range), value);
else if (CONSP (range))
{
ARG is passed to C_FUNCTION when that is called.
It returns the value of last character covered by TABLE (not the
- value inheritted from the parent), and by side-effect, the car part
+ value inherited from the parent), and by side-effect, the car part
of RANGE is updated to the minimum character C where C and all the
following characters in TABLE have the same value. */
{
/* Depth of TABLE. */
int depth;
- /* Minimum and maxinum characters covered by TABLE. */
+ /* Minimum and maximum characters covered by TABLE. */
int min_char, max_char;
/* Number of characters covered by one element of TABLE. */
int chars_in_block;
\f
/* Unicode character property tables.
- This section provides a convenient and efficient way to get a
- Unicode character property from C code (from Lisp, you must use
- get-char-code-property).
+ This section provides a convenient and efficient way to get Unicode
+ character properties of characters from C code (from Lisp, you must
+ use get-char-code-property).
- The typical usage is to get a char-table for a specific property at
- a proper initialization time as this:
+ The typical usage is to get a char-table object for a specific
+ property like this (use of the "bidi-class" property below is just
+ an example):
Lisp_Object bidi_class_table = uniprop_table (intern ("bidi-class"));
- and get a property value for character CH as this:
+ (uniprop_table can return nil if it fails to find data for the
+ named property, or if it fails to load the appropriate Lisp support
+ file, so the return value should be tested to be non-nil, before it
+ is used.)
- Lisp_Object bidi_class = CHAR_TABLE_REF (CH, bidi_class_table);
+ To get a property value for character CH use CHAR_TABLE_REF:
+
+ Lisp_Object bidi_class = CHAR_TABLE_REF (bidi_class_table, CH);
In this case, what you actually get is an index number to the
vector of property values (symbols nil, L, R, etc).
+ The full list of Unicode character properties supported by Emacs is
+ documented in the ELisp manual, in the node "Character Properties".
+
A table for Unicode character property has these characteristics:
o The purpose is `char-code-property-table', which implies that the
means that we don't have to decode values.
o The third extra slot is a Lisp function, an index (integer) to
- the array uniprop_enncoder[], or nil. If it is a Lisp function, we
+ the array uniprop_encoder[], or nil. If it is a Lisp function, we
can't use such a table from C (at the moment). If it is nil, it
means that we don't have to encode values. */
}
-/* Decode VALUE as an elemnet of char-table TABLE. */
+/* Decode VALUE as an element of char-table TABLE. */
static Lisp_Object
uniprop_decode_value_run_length (Lisp_Object table, Lisp_Object value)
static uniprop_decoder_t
uniprop_get_decoder (Lisp_Object table)
{
- int i;
+ EMACS_INT i;
if (! INTEGERP (XCHAR_TABLE (table)->extras[1]))
return NULL;
static uniprop_decoder_t
uniprop_get_encoder (Lisp_Object table)
{
- int i;
+ EMACS_INT i;
if (! INTEGERP (XCHAR_TABLE (table)->extras[2]))
return NULL;
function may load a Lisp file and thus may cause
garbage-collection. */
-static Lisp_Object
+Lisp_Object
uniprop_table (Lisp_Object prop)
{
Lisp_Object val, table, result;