X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fchartab.c;h=e90bb3d274fb67676258c316e279e64f0e703612;hb=dc6e13eb34013b5568cbdced4bb6d0ec3c3f0275;hp=79e91d6510ea8966e75767d1f79bf8190de58bc7;hpb=cf5826ba66a06da2de9b9a3cc029d811a0887e51;p=chise%2Fxemacs-chise.git- diff --git a/src/chartab.c b/src/chartab.c index 79e91d6..e90bb3d 100644 --- a/src/chartab.c +++ b/src/chartab.c @@ -97,7 +97,7 @@ Lisp_Object Vword_combining_categories, Vword_separating_categories; static 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++) @@ -110,8 +110,8 @@ mark_char_table_entry (Lisp_Object obj) 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++) @@ -124,13 +124,13 @@ char_table_entry_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) 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, offsetof(struct Lisp_Char_Table_Entry, level2), 96 }, + { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Char_Table_Entry, level2), 96 }, { XD_END } }; @@ -139,13 +139,13 @@ DEFINE_LRECORD_IMPLEMENTATION ("char-table-entry", char_table_entry, 0, char_table_entry_equal, char_table_entry_hash, char_table_entry_description, - struct Lisp_Char_Table_Entry); + Lisp_Char_Table_Entry); #endif /* MULE */ static 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++) @@ -241,7 +241,7 @@ print_chartab_range (Emchar first, Emchar last, Lisp_Object val, 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; @@ -289,7 +289,7 @@ print_chartab_charset_row (Lisp_Object charset, 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; @@ -319,7 +319,7 @@ print_chartab_two_byte_charset (Lisp_Object charset, 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 (", @@ -377,7 +377,7 @@ print_char_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) } 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 @@ -393,8 +393,8 @@ print_char_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) 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)) @@ -416,7 +416,7 @@ char_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) 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 @@ -427,12 +427,12 @@ char_table_hash (Lisp_Object obj, int depth) } static const struct lrecord_description char_table_description[] = { - { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Table, ascii), NUM_ASCII_CHARS }, + { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Char_Table, ascii), NUM_ASCII_CHARS }, #ifdef MULE - { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Table, level1), NUM_LEADING_BYTES }, + { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Char_Table, level1), NUM_LEADING_BYTES }, #endif - { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Table, mirror_table), 1 }, - { XD_LO_LINK, offsetof(struct Lisp_Char_Table, next_table) }, + { XD_LISP_OBJECT, offsetof (Lisp_Char_Table, mirror_table) }, + { XD_LO_LINK, offsetof (Lisp_Char_Table, next_table) }, { XD_END } }; @@ -440,7 +440,7 @@ DEFINE_LRECORD_IMPLEMENTATION ("char-table", char_table, mark_char_table, print_char_table, 0, char_table_equal, char_table_hash, char_table_description, - struct Lisp_Char_Table); + Lisp_Char_Table); DEFUN ("char-table-p", Fchar_table_p, 1, 1, 0, /* Return non-nil if OBJECT is a char table. @@ -468,12 +468,12 @@ assigned values are -- 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)) { @@ -533,17 +533,17 @@ sorts of values. The different char table types are } 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; @@ -559,14 +559,14 @@ fill_char_table (struct Lisp_Char_Table *ct, Lisp_Object value) } 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) { @@ -599,11 +599,11 @@ and 'syntax. See `valid-char-table-type-p'. */ (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) { @@ -631,9 +631,8 @@ make_char_table_entry (Lisp_Object initval) { 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; @@ -645,12 +644,11 @@ make_char_table_entry (Lisp_Object 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++) { @@ -668,19 +666,19 @@ copy_char_table_entry (Lisp_Object entry) #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++) @@ -735,7 +733,7 @@ decode_char_table_range (Lisp_Object range, struct chartab_range *outrange) #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", @@ -777,8 +775,8 @@ decode_char_table_range (Lisp_Object range, struct chartab_range *outrange) /* called from CHAR_TABLE_VALUE(). */ Lisp_Object -get_non_ascii_char_table_value (struct Lisp_Char_Table *ct, - Charset_ID leading_byte, Emchar c) +get_non_ascii_char_table_value (Lisp_Char_Table *ct, Charset_ID leading_byte, + Emchar c) { Lisp_Object val; #ifdef UTF2000 @@ -796,7 +794,7 @@ get_non_ascii_char_table_value (struct Lisp_Char_Table *ct, 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)) { @@ -813,7 +811,7 @@ get_non_ascii_char_table_value (struct Lisp_Char_Table *ct, #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 { @@ -833,7 +831,7 @@ get_char_table (Emchar ch, struct Lisp_Char_Table *ct) 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)) { @@ -854,32 +852,29 @@ get_char_table (Emchar ch, struct Lisp_Char_Table *ct) 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) @@ -1058,7 +1053,7 @@ Signal an error if VALUE is not a valid value for CHAR-TABLE-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) @@ -1091,7 +1086,7 @@ put_char_table (struct Lisp_Char_Table *ct, struct chartab_range *range, 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])) @@ -1115,7 +1110,7 @@ put_char_table (struct Lisp_Char_Table *ct, struct chartab_range *range, 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])) @@ -1150,7 +1145,7 @@ put_char_table (struct Lisp_Char_Table *ct, struct chartab_range *range, } 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: @@ -1161,27 +1156,27 @@ 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) @@ -1211,7 +1206,7 @@ map_over_charset_ascii (struct Lisp_Char_Table *ct, /* 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) @@ -1237,7 +1232,7 @@ map_over_charset_control_1 (struct Lisp_Char_Table *ct, 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), @@ -1277,7 +1272,7 @@ map_over_charset_row (struct Lisp_Char_Table_Entry *cte, static int -map_over_other_charset (struct Lisp_Char_Table *ct, Charset_ID 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) @@ -1300,7 +1295,7 @@ map_over_other_charset (struct Lisp_Char_Table *ct, Charset_ID lb, } { - 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; @@ -1334,7 +1329,7 @@ map_over_other_charset (struct Lisp_Char_Table *ct, Charset_ID lb, 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), @@ -1453,22 +1448,22 @@ slow_map_char_table_fun (struct chartab_range *range, } 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); @@ -1585,7 +1580,7 @@ chartab_instantiate (Lisp_Object data) /************************************************************************/ 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 @@ -1608,21 +1603,21 @@ whether the character is in that category. 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 @@ -1630,7 +1625,7 @@ check_category_char (Emchar ch, Lisp_Object table, 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); @@ -1645,32 +1640,33 @@ check_category_char (Emchar ch, Lisp_Object 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; @@ -1678,16 +1674,15 @@ which defaults to the system default table. 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)) { @@ -1704,48 +1699,48 @@ This is the one used for new buffers. } 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; } @@ -1817,7 +1812,11 @@ word_boundary_p (Emchar c1, Emchar c2) 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"); @@ -1891,7 +1890,7 @@ 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 +\(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 @@ -1905,7 +1904,7 @@ 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 +\(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