Copyright (C) 1992, 1995 Free Software Foundation, Inc.
Copyright (C) 1995 Sun Microsystems, Inc.
Copyright (C) 1995, 1996 Ben Wing.
+ Copyright (C) 1995, 1997, 1999 Electrotechnical Laboratory, JAPAN.
+ Licensed to the Free Software Foundation.
This file is part of XEmacs.
#include "buffer.h"
#include "chartab.h"
-#include "commands.h"
#include "syntax.h"
Lisp_Object Qchar_tablep, Qchar_table;
Lisp_Object Qcategory_table_value_p;
Lisp_Object Vstandard_category_table;
+
+/* Variables to determine word boundary. */
+Lisp_Object Vword_combining_categories, Vword_separating_categories;
#endif /* MULE */
\f
#ifdef MULE
static Lisp_Object
-mark_char_table_entry (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_char_table_entry (Lisp_Object obj)
{
- struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj);
+ Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj);
int i;
for (i = 0; i < 96; i++)
{
- (markobj) (cte->level2[i]);
+ mark_object (cte->level2[i]);
}
return Qnil;
}
static int
char_table_entry_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
{
- struct Lisp_Char_Table_Entry *cte1 = XCHAR_TABLE_ENTRY (obj1);
- struct Lisp_Char_Table_Entry *cte2 = XCHAR_TABLE_ENTRY (obj2);
+ Lisp_Char_Table_Entry *cte1 = XCHAR_TABLE_ENTRY (obj1);
+ Lisp_Char_Table_Entry *cte2 = XCHAR_TABLE_ENTRY (obj2);
int i;
for (i = 0; i < 96; i++)
static unsigned long
char_table_entry_hash (Lisp_Object obj, int depth)
{
- struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj);
+ Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj);
return internal_array_hash (cte->level2, 96, depth);
}
+static const struct lrecord_description char_table_entry_description[] = {
+ { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Char_Table_Entry, level2), 96 },
+ { XD_END }
+};
+
DEFINE_LRECORD_IMPLEMENTATION ("char-table-entry", char_table_entry,
mark_char_table_entry, internal_object_printer,
0, char_table_entry_equal,
char_table_entry_hash,
- struct Lisp_Char_Table_Entry);
+ char_table_entry_description,
+ Lisp_Char_Table_Entry);
#endif /* MULE */
static Lisp_Object
-mark_char_table (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_char_table (Lisp_Object obj)
{
- struct Lisp_Char_Table *ct = XCHAR_TABLE (obj);
+ Lisp_Char_Table *ct = XCHAR_TABLE (obj);
int i;
for (i = 0; i < NUM_ASCII_CHARS; i++)
- (markobj) (ct->ascii[i]);
+ mark_object (ct->ascii[i]);
#ifdef MULE
for (i = 0; i < NUM_LEADING_BYTES; i++)
- (markobj) (ct->level1[i]);
+ mark_object (ct->level1[i]);
#endif
return ct->mirror_table;
}
/* WARNING: All functions of this nature need to be written extremely
carefully to avoid crashes during GC. Cf. prune_specifiers()
- and prune_weak_hashtables(). */
+ and prune_weak_hash_tables(). */
void
-prune_syntax_tables (int (*obj_marked_p) (Lisp_Object))
+prune_syntax_tables (void)
{
Lisp_Object rest, prev = Qnil;
for (rest = Vall_syntax_tables;
- !GC_NILP (rest);
+ !NILP (rest);
rest = XCHAR_TABLE (rest)->next_table)
{
- if (! ((*obj_marked_p) (rest)))
+ if (! marked_p (rest))
{
/* This table is garbage. Remove it from the list. */
- if (GC_NILP (prev))
+ if (NILP (prev))
Vall_syntax_tables = XCHAR_TABLE (rest)->next_table;
else
XCHAR_TABLE (prev)->next_table =
{
switch (type)
{
+ default: abort();
case CHAR_TABLE_TYPE_GENERIC: return Qgeneric;
case CHAR_TABLE_TYPE_SYNTAX: return Qsyntax;
case CHAR_TABLE_TYPE_DISPLAY: return Qdisplay;
case CHAR_TABLE_TYPE_CATEGORY: return Qcategory;
#endif
}
-
- abort ();
- return Qnil; /* not reached */
}
static enum char_table_type
static void
print_chartab_charset_row (Lisp_Object charset,
int row,
- struct Lisp_Char_Table_Entry *cte,
+ Lisp_Char_Table_Entry *cte,
Lisp_Object printcharfun)
{
int i;
static void
print_chartab_two_byte_charset (Lisp_Object charset,
- struct Lisp_Char_Table_Entry *cte,
+ Lisp_Char_Table_Entry *cte,
Lisp_Object printcharfun)
{
int i;
static void
print_char_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
{
- struct Lisp_Char_Table *ct = XCHAR_TABLE (obj);
+ Lisp_Char_Table *ct = XCHAR_TABLE (obj);
char buf[200];
sprintf (buf, "#s(char-table type %s data (",
#ifdef MULE
{
- int i;
+ Charset_ID i;
for (i = MIN_LEADING_BYTE; i < MIN_LEADING_BYTE + NUM_LEADING_BYTES;
i++)
}
else
{
- struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (ann);
+ Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (ann);
if (XCHARSET_DIMENSION (charset) == 1)
print_chartab_charset_row (charset, -1, cte, printcharfun);
else
static int
char_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
{
- struct Lisp_Char_Table *ct1 = XCHAR_TABLE (obj1);
- struct Lisp_Char_Table *ct2 = XCHAR_TABLE (obj2);
+ Lisp_Char_Table *ct1 = XCHAR_TABLE (obj1);
+ Lisp_Char_Table *ct2 = XCHAR_TABLE (obj2);
int i;
if (CHAR_TABLE_TYPE (ct1) != CHAR_TABLE_TYPE (ct2))
static unsigned long
char_table_hash (Lisp_Object obj, int depth)
{
- struct Lisp_Char_Table *ct = XCHAR_TABLE (obj);
+ Lisp_Char_Table *ct = XCHAR_TABLE (obj);
unsigned long hashval = internal_array_hash (ct->ascii, NUM_ASCII_CHARS,
depth);
#ifdef MULE
return hashval;
}
+static const struct lrecord_description char_table_description[] = {
+ { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Char_Table, ascii), NUM_ASCII_CHARS },
+#ifdef MULE
+ { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Char_Table, level1), NUM_LEADING_BYTES },
+#endif
+ { XD_LISP_OBJECT, offsetof (Lisp_Char_Table, mirror_table) },
+ { XD_LO_LINK, offsetof (Lisp_Char_Table, next_table) },
+ { XD_END }
+};
+
DEFINE_LRECORD_IMPLEMENTATION ("char-table", char_table,
mark_char_table, print_char_table, 0,
char_table_equal, char_table_hash,
- struct Lisp_Char_Table);
+ char_table_description,
+ Lisp_Char_Table);
DEFUN ("char-table-p", Fchar_table_p, 1, 1, 0, /*
Return non-nil if OBJECT is a char table.
-- all characters
-- a single character
-To create a char table, use `make-char-table'. To modify a char
-table, use `put-char-table' or `remove-char-table'. To retrieve the
-value for a particular character, use `get-char-table'. See also
-`map-char-table', `clear-char-table', `copy-char-table',
-`valid-char-table-type-p', `char-table-type-list', `valid-char-table-value-p',
-and `check-char-table-value'.
+To create a char table, use `make-char-table'.
+To modify a char table, use `put-char-table' or `remove-char-table'.
+To retrieve the value for a particular character, use `get-char-table'.
+See also `map-char-table', `clear-char-table', `copy-char-table',
+`valid-char-table-type-p', `char-table-type-list',
+`valid-char-table-value-p', and `check-char-table-value'.
*/
(object))
{
}
DEFUN ("char-table-type", Fchar_table_type, 1, 1, 0, /*
-Return the type of char table TABLE.
+Return the type of CHAR-TABLE.
See `valid-char-table-type-p'.
*/
- (table))
+ (char_table))
{
- CHECK_CHAR_TABLE (table);
- return char_table_type_to_symbol (XCHAR_TABLE (table)->type);
+ CHECK_CHAR_TABLE (char_table);
+ return char_table_type_to_symbol (XCHAR_TABLE (char_table)->type);
}
void
-fill_char_table (struct Lisp_Char_Table *ct, Lisp_Object value)
+fill_char_table (Lisp_Char_Table *ct, Lisp_Object value)
{
int i;
}
DEFUN ("reset-char-table", Freset_char_table, 1, 1, 0, /*
-Reset a char table to its default state.
+Reset CHAR-TABLE to its default state.
*/
- (table))
+ (char_table))
{
- struct Lisp_Char_Table *ct;
+ Lisp_Char_Table *ct;
- CHECK_CHAR_TABLE (table);
- ct = XCHAR_TABLE (table);
+ CHECK_CHAR_TABLE (char_table);
+ ct = XCHAR_TABLE (char_table);
switch (ct->type)
{
*/
(type))
{
- struct Lisp_Char_Table *ct;
+ Lisp_Char_Table *ct;
Lisp_Object obj;
enum char_table_type ty = symbol_to_char_table_type (type);
- ct = alloc_lcrecord_type (struct Lisp_Char_Table, lrecord_char_table);
+ ct = alloc_lcrecord_type (Lisp_Char_Table, &lrecord_char_table);
ct->type = ty;
if (ty == CHAR_TABLE_TYPE_SYNTAX)
{
{
Lisp_Object obj;
int i;
- struct Lisp_Char_Table_Entry *cte =
- alloc_lcrecord_type (struct Lisp_Char_Table_Entry,
- lrecord_char_table_entry);
+ Lisp_Char_Table_Entry *cte =
+ alloc_lcrecord_type (Lisp_Char_Table_Entry, &lrecord_char_table_entry);
for (i = 0; i < 96; i++)
cte->level2[i] = initval;
static Lisp_Object
copy_char_table_entry (Lisp_Object entry)
{
- struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (entry);
+ Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (entry);
Lisp_Object obj;
int i;
- struct Lisp_Char_Table_Entry *ctenew =
- alloc_lcrecord_type (struct Lisp_Char_Table_Entry,
- lrecord_char_table_entry);
+ Lisp_Char_Table_Entry *ctenew =
+ alloc_lcrecord_type (Lisp_Char_Table_Entry, &lrecord_char_table_entry);
for (i = 0; i < 96; i++)
{
#endif /* MULE */
DEFUN ("copy-char-table", Fcopy_char_table, 1, 1, 0, /*
-Make a new char table which is a copy of OLD-TABLE.
+Return a new char table which is a copy of CHAR-TABLE.
It will contain the same values for the same characters and ranges
-as OLD-TABLE. The values will not themselves be copied.
+as CHAR-TABLE. The values will not themselves be copied.
*/
- (old_table))
+ (char_table))
{
- struct Lisp_Char_Table *ct, *ctnew;
+ Lisp_Char_Table *ct, *ctnew;
Lisp_Object obj;
int i;
- CHECK_CHAR_TABLE (old_table);
- ct = XCHAR_TABLE (old_table);
- ctnew = alloc_lcrecord_type (struct Lisp_Char_Table, lrecord_char_table);
+ CHECK_CHAR_TABLE (char_table);
+ ct = XCHAR_TABLE (char_table);
+ ctnew = alloc_lcrecord_type (Lisp_Char_Table, &lrecord_char_table);
ctnew->type = ct->type;
for (i = 0; i < NUM_ASCII_CHARS; i++)
ctnew->mirror_table = Fcopy_char_table (ct->mirror_table);
else
ctnew->mirror_table = ct->mirror_table;
+ ctnew->next_table = Qnil;
XSETCHAR_TABLE (obj, ctnew);
+ if (ctnew->type == CHAR_TABLE_TYPE_SYNTAX)
+ {
+ ctnew->next_table = Vall_syntax_tables;
+ Vall_syntax_tables = obj;
+ }
return obj;
}
#else /* MULE */
else if (VECTORP (range))
{
- struct Lisp_Vector *vec = XVECTOR (range);
+ 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",
outrange->charset = Fget_charset (elts[0]);
CHECK_INT (elts[1]);
outrange->row = XINT (elts[1]);
- switch (XCHARSET_TYPE (outrange->charset))
+ if (XCHARSET_DIMENSION (outrange->charset) >= 2)
{
- case CHARSET_TYPE_94:
- case CHARSET_TYPE_96:
- signal_simple_error ("Charset in row vector must be multi-byte",
- outrange->charset);
- case CHARSET_TYPE_94X94:
- check_int_range (outrange->row, 33, 126);
- break;
- case CHARSET_TYPE_96X96:
- check_int_range (outrange->row, 32, 127);
- break;
- default:
- abort ();
+ 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 ();
+ }
}
+ else
+ signal_simple_error ("Charset in row vector must be multi-byte",
+ outrange->charset);
}
else
{
/* called from CHAR_TABLE_VALUE(). */
Lisp_Object
-get_non_ascii_char_table_value (struct Lisp_Char_Table *ct, int leading_byte,
+get_non_ascii_char_table_value (Lisp_Char_Table *ct, Charset_ID leading_byte,
Emchar c)
{
Lisp_Object val;
+#ifdef UTF2000
+ Lisp_Object charset;
+#else
Lisp_Object charset = CHARSET_BY_LEADING_BYTE (leading_byte);
+#endif
int byte1, byte2;
+#ifdef UTF2000
+ BREAKUP_CHAR (c, charset, byte1, byte2);
+#else
BREAKUP_CHAR_1_UNSAFE (c, charset, byte1, byte2);
+#endif
val = ct->level1[leading_byte - MIN_LEADING_BYTE];
if (CHAR_TABLE_ENTRYP (val))
{
- struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);
+ Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);
val = cte->level2[byte1 - 32];
if (CHAR_TABLE_ENTRYP (val))
{
#endif /* MULE */
Lisp_Object
-get_char_table (Emchar ch, struct Lisp_Char_Table *ct)
+get_char_table (Emchar ch, Lisp_Char_Table *ct)
{
#ifdef MULE
{
val = ct->level1[lb];
if (CHAR_TABLE_ENTRYP (val))
{
- struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);
+ Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);
val = cte->level2[byte1 - 32];
if (CHAR_TABLE_ENTRYP (val))
{
DEFUN ("get-char-table", Fget_char_table, 2, 2, 0, /*
-Find value for char CH in TABLE.
+Find value for CHARACTER in CHAR-TABLE.
*/
- (ch, table))
+ (character, char_table))
{
- struct Lisp_Char_Table *ct;
+ CHECK_CHAR_TABLE (char_table);
+ CHECK_CHAR_COERCE_INT (character);
- CHECK_CHAR_TABLE (table);
- ct = XCHAR_TABLE (table);
- CHECK_CHAR_COERCE_INT (ch);
-
- return get_char_table (XCHAR (ch), ct);
+ return get_char_table (XCHAR (character), XCHAR_TABLE (char_table));
}
DEFUN ("get-range-char-table", Fget_range_char_table, 2, 3, 0, /*
-Find value for a range in TABLE.
+Find value for a range in CHAR-TABLE.
If there is more than one value, return MULTI (defaults to nil).
*/
- (range, table, multi))
+ (range, char_table, multi))
{
- struct Lisp_Char_Table *ct;
+ Lisp_Char_Table *ct;
struct chartab_range rainj;
if (CHAR_OR_CHAR_INTP (range))
- return Fget_char_table (range, table);
- CHECK_CHAR_TABLE (table);
- ct = XCHAR_TABLE (table);
+ return Fget_char_table (range, char_table);
+ CHECK_CHAR_TABLE (char_table);
+ ct = XCHAR_TABLE (char_table);
decode_char_table_range (range, &rainj);
switch (rainj.type)
/* Assign VAL to all characters in RANGE in char table CT. */
void
-put_char_table (struct Lisp_Char_Table *ct, struct chartab_range *range,
+put_char_table (Lisp_Char_Table *ct, struct chartab_range *range,
Lisp_Object val)
{
switch (range->type)
case CHARTAB_RANGE_ROW:
{
- struct Lisp_Char_Table_Entry *cte;
+ Lisp_Char_Table_Entry *cte;
int lb = XCHARSET_LEADING_BYTE (range->charset) - MIN_LEADING_BYTE;
/* make sure that there is a separate entry for the row. */
if (!CHAR_TABLE_ENTRYP (ct->level1[lb]))
ct->ascii[byte1 + 128] = val;
else
{
- struct Lisp_Char_Table_Entry *cte;
+ Lisp_Char_Table_Entry *cte;
int lb = XCHARSET_LEADING_BYTE (charset) - MIN_LEADING_BYTE;
/* make sure that there is a separate entry for the row. */
if (!CHAR_TABLE_ENTRYP (ct->level1[lb]))
}
DEFUN ("put-char-table", Fput_char_table, 3, 3, 0, /*
-Set the value for chars in RANGE to be VAL in TABLE.
+Set the value for chars in RANGE to be VALUE in CHAR-TABLE.
RANGE specifies one or more characters to be affected and should be
one of the following:
(only allowed when Mule support is present)
-- A single character
-VAL must be a value appropriate for the type of TABLE.
+VALUE must be a value appropriate for the type of CHAR-TABLE.
See `valid-char-table-type-p'.
*/
- (range, val, table))
+ (range, value, char_table))
{
- struct Lisp_Char_Table *ct;
+ Lisp_Char_Table *ct;
struct chartab_range rainj;
- CHECK_CHAR_TABLE (table);
- ct = XCHAR_TABLE (table);
- check_valid_char_table_value (val, ct->type, ERROR_ME);
+ CHECK_CHAR_TABLE (char_table);
+ ct = XCHAR_TABLE (char_table);
+ check_valid_char_table_value (value, ct->type, ERROR_ME);
decode_char_table_range (range, &rainj);
- val = canonicalize_char_table_value (val, ct->type);
- put_char_table (ct, &rainj, val);
+ value = canonicalize_char_table_value (value, ct->type);
+ put_char_table (ct, &rainj, value);
return Qnil;
}
/* Map FN over the ASCII chars in CT. */
static int
-map_over_charset_ascii (struct Lisp_Char_Table *ct,
+map_over_charset_ascii (Lisp_Char_Table *ct,
int (*fn) (struct chartab_range *range,
Lisp_Object val, void *arg),
void *arg)
/* Map FN over the Control-1 chars in CT. */
static int
-map_over_charset_control_1 (struct Lisp_Char_Table *ct,
+map_over_charset_control_1 (Lisp_Char_Table *ct,
int (*fn) (struct chartab_range *range,
Lisp_Object val, void *arg),
void *arg)
CTE specifies the char table entry for CHARSET. */
static int
-map_over_charset_row (struct Lisp_Char_Table_Entry *cte,
+map_over_charset_row (Lisp_Char_Table_Entry *cte,
Lisp_Object charset, int row,
int (*fn) (struct chartab_range *range,
Lisp_Object val, void *arg),
static int
-map_over_other_charset (struct Lisp_Char_Table *ct, int lb,
+map_over_other_charset (Lisp_Char_Table *ct, Charset_ID lb,
int (*fn) (struct chartab_range *range,
Lisp_Object val, void *arg),
void *arg)
}
{
- struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);
+ Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);
int charset94_p = (XCHARSET_CHARS (charset) == 94);
int start = charset94_p ? 33 : 32;
int stop = charset94_p ? 127 : 128;
becomes the return value of map_char_table(). */
int
-map_char_table (struct Lisp_Char_Table *ct,
+map_char_table (Lisp_Char_Table *ct,
struct chartab_range *range,
int (*fn) (struct chartab_range *range,
Lisp_Object val, void *arg),
if (retval)
return retval;
{
- int i;
- int start = MIN_LEADING_BYTE;
- int stop = start + NUM_LEADING_BYTES;
+ Charset_ID i;
+ Charset_ID start = MIN_LEADING_BYTE;
+ Charset_ID stop = start + NUM_LEADING_BYTES;
for (i = start, retval = 0; i < stop && retval == 0; i++)
{
case CHARTAB_RANGE_ROW:
{
- Lisp_Object val = ct->level1[XCHARSET_LEADING_BYTE (range->charset) - MIN_LEADING_BYTE];
+ Lisp_Object val = ct->level1[XCHARSET_LEADING_BYTE (range->charset)
+ - MIN_LEADING_BYTE];
if (!CHAR_TABLE_ENTRYP (val))
{
struct chartab_range rainj;
}
DEFUN ("map-char-table", Fmap_char_table, 2, 3, 0, /*
-Map FUNCTION over entries in TABLE, calling it with two args,
+Map FUNCTION over entries in CHAR-TABLE, calling it with two args,
each key and value in the table.
RANGE specifies a subrange to map over and is in the same format as
the RANGE argument to `put-range-table'. If omitted or t, it defaults to
the entire table.
*/
- (function, table, range))
+ (function, char_table, range))
{
- struct Lisp_Char_Table *ct;
+ Lisp_Char_Table *ct;
struct slow_map_char_table_arg slarg;
struct gcpro gcpro1, gcpro2;
struct chartab_range rainj;
- CHECK_CHAR_TABLE (table);
- ct = XCHAR_TABLE (table);
+ CHECK_CHAR_TABLE (char_table);
+ ct = XCHAR_TABLE (char_table);
if (NILP (range))
range = Qt;
decode_char_table_range (range, &rainj);
/************************************************************************/
DEFUN ("category-table-p", Fcategory_table_p, 1, 1, 0, /*
-Return t if ARG is a category table.
+Return t if OBJECT is a category table.
A category table is a type of char table used for keeping track of
categories. Categories are used for classifying characters for use
in regexps -- you can refer to a category rather than having to use
Special Lisp functions are provided that abstract this, so you do not
have to directly manipulate bit vectors.
*/
- (obj))
+ (object))
{
- return (CHAR_TABLEP (obj) &&
- XCHAR_TABLE_TYPE (obj) == CHAR_TABLE_TYPE_CATEGORY) ?
+ return (CHAR_TABLEP (object) &&
+ XCHAR_TABLE_TYPE (object) == CHAR_TABLE_TYPE_CATEGORY) ?
Qt : Qnil;
}
static Lisp_Object
-check_category_table (Lisp_Object obj, Lisp_Object def)
+check_category_table (Lisp_Object object, Lisp_Object default_)
{
- if (NILP (obj))
- obj = def;
- while (NILP (Fcategory_table_p (obj)))
- obj = wrong_type_argument (Qcategory_table_p, obj);
- return obj;
+ if (NILP (object))
+ object = default_;
+ while (NILP (Fcategory_table_p (object)))
+ object = wrong_type_argument (Qcategory_table_p, object);
+ return object;
}
int
unsigned int designator, unsigned int not)
{
REGISTER Lisp_Object temp;
- struct Lisp_Char_Table *ctbl;
+ Lisp_Char_Table *ctbl;
#ifdef ERROR_CHECK_TYPECHECK
if (NILP (Fcategory_table_p (table)))
signal_simple_error ("Expected category table", table);
}
DEFUN ("check-category-at", Fcheck_category_at, 2, 4, 0, /*
-Return t if category of a character at POS includes DESIGNATOR,
-else return nil. Optional third arg specifies which buffer
-\(defaulting to current), and fourth specifies the CATEGORY-TABLE,
-\(defaulting to the buffer's category table).
+Return t if category of the character at POSITION includes DESIGNATOR.
+Optional third arg BUFFER specifies which buffer to use, and defaults
+to the current buffer.
+Optional fourth arg CATEGORY-TABLE specifies the category table to
+use, and defaults to BUFFER's category table.
*/
- (pos, designator, buffer, category_table))
+ (position, designator, buffer, category_table))
{
Lisp_Object ctbl;
Emchar ch;
unsigned int des;
struct buffer *buf = decode_buffer (buffer, 0);
- CHECK_INT (pos);
+ CHECK_INT (position);
CHECK_CATEGORY_DESIGNATOR (designator);
des = XCHAR (designator);
ctbl = check_category_table (category_table, Vstandard_category_table);
- ch = BUF_FETCH_CHAR (buf, XINT (pos));
+ ch = BUF_FETCH_CHAR (buf, XINT (position));
return check_category_char (ch, ctbl, des, 0) ? Qt : Qnil;
}
DEFUN ("char-in-category-p", Fchar_in_category_p, 2, 3, 0, /*
-Return t if category of character CHR includes DESIGNATOR, else nil.
-Optional third arg specifies the CATEGORY-TABLE to use,
-which defaults to the system default table.
+Return t if category of CHARACTER includes DESIGNATOR, else nil.
+Optional third arg CATEGORY-TABLE specifies the category table to use,
+and defaults to the standard category table.
*/
- (chr, designator, category_table))
+ (character, designator, category_table))
{
Lisp_Object ctbl;
Emchar ch;
CHECK_CATEGORY_DESIGNATOR (designator);
des = XCHAR (designator);
- CHECK_CHAR (chr);
- ch = XCHAR (chr);
+ CHECK_CHAR (character);
+ ch = XCHAR (character);
ctbl = check_category_table (category_table, Vstandard_category_table);
return check_category_char (ch, ctbl, des, 0) ? Qt : Qnil;
}
DEFUN ("category-table", Fcategory_table, 0, 1, 0, /*
-Return the current category table.
-This is the one specified by the current buffer, or by BUFFER if it
-is non-nil.
+Return BUFFER's current category table.
+BUFFER defaults to the current buffer.
*/
(buffer))
{
}
DEFUN ("copy-category-table", Fcopy_category_table, 0, 1, 0, /*
-Construct a new category table and return it.
-It is a copy of the TABLE, which defaults to the standard category table.
+Return a new category table which is a copy of CATEGORY-TABLE.
+CATEGORY-TABLE defaults to the standard category table.
*/
- (table))
+ (category_table))
{
if (NILP (Vstandard_category_table))
return Fmake_char_table (Qcategory);
- table = check_category_table (table, Vstandard_category_table);
- return Fcopy_char_table (table);
+ category_table =
+ check_category_table (category_table, Vstandard_category_table);
+ return Fcopy_char_table (category_table);
}
DEFUN ("set-category-table", Fset_category_table, 1, 2, 0, /*
-Select a new category table for BUFFER.
-One argument, a category table.
+Select CATEGORY-TABLE as the new category table for BUFFER.
BUFFER defaults to the current buffer if omitted.
*/
- (table, buffer))
+ (category_table, buffer))
{
struct buffer *buf = decode_buffer (buffer, 0);
- table = check_category_table (table, Qnil);
- buf->category_table = table;
+ category_table = check_category_table (category_table, Qnil);
+ buf->category_table = category_table;
/* Indicate that this buffer now has a specified category table. */
buf->local_var_flags |= XINT (buffer_local_flags.category_table);
- return table;
+ return category_table;
}
DEFUN ("category-designator-p", Fcategory_designator_p, 1, 1, 0, /*
-Return t if ARG is a category designator (a char in the range ' ' to '~').
+Return t if OBJECT is a category designator (a char in the range ' ' to '~').
*/
- (obj))
+ (object))
{
- return CATEGORY_DESIGNATORP (obj) ? Qt : Qnil;
+ return CATEGORY_DESIGNATORP (object) ? Qt : Qnil;
}
DEFUN ("category-table-value-p", Fcategory_table_value_p, 1, 1, 0, /*
-Return t if ARG is a category table value.
+Return t if OBJECT is a category table value.
Valid values are nil or a bit vector of size 95.
*/
- (obj))
+ (object))
{
- return CATEGORY_TABLE_VALUEP (obj) ? Qt : Qnil;
+ return CATEGORY_TABLE_VALUEP (object) ? Qt : Qnil;
}
+
+#define CATEGORYP(x) \
+ (CHARP (x) && XCHAR (x) >= 0x20 && XCHAR (x) <= 0x7E)
+
+#define CATEGORY_SET(c) \
+ (get_char_table(c, XCHAR_TABLE(current_buffer->category_table)))
+
+/* Return 1 if CATEGORY_SET contains CATEGORY, else return 0.
+ The faster version of `!NILP (Faref (category_set, category))'. */
+#define CATEGORY_MEMBER(category, category_set) \
+ (bit_vector_bit(XBIT_VECTOR (category_set), category - 32))
+
+/* Return 1 if there is a word boundary between two word-constituent
+ characters C1 and C2 if they appear in this order, else return 0.
+ Use the macro WORD_BOUNDARY_P instead of calling this function
+ directly. */
+
+int word_boundary_p (Emchar c1, Emchar c2);
+int
+word_boundary_p (Emchar c1, Emchar c2)
+{
+ Lisp_Object category_set1, category_set2;
+ Lisp_Object tail;
+ int default_result;
+
+#if 0
+ if (COMPOSITE_CHAR_P (c1))
+ c1 = cmpchar_component (c1, 0, 1);
+ if (COMPOSITE_CHAR_P (c2))
+ c2 = cmpchar_component (c2, 0, 1);
+#endif
+
+ if (EQ (CHAR_CHARSET (c1), CHAR_CHARSET (c2)))
+ {
+ tail = Vword_separating_categories;
+ default_result = 0;
+ }
+ else
+ {
+ tail = Vword_combining_categories;
+ default_result = 1;
+ }
+
+ category_set1 = CATEGORY_SET (c1);
+ if (NILP (category_set1))
+ return default_result;
+ category_set2 = CATEGORY_SET (c2);
+ if (NILP (category_set2))
+ return default_result;
+
+ for (; CONSP (tail); tail = XCONS (tail)->cdr)
+ {
+ Lisp_Object elt = XCONS(tail)->car;
+
+ if (CONSP (elt)
+ && CATEGORYP (XCONS (elt)->car)
+ && CATEGORYP (XCONS (elt)->cdr)
+ && CATEGORY_MEMBER (XCHAR (XCONS (elt)->car), category_set1)
+ && CATEGORY_MEMBER (XCHAR (XCONS (elt)->cdr), category_set2))
+ return !default_result;
+ }
+ return default_result;
+}
#endif /* MULE */
\f
void
syms_of_chartab (void)
{
+ INIT_LRECORD_IMPLEMENTATION (char_table);
+
#ifdef MULE
+ INIT_LRECORD_IMPLEMENTATION (char_table_entry);
+
defsymbol (&Qcategory_table_p, "category-table-p");
defsymbol (&Qcategory_designator_p, "category-designator-p");
defsymbol (&Qcategory_table_value_p, "category-table-value-p");
DEFSUBR (Fcategory_table_value_p);
#endif /* MULE */
+}
+
+void
+vars_of_chartab (void)
+{
/* DO NOT staticpro this. It works just like Vweak_hash_tables. */
Vall_syntax_tables = Qnil;
+ pdump_wire_list (&Vall_syntax_tables);
}
void
Vstandard_category_table = Qnil;
Vstandard_category_table = Fcopy_category_table (Qnil);
staticpro (&Vstandard_category_table);
+
+ DEFVAR_LISP ("word-combining-categories", &Vword_combining_categories /*
+List of pair (cons) of categories to determine word boundary.
+
+Emacs treats a sequence of word constituent characters as a single
+word (i.e. finds no word boundary between them) iff they belongs to
+the same charset. But, exceptions are allowed in the following cases.
+
+\(1) The case that characters are in different charsets is controlled
+by the variable `word-combining-categories'.
+
+Emacs finds no word boundary between characters of different charsets
+if they have categories matching some element of this list.
+
+More precisely, if an element of this list is a cons of category CAT1
+and CAT2, and a multibyte character C1 which has CAT1 is followed by
+C2 which has CAT2, there's no word boundary between C1 and C2.
+
+For instance, to tell that ASCII characters and Latin-1 characters can
+form a single word, the element `(?l . ?l)' should be in this list
+because both characters have the category `l' (Latin characters).
+
+\(2) The case that character are in the same charset is controlled by
+the variable `word-separating-categories'.
+
+Emacs find a word boundary between characters of the same charset
+if they have categories matching some element of this list.
+
+More precisely, if an element of this list is a cons of category CAT1
+and CAT2, and a multibyte character C1 which has CAT1 is followed by
+C2 which has CAT2, there's a word boundary between C1 and C2.
+
+For instance, to tell that there's a word boundary between Japanese
+Hiragana and Japanese Kanji (both are in the same charset), the
+element `(?H . ?C) should be in this list.
+*/ );
+
+ Vword_combining_categories = Qnil;
+
+ DEFVAR_LISP ("word-separating-categories", &Vword_separating_categories /*
+List of pair (cons) of categories to determine word boundary.
+See the documentation of the variable `word-combining-categories'.
+*/ );
+
+ Vword_separating_categories = Qnil;
#endif /* MULE */
}