X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fchartab.h;h=a0c5bd6eb86a27e98a418b55c94bdab6c0836d38;hb=43832d21823b1480b4d0d5ddd10ed70cf37ea91c;hp=98901fa27a125071b34d22efeb61fb6d3b1bb62d;hpb=716cfba952c1dc0d2cf5c968971f3780ba728a89;p=chise%2Fxemacs-chise.git.1

diff --git a/src/chartab.h b/src/chartab.h
index 98901fa..a0c5bd6 100644
--- a/src/chartab.h
+++ b/src/chartab.h
@@ -1,6 +1,8 @@
 /* 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, 2002, 2003, 2004, 2006, 2010, 2013, 2016
+     MORIOKA Tomohiko
 
 This file is part of XEmacs.
 
@@ -27,6 +29,114 @@ Boston, MA 02111-1307, USA.  */
 #ifndef INCLUDED_chartab_h_
 #define INCLUDED_chartab_h_
 
+
+#ifdef UTF2000
+
+#ifdef HAVE_CHISE
+#  ifdef HAVE_LIBCHISE
+#    include <chise.h>
+#  else /* HAVE_LIBCHISE */
+#    include "database.h"
+#  endif /* not HAVE_LIBCHISE */
+#  define USE_CONCORD_OBJECT_SYSTEM 1
+#  define USE_CONCORD_OBJECT_SYSTEM_TO_COMPOSE 1
+#endif
+
+EXFUN (Fmake_char, 3);
+EXFUN (Fdecode_char, 4);
+
+EXFUN (Fput_char_attribute, 3);
+
+EXFUN (Fdefine_char, 1);
+
+EXFUN (Ffind_char, 1);
+
+extern Lisp_Object Qdowncase, Qflippedcase, Q_lowercase, Q_uppercase;
+
+#ifdef HAVE_LIBCHISE
+extern CHISE_DS *default_chise_data_source;
+
+int open_chise_data_source_maybe (void);
+#endif
+
+#if defined(UTF2000) || defined(HAVE_CONCORD)
+extern Lisp_Object Q_denotational;
+extern Lisp_Object Q_denotational_from;
+extern Lisp_Object Q_subsumptive;
+extern Lisp_Object Q_subsumptive_from;
+#endif
+
+#ifdef HAVE_CONCORD
+extern Lisp_Object Vchise_system_db_directory;
+#endif
+
+/************************************************************************/
+/*			    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 */
+
+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 make_char_id_table (Lisp_Object initval);
+
+#endif
+
+
 /************************************************************************/
 /*                               Char Tables                            */
 /************************************************************************/
@@ -35,7 +145,7 @@ Boston, MA 02111-1307, USA.  */
    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
 {
@@ -69,16 +179,27 @@ 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;
+  Lisp_Object name;
+#ifndef HAVE_LIBCHISE
+  Lisp_Object db;
+#endif
+  unsigned char unloaded;
+#else
   Lisp_Object ascii[NUM_ASCII_CHARS];
 
 #ifdef MULE
@@ -110,11 +231,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;
@@ -129,18 +253,49 @@ 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
+
+#define CHAR_TABLE_NAME(ct) ((ct)->name)
+#define XCHAR_TABLE_NAME(ct) CHAR_TABLE_NAME (XCHAR_TABLE (ct))
+
+#define CHAR_TABLE_UNLOADED(ct) ((ct)->unloaded)
+#define XCHAR_TABLE_UNLOADED(ct) CHAR_TABLE_UNLOADED (XCHAR_TABLE (ct))
+
+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,
-					    int leading_byte,
+					    Charset_ID leading_byte,
 					    Emchar c);
 
-INLINE Lisp_Object
+INLINE_HEADER Lisp_Object
 CHAR_TABLE_NON_ASCII_VALUE_UNSAFE (Lisp_Char_Table *ct, Emchar ch);
-INLINE Lisp_Object
+INLINE_HEADER Lisp_Object
 CHAR_TABLE_NON_ASCII_VALUE_UNSAFE (Lisp_Char_Table *ct, Emchar ch)
 {
-  unsigned char lb = CHAR_LEADING_BYTE (ch);
+#ifdef UTF2000
+  Charset_ID lb = CHAR_CHARSET_ID (ch);
+#else
+  Charset_ID lb = CHAR_LEADING_BYTE (ch);
+#endif
   if (!CHAR_TABLE_ENTRYP ((ct)->level1[lb - MIN_LEADING_BYTE]))
     return (ct)->level1[lb - MIN_LEADING_BYTE];
   else
@@ -158,9 +313,15 @@ CHAR_TABLE_NON_ASCII_VALUE_UNSAFE (Lisp_Char_Table *ct, Emchar ch)
 
 #endif /* not MULE */
 
+#define XCHAR_TABLE_VALUE_UNSAFE(ct, ch) \
+  CHAR_TABLE_VALUE_UNSAFE (XCHAR_TABLE (ct), ch)
+
 enum chartab_range_type
 {
   CHARTAB_RANGE_ALL,
+#ifdef UTF2000
+  CHARTAB_RANGE_DEFAULT,
+#endif
 #ifdef MULE
   CHARTAB_RANGE_CHARSET,
   CHARTAB_RANGE_ROW,
@@ -195,10 +356,132 @@ EXFUN (Fget_char_table, 2);
 extern Lisp_Object Vall_syntax_tables;
 
 
+#ifdef UTF2000
+
+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);
+}
+
+#ifdef HAVE_CHISE
+Lisp_Object load_char_attribute_maybe (Lisp_Char_Table* cit, Emchar ch);
+
+#ifdef USE_CONCORD_OBJECT_SYSTEM
+COS_object load_char_attribute_maybe_cos (Lisp_Char_Table* cit, Emchar ch);
+#endif
+
+#ifndef HAVE_LIBCHISE
+extern Lisp_Object Qsystem_char_id;
+
+Lisp_Object
+char_attribute_system_db_file (Lisp_Object key_type, Lisp_Object attribute,
+			       int writing_mode);
+#endif /* not HAVE_LIBCHISE */
+#endif /* HAVE_CHISE */
+
+INLINE_HEADER Lisp_Object
+get_char_id_table_0 (Lisp_Char_Table* cit, Emchar ch);
+INLINE_HEADER Lisp_Object
+get_char_id_table_0 (Lisp_Char_Table* cit, Emchar ch)
+{
+  return 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);
+}
+
+INLINE_HEADER Lisp_Object
+get_char_id_table (Lisp_Char_Table* cit, Emchar ch);
+INLINE_HEADER Lisp_Object
+get_char_id_table (Lisp_Char_Table* cit, Emchar ch)
+{
+  Lisp_Object val = get_char_id_table_0 (cit, ch);
+
+#ifdef HAVE_CHISE
+  if (EQ (val, Qunloaded))
+    {
+      val = load_char_attribute_maybe (cit, ch);
+      put_char_id_table_0 (cit, ch, val);
+    }
+#endif /* HAVE_CHISE */
+  if (UNBOUNDP (val))
+    return cit->default_value;
+  else
+    return val;
+}
+
+#ifdef USE_CONCORD_OBJECT_SYSTEM
+INLINE_HEADER Lisp_Object
+get_char_id_table_ce (Lisp_Char_Table* cit, Emchar ch);
+INLINE_HEADER Lisp_Object
+get_char_id_table_ce (Lisp_Char_Table* cit, Emchar ch)
+{
+  Lisp_Object val = get_char_id_table_0 (cit, ch);
+
+  if (EQ (val, Qunloaded))
+    {
+#if 0
+      val = load_char_attribute_maybe (cit, ch);
+#else
+      COS_object ret = load_char_attribute_maybe_cos (cit, ch);
+      if ( ret == NULL )
+	return cit->default_value;
+      else
+	return ret;
+#endif
+    }
+  if (UNBOUNDP (val))
+    return cit->default_value;
+  else
+    return val;
+}
+#else
+#define get_char_id_table_ce(cit, ch) get_char_id_table(cit, ch)
+#endif
+
+void
+decode_char_table_range (Lisp_Object range, struct chartab_range *outrange);
+
+INLINE_HEADER void
+put_char_id_table (Lisp_Char_Table* table,
+		   Lisp_Object character, Lisp_Object value);
+INLINE_HEADER void
+put_char_id_table (Lisp_Char_Table* table,
+		   Lisp_Object character, Lisp_Object value)
+{
+  struct chartab_range range;
+
+  decode_char_table_range (character, &range);
+  put_char_table (table, &range, value);
+}
+
+
+EXFUN (Fget_char_attribute, 3);
+EXFUN (Fchar_feature, 5);
+
+#endif
+
 
 #ifdef MULE
 int check_category_char(Emchar ch, Lisp_Object ctbl,
-		        unsigned int designator, unsigned int not);
+		        unsigned int designator, unsigned int not_p);
 
 extern Lisp_Object Vstandard_category_table;