+2001-09-02 MORIOKA Tomohiko <tomo@calliope.mousai.mahoroba.ne.jp>
+
+ * list-mode.el: Delete dirty hack for XEmacs UTF-2000.
+
2001-08-07 MORIOKA Tomohiko <tomo@kanji.zinbun.kyoto-u.ac.jp>
* mule/mule-charset.el (default-coded-charset-priority-list): Add
(point-max)))))
;;; list-mode.el ends here
-
-;; [tomo] ad-hoc method to avoid slowness of the first completion
-(if (featurep 'utf-2000)
- (with-temp-buffer
- (completion-list-mode)))
+2001-09-05 MORIOKA Tomohiko <tomo@kanji.zinbun.kyoto-u.ac.jp>
+
+ * syntax.h (SYNTAX_CODE_UNSAFE): New implementation in XEmacs
+ UTF-2000.
+ (update_syntax_table): Deleted in XEmacs UTF-2000.
+
+ * syntax.c (find_defun_start): Use `syntax_table' instead of
+ `mirror_syntax_table' in XEmacs UTF-2000.
+ (Fset_syntax_table): Don't use `mirror_syntax_table' in XEmacs
+ UTF-2000.
+ (Fchar_syntax): Use `syntax_table' instead of `mirror_table' in
+ XEmacs UTF-2000.
+ (Fmatching_paren): Likewise.
+ (scan_words): Use `syntax_table' instead of `mirror_syntax_table'
+ in XEmacs UTF-2000.
+ (find_start_of_comment): Likewise.
+ (find_end_of_comment): Likewise.
+ (Fforward_comment): Likewise.
+ (scan_lists): Likewise.
+ (char_quoted): Likewise.
+ (Fbackward_prefix_chars): Likewise.
+ (scan_sexps_forward): Likewise.
+ (update_just_this_syntax_table): Deleted in XEmacs UTF-2000.
+ (update_syntax_table): Likewise.
+
+ * search.c (skip_chars): Use `syntax_table' instead of
+ `mirror_syntax_table' in XEmacs UTF-2000.
+ (wordify): Likewise.
+ (Freplace_match): Likewise.
+
+ * regex.c (re_compile_fastmap): Use `syntax_table' instead of
+ `mirror_syntax_table' in XEmacs UTF-2000.
+ (WORDCHAR_P_UNSAFE): Likewise.
+ (re_match_2_internal): Likewise.
+
+ * font-lock.c (find_context): Use `buf->syntax_table' instead of
+ `buf->mirror_syntax_table' in XEmacs UTF-2000.
+
+ * cmds.c (internal_self_insert): Use `buf->syntax_table' instead
+ of `buf->mirror_syntax_table' in XEmacs UTF-2000.
+
+ * chartab.h (struct Lisp_Char_Table): Delete `mirror_table' in
+ XEmacs UTF-2000.
+
+ * chartab.c (mark_char_table): Don't mark `mirror_table' in XEmacs
+ UTF-2000.
+ (print_char_table): Print `default_value' in XEmacs UTF-2000.
+ (char_table_description): Delete `mirror_table' in XEmacs
+ UTF-2000.
+ (fill_char_table): Don't call `update_syntax_table' in XEmacs
+ UTF-2000.
+ (Fmake_char_table): Don't use `mirror_table' in XEmacs UTF-2000.
+ (Fcopy_char_table): Likewise.
+ (put_char_table): Don't call `update_syntax_table' in XEmacs
+ UTF-2000.
+
+ * casefiddle.c (casify_object): Use `buf->syntax_table' instead of
+ `buf->mirror_syntax_table' in XEmacs UTF-2000.
+ (casify_region_internal): Likewise.
+
+ * bufslots.h: Delete `mirror_syntax_table' in XEmacs UTF-2000.
+
+ * buffer.c (common_init_complex_vars_of_buffer): Don't use
+ `mirror_syntax_table' in XEmacs UTF-2000.
+
+ * abbrev.c (abbrev_match): Use `buf->syntax_table' instead of
+ `buf->mirror_syntax_table' in XEmacs UTF-2000.
+ (Fexpand_abbrev): Likewise.
+
+2001-09-04 MORIOKA Tomohiko <tomo@kanji.zinbun.kyoto-u.ac.jp>
+
+ * chartab.c (vars_of_chartab): Update `utf-2000-version' to 0.18.
+
+2001-09-04 MORIOKA Tomohiko <tomo@kanji.zinbun.kyoto-u.ac.jp>
+
+ * chartab.c (map_over_uint8_byte_table): Cancel temporary hack.
+ (map_over_uint16_byte_table): Likewise.
+ (map_over_byte_table): Likewise.
+ (get_char_id_table): Refer `cit->default_value'.
+ (put_char_id_table): Support `CHARTAB_RANGE_DEFAULT'.
+ (map_char_id_table): Use `1 << 30' instead of `1 << 24' as number
+ of character-id ranges.
+ (mark_char_table): Mark `ct->default_value'.
+ (char_table_description): Add `default_value'.
+ (fill_char_table): Use `default_value'.
+ (decode_char_table_range): Decode `nil' as
+ `CHARTAB_RANGE_DEFAULT'.
+ (get_char_id_table): Refer `cit->default_value'.
+ (put_char_id_table): Support `CHARTAB_RANGE_DEFAULT'.
+ (map_char_table): Support `CHARTAB_RANGE_DEFAULT'; cancel
+ temporary hack; check value of char-table is bound or not.
+ (slow_map_char_table_fun): Support `CHARTAB_RANGE_DEFAULT'.
+
+ * chartab.h (struct Lisp_Char_Table): Add new member
+ `default_value' in XEmacs UTF-2000.
+ (CHAR_TABLE_VALUE_UNSAFE): Use `default_value'.
+ (enum chartab_range_type): Add `CHARTAB_RANGE_DEFAULT' in XEmacs
+ UTF-2000.
+
+2001-09-03 MORIOKA Tomohiko <tomo@kanji.zinbun.kyoto-u.ac.jp>
+
+ * chartab.h (Lisp_Char_ID_Table): Deleted.
+
+ * chartab.c (char_table_description): Fix typo.
+ (Fmap_char_attribute): Use `Lisp_Char_Table' instead of
+ `Lisp_Char_ID_Table'.
+
+2001-09-03 MORIOKA Tomohiko <tomo@kanji.zinbun.kyoto-u.ac.jp>
+
+ * text-coding.c (COMPOSE_ADD_CHAR): Use `CHAR_TABLEP' instead of
+ `CHAR_ID_TABLE_P'.
+
+ * mule-charset.c (remove_char_ccs): Use `CHAR_TABLEP' instead of
+ `CHAR_ID_TABLE_P'.
+
+ * chartab.h (XCHAR_ID_TABLE): Deleted.
+ (XSETCHAR_ID_TABLE): Deleted.
+ (CHAR_ID_TABLE_P): Deleted.
+
+ * chartab.c (put_char_id_table): Use `CHAR_TABLEP' instead of
+ `CHAR_ID_TABLE_P'.
+ (Fget_composite_char): Likewise.
+ (put_char_table): Likewise.
+ (add_char_attribute_alist_mapper): Fixed.
+ (Fchar_attribute_alist): Use `CHAR_TABLEP' instead of
+ `CHAR_ID_TABLE_P'.
+ (Fget_char_attribute): Likewise.
+ (Fget_char_attribute): Likewise.
+ (Fmap_char_attribute): Likewise.
+
+ * char-ucs.h (charset_code_point): Use `CHAR_TABLEP' instead of
+ `CHAR_ID_TABLE_P'.
+ (encode_char_1): Likewise.
+
+2001-09-03 MORIOKA Tomohiko <tomo@kanji.zinbun.kyoto-u.ac.jp>
+
+ * text-coding.c (COMPOSE_ADD_CHAR): Use `XCHAR_TABLE' instead of
+ `XCHAR_ID_TABLE'.
+
+ * mule-charset.c (put_char_ccs_code_point): Use `XCHAR_TABLE'
+ instead of `XCHAR_ID_TABLE'.
+ (remove_char_ccs): Likewise.
+
+ * chartab.c (put_char_id_table): Use `XCHAR_TABLE' instead of
+ `XCHAR_ID_TABLE'.
+ (Fget_composite_char): Likewise.
+ (Fchar_variants): Likewise.
+ (put_char_table): Likewise.
+ (add_char_attribute_alist_mapper): Likewise.
+ (Fchar_attribute_alist): Likewise.
+ (Fget_char_attribute): Likewise.
+ (Fput_char_attribute): Likewise.
+ (Fmap_char_attribute): Likewise.
+ (Fmap_char_attribute): Likewise.
+
+ * char-ucs.h (charset_code_point): Use `XCHAR_TABLE' instead of
+ `XCHAR_ID_TABLE'.
+ (encode_char_1): Likewise.
+
+2001-09-03 MORIOKA Tomohiko <tomo@kanji.zinbun.kyoto-u.ac.jp>
+
+ * chartab.c (map_char_id_table): Use `Lisp_Char_Table' instead of
+ `Lisp_Char_ID_Table'.
+ (mark_char_id_table): Deleted.
+ (print_char_id_table): Likewise.
+ (char_id_table_equal): Likewise.
+ (char_id_table_hash): Likewise.
+ (char_id_table_description): Likewise.
+ (char_id_table): Likewise.
+ (make_char_id_table): Use `Fmake_char_table' and
+ `fill_char_table'.
+ (get_char_id_table): Use `Lisp_Char_Table' instead of
+ `Lisp_Char_ID_Table'.
+ (put_char_id_table): Likewise.
+ (Fput_char_attribute): Use `XCHAR_TABLE' instead of
+ `XCHAR_ID_TABLE'.
+ (Fremove_char_attribute): Likewise.
+ (syms_of_chartab): Don't define type `char-id-table'.
+
+ * chartab.h (struct Lisp_Char_ID_Table): Deleted.
+ (char_id_table): Likewise.
+ (GC_CHAR_ID_TABLE_P): Likewise.
+ (Lisp_Char_ID_Table): Use structure `Lisp_Char_Table'.
+ (XCHAR_ID_TABLE): Use `XCHAR_TABLE'.
+ (XSETCHAR_ID_TABLE): Use `XSETCHAR_TABLE'.
+ (CHAR_ID_TABLE_P): Use `CHAR_TABLEP'.
+ (get_char_id_table): Use `Lisp_Char_Table' instead of
+ `Lisp_Char_ID_Table'.
+ (put_char_id_table_0): Likewise.
+ (put_char_id_table): Likewise.
+
+2001-09-02 MORIOKA Tomohiko <tomo@mousai.mahoroba.ne.jp>
+
+ * chartab.h: Lisp_Byte_Table related codes are moved from
+ chartab.h.
+
+ * char-ucs.h: Move Lisp_Byte_Table related codes to chartab.h.
+
+2001-09-02 MORIOKA Tomohiko <tomo@mousai.mahoroba.ne.jp>
+
+ * chartab.h: Don't include "chartab.h".
+ (struct Lisp_Char_ID_Table): Moved from char-ucs.h.
+ (Lisp_Char_ID_Table): Likewise.
+ (char_id_table): Likewise.
+ (XCHAR_ID_TABLE): Likewise.
+ (XSETCHAR_ID_TABLE): Likewise.
+ (CHAR_ID_TABLE_P): Likewise.
+ (GC_CHAR_ID_TABLE_P): Likewise.
+ (get_char_id_table): Likewise.
+
+ * char-ucs.h: Include "chartab.h".
+ (struct Lisp_Char_ID_Table): Moved to chartab.h.
+ (Lisp_Char_ID_Table): Likewise.
+ (char_id_table): Likewise.
+ (XCHAR_ID_TABLE): Likewise.
+ (XSETCHAR_ID_TABLE): Likewise.
+ (CHAR_ID_TABLE_P): Likewise.
+ (GC_CHAR_ID_TABLE_P): Likewise.
+ (get_char_id_table): Likewise.
+
+2001-09-01 MORIOKA Tomohiko <tomo@mousai.mahoroba.ne.jp>
+
+ * chartab.c (copy_uint8_byte_table): New function.
+ (copy_uint16_byte_table): New function.
+ (copy_byte_table): New function.
+ (map_over_uint8_byte_table): Modify to avoid huge numbers of
+ characters to call.
+ (map_over_uint16_byte_table): Likewise.
+ (map_over_byte_table): Likewise.
+ (get_byte_table): Move prototype to chartab.h.
+ (put_byte_table): Likewise.
+ (put_char_id_table_0): Moved to chartab.h.
+ (mark_char_table_entry): Don't define in XEmacs UTF-2000.
+ (char_table_entry_equal): Likewise.
+ (char_table_entry_hash): Likewise.
+ (char_table_entry_description): Likewise.
+ (char_table_entry): Likewise.
+ (make_char_table_entry): Likewise.
+ (copy_char_table_entry): Likewise.
+ (get_non_ascii_char_table_value): Likewise.
+ (map_over_charset_ascii): Likewise.
+ (map_over_charset_control_1): Likewise.
+ (map_over_charset_row): Likewise.
+ (map_over_other_charset): Likewise.
+ (mark_char_table): Modify for new structure in XEmacs UTF-2000.
+ (print_char_table): Likewise.
+ (char_table_equal): Likewise.
+ (char_table_hash): Likewise.
+ (char_table_description): Likewise.
+ (fill_char_table): Likewise.
+ (Fcopy_char_table): Likewise.
+ (get_char_table): Likewise.
+ (Fget_range_char_table): Likewise.
+ (put_char_table): Likewise.
+ (map_char_table): Likewise.
+ (syms_of_chartab): Don't define `char_table_entry' in XEmacs
+ UTF-2000.
+
+2001-08-31 MORIOKA Tomohiko <tomo@kanji.zinbun.kyoto-u.ac.jp>
+
+ * cmds.c (vars_of_cmds): Use `put_char_id_table_0' for
+ `Vauto_fill_chars' in XEmacs UTF-2000.
+
+ * chartab.h (get_byte_table): New prototype [moved from
+ chartab.c].
+ (put_byte_table): Likewise [moved from chartab.c].
+ (put_char_id_table_0): New inline function [moved from chartab.c].
+ (struct Lisp_Char_Table_Entry): Don't define in XEmacs UTF-2000.
+ (Lisp_Char_Table_Entry): Likewise.
+ (char_table_entry): Likewise.
+ (XCHAR_TABLE_ENTRY): Likewise.
+ (XSETCHAR_TABLE_ENTRY): Likewise.
+ (CHAR_TABLE_ENTRYP): Likewise.
+ (CHECK_CHAR_TABLE_ENTRY): Likewise.
+ (NUM_ASCII_CHARS): Likewise.
+ (struct Lisp_Char_Table): New implementation in XEmacs UTF-2000.
+ (CHAR_TABLE_VALUE_UNSAFE): Likewise.
+
2001-08-30 MORIOKA Tomohiko <tomo@kanji.zinbun.kyoto-u.ac.jp>
* chartab.c (get_char_id_table): Change interface.
(put_char_ccs_code_point): New prototype.
(remove_char_ccs): Likewise.
-2001-08-14 MORIOKA Tomohiko <tomo@calliope.mousai.mahoroba.ne.jp>
+2001-08-14 MORIOKA Tomohiko <tomo@mousai.mahoroba.ne.jp>
* mule-charset.c (Vcharset_ucs_jis): New variable.
(Qucs_jis): Likewise.
/* Primitives for word-abbrev mode.
Copyright (C) 1985, 1986, 1992, 1993 Free Software Foundation, Inc.
+ Copyright (C) 2001 MORIOKA Tomohiko
This file is part of XEmacs.
closure.buf = buf;
closure.point = BUF_PT (buf);
closure.maxlen = closure.point - BUF_BEGV (buf);
+#ifdef UTF2000
+ closure.chartab = XCHAR_TABLE (buf->syntax_table);
+#else
closure.chartab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
closure.found = 0;
map_obarray (obarray, abbrev_match_mapper, &closure);
Bufpos pos = abbrev_start;
/* Find the initial. */
while (pos < point
+#ifdef UTF2000
+ && !WORD_SYNTAX_P (XCHAR_TABLE (buf->syntax_table),
+ BUF_FETCH_CHAR (buf, pos))
+#else
&& !WORD_SYNTAX_P (XCHAR_TABLE (buf->mirror_syntax_table),
- BUF_FETCH_CHAR (buf, pos)))
+ BUF_FETCH_CHAR (buf, pos))
+#endif
+ )
pos++;
/* Change just that. */
Fupcase_initials_region (make_int (pos), make_int (pos + 1),
Copyright (C) 1985-1989, 1992-1995 Free Software Foundation, Inc.
Copyright (C) 1995 Sun Microsystems, Inc.
Copyright (C) 1995, 1996 Ben Wing.
+ Copyright (C) 1999,2000,2001 MORIOKA Tomohiko
This file is part of XEmacs.
list per frame.)
Mly: a few changes for buffer-local vars, 19.8 or 19.9.
Ben Wing: some changes and cleanups for Mule, 19.12.
+ MORIOKA Tomohiko: some changes for XEmacs UTF-2000.
*/
/* This file contains functions that work with buffer objects.
defs->category_table = Vstandard_category_table;
#endif /* MULE */
defs->syntax_table = Vstandard_syntax_table;
+#ifndef UTF2000
defs->mirror_syntax_table =
XCHAR_TABLE (Vstandard_syntax_table)->mirror_table;
+#endif
defs->modeline_format = build_string ("%-"); /* reset in loaddefs.el */
defs->case_fold_search = Qt;
defs->selective_display_ellipses = Qt;
/* Definitions of marked slots in buffers
Copyright (C) 1990, 1992, 1993 Free Software Foundation, Inc.
+ Copyright (C) 2001 MORIOKA Tomohiko
This file is part of XEmacs.
MARKED_SLOT (abbrev_table);
/* This buffer's syntax table. */
MARKED_SLOT (syntax_table);
+#ifndef UTF2000
/* Massaged values from the syntax table, for faster lookup. */
MARKED_SLOT (mirror_syntax_table);
+#endif
#ifdef MULE
/* This buffer's category table. */
/* XEmacs case conversion functions.
Copyright (C) 1985, 1992, 1993, 1994, 1997, 1998 Free Software Foundation, Inc.
+ Copyright (C) 2001 MORIOKA Tomohiko
This file is part of XEmacs.
if (STRINGP (string_or_char))
{
+#ifdef UTF2000
+ Lisp_Char_Table *syntax_table = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *syntax_table = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
Bufbyte *storage =
alloca_array (Bufbyte, XSTRING_LENGTH (string_or_char) * MAX_EMCHAR_LEN);
Bufbyte *newp = storage;
{
/* This function can GC */
Bufpos pos, s, e;
+#ifdef UTF2000
+ Lisp_Char_Table *syntax_table = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *syntax_table = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
int mccount;
int wordp = 0, wordp_prev;
#ifndef INCLUDED_char_ucs_h_
#define INCLUDED_char_ucs_h_
+#include "chartab.h"
+
#define valid_char_p(ch) 1
#define CHAR_ASCII_P(ch) ((ch) <= 0x7F)
-\f
-/************************************************************************/
-/* Char-ID Tables */
-/************************************************************************/
-
-struct Lisp_Uint8_Byte_Table
-{
- struct lcrecord_header header;
-
- unsigned char property[256];
-};
-typedef struct Lisp_Uint8_Byte_Table Lisp_Uint8_Byte_Table;
-
-DECLARE_LRECORD (uint8_byte_table, Lisp_Uint8_Byte_Table);
-#define XUINT8_BYTE_TABLE(x) \
- XRECORD (x, uint8_byte_table, Lisp_Uint8_Byte_Table)
-#define XSETUINT8_BYTE_TABLE(x, p) XSETRECORD (x, p, uint8_byte_table)
-#define UINT8_BYTE_TABLE_P(x) RECORDP (x, uint8_byte_table)
-#define GC_UINT8_BYTE_TABLE_P(x) GC_RECORDP (x, uint8_byte_table)
-/* #define CHECK_UINT8_BYTE_TABLE(x) CHECK_RECORD (x, uint8_byte_table)
- char table entries should never escape to Lisp */
-
-
-struct Lisp_Uint16_Byte_Table
-{
- struct lcrecord_header header;
-
- unsigned short property[256];
-};
-typedef struct Lisp_Uint16_Byte_Table Lisp_Uint16_Byte_Table;
-
-DECLARE_LRECORD (uint16_byte_table, Lisp_Uint16_Byte_Table);
-#define XUINT16_BYTE_TABLE(x) \
- XRECORD (x, uint16_byte_table, Lisp_Uint16_Byte_Table)
-#define XSETUINT16_BYTE_TABLE(x, p) XSETRECORD (x, p, uint16_byte_table)
-#define UINT16_BYTE_TABLE_P(x) RECORDP (x, uint16_byte_table)
-#define GC_UINT16_BYTE_TABLE_P(x) GC_RECORDP (x, uint16_byte_table)
-/* #define CHECK_UINT16_BYTE_TABLE(x) CHECK_RECORD (x, uint16_byte_table)
- char table entries should never escape to Lisp */
-
-
-struct Lisp_Byte_Table
-{
- struct lcrecord_header header;
-
- Lisp_Object property[256];
-};
-typedef struct Lisp_Byte_Table Lisp_Byte_Table;
-
-DECLARE_LRECORD (byte_table, Lisp_Byte_Table);
-#define XBYTE_TABLE(x) XRECORD (x, byte_table, Lisp_Byte_Table)
-#define XSETBYTE_TABLE(x, p) XSETRECORD (x, p, byte_table)
-#define BYTE_TABLE_P(x) RECORDP (x, byte_table)
-#define GC_BYTE_TABLE_P(x) GC_RECORDP (x, byte_table)
-/* #define CHECK_BYTE_TABLE(x) CHECK_RECORD (x, byte_table)
- char table entries should never escape to Lisp */
-
-
-struct Lisp_Char_ID_Table
-{
- struct lcrecord_header header;
-
- Lisp_Object table;
-};
-typedef struct Lisp_Char_ID_Table Lisp_Char_ID_Table;
-
-DECLARE_LRECORD (char_id_table, Lisp_Char_ID_Table);
-#define XCHAR_ID_TABLE(x) XRECORD (x, char_id_table, Lisp_Char_ID_Table)
-#define XSETCHAR_ID_TABLE(x, p) XSETRECORD (x, p, char_id_table)
-#define CHAR_ID_TABLE_P(x) RECORDP (x, char_id_table)
-#define GC_CHAR_ID_TABLE_P(x) GC_RECORDP (x, char_id_table)
-/* #define CHECK_CHAR_ID_TABLE(x) CHECK_RECORD (x, char_id_table)
- char table entries should never escape to Lisp */
-
-
-Lisp_Object get_char_id_table (Lisp_Char_ID_Table* cit, Emchar ch);
-
-
extern Lisp_Object Vcharset_mojikyo;
extern Lisp_Object Vcharset_mojikyo_2022_1;
extern Lisp_Object Vcharset_latin_jisx0201;
Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (charset);
Lisp_Object ret;
- if ( CHAR_ID_TABLE_P (encoding_table)
- && INTP (ret = get_char_id_table (XCHAR_ID_TABLE(encoding_table),
+ if ( CHAR_TABLEP (encoding_table)
+ && INTP (ret = get_char_id_table (XCHAR_TABLE(encoding_table),
ch)) )
return XINT (ret);
else
Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (*charset);
Lisp_Object ret;
- if ( CHAR_ID_TABLE_P (encoding_table)
+ if ( CHAR_TABLEP (encoding_table)
&& INTP (ret
- = get_char_id_table (XCHAR_ID_TABLE(encoding_table),
+ = get_char_id_table (XCHAR_TABLE(encoding_table),
ch)) )
return XINT (ret);
else
decode_char_table_range (Lisp_Object range, struct chartab_range *outrange);
int
-map_char_id_table (Lisp_Char_ID_Table *ct,
+map_char_id_table (Lisp_Char_Table *ct,
struct chartab_range *range,
int (*fn) (struct chartab_range *range,
Lisp_Object val, void *arg),
return obj;
}
+static Lisp_Object
+copy_uint8_byte_table (Lisp_Object entry)
+{
+ Lisp_Uint8_Byte_Table *cte = XUINT8_BYTE_TABLE (entry);
+ Lisp_Object obj;
+ int i;
+ Lisp_Uint8_Byte_Table *ctenew
+ = alloc_lcrecord_type (Lisp_Uint8_Byte_Table,
+ &lrecord_uint8_byte_table);
+
+ for (i = 0; i < 256; i++)
+ {
+ ctenew->property[i] = cte->property[i];
+ }
+
+ XSETUINT8_BYTE_TABLE (obj, ctenew);
+ return obj;
+}
+
static int
uint8_byte_table_same_value_p (Lisp_Object obj)
{
}
static Lisp_Object
+copy_uint16_byte_table (Lisp_Object entry)
+{
+ Lisp_Uint16_Byte_Table *cte = XUINT16_BYTE_TABLE (entry);
+ Lisp_Object obj;
+ int i;
+ Lisp_Uint16_Byte_Table *ctenew
+ = alloc_lcrecord_type (Lisp_Uint16_Byte_Table,
+ &lrecord_uint16_byte_table);
+
+ for (i = 0; i < 256; i++)
+ {
+ ctenew->property[i] = cte->property[i];
+ }
+
+ XSETUINT16_BYTE_TABLE (obj, ctenew);
+ return obj;
+}
+
+static Lisp_Object
expand_uint8_byte_table_to_uint16 (Lisp_Object table)
{
Lisp_Object obj;
return obj;
}
+static Lisp_Object
+copy_byte_table (Lisp_Object entry)
+{
+ Lisp_Byte_Table *cte = XBYTE_TABLE (entry);
+ Lisp_Object obj;
+ int i;
+ Lisp_Byte_Table *ctnew
+ = alloc_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table);
+
+ for (i = 0; i < 256; i++)
+ {
+ if (UINT8_BYTE_TABLE_P (cte->property[i]))
+ {
+ ctnew->property[i] = copy_uint8_byte_table (cte->property[i]);
+ }
+ else if (UINT16_BYTE_TABLE_P (cte->property[i]))
+ {
+ ctnew->property[i] = copy_uint16_byte_table (cte->property[i]);
+ }
+ else if (BYTE_TABLE_P (cte->property[i]))
+ {
+ ctnew->property[i] = copy_byte_table (cte->property[i]);
+ }
+ else
+ ctnew->property[i] = cte->property[i];
+ }
+
+ XSETBYTE_TABLE (obj, ctnew);
+ return obj;
+}
+
static int
byte_table_same_value_p (Lisp_Object obj)
{
}
-Lisp_Object get_byte_table (Lisp_Object table, unsigned char idx);
-Lisp_Object put_byte_table (Lisp_Object table, unsigned char idx,
- Lisp_Object value);
-
Lisp_Object
get_byte_table (Lisp_Object table, unsigned char idx)
{
return table;
}
-static Lisp_Object
-mark_char_id_table (Lisp_Object obj)
-{
- Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj);
-
- return cte->table;
-}
-
-static void
-print_char_id_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
-{
- Lisp_Object table = XCHAR_ID_TABLE (obj)->table;
- int i;
- struct gcpro gcpro1, gcpro2;
- GCPRO2 (obj, printcharfun);
-
- write_c_string ("#<char-id-table ", printcharfun);
- for (i = 0; i < 256; i++)
- {
- Lisp_Object elt = get_byte_table (table, i);
- if (i != 0) write_c_string ("\n ", printcharfun);
- if (EQ (elt, Qunbound))
- write_c_string ("void", printcharfun);
- else
- print_internal (elt, printcharfun, escapeflag);
- }
- UNGCPRO;
- write_c_string (">", printcharfun);
-}
-
-static int
-char_id_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
-{
- Lisp_Object table1 = XCHAR_ID_TABLE (obj1)->table;
- Lisp_Object table2 = XCHAR_ID_TABLE (obj2)->table;
- int i;
-
- for (i = 0; i < 256; i++)
- {
- if (!internal_equal (get_byte_table (table1, i),
- get_byte_table (table2, i), 0))
- return 0;
- }
- return -1;
-}
-
-static unsigned long
-char_id_table_hash (Lisp_Object obj, int depth)
-{
- Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj);
-
- return char_id_table_hash (cte->table, depth + 1);
-}
-
-static const struct lrecord_description char_id_table_description[] = {
- { XD_LISP_OBJECT, offsetof(Lisp_Char_ID_Table, table) },
- { XD_END }
-};
-
-DEFINE_LRECORD_IMPLEMENTATION ("char-id-table", char_id_table,
- mark_char_id_table,
- print_char_id_table,
- 0, char_id_table_equal,
- char_id_table_hash,
- char_id_table_description,
- Lisp_Char_ID_Table);
Lisp_Object
make_char_id_table (Lisp_Object initval)
{
Lisp_Object obj;
- Lisp_Char_ID_Table *cte;
-
- cte = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table);
-
- cte->table = make_byte_table (initval);
-
- XSETCHAR_ID_TABLE (obj, cte);
+ obj = Fmake_char_table (Qgeneric);
+ fill_char_table (XCHAR_TABLE (obj), initval);
return obj;
}
-
Lisp_Object
-get_char_id_table (Lisp_Char_ID_Table* cit, Emchar ch)
-{
- unsigned int code = ch;
-
- return get_byte_table (get_byte_table
- (get_byte_table
- (get_byte_table
- (cit->table,
- (unsigned char)(code >> 24)),
- (unsigned char) (code >> 16)),
- (unsigned char) (code >> 8)),
- (unsigned char) code);
-}
-
-INLINE_HEADER void
-put_char_id_table_0 (Lisp_Char_ID_Table* cit, Emchar code, Lisp_Object value);
-INLINE_HEADER void
-put_char_id_table_0 (Lisp_Char_ID_Table* cit, Emchar code, Lisp_Object value)
-{
- Lisp_Object table1, table2, table3, table4;
-
- table1 = cit->table;
- table2 = get_byte_table (table1, (unsigned char)(code >> 24));
- table3 = get_byte_table (table2, (unsigned char)(code >> 16));
- table4 = get_byte_table (table3, (unsigned char)(code >> 8));
-
- table4 = put_byte_table (table4, (unsigned char) code, value);
- table3 = put_byte_table (table3, (unsigned char)(code >> 8), table4);
- table2 = put_byte_table (table2, (unsigned char)(code >> 16), table3);
- cit->table = put_byte_table (table1, (unsigned char)(code >> 24), table2);
+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_ID_Table* cit,
+put_char_id_table (Lisp_Char_Table* cit,
Lisp_Object character, Lisp_Object value)
{
struct chartab_range range;
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_ID_TABLE_P (encoding_table) )
+ if ( CHAR_TABLEP (encoding_table) )
{
for (c = 0; c < 1 << 24; c++)
{
- if ( INTP (get_char_id_table (XCHAR_ID_TABLE(encoding_table),
+ if ( INTP (get_char_id_table (XCHAR_TABLE(encoding_table),
c)) )
put_char_id_table_0 (cit, c, value);
}
Mapping stops the first time FN returns non-zero, and that value
becomes the return value of map_char_id_table(). */
int
-map_char_id_table (Lisp_Char_ID_Table *ct,
+map_char_id_table (Lisp_Char_Table *ct,
struct chartab_range *range,
int (*fn) (struct chartab_range *range,
Lisp_Object val, void *arg),
else if (!UNBOUNDP (v))
{
struct chartab_range rainj;
- int unit = 1 << 24;
+ int unit = 1 << 30;
Emchar c = 0;
Emchar c1 = c + unit;
int retval;
else if (!UNBOUNDP (v))
{
struct chartab_range rainj;
- int unit = 1 << 24;
+ int unit = 1 << 30;
Emchar c = 0;
Emchar c1 = c + unit;
int retval;
Lisp_Object ret;
Emchar c = to_char_id (v, "Invalid value for composition", list);
- ret = get_char_id_table (XCHAR_ID_TABLE(table), c);
+ ret = get_char_id_table (XCHAR_TABLE(table), c);
rest = Fcdr (rest);
if (NILP (rest))
{
- if (!CHAR_ID_TABLE_P (ret))
+ if (!CHAR_TABLEP (ret))
return ret;
else
return Qt;
}
else if (!CONSP (rest))
break;
- else if (CHAR_ID_TABLE_P (ret))
+ else if (CHAR_TABLEP (ret))
table = ret;
else
signal_simple_error ("Invalid table is found with", list);
{
CHECK_CHAR (character);
return Fcopy_list (get_char_id_table
- (XCHAR_ID_TABLE(Vcharacter_variant_table),
+ (XCHAR_TABLE(Vcharacter_variant_table),
XCHAR (character)));
}
/* Char Table object */
/************************************************************************/
-#ifdef MULE
+#if defined(MULE)&&!defined(UTF2000)
static Lisp_Object
mark_char_table_entry (Lisp_Object obj)
mark_char_table (Lisp_Object obj)
{
Lisp_Char_Table *ct = XCHAR_TABLE (obj);
+#ifdef UTF2000
+
+ mark_object (ct->table);
+#else
int i;
for (i = 0; i < NUM_ASCII_CHARS; i++)
for (i = 0; i < NUM_LEADING_BYTES; i++)
mark_object (ct->level1[i]);
#endif
+#endif
+#ifdef UTF2000
+ return ct->default_value;
+#else
return ct->mirror_table;
+#endif
}
/* WARNING: All functions of this nature need to be written extremely
print_internal (val, printcharfun, 1);
}
-#ifdef MULE
+#if defined(MULE)&&!defined(UTF2000)
static void
print_chartab_charset_row (Lisp_Object charset,
print_char_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
{
Lisp_Char_Table *ct = XCHAR_TABLE (obj);
+#ifdef UTF2000
+ int i;
+ struct gcpro gcpro1, gcpro2;
+ GCPRO2 (obj, printcharfun);
+
+ write_c_string ("#s(char-table ", printcharfun);
+ write_c_string (" ", printcharfun);
+ write_c_string (string_data
+ (symbol_name
+ (XSYMBOL (char_table_type_to_symbol (ct->type)))),
+ printcharfun);
+ write_c_string ("\n ", printcharfun);
+ print_internal (ct->default_value, printcharfun, escapeflag);
+ for (i = 0; i < 256; i++)
+ {
+ Lisp_Object elt = get_byte_table (ct->table, i);
+ if (i != 0) write_c_string ("\n ", printcharfun);
+ if (EQ (elt, Qunbound))
+ write_c_string ("void", printcharfun);
+ else
+ print_internal (elt, printcharfun, escapeflag);
+ }
+ UNGCPRO;
+#else /* non UTF2000 */
char buf[200];
sprintf (buf, "#s(char-table type %s data (",
}
}
#endif /* MULE */
+#endif /* non UTF2000 */
write_c_string ("))", printcharfun);
}
if (CHAR_TABLE_TYPE (ct1) != CHAR_TABLE_TYPE (ct2))
return 0;
+#ifdef UTF2000
+ for (i = 0; i < 256; i++)
+ {
+ if (!internal_equal (get_byte_table (ct1->table, i),
+ get_byte_table (ct2->table, i), 0))
+ return 0;
+ }
+#else
for (i = 0; i < NUM_ASCII_CHARS; i++)
if (!internal_equal (ct1->ascii[i], ct2->ascii[i], depth + 1))
return 0;
if (!internal_equal (ct1->level1[i], ct2->level1[i], depth + 1))
return 0;
#endif /* MULE */
+#endif /* non UTF2000 */
return 1;
}
char_table_hash (Lisp_Object obj, int depth)
{
Lisp_Char_Table *ct = XCHAR_TABLE (obj);
+#ifdef UTF2000
+ return byte_table_hash (ct->table, depth + 1);
+#else
unsigned long hashval = internal_array_hash (ct->ascii, NUM_ASCII_CHARS,
depth);
#ifdef MULE
internal_array_hash (ct->level1, NUM_LEADING_BYTES, depth));
#endif /* MULE */
return hashval;
+#endif
}
static const struct lrecord_description char_table_description[] = {
+#ifdef UTF2000
+ { XD_LISP_OBJECT, offsetof(Lisp_Char_Table, table) },
+ { XD_LISP_OBJECT, offsetof(Lisp_Char_Table, default_value) },
+#else
{ 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
+#endif
+#ifndef UTF2000
{ XD_LISP_OBJECT, offsetof (Lisp_Char_Table, mirror_table) },
+#endif
{ XD_LO_LINK, offsetof (Lisp_Char_Table, next_table) },
{ XD_END }
};
void
fill_char_table (Lisp_Char_Table *ct, Lisp_Object value)
{
+#ifdef UTF2000
+ ct->table = Qunbound;
+ ct->default_value = value;
+#else
int i;
for (i = 0; i < NUM_ASCII_CHARS; i++)
for (i = 0; i < NUM_LEADING_BYTES; i++)
ct->level1[i] = value;
#endif /* MULE */
+#endif
+#ifndef UTF2000
if (ct->type == CHAR_TABLE_TYPE_SYNTAX)
update_syntax_table (ct);
+#endif
}
DEFUN ("reset-char-table", Freset_char_table, 1, 1, 0, /*
ct = alloc_lcrecord_type (Lisp_Char_Table, &lrecord_char_table);
ct->type = ty;
+#ifndef UTF2000
if (ty == CHAR_TABLE_TYPE_SYNTAX)
{
ct->mirror_table = Fmake_char_table (Qgeneric);
}
else
ct->mirror_table = Qnil;
+#endif
ct->next_table = Qnil;
XSETCHAR_TABLE (obj, ct);
if (ty == CHAR_TABLE_TYPE_SYNTAX)
return obj;
}
-#ifdef MULE
+#if defined(MULE)&&!defined(UTF2000)
static Lisp_Object
make_char_table_entry (Lisp_Object initval)
{
Lisp_Char_Table *ct, *ctnew;
Lisp_Object obj;
+#ifndef UTF2000
int i;
+#endif
CHECK_CHAR_TABLE (char_table);
ct = XCHAR_TABLE (char_table);
ctnew = alloc_lcrecord_type (Lisp_Char_Table, &lrecord_char_table);
ctnew->type = ct->type;
+#ifdef UTF2000
+ ctnew->default_value = ct->default_value;
+
+ if (UINT8_BYTE_TABLE_P (ct->table))
+ {
+ ctnew->table = copy_uint8_byte_table (ct->table);
+ }
+ else if (UINT16_BYTE_TABLE_P (ct->table))
+ {
+ ctnew->table = copy_uint16_byte_table (ct->table);
+ }
+ else if (BYTE_TABLE_P (ct->table))
+ {
+ ctnew->table = copy_byte_table (ct->table);
+ }
+ else if (!UNBOUNDP (ct->table))
+ ctnew->table = ct->table;
+#else /* non UTF2000 */
for (i = 0; i < NUM_ASCII_CHARS; i++)
{
}
#endif /* MULE */
+#endif /* non UTF2000 */
+#ifndef UTF2000
if (CHAR_TABLEP (ct->mirror_table))
ctnew->mirror_table = Fcopy_char_table (ct->mirror_table);
else
ctnew->mirror_table = ct->mirror_table;
+#endif
ctnew->next_table = Qnil;
XSETCHAR_TABLE (obj, ctnew);
if (ctnew->type == CHAR_TABLE_TYPE_SYNTAX)
{
if (EQ (range, Qt))
outrange->type = CHARTAB_RANGE_ALL;
+ else if (EQ (range, Qnil))
+ outrange->type = CHARTAB_RANGE_DEFAULT;
else if (CHAR_OR_CHAR_INTP (range))
{
outrange->type = CHARTAB_RANGE_CHAR;
#endif /* MULE */
}
-#ifdef MULE
+#if defined(MULE)&&!defined(UTF2000)
/* called from CHAR_TABLE_VALUE(). */
Lisp_Object
Lisp_Object
get_char_table (Emchar ch, Lisp_Char_Table *ct)
{
-#ifdef MULE
+#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;
+#elif defined(MULE)
{
Lisp_Object charset;
int byte1, byte2;
{
case CHARTAB_RANGE_ALL:
{
+#ifdef UTF2000
+ if (UINT8_BYTE_TABLE_P (ct->table))
+ return multi;
+ else if (UINT16_BYTE_TABLE_P (ct->table))
+ return multi;
+ else if (BYTE_TABLE_P (ct->table))
+ return multi;
+ else
+ return ct->table;
+#else /* non UTF2000 */
int i;
Lisp_Object first = ct->ascii[0];
#endif /* MULE */
return first;
+#endif /* non UTF2000 */
}
#ifdef MULE
case CHARTAB_RANGE_CHARSET:
+#ifdef UTF2000
+ return multi;
+#else
if (EQ (rainj.charset, Vcharset_ascii))
{
int i;
return multi;
return val;
}
+#endif
case CHARTAB_RANGE_ROW:
+#ifdef UTF2000
+ return multi;
+#else
{
Lisp_Object val = ct->level1[XCHARSET_LEADING_BYTE (rainj.charset) -
MIN_LEADING_BYTE];
return multi;
return val;
}
+#endif /* not UTF2000 */
#endif /* not MULE */
default:
switch (range->type)
{
case CHARTAB_RANGE_ALL:
+ /* printf ("put-char-table: range = all\n"); */
fill_char_table (ct, val);
return; /* avoid the duplicate call to update_syntax_table() below,
since fill_char_table() also did that. */
+#ifdef UTF2000
+ case CHARTAB_RANGE_DEFAULT:
+ ct->default_value = val;
+ return;
+#endif
+
#ifdef MULE
case CHARTAB_RANGE_CHARSET:
+#ifdef UTF2000
+ {
+ Emchar c;
+ Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (range->charset);
+
+ /* printf ("put-char-table: range = charset: %d\n",
+ XCHARSET_LEADING_BYTE (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 (ct, c, val);
+ }
+ }
+ else
+ {
+ for (c = 0; c < 1 << 24; c++)
+ {
+ if ( charset_code_point (range->charset, c) >= 0 )
+ put_char_id_table_0 (ct, c, val);
+ }
+ }
+ }
+#else
if (EQ (range->charset, Vcharset_ascii))
{
int i;
int lb = XCHARSET_LEADING_BYTE (range->charset) - MIN_LEADING_BYTE;
ct->level1[lb] = val;
}
+#endif
break;
case CHARTAB_RANGE_ROW:
+#ifdef UTF2000
+ {
+ 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 ();
+
+ 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);
+ }
+ }
+#else
{
Lisp_Char_Table_Entry *cte;
int lb = XCHARSET_LEADING_BYTE (range->charset) - MIN_LEADING_BYTE;
cte = XCHAR_TABLE_ENTRY (ct->level1[lb]);
cte->level2[range->row - 32] = val;
}
+#endif /* not UTF2000 */
break;
#endif /* MULE */
case CHARTAB_RANGE_CHAR:
-#ifdef MULE
+#ifdef UTF2000
+ /* printf ("put-char-table: range = char: 0x%x\n", range->ch); */
+ put_char_id_table_0 (ct, range->ch, val);
+ break;
+#elif defined(MULE)
{
Lisp_Object charset;
int byte1, byte2;
#endif /* not MULE */
}
+#ifndef UTF2000
if (ct->type == CHAR_TABLE_TYPE_SYNTAX)
update_syntax_table (ct);
+#endif
}
DEFUN ("put-char-table", Fput_char_table, 3, 3, 0, /*
return Qnil;
}
+#ifndef UTF2000
/* Map FN over the ASCII chars in CT. */
static int
}
#endif /* MULE */
+#endif /* not UTF2000 */
/* Map FN (with client data ARG) over range RANGE in char table CT.
Mapping stops the first time FN returns non-zero, and that value
switch (range->type)
{
case CHARTAB_RANGE_ALL:
+#ifdef UTF2000
+ if (!UNBOUNDP (ct->default_value))
+ {
+ struct chartab_range rainj;
+ int retval;
+
+ rainj.type = CHARTAB_RANGE_DEFAULT;
+ retval = (fn) (&rainj, ct->default_value, arg);
+ if (retval != 0)
+ 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);
+ else if (UINT16_BYTE_TABLE_P (ct->table))
+ return map_over_uint16_byte_table (XUINT16_BYTE_TABLE(ct->table), 0, 3,
+ Qnil, fn, arg);
+ else if (BYTE_TABLE_P (ct->table))
+ return map_over_byte_table (XBYTE_TABLE(ct->table), 0, 3,
+ Qnil, fn, arg);
+ else if (!UNBOUNDP (ct->table))
+#if 0
+ {
+ struct chartab_range rainj;
+ int unit = 1 << 30;
+ Emchar c = 0;
+ Emchar c1 = c + unit;
+ int retval;
+
+ rainj.type = CHARTAB_RANGE_CHAR;
+
+ for (retval = 0; c < c1 && retval == 0; c++)
+ {
+ rainj.ch = c;
+ retval = (fn) (&rainj, ct->table, arg);
+ }
+ return retval;
+ }
+#else
+ return (fn) (range, ct->table, arg);
+#endif
+ return 0;
+#else
{
int retval;
#endif /* MULE */
return retval;
}
+#endif
+
+#ifdef UTF2000
+ case CHARTAB_RANGE_DEFAULT:
+ if (!UNBOUNDP (ct->default_value))
+ return (fn) (range, ct->default_value, arg);
+ return 0;
+#endif
#ifdef MULE
case CHARTAB_RANGE_CHARSET:
+#ifdef UTF2000
+ if (UINT8_BYTE_TABLE_P (ct->table))
+ return map_over_uint8_byte_table (XUINT8_BYTE_TABLE(ct->table), 0, 3,
+ range->charset, fn, arg);
+ else if (UINT16_BYTE_TABLE_P (ct->table))
+ return map_over_uint16_byte_table (XUINT16_BYTE_TABLE(ct->table), 0, 3,
+ range->charset, fn, arg);
+ else if (BYTE_TABLE_P (ct->table))
+ return map_over_byte_table (XBYTE_TABLE(ct->table), 0, 3,
+ range->charset, fn, arg);
+ else if (!UNBOUNDP (ct->table))
+ {
+#if 0
+ struct chartab_range rainj;
+ int unit = 1 << 24;
+ Emchar c = 0;
+ Emchar c1 = c + unit;
+ int retval;
+
+ rainj.type = CHARTAB_RANGE_CHAR;
+
+ for (retval = 0; c < c1 && retval == 0; c++)
+ {
+ if ( charset_code_point (range->charset, c) >= 0 )
+ {
+ rainj.ch = c;
+ retval = (fn) (&rainj, ct->table, arg);
+ }
+ }
+#else
+ return (fn) (range, ct->table, arg);
+#endif
+ }
+ return 0;
+#else
return map_over_other_charset (ct,
XCHARSET_LEADING_BYTE (range->charset),
fn, arg);
+#endif
case CHARTAB_RANGE_ROW:
+#ifdef UTF2000
+ {
+ int cell_min, cell_max, i;
+ 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 ();
+
+ rainj.type = CHARTAB_RANGE_CHAR;
+ for (retval =0, i = cell_min; i <= cell_max && retval == 0; i++)
+ {
+ Emchar ch = DECODE_CHAR (range->charset, (range->row << 8) | i);
+ 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))
+ {
+ rainj.ch = ch;
+ retval = (fn) (&rainj, val, arg);
+ }
+ }
+ return retval;
+ }
+#else
{
Lisp_Object val = ct->level1[XCHARSET_LEADING_BYTE (range->charset)
- MIN_LEADING_BYTE];
range->charset, range->row,
fn, arg);
}
+#endif /* not UTF2000 */
#endif /* MULE */
case CHARTAB_RANGE_CHAR:
{
Emchar ch = range->ch;
Lisp_Object val = CHAR_TABLE_VALUE_UNSAFE (ct, ch);
- struct chartab_range rainj;
- rainj.type = CHARTAB_RANGE_CHAR;
- rainj.ch = ch;
- return (fn) (&rainj, val, arg);
+ if (!UNBOUNDP (val))
+ {
+ struct chartab_range rainj;
+
+ rainj.type = CHARTAB_RANGE_CHAR;
+ rainj.ch = ch;
+ return (fn) (&rainj, val, arg);
+ }
+ return 0;
}
default:
ranjarg = Qt;
break;
+#ifdef UTF2000
+ case CHARTAB_RANGE_DEFAULT:
+ ranjarg = Qnil;
+ break;
+#endif
+
#ifdef MULE
case CHARTAB_RANGE_CHARSET:
ranjarg = XCHARSET_NAME (range->charset);
/* This function can GC */
struct char_attribute_alist_closure *caacl =
(struct char_attribute_alist_closure*) char_attribute_alist_closure;
- Lisp_Object ret = get_char_id_table (XCHAR_ID_TABLE(caacl->char_id), value);
+ Lisp_Object ret
+ = get_char_id_table (XCHAR_TABLE(value), caacl->char_id);
if (!UNBOUNDP (ret))
{
Lisp_Object *char_attribute_alist = caacl->char_attribute_alist;
Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs);
Lisp_Object cpos;
- if ( CHAR_ID_TABLE_P (encoding_table)
+ if ( CHAR_TABLEP (encoding_table)
&& INTP (cpos
- = get_char_id_table (XCHAR_ID_TABLE(encoding_table),
+ = get_char_id_table (XCHAR_TABLE(encoding_table),
XCHAR (character))) )
{
alist = Fcons (Fcons (ccs, cpos), alist);
{
Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs);
- if (CHAR_ID_TABLE_P (encoding_table))
- return get_char_id_table (XCHAR_ID_TABLE(encoding_table),
+ if (CHAR_TABLEP (encoding_table))
+ return get_char_id_table (XCHAR_TABLE(encoding_table),
XCHAR (character));
}
else
Qunbound);
if (!UNBOUNDP (table))
{
- Lisp_Object ret = get_char_id_table (XCHAR_ID_TABLE(table),
+ Lisp_Object ret = get_char_id_table (XCHAR_TABLE(table),
XCHAR (character));
if (!UNBOUNDP (ret))
return ret;
rest = Fcdr (rest);
if (!CONSP (rest))
{
- put_char_id_table (XCHAR_ID_TABLE(table),
+ put_char_id_table (XCHAR_TABLE(table),
make_char (c), character);
break;
}
else
{
- ntable = get_char_id_table (XCHAR_ID_TABLE(table), c);
- if (!CHAR_ID_TABLE_P (ntable))
+ ntable = get_char_id_table (XCHAR_TABLE(table), c);
+ if (!CHAR_TABLEP (ntable))
{
ntable = make_char_id_table (Qnil);
- put_char_id_table (XCHAR_ID_TABLE(table),
+ put_char_id_table (XCHAR_TABLE(table),
make_char (c), ntable);
}
table = ntable;
{
Emchar c = XINT (v);
Lisp_Object ret
- = get_char_id_table (XCHAR_ID_TABLE(Vcharacter_variant_table),
+ = get_char_id_table (XCHAR_TABLE(Vcharacter_variant_table),
c);
if (NILP (Fmemq (v, ret)))
{
- put_char_id_table (XCHAR_ID_TABLE(Vcharacter_variant_table),
+ put_char_id_table (XCHAR_TABLE(Vcharacter_variant_table),
make_char (c), Fcons (character, ret));
}
}
c = XINT (value);
- ret = get_char_id_table (XCHAR_ID_TABLE(Vcharacter_variant_table), c);
+ ret = get_char_id_table (XCHAR_TABLE(Vcharacter_variant_table), c);
if (NILP (Fmemq (character, ret)))
{
- put_char_id_table (XCHAR_ID_TABLE(Vcharacter_variant_table),
+ put_char_id_table (XCHAR_TABLE(Vcharacter_variant_table),
make_char (c), Fcons (character, ret));
}
#if 0
table = make_char_id_table (Qunbound);
Fputhash (attribute, table, Vchar_attribute_hash_table);
}
- put_char_id_table (XCHAR_ID_TABLE(table), character, value);
+ put_char_id_table (XCHAR_TABLE(table), character, value);
return value;
}
}
Qunbound);
if (!UNBOUNDP (table))
{
- put_char_id_table (XCHAR_ID_TABLE(table), character, Qunbound);
+ put_char_id_table (XCHAR_TABLE(table), character, Qunbound);
return Qt;
}
}
(function, attribute, range))
{
Lisp_Object ccs;
- Lisp_Char_ID_Table *ct;
+ Lisp_Char_Table *ct;
struct slow_map_char_table_arg slarg;
struct gcpro gcpro1, gcpro2;
struct chartab_range rainj;
{
Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs);
- if (CHAR_ID_TABLE_P (encoding_table))
- ct = XCHAR_ID_TABLE (encoding_table);
+ if (CHAR_TABLEP (encoding_table))
+ ct = XCHAR_TABLE (encoding_table);
else
return Qnil;
}
Lisp_Object table = Fgethash (attribute,
Vchar_attribute_hash_table,
Qunbound);
- if (CHAR_ID_TABLE_P (table))
- ct = XCHAR_ID_TABLE (table);
+ if (CHAR_TABLEP (table))
+ ct = XCHAR_TABLE (table);
else
return Qnil;
}
INIT_LRECORD_IMPLEMENTATION (uint8_byte_table);
INIT_LRECORD_IMPLEMENTATION (uint16_byte_table);
INIT_LRECORD_IMPLEMENTATION (byte_table);
- INIT_LRECORD_IMPLEMENTATION (char_id_table);
defsymbol (&Qto_ucs, "=>ucs");
defsymbol (&Q_ucs, "->ucs");
INIT_LRECORD_IMPLEMENTATION (char_table);
#ifdef MULE
+#ifndef UTF2000
INIT_LRECORD_IMPLEMENTATION (char_table_entry);
+#endif
defsymbol (&Qcategory_table_p, "category-table-p");
defsymbol (&Qcategory_designator_p, "category-designator-p");
vars_of_chartab (void)
{
#ifdef UTF2000
- Vutf_2000_version = build_string("0.17 (Hōryūji)");
+ Vutf_2000_version = build_string("0.18 (Yamato-Koizumi)");
DEFVAR_LISP ("utf-2000-version", &Vutf_2000_version /*
Version number of XEmacs UTF-2000.
*/ );
/* Declarations having to do with Mule char tables.
Copyright (C) 1992 Free Software Foundation, Inc.
Copyright (C) 1995 Sun Microsystems, Inc.
+ Copyright (C) 1999,2000,2001 MORIOKA Tomohiko
This file is part of XEmacs.
#ifdef UTF2000
-#include "char-ucs.h"
+/************************************************************************/
+/* Char-ID Tables */
+/************************************************************************/
-Lisp_Object make_char_id_table (Lisp_Object initval);
+struct Lisp_Uint8_Byte_Table
+{
+ struct lcrecord_header header;
-void put_char_id_table (Lisp_Char_ID_Table* table,
- Lisp_Object character, Lisp_Object value);
+ unsigned char property[256];
+};
+typedef struct Lisp_Uint8_Byte_Table Lisp_Uint8_Byte_Table;
+
+DECLARE_LRECORD (uint8_byte_table, Lisp_Uint8_Byte_Table);
+#define XUINT8_BYTE_TABLE(x) \
+ XRECORD (x, uint8_byte_table, Lisp_Uint8_Byte_Table)
+#define XSETUINT8_BYTE_TABLE(x, p) XSETRECORD (x, p, uint8_byte_table)
+#define UINT8_BYTE_TABLE_P(x) RECORDP (x, uint8_byte_table)
+#define GC_UINT8_BYTE_TABLE_P(x) GC_RECORDP (x, uint8_byte_table)
+/* #define CHECK_UINT8_BYTE_TABLE(x) CHECK_RECORD (x, uint8_byte_table)
+ char table entries should never escape to Lisp */
+
+
+struct Lisp_Uint16_Byte_Table
+{
+ struct lcrecord_header header;
+
+ unsigned short property[256];
+};
+typedef struct Lisp_Uint16_Byte_Table Lisp_Uint16_Byte_Table;
+
+DECLARE_LRECORD (uint16_byte_table, Lisp_Uint16_Byte_Table);
+#define XUINT16_BYTE_TABLE(x) \
+ XRECORD (x, uint16_byte_table, Lisp_Uint16_Byte_Table)
+#define XSETUINT16_BYTE_TABLE(x, p) XSETRECORD (x, p, uint16_byte_table)
+#define UINT16_BYTE_TABLE_P(x) RECORDP (x, uint16_byte_table)
+#define GC_UINT16_BYTE_TABLE_P(x) GC_RECORDP (x, uint16_byte_table)
+/* #define CHECK_UINT16_BYTE_TABLE(x) CHECK_RECORD (x, uint16_byte_table)
+ char table entries should never escape to Lisp */
+
+
+struct Lisp_Byte_Table
+{
+ struct lcrecord_header header;
+
+ Lisp_Object property[256];
+};
+typedef struct Lisp_Byte_Table Lisp_Byte_Table;
+
+DECLARE_LRECORD (byte_table, Lisp_Byte_Table);
+#define XBYTE_TABLE(x) XRECORD (x, byte_table, Lisp_Byte_Table)
+#define XSETBYTE_TABLE(x, p) XSETRECORD (x, p, byte_table)
+#define BYTE_TABLE_P(x) RECORDP (x, byte_table)
+#define GC_BYTE_TABLE_P(x) GC_RECORDP (x, byte_table)
+/* #define CHECK_BYTE_TABLE(x) CHECK_RECORD (x, byte_table)
+ char table entries should never escape to Lisp */
+
+Lisp_Object get_byte_table (Lisp_Object table, unsigned char idx);
+
+Lisp_Object put_byte_table (Lisp_Object table, unsigned char idx,
+ Lisp_Object value);
-EXFUN (Fget_char_attribute, 3);
+
+Lisp_Object make_char_id_table (Lisp_Object initval);
#endif
When not under Mule, there are only 256 possible characters
so we just represent them directly. */
-#ifdef MULE
+#if defined(MULE)&&!defined(UTF2000)
struct Lisp_Char_Table_Entry
{
CHAR_TABLE_TYPE_CHAR
};
+#ifndef UTF2000
#ifdef MULE
#define NUM_ASCII_CHARS 160
#else
#define NUM_ASCII_CHARS 256
#endif
+#endif
struct Lisp_Char_Table
{
struct lcrecord_header header;
+#ifdef UTF2000
+ Lisp_Object table;
+ Lisp_Object default_value;
+#else
Lisp_Object ascii[NUM_ASCII_CHARS];
#ifdef MULE
Lisp_Object level1[NUM_LEADING_BYTES];
#endif /* MULE */
+#endif /* non UTF2000 */
enum char_table_type type;
+#ifndef UTF2000
/* stuff used for syntax tables */
Lisp_Object mirror_table;
+#endif
Lisp_Object next_table; /* DO NOT mark through this. */
};
typedef struct Lisp_Char_Table Lisp_Char_Table;
#define CHAR_TABLE_TYPE(ct) ((ct)->type)
#define XCHAR_TABLE_TYPE(ct) CHAR_TABLE_TYPE (XCHAR_TABLE (ct))
-#ifdef MULE
+#ifdef UTF2000
+
+INLINE_HEADER Lisp_Object
+CHAR_TABLE_VALUE_UNSAFE (Lisp_Char_Table *ct, Emchar ch);
+INLINE_HEADER Lisp_Object
+CHAR_TABLE_VALUE_UNSAFE (Lisp_Char_Table *ct, Emchar ch)
+{
+ 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;
+}
+
+#elif defined(MULE)
Lisp_Object get_non_ascii_char_table_value (Lisp_Char_Table *ct,
Charset_ID leading_byte,
enum chartab_range_type
{
CHARTAB_RANGE_ALL,
+#ifdef UTF2000
+ CHARTAB_RANGE_DEFAULT,
+#endif
#ifdef MULE
CHARTAB_RANGE_CHARSET,
CHARTAB_RANGE_ROW,
extern Lisp_Object Vall_syntax_tables;
\f
+#ifdef UTF2000
+
+Lisp_Object get_char_id_table (Lisp_Char_Table* cit, Emchar ch);
+
+INLINE_HEADER void
+put_char_id_table_0 (Lisp_Char_Table* cit, Emchar code, Lisp_Object value);
+INLINE_HEADER void
+put_char_id_table_0 (Lisp_Char_Table* cit, Emchar code, Lisp_Object value)
+{
+ Lisp_Object table1, table2, table3, table4;
+
+ table1 = cit->table;
+ table2 = get_byte_table (table1, (unsigned char)(code >> 24));
+ table3 = get_byte_table (table2, (unsigned char)(code >> 16));
+ table4 = get_byte_table (table3, (unsigned char)(code >> 8));
+
+ table4 = put_byte_table (table4, (unsigned char) code, value);
+ table3 = put_byte_table (table3, (unsigned char)(code >> 8), table4);
+ table2 = put_byte_table (table2, (unsigned char)(code >> 16), table3);
+ cit->table = put_byte_table (table1, (unsigned char)(code >> 24), table2);
+}
+
+void put_char_id_table (Lisp_Char_Table* table,
+ Lisp_Object character, Lisp_Object value);
+
+EXFUN (Fget_char_attribute, 3);
+
+#endif
+\f
#ifdef MULE
int check_category_char(Emchar ch, Lisp_Object ctbl,
/* Simple built-in editing commands.
Copyright (C) 1985, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+ Copyright (C) 2001 MORIOKA Tomohiko
This file is part of XEmacs.
int tab_width;
overwrite = buf->overwrite_mode;
+#ifdef UTF2000
+ syntax_table = XCHAR_TABLE (buf->syntax_table);
+#else
syntax_table = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
#if 0
/* No, this is very bad, it makes undo *always* undo a character at a time
Such characters have value t in this table.
*/);
Vauto_fill_chars = Fmake_char_table (Qgeneric);
+#ifdef UTF2000
+ put_char_id_table_0 (XCHAR_TABLE (Vauto_fill_chars), ' ', Qt);
+ put_char_id_table_0 (XCHAR_TABLE (Vauto_fill_chars), '\n', Qt);
+#else
XCHAR_TABLE (Vauto_fill_chars)->ascii[' '] = Qt;
XCHAR_TABLE (Vauto_fill_chars)->ascii['\n'] = Qt;
+#endif
}
/* Routines to compute the current syntactic context, for font-lock mode.
Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
Copyright (C) 1995 Sun Microsystems, Inc.
+ Copyright (C) 2001 MORIOKA Tomohiko
This file is part of XEmacs.
find_context (struct buffer *buf, Bufpos pt)
{
/* This function can GC */
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
Lisp_Object syntaxtab = buf->syntax_table;
Emchar prev_c, c;
Bufpos target = pt;
XCHARSET_ENCODING_TABLE (ccs)
= encoding_table = make_char_id_table (Qnil);
}
- put_char_id_table (XCHAR_ID_TABLE(encoding_table), character, value);
+ put_char_id_table (XCHAR_TABLE(encoding_table), character, value);
return Qt;
}
XINT (cpos));
}
}
- if (CHAR_ID_TABLE_P (encoding_table))
+ if (CHAR_TABLEP (encoding_table))
{
- put_char_id_table (XCHAR_ID_TABLE(encoding_table), character, Qnil);
+ put_char_id_table (XCHAR_TABLE(encoding_table), character, Qnil);
}
return Qt;
}
Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
Copyright (C) 1995 Sun Microsystems, Inc.
Copyright (C) 1995 Ben Wing.
+ Copyright (C) 1999,2000,2001 MORIOKA Tomohiko
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
k = *p++;
matchsyntax:
#ifdef MULE
+#ifdef UTF2000
+ for (j = 0; j < 0x80; j++)
+ if (SYNTAX_UNSAFE
+ (XCHAR_TABLE
+ (regex_emacs_buffer->syntax_table), j) ==
+ (enum syntaxcode) k)
+ fastmap[j] = 1;
+#else
for (j = 0; j < 0x80; j++)
if (SYNTAX_UNSAFE
(XCHAR_TABLE
(regex_emacs_buffer->mirror_syntax_table), j) ==
(enum syntaxcode) k)
fastmap[j] = 1;
+#endif
for (j = 0x80; j < 0xA0; j++)
{
#ifndef UTF2000
k = *p++;
matchnotsyntax:
#ifdef MULE
+#ifdef UTF2000
+ for (j = 0; j < 0x80; j++)
+ if (SYNTAX_UNSAFE
+ (XCHAR_TABLE
+ (regex_emacs_buffer->syntax_table), j) !=
+ (enum syntaxcode) k)
+ fastmap[j] = 1;
+#else
for (j = 0; j < 0x80; j++)
if (SYNTAX_UNSAFE
(XCHAR_TABLE
(regex_emacs_buffer->mirror_syntax_table), j) !=
(enum syntaxcode) k)
fastmap[j] = 1;
+#endif
for (j = 0x80; j < 0xA0; j++)
{
#ifndef UTF2000
#define POS_AFTER_GAP_UNSAFE(d) ((d) == end1 ? string2 : (d))
/* Test if CH is a word-constituent character. (XEmacs change) */
+#ifdef UTF2000
+#define WORDCHAR_P_UNSAFE(ch) \
+ (SYNTAX_UNSAFE (XCHAR_TABLE (regex_emacs_buffer->syntax_table), \
+ ch) == Sword)
+#else
#define WORDCHAR_P_UNSAFE(ch) \
(SYNTAX_UNSAFE (XCHAR_TABLE (regex_emacs_buffer->mirror_syntax_table), \
ch) == Sword)
+#endif
/* Free everything we malloc. */
#ifdef MATCH_MAY_ALLOCATE
REGEX_PREFETCH ();
emch = charptr_emchar ((const Bufbyte *) d);
+#ifdef UTF2000
+ matches = (SYNTAX_UNSAFE
+ (XCHAR_TABLE (regex_emacs_buffer->syntax_table),
+ emch) == (enum syntaxcode) mcnt);
+#else
matches = (SYNTAX_UNSAFE
(XCHAR_TABLE (regex_emacs_buffer->mirror_syntax_table),
emch) == (enum syntaxcode) mcnt);
+#endif
INC_CHARPTR (d);
if (matches != should_succeed)
goto fail;
/* String search routines for XEmacs.
Copyright (C) 1985, 1986, 1987, 1992-1995 Free Software Foundation, Inc.
Copyright (C) 1995 Sun Microsystems, Inc.
+ Copyright (C) 1999,2000,2001 MORIOKA Tomohiko
This file is part of XEmacs.
unsigned char fastmap[0400];
int negate = 0;
REGISTER int i;
+#ifdef UTF2000
+ Lisp_Char_Table *syntax_table = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *syntax_table = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
Bufpos limit;
if (NILP (lim))
Charcount i, len;
EMACS_INT punct_count = 0, word_count = 0;
struct buffer *buf = decode_buffer (buffer, 0);
+#ifdef UTF2000
+ Lisp_Char_Table *syntax_table = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *syntax_table = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
CHECK_STRING (string);
len = XSTRING_CHAR_LENGTH (string);
buf = XBUFFER (buffer);
}
+#ifdef UTF2000
+ syntax_table = XCHAR_TABLE (buf->syntax_table);
+#else
syntax_table = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
case_action = nochange; /* We tried an initialization */
/* but some C compilers blew it */
/* XEmacs routines to deal with syntax tables; also word and list parsing.
Copyright (C) 1985-1994 Free Software Foundation, Inc.
Copyright (C) 1995 Sun Microsystems, Inc.
+ Copyright (C) 2001 MORIOKA Tomohiko
This file is part of XEmacs.
find_defun_start (struct buffer *buf, Bufpos pos)
{
Bufpos tem;
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
/* Use previous finding, if it's valid and applies to this inquiry. */
if (buf == find_start_buffer
struct buffer *buf = decode_buffer (buffer, 0);
syntax_table = check_syntax_table (syntax_table, Qnil);
buf->syntax_table = syntax_table;
+#ifndef UTF2000
buf->mirror_syntax_table = XCHAR_TABLE (syntax_table)->mirror_table;
+#endif
/* Indicate that this buffer now has a specified syntax table. */
buf->local_var_flags |= XINT (buffer_local_flags.syntax_table);
return syntax_table;
*/
(character, syntax_table))
{
+#ifndef UTF2000
Lisp_Char_Table *mirrortab;
+#endif
if (NILP (character))
{
}
CHECK_CHAR_COERCE_INT (character);
syntax_table = check_syntax_table (syntax_table, current_buffer->syntax_table);
+#ifdef UTF2000
+ return make_char (syntax_code_spec[(int) SYNTAX (XCHAR_TABLE(syntax_table),
+ XCHAR (character))]);
+#else
mirrortab = XCHAR_TABLE (XCHAR_TABLE (syntax_table)->mirror_table);
return make_char (syntax_code_spec[(int) SYNTAX (mirrortab, XCHAR (character))]);
+#endif
}
#ifdef MULE
*/
(character, syntax_table))
{
+#ifndef UTF2000
Lisp_Char_Table *mirrortab;
+#endif
int code;
CHECK_CHAR_COERCE_INT (character);
syntax_table = check_syntax_table (syntax_table, current_buffer->syntax_table);
+#ifdef UTF2000
+ code = SYNTAX (XCHAR_TABLE (syntax_table), XCHAR (character));
+#else
mirrortab = XCHAR_TABLE (XCHAR_TABLE (syntax_table)->mirror_table);
code = SYNTAX (mirrortab, XCHAR (character));
+#endif
if (code == Sopen || code == Sclose || code == Sstring)
return syntax_match (syntax_table, XCHAR (character));
return Qnil;
scan_words (struct buffer *buf, Bufpos from, int count)
{
Bufpos limit = count > 0 ? BUF_ZV (buf) : BUF_BEGV (buf);
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
Emchar ch0, ch1;
enum syntaxcode code;
{
Emchar c;
enum syntaxcode code;
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
/* Look back, counting the parity of string-quotes,
and recording the comment-starters seen.
find_end_of_comment (struct buffer *buf, Bufpos from, Bufpos stop, int mask)
{
int c;
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
while (1)
{
enum syntaxcode code;
EMACS_INT n;
struct buffer *buf = decode_buffer (buffer, 0);
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
if (NILP (count))
n = 1;
enum syntaxcode code;
int min_depth = depth; /* Err out if depth gets less than this. */
Lisp_Object syntaxtab = buf->syntax_table;
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
if (depth > 0) min_depth = 0;
enum syntaxcode code;
Bufpos beg = BUF_BEGV (buf);
int quoted = 0;
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
while (pos > beg
&& ((code = SYNTAX (mirrortab, BUF_FETCH_CHAR (buf, pos - 1)))
struct buffer *buf = decode_buffer (buffer, 0);
Bufpos beg = BUF_BEGV (buf);
Bufpos pos = BUF_PT (buf);
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
while (pos > beg && !char_quoted (buf, pos - 1)
&& (SYNTAX (mirrortab, BUF_FETCH_CHAR (buf, pos - 1)) == Squote
Lisp_Object tem;
int mask; /* comment mask */
Lisp_Object syntaxtab = buf->syntax_table;
+#ifdef UTF2000
+ Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->syntax_table);
+#else
Lisp_Char_Table *mirrortab = XCHAR_TABLE (buf->mirror_syntax_table);
+#endif
if (NILP (oldstate))
{
return 0;
}
+#ifndef UTF2000
static void
update_just_this_syntax_table (Lisp_Char_Table *ct)
{
else
update_just_this_syntax_table (ct);
}
+#endif
\f
/************************************************************************/
/* Declarations having to do with XEmacs syntax tables.
Copyright (C) 1985, 1992, 1993 Free Software Foundation, Inc.
+ Copyright (C) 2001 MORIOKA Tomohiko
This file is part of XEmacs.
now an abstract type, where we control all access.
*/
+/* The standard syntax table is stored where it will automatically
+ be used in all new buffers. */
+extern Lisp_Object Vstandard_syntax_table;
+
enum syntaxcode
{
Swhitespace, /* whitespace character */
/* Return the syntax code for a particular character and mirror table. */
+#ifdef UTF2000
+INLINE_HEADER int SYNTAX_CODE_UNSAFE (Lisp_Char_Table *table, Emchar c);
+INLINE_HEADER int
+SYNTAX_CODE_UNSAFE (Lisp_Char_Table *table, Emchar c)
+{
+ int code = CHAR_TABLE_VALUE_UNSAFE (table, c);
+ int ret = Spunct;
+
+ if (CONSP (code))
+ code = XCAR (code);
+ ret = XINT (code);
+
+ if (ret == Sinherit)
+ {
+ code = CHAR_TABLE_VALUE_UNSAFE (XCHAR_TABLE
+ (Vstandard_syntax_table), c);
+ if (CONSP (code))
+ code = XCAR (code);
+ return XINT (code);
+ }
+ else
+ return ret;
+}
+#else
#define SYNTAX_CODE_UNSAFE(table, c) \
XINT (CHAR_TABLE_VALUE_UNSAFE (table, c))
+#endif
INLINE_HEADER int SYNTAX_CODE (Lisp_Char_Table *table, Emchar c);
INLINE_HEADER int
EXFUN (Fchar_syntax, 2);
EXFUN (Fforward_word, 2);
-/* The standard syntax table is stored where it will automatically
- be used in all new buffers. */
-extern Lisp_Object Vstandard_syntax_table;
-
/* This array, indexed by a character, contains the syntax code which
that character signifies (as a char).
For example, (enum syntaxcode) syntax_spec_code['w'] is Sword. */
extern struct buffer *regex_emacs_buffer;
extern int regex_emacs_buffer_p;
+#ifndef UTF2000
void update_syntax_table (Lisp_Char_Table *ct);
+#endif
#endif /* INCLUDED_syntax_h_ */
{
if (CODING_SYSTEM_DISABLE_COMPOSITION (str->codesys))
DECODE_ADD_UCS_CHAR (character, dst);
- else if (!CHAR_ID_TABLE_P (str->combining_table))
+ else if (!CHAR_TABLEP (str->combining_table))
{
Lisp_Object ret
- = get_char_id_table (XCHAR_ID_TABLE(Vcharacter_composition_table),
+ = get_char_id_table (XCHAR_TABLE(Vcharacter_composition_table),
character);
if (NILP (ret))
else
{
Lisp_Object ret
- = get_char_id_table (XCHAR_ID_TABLE(str->combining_table),
+ = get_char_id_table (XCHAR_TABLE(str->combining_table),
character);
if (CHARP (ret))
{
Emchar char2 = XCHARVAL (ret);
ret =
- get_char_id_table (XCHAR_ID_TABLE(Vcharacter_composition_table),
+ get_char_id_table (XCHAR_TABLE(Vcharacter_composition_table),
char2);
if (NILP (ret))
{
str->combining_table = ret;
}
}
- else if (CHAR_ID_TABLE_P (ret))
+ else if (CHAR_TABLEP (ret))
{
str->combined_chars[str->combined_char_count++] = character;
str->combining_table = ret;
projects / chise / xemacs-chise.git.1 / commitdiff