From f605cb3c49256c49ad76f21deed0f58d111a8571 Mon Sep 17 00:00:00 2001 From: tomo Date: Wed, 5 Sep 2001 16:06:50 +0000 Subject: [PATCH] Merge r21-2-41-syntax-1. --- lisp/ChangeLog | 4 + lisp/list-mode.el | 5 - src/ChangeLog | 280 +++++++++++++++++++++- src/abbrev.c | 13 +- src/buffer.c | 4 + src/bufslots.h | 3 + src/casefiddle.c | 9 + src/char-ucs.h | 88 +------ src/chartab.c | 670 ++++++++++++++++++++++++++++++++++++++++------------ src/chartab.h | 132 ++++++++++- src/cmds.c | 10 + src/font-lock.c | 5 + src/mule-charset.c | 6 +- src/regex.c | 31 +++ src/search.c | 13 + src/syntax.c | 54 +++++ src/syntax.h | 36 ++- src/text-coding.c | 10 +- 18 files changed, 1113 insertions(+), 260 deletions(-) diff --git a/lisp/ChangeLog b/lisp/ChangeLog index 286eb10..7c67832 100644 --- a/lisp/ChangeLog +++ b/lisp/ChangeLog @@ -1,3 +1,7 @@ +2001-09-02 MORIOKA Tomohiko + + * list-mode.el: Delete dirty hack for XEmacs UTF-2000. + 2001-08-07 MORIOKA Tomohiko * mule/mule-charset.el (default-coded-charset-priority-list): Add diff --git a/lisp/list-mode.el b/lisp/list-mode.el index 60c0ee3..25d2418 100644 --- a/lisp/list-mode.el +++ b/lisp/list-mode.el @@ -658,8 +658,3 @@ Go to the window from which completion was requested." (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))) diff --git a/src/ChangeLog b/src/ChangeLog index a6f012a..a539ded 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,281 @@ +2001-09-05 MORIOKA Tomohiko + + * 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 + + * chartab.c (vars_of_chartab): Update `utf-2000-version' to 0.18. + +2001-09-04 MORIOKA Tomohiko + + * 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 + + * 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 + + * 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 + + * 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 + + * 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 + + * 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 + + * 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 + + * 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 + + * 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 * chartab.c (get_char_id_table): Change interface. @@ -92,7 +370,7 @@ (put_char_ccs_code_point): New prototype. (remove_char_ccs): Likewise. -2001-08-14 MORIOKA Tomohiko +2001-08-14 MORIOKA Tomohiko * mule-charset.c (Vcharset_ucs_jis): New variable. (Qucs_jis): Likewise. diff --git a/src/abbrev.c b/src/abbrev.c index 30b5993..2b2f00e 100644 --- a/src/abbrev.c +++ b/src/abbrev.c @@ -1,5 +1,6 @@ /* 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. @@ -157,7 +158,11 @@ abbrev_match (struct buffer *buf, Lisp_Object obarray) 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); @@ -385,8 +390,14 @@ If no abbrev matched, but `pre-abbrev-expand-hook' changed the buffer, 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), diff --git a/src/buffer.c b/src/buffer.c index 4487baa..4ec3d0c 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -2,6 +2,7 @@ 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. @@ -29,6 +30,7 @@ Boston, MA 02111-1307, USA. */ 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. @@ -2433,8 +2435,10 @@ common_init_complex_vars_of_buffer (void) 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; diff --git a/src/bufslots.h b/src/bufslots.h index 2b622c7..fd5d36f 100644 --- a/src/bufslots.h +++ b/src/bufslots.h @@ -1,5 +1,6 @@ /* 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. @@ -98,8 +99,10 @@ Boston, MA 02111-1307, USA. */ 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. */ diff --git a/src/casefiddle.c b/src/casefiddle.c index 49cf028..c37860a 100644 --- a/src/casefiddle.c +++ b/src/casefiddle.c @@ -1,5 +1,6 @@ /* 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. @@ -48,7 +49,11 @@ casify_object (enum case_action flag, Lisp_Object string_or_char, 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; @@ -155,7 +160,11 @@ casify_region_internal (enum case_action flag, Lisp_Object start, { /* 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; diff --git a/src/char-ucs.h b/src/char-ucs.h index 35038ad..e3c6763 100644 --- a/src/char-ucs.h +++ b/src/char-ucs.h @@ -21,88 +21,12 @@ Boston, MA 02111-1307, USA. */ #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) - -/************************************************************************/ -/* 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; @@ -662,8 +586,8 @@ charset_code_point (Lisp_Object charset, Emchar ch) 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 @@ -687,9 +611,9 @@ encode_char_1 (Emchar ch, Lisp_Object* charset) 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 diff --git a/src/chartab.c b/src/chartab.c index d3b8b9d..4bf4e1b 100644 --- a/src/chartab.c +++ b/src/chartab.c @@ -71,7 +71,7 @@ static void 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), @@ -225,6 +225,25 @@ make_uint8_byte_table (unsigned char initval) 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) { @@ -436,6 +455,25 @@ make_uint16_byte_table (unsigned short initval) } 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; @@ -604,6 +642,37 @@ make_byte_table (Lisp_Object initval) 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) { @@ -677,10 +746,6 @@ map_over_byte_table (Lisp_Byte_Table *ct, Emchar ofs, int place, } -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) { @@ -787,123 +852,35 @@ put_byte_table (Lisp_Object table, unsigned char idx, Lisp_Object value) 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 ("#", 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; @@ -914,16 +891,19 @@ put_char_id_table (Lisp_Char_ID_Table* cit, 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); } @@ -999,7 +979,7 @@ put_char_id_table (Lisp_Char_ID_Table* cit, 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), @@ -1021,7 +1001,7 @@ map_char_id_table (Lisp_Char_ID_Table *ct, 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; @@ -1048,7 +1028,7 @@ map_char_id_table (Lisp_Char_ID_Table *ct, 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; @@ -1245,19 +1225,19 @@ Return character corresponding with list. 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); @@ -1272,7 +1252,7 @@ Return variants of CHARACTER. { CHECK_CHAR (character); return Fcopy_list (get_char_id_table - (XCHAR_ID_TABLE(Vcharacter_variant_table), + (XCHAR_TABLE(Vcharacter_variant_table), XCHAR (character))); } @@ -1313,7 +1293,7 @@ Return variants of CHARACTER. /* Char Table object */ /************************************************************************/ -#ifdef MULE +#if defined(MULE)&&!defined(UTF2000) static Lisp_Object mark_char_table_entry (Lisp_Object obj) @@ -1367,6 +1347,10 @@ static Lisp_Object 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++) @@ -1375,7 +1359,12 @@ mark_char_table (Lisp_Object obj) 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 @@ -1457,7 +1446,7 @@ print_chartab_range (Emchar first, Emchar last, Lisp_Object val, print_internal (val, printcharfun, 1); } -#ifdef MULE +#if defined(MULE)&&!defined(UTF2000) static void print_chartab_charset_row (Lisp_Object charset, @@ -1541,6 +1530,30 @@ static void 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 (", @@ -1607,6 +1620,7 @@ print_char_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) } } #endif /* MULE */ +#endif /* non UTF2000 */ write_c_string ("))", printcharfun); } @@ -1621,6 +1635,14 @@ char_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) 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; @@ -1630,6 +1652,7 @@ char_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) if (!internal_equal (ct1->level1[i], ct2->level1[i], depth + 1)) return 0; #endif /* MULE */ +#endif /* non UTF2000 */ return 1; } @@ -1638,6 +1661,9 @@ static unsigned long 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 @@ -1645,14 +1671,22 @@ char_table_hash (Lisp_Object obj, int depth) 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 } }; @@ -1766,6 +1800,10 @@ See `valid-char-table-type-p'. 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++) @@ -1774,9 +1812,12 @@ fill_char_table (Lisp_Char_Table *ct, Lisp_Object value) 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, /* @@ -1826,6 +1867,7 @@ and 'syntax. See `valid-char-table-type-p'. 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); @@ -1834,6 +1876,7 @@ and 'syntax. See `valid-char-table-type-p'. } else ct->mirror_table = Qnil; +#endif ct->next_table = Qnil; XSETCHAR_TABLE (obj, ct); if (ty == CHAR_TABLE_TYPE_SYNTAX) @@ -1845,7 +1888,7 @@ and 'syntax. See `valid-char-table-type-p'. return obj; } -#ifdef MULE +#if defined(MULE)&&!defined(UTF2000) static Lisp_Object make_char_table_entry (Lisp_Object initval) @@ -1895,12 +1938,32 @@ as CHAR-TABLE. The values will not themselves be copied. { 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++) { @@ -1923,11 +1986,14 @@ as CHAR-TABLE. The values will not themselves be copied. } #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) @@ -1943,6 +2009,8 @@ decode_char_table_range (Lisp_Object range, struct chartab_range *outrange) { 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; @@ -1992,7 +2060,7 @@ decode_char_table_range (Lisp_Object range, struct chartab_range *outrange) #endif /* MULE */ } -#ifdef MULE +#if defined(MULE)&&!defined(UTF2000) /* called from CHAR_TABLE_VALUE(). */ Lisp_Object @@ -2034,7 +2102,20 @@ get_non_ascii_char_table_value (Lisp_Char_Table *ct, Charset_ID leading_byte, 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; @@ -2102,6 +2183,16 @@ If there is more than one value, return MULTI (defaults to nil). { 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]; @@ -2123,10 +2214,14 @@ If there is more than one value, return MULTI (defaults to nil). #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; @@ -2156,8 +2251,12 @@ If there is more than one value, return MULTI (defaults to nil). 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]; @@ -2168,6 +2267,7 @@ If there is more than one value, return MULTI (defaults to nil). return multi; return val; } +#endif /* not UTF2000 */ #endif /* not MULE */ default: @@ -2280,12 +2380,46 @@ put_char_table (Lisp_Char_Table *ct, struct chartab_range *range, 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; @@ -2303,9 +2437,63 @@ put_char_table (Lisp_Char_Table *ct, struct chartab_range *range, 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; @@ -2315,11 +2503,16 @@ put_char_table (Lisp_Char_Table *ct, struct chartab_range *range, 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; @@ -2361,8 +2554,10 @@ put_char_table (Lisp_Char_Table *ct, struct chartab_range *range, #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, /* @@ -2394,6 +2589,7 @@ See `valid-char-table-type-p'. return Qnil; } +#ifndef UTF2000 /* Map FN over the ASCII chars in CT. */ static int @@ -2544,6 +2740,7 @@ map_over_other_charset (Lisp_Char_Table *ct, Charset_ID lb, } #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 @@ -2559,6 +2756,49 @@ map_char_table (Lisp_Char_Table *ct, 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; @@ -2582,14 +2822,126 @@ map_char_table (Lisp_Char_Table *ct, #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]; @@ -2607,17 +2959,23 @@ map_char_table (Lisp_Char_Table *ct, 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: @@ -2647,6 +3005,12 @@ slow_map_char_table_fun (struct chartab_range *range, ranjarg = Qt; break; +#ifdef UTF2000 + case CHARTAB_RANGE_DEFAULT: + ranjarg = Qnil; + break; +#endif + #ifdef MULE case CHARTAB_RANGE_CHARSET: ranjarg = XCHARSET_NAME (range->charset); @@ -2774,7 +3138,8 @@ add_char_attribute_alist_mapper (Lisp_Object key, Lisp_Object value, /* 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; @@ -2815,9 +3180,9 @@ Return the alist of attributes of CHARACTER. 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); @@ -2840,8 +3205,8 @@ Return DEFAULT-VALUE if the value is not exist. { 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 @@ -2851,7 +3216,7 @@ Return DEFAULT-VALUE if the value is not exist. 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; @@ -2906,17 +3271,17 @@ Store CHARACTER's ATTRIBUTE with VALUE. 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; @@ -2931,12 +3296,12 @@ Store CHARACTER's ATTRIBUTE with VALUE. { 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)); } } @@ -2955,10 +3320,10 @@ Store CHARACTER's ATTRIBUTE with VALUE. 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 @@ -2976,7 +3341,7 @@ Store CHARACTER's ATTRIBUTE with VALUE. 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; } } @@ -3001,7 +3366,7 @@ Remove CHARACTER's ATTRIBUTE. 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; } } @@ -3019,7 +3384,7 @@ the entire table. (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; @@ -3028,8 +3393,8 @@ the entire table. { 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; } @@ -3038,8 +3403,8 @@ the entire table. 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; } @@ -3499,7 +3864,6 @@ syms_of_chartab (void) 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"); @@ -3538,7 +3902,9 @@ syms_of_chartab (void) 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"); @@ -3580,7 +3946,7 @@ void 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. */ ); diff --git a/src/chartab.h b/src/chartab.h index 8d745b7..444d41a 100644 --- a/src/chartab.h +++ b/src/chartab.h @@ -1,6 +1,7 @@ /* 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. @@ -30,14 +31,69 @@ Boston, MA 02111-1307, USA. */ #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 @@ -50,7 +106,7 @@ EXFUN (Fget_char_attribute, 3); 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 { @@ -84,16 +140,22 @@ enum char_table_type 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 @@ -125,11 +187,14 @@ struct Lisp_Char_Table 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; @@ -144,7 +209,28 @@ DECLARE_LRECORD (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, @@ -183,6 +269,9 @@ CHAR_TABLE_NON_ASCII_VALUE_UNSAFE (Lisp_Char_Table *ct, Emchar ch) enum chartab_range_type { CHARTAB_RANGE_ALL, +#ifdef UTF2000 + CHARTAB_RANGE_DEFAULT, +#endif #ifdef MULE CHARTAB_RANGE_CHARSET, CHARTAB_RANGE_ROW, @@ -217,6 +306,35 @@ EXFUN (Fget_char_table, 2); extern Lisp_Object Vall_syntax_tables; +#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 + #ifdef MULE int check_category_char(Emchar ch, Lisp_Object ctbl, diff --git a/src/cmds.c b/src/cmds.c index 881bb63..df7ad59 100644 --- a/src/cmds.c +++ b/src/cmds.c @@ -1,5 +1,6 @@ /* 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. @@ -350,7 +351,11 @@ internal_self_insert (Emchar c1, int noautofill) 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 @@ -524,6 +529,11 @@ A char-table for characters which invoke auto-filling. 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 } diff --git a/src/font-lock.c b/src/font-lock.c index 6cd74d7..111bd0a 100644 --- a/src/font-lock.c +++ b/src/font-lock.c @@ -1,6 +1,7 @@ /* 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. @@ -414,7 +415,11 @@ static void 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; diff --git a/src/mule-charset.c b/src/mule-charset.c index 69102db..ddfa753 100644 --- a/src/mule-charset.c +++ b/src/mule-charset.c @@ -353,7 +353,7 @@ put_char_ccs_code_point (Lisp_Object character, 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; } @@ -375,9 +375,9 @@ remove_char_ccs (Lisp_Object character, Lisp_Object ccs) 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; } diff --git a/src/regex.c b/src/regex.c index 677db05..3652b91 100644 --- a/src/regex.c +++ b/src/regex.c @@ -6,6 +6,7 @@ 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 @@ -3625,12 +3626,21 @@ re_compile_fastmap (struct re_pattern_buffer *bufp) 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 @@ -3670,12 +3680,21 @@ re_compile_fastmap (struct re_pattern_buffer *bufp) 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 @@ -4194,9 +4213,15 @@ re_search_2 (struct re_pattern_buffer *bufp, const char *str1, #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 @@ -5608,9 +5633,15 @@ re_match_2_internal (struct re_pattern_buffer *bufp, re_char *string1, 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; diff --git a/src/search.c b/src/search.c index 49c4c8d..b5ac56d 100644 --- a/src/search.c +++ b/src/search.c @@ -1,6 +1,7 @@ /* 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. @@ -784,7 +785,11 @@ skip_chars (struct buffer *buf, int forwardp, int syntaxp, 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)) @@ -1934,7 +1939,11 @@ wordify (Lisp_Object buffer, Lisp_Object string) 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); @@ -2290,7 +2299,11 @@ and you do not need to specify it. 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 */ diff --git a/src/syntax.c b/src/syntax.c index a3bbcc2..6b580a0 100644 --- a/src/syntax.c +++ b/src/syntax.c @@ -1,6 +1,7 @@ /* 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. @@ -120,7 +121,11 @@ static Bufpos 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 @@ -217,7 +222,9 @@ BUFFER defaults to the current buffer if omitted. 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; @@ -272,7 +279,9 @@ syntax table. */ (character, syntax_table)) { +#ifndef UTF2000 Lisp_Char_Table *mirrortab; +#endif if (NILP (character)) { @@ -280,8 +289,13 @@ syntax table. } 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 @@ -317,13 +331,19 @@ syntax table. */ (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; @@ -351,7 +371,11 @@ Bufpos 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; @@ -489,7 +513,11 @@ find_start_of_comment (struct buffer *buf, Bufpos from, Bufpos stop, int mask) { 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. @@ -623,7 +651,11 @@ static Bufpos 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) { @@ -676,7 +708,11 @@ COUNT defaults to 1, and BUFFER defaults to the current buffer. 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; @@ -835,7 +871,11 @@ scan_lists (struct buffer *buf, Bufpos from, int count, int depth, 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; @@ -1154,7 +1194,11 @@ char_quoted (struct buffer *buf, Bufpos pos) 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))) @@ -1236,7 +1280,11 @@ Optional arg BUFFER defaults to the current buffer. 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 @@ -1276,7 +1324,11 @@ scan_sexps_forward (struct buffer *buf, struct lisp_parse_state *stateptr, 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)) { @@ -1628,6 +1680,7 @@ cmst_mapfun (struct chartab_range *range, Lisp_Object val, void *arg) return 0; } +#ifndef UTF2000 static void update_just_this_syntax_table (Lisp_Char_Table *ct) { @@ -1662,6 +1715,7 @@ update_syntax_table (Lisp_Char_Table *ct) else update_just_this_syntax_table (ct); } +#endif /************************************************************************/ diff --git a/src/syntax.h b/src/syntax.h index 4b2709b..76301cf 100644 --- a/src/syntax.h +++ b/src/syntax.h @@ -1,5 +1,6 @@ /* 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. @@ -45,6 +46,10 @@ integers. We can do this successfully because syntax tables are 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 */ @@ -69,8 +74,33 @@ enum syntaxcode charset_syntax (struct buffer *buf, Lisp_Object charset, /* 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 @@ -230,10 +260,6 @@ WORD_SYNTAX_P (Lisp_Char_Table *table, Emchar c) 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. */ @@ -256,6 +282,8 @@ extern int no_quit_in_re_search; 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_ */ diff --git a/src/text-coding.c b/src/text-coding.c index e9749b1..35e8523 100644 --- a/src/text-coding.c +++ b/src/text-coding.c @@ -2226,10 +2226,10 @@ COMPOSE_ADD_CHAR(struct decoding_stream *str, { 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)) @@ -2244,14 +2244,14 @@ COMPOSE_ADD_CHAR(struct decoding_stream *str, 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)) { @@ -2266,7 +2266,7 @@ COMPOSE_ADD_CHAR(struct decoding_stream *str, 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; -- 1.7.10.4