git.chise.org Git - chise/xemacs-chise.git.1/blob - src/chartab.h

   1 /* Declarations having to do with Mule char tables.
   2    Copyright (C) 1992 Free Software Foundation, Inc.
   3    Copyright (C) 1995 Sun Microsystems, Inc.
   4    Copyright (C) 1999,2000,2001,2002,2003,2004,2006,2010 MORIOKA Tomohiko
   5
   6 This file is part of XEmacs.
   7
   8 XEmacs is free software; you can redistribute it and/or modify it
   9 under the terms of the GNU General Public License as published by the
  10 Free Software Foundation; either version 2, or (at your option) any
  11 later version.
  12
  13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
  14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with XEmacs; see the file COPYING.  If not, write to
  20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 /* Synched up with: Mule 2.3.  Not synched with FSF.
  24
  25    This file was written independently of the FSF implementation,
  26    and is not compatible. */
  27
  28 #ifndef INCLUDED_chartab_h_
  29 #define INCLUDED_chartab_h_
  30
  31
  32 #ifdef UTF2000
  33
  34 #ifdef HAVE_CHISE
  35 #  ifdef HAVE_LIBCHISE
  36 #    include <chise.h>
  37 #  else /* HAVE_LIBCHISE */
  38 #    include "database.h"
  39 #  endif /* not HAVE_LIBCHISE */
  40 #endif
  41
  42 EXFUN (Fmake_char, 3);
  43 EXFUN (Fdecode_char, 4);
  44
  45 EXFUN (Fput_char_attribute, 3);
  46
  47 EXFUN (Fdefine_char, 1);
  48
  49 EXFUN (Ffind_char, 1);
  50
  51 extern Lisp_Object Qdowncase, Qflippedcase, Q_lowercase, Q_uppercase;
  52
  53 #ifdef HAVE_LIBCHISE
  54 extern CHISE_DS *default_chise_data_source;
  55
  56 int open_chise_data_source_maybe (void);
  57 #endif
  58
  59 #if defined(UTF2000) || defined(HAVE_CONCORD)
  60 extern Lisp_Object Q_denotational;
  61 extern Lisp_Object Q_denotational_from;
  62 extern Lisp_Object Q_subsumptive;
  63 extern Lisp_Object Q_subsumptive_from;
  64 #endif
  65
  66 #ifdef HAVE_CONCORD
  67 extern Lisp_Object Vchise_system_db_directory;
  68 #endif
  69
  70 /************************************************************************/
  71 /*                          Char-ID Tables                              */
  72 /************************************************************************/
  73
  74 struct Lisp_Uint8_Byte_Table
  75 {
  76   struct lcrecord_header header;
  77
  78   unsigned char property[256];
  79 };
  80 typedef struct Lisp_Uint8_Byte_Table Lisp_Uint8_Byte_Table;
  81
  82 DECLARE_LRECORD (uint8_byte_table, Lisp_Uint8_Byte_Table);
  83 #define XUINT8_BYTE_TABLE(x) \
  84    XRECORD (x, uint8_byte_table, Lisp_Uint8_Byte_Table)
  85 #define XSETUINT8_BYTE_TABLE(x, p) XSETRECORD (x, p, uint8_byte_table)
  86 #define UINT8_BYTE_TABLE_P(x) RECORDP (x, uint8_byte_table)
  87 #define GC_UINT8_BYTE_TABLE_P(x) GC_RECORDP (x, uint8_byte_table)
  88 /* #define CHECK_UINT8_BYTE_TABLE(x) CHECK_RECORD (x, uint8_byte_table)
  89    char table entries should never escape to Lisp */
  90
  91
  92 struct Lisp_Uint16_Byte_Table
  93 {
  94   struct lcrecord_header header;
  95
  96   unsigned short property[256];
  97 };
  98 typedef struct Lisp_Uint16_Byte_Table Lisp_Uint16_Byte_Table;
  99
 100 DECLARE_LRECORD (uint16_byte_table, Lisp_Uint16_Byte_Table);
 101 #define XUINT16_BYTE_TABLE(x) \
 102    XRECORD (x, uint16_byte_table, Lisp_Uint16_Byte_Table)
 103 #define XSETUINT16_BYTE_TABLE(x, p) XSETRECORD (x, p, uint16_byte_table)
 104 #define UINT16_BYTE_TABLE_P(x) RECORDP (x, uint16_byte_table)
 105 #define GC_UINT16_BYTE_TABLE_P(x) GC_RECORDP (x, uint16_byte_table)
 106 /* #define CHECK_UINT16_BYTE_TABLE(x) CHECK_RECORD (x, uint16_byte_table)
 107    char table entries should never escape to Lisp */
 108
 109
 110 struct Lisp_Byte_Table
 111 {
 112   struct lcrecord_header header;
 113
 114   Lisp_Object property[256];
 115 };
 116 typedef struct Lisp_Byte_Table Lisp_Byte_Table;
 117
 118 DECLARE_LRECORD (byte_table, Lisp_Byte_Table);
 119 #define XBYTE_TABLE(x) XRECORD (x, byte_table, Lisp_Byte_Table)
 120 #define XSETBYTE_TABLE(x, p) XSETRECORD (x, p, byte_table)
 121 #define BYTE_TABLE_P(x) RECORDP (x, byte_table)
 122 #define GC_BYTE_TABLE_P(x) GC_RECORDP (x, byte_table)
 123 /* #define CHECK_BYTE_TABLE(x) CHECK_RECORD (x, byte_table)
 124    char table entries should never escape to Lisp */
 125
 126 Lisp_Object get_byte_table (Lisp_Object table, unsigned char idx);
 127
 128 Lisp_Object put_byte_table (Lisp_Object table, unsigned char idx,
 129                             Lisp_Object value);
 130
 131
 132 Lisp_Object make_char_id_table (Lisp_Object initval);
 133
 134 #endif
 135
 136
 137 /************************************************************************/
 138 /*                               Char Tables                            */
 139 /************************************************************************/
 140
 141 /* Under Mule, we use a complex representation (see below).
 142    When not under Mule, there are only 256 possible characters
 143    so we just represent them directly. */
 144
 145 #if defined(MULE)&&!defined(UTF2000)
 146
 147 struct Lisp_Char_Table_Entry
 148 {
 149   struct lcrecord_header header;
 150
 151   /* In the interests of simplicity, we just use a fixed 96-entry
 152      table.  If we felt like being smarter, we could make this
 153      variable-size and add an offset value into this structure. */
 154   Lisp_Object level2[96];
 155 };
 156 typedef struct Lisp_Char_Table_Entry Lisp_Char_Table_Entry;
 157
 158 DECLARE_LRECORD (char_table_entry, Lisp_Char_Table_Entry);
 159 #define XCHAR_TABLE_ENTRY(x) \
 160   XRECORD (x, char_table_entry, Lisp_Char_Table_Entry)
 161 #define XSETCHAR_TABLE_ENTRY(x, p) XSETRECORD (x, p, char_table_entry)
 162 #define CHAR_TABLE_ENTRYP(x) RECORDP (x, char_table_entry)
 163 /* #define CHECK_CHAR_TABLE_ENTRY(x) CHECK_RECORD (x, char_table_entry)
 164    char table entries should never escape to Lisp */
 165
 166 #endif /* MULE */
 167
 168 enum char_table_type
 169 {
 170   CHAR_TABLE_TYPE_GENERIC,
 171 #ifdef MULE
 172   CHAR_TABLE_TYPE_CATEGORY,
 173 #endif
 174   CHAR_TABLE_TYPE_SYNTAX,
 175   CHAR_TABLE_TYPE_DISPLAY,
 176   CHAR_TABLE_TYPE_CHAR
 177 };
 178
 179 #ifndef UTF2000
 180 #ifdef MULE
 181 #define NUM_ASCII_CHARS 160
 182 #else
 183 #define NUM_ASCII_CHARS 256
 184 #endif
 185 #endif
 186
 187 struct Lisp_Char_Table
 188 {
 189   struct lcrecord_header header;
 190
 191 #ifdef UTF2000
 192   Lisp_Object table;
 193   Lisp_Object default_value;
 194   Lisp_Object name;
 195 #ifndef HAVE_LIBCHISE
 196   Lisp_Object db;
 197 #endif
 198   unsigned char unloaded;
 199 #else
 200   Lisp_Object ascii[NUM_ASCII_CHARS];
 201
 202 #ifdef MULE
 203   /* We basically duplicate the Mule vectors-of-vectors implementation.
 204      We can do this because we know a great deal about the sorts of
 205      things we are going to be indexing.
 206
 207      The current implementation is as follows:
 208
 209      ascii[0-159] is used for ASCII and Control-1 characters.
 210
 211      level1[0 .. (NUM_LEADING_BYTES-1)] indexes charsets by leading
 212      byte (subtract MIN_LEADING_BYTE from the leading byte).  If the
 213      value of this is not an opaque, then it specifies a value for all
 214      characters in the charset.  Otherwise, it will be a
 215      96-Lisp-Object opaque that we created, specifying a value for
 216      each row.  If the value of this is not an opaque, then it
 217      specifies a value for all characters in the row.  Otherwise, it
 218      will be a 96-Lisp-Object opaque that we created, specifying a
 219      value for each character.
 220
 221      NOTE: 1) This will fail if some C routine passes an opaque to
 222               Fput_char_table().  Currently this is not a problem
 223               since all char tables that are created are Lisp-visible
 224               and thus no one should ever be putting an opaque in
 225               a char table.  Another possibility is to consider
 226               adding a type to */
 227
 228   Lisp_Object level1[NUM_LEADING_BYTES];
 229
 230 #endif /* MULE */
 231 #endif /* non UTF2000 */
 232
 233   enum char_table_type type;
 234
 235 #ifndef UTF2000
 236   /* stuff used for syntax tables */
 237   Lisp_Object mirror_table;
 238 #endif
 239   Lisp_Object next_table; /* DO NOT mark through this. */
 240 };
 241 typedef struct Lisp_Char_Table Lisp_Char_Table;
 242
 243 DECLARE_LRECORD (char_table, Lisp_Char_Table);
 244 #define XCHAR_TABLE(x) XRECORD (x, char_table, Lisp_Char_Table)
 245 #define XSETCHAR_TABLE(x, p) XSETRECORD (x, p, char_table)
 246 #define CHAR_TABLEP(x) RECORDP (x, char_table)
 247 #define CHECK_CHAR_TABLE(x) CHECK_RECORD (x, char_table)
 248 #define CONCHECK_CHAR_TABLE(x) CONCHECK_RECORD (x, char_table)
 249
 250 #define CHAR_TABLE_TYPE(ct) ((ct)->type)
 251 #define XCHAR_TABLE_TYPE(ct) CHAR_TABLE_TYPE (XCHAR_TABLE (ct))
 252
 253 #ifdef UTF2000
 254
 255 #define CHAR_TABLE_NAME(ct) ((ct)->name)
 256 #define XCHAR_TABLE_NAME(ct) CHAR_TABLE_NAME (XCHAR_TABLE (ct))
 257
 258 #define CHAR_TABLE_UNLOADED(ct) ((ct)->unloaded)
 259 #define XCHAR_TABLE_UNLOADED(ct) CHAR_TABLE_UNLOADED (XCHAR_TABLE (ct))
 260
 261 INLINE_HEADER Lisp_Object
 262 CHAR_TABLE_VALUE_UNSAFE (Lisp_Char_Table *ct, Emchar ch);
 263 INLINE_HEADER Lisp_Object
 264 CHAR_TABLE_VALUE_UNSAFE (Lisp_Char_Table *ct, Emchar ch)
 265 {
 266   Lisp_Object val = get_byte_table (get_byte_table
 267                                     (get_byte_table
 268                                      (get_byte_table
 269                                       (ct->table,
 270                                        (unsigned char)(ch >> 24)),
 271                                       (unsigned char) (ch >> 16)),
 272                                      (unsigned char)  (ch >> 8)),
 273                                     (unsigned char)    ch);
 274   if (UNBOUNDP (val))
 275     return ct->default_value;
 276   else
 277     return val;
 278 }
 279
 280 #elif defined(MULE)
 281
 282 Lisp_Object get_non_ascii_char_table_value (Lisp_Char_Table *ct,
 283                                             Charset_ID leading_byte,
 284                                             Emchar c);
 285
 286 INLINE_HEADER Lisp_Object
 287 CHAR_TABLE_NON_ASCII_VALUE_UNSAFE (Lisp_Char_Table *ct, Emchar ch);
 288 INLINE_HEADER Lisp_Object
 289 CHAR_TABLE_NON_ASCII_VALUE_UNSAFE (Lisp_Char_Table *ct, Emchar ch)
 290 {
 291 #ifdef UTF2000
 292   Charset_ID lb = CHAR_CHARSET_ID (ch);
 293 #else
 294   Charset_ID lb = CHAR_LEADING_BYTE (ch);
 295 #endif
 296   if (!CHAR_TABLE_ENTRYP ((ct)->level1[lb - MIN_LEADING_BYTE]))
 297     return (ct)->level1[lb - MIN_LEADING_BYTE];
 298   else
 299     return get_non_ascii_char_table_value (ct, lb, ch);
 300 }
 301
 302 #define CHAR_TABLE_VALUE_UNSAFE(ct, ch)         \
 303   ((ch) < NUM_ASCII_CHARS                       \
 304    ? (ct)->ascii[ch]                            \
 305    : CHAR_TABLE_NON_ASCII_VALUE_UNSAFE (ct, ch))
 306
 307 #else /* not MULE */
 308
 309 #define CHAR_TABLE_VALUE_UNSAFE(ct, ch) ((ct)->ascii[(unsigned char) (ch)])
 310
 311 #endif /* not MULE */
 312
 313 #define XCHAR_TABLE_VALUE_UNSAFE(ct, ch) \
 314   CHAR_TABLE_VALUE_UNSAFE (XCHAR_TABLE (ct), ch)
 315
 316 enum chartab_range_type
 317 {
 318   CHARTAB_RANGE_ALL,
 319 #ifdef UTF2000
 320   CHARTAB_RANGE_DEFAULT,
 321 #endif
 322 #ifdef MULE
 323   CHARTAB_RANGE_CHARSET,
 324   CHARTAB_RANGE_ROW,
 325 #endif
 326   CHARTAB_RANGE_CHAR
 327 };
 328
 329 struct chartab_range
 330 {
 331   enum chartab_range_type type;
 332   Emchar ch;
 333   Lisp_Object charset;
 334   int row;
 335 };
 336
 337 void fill_char_table (Lisp_Char_Table *ct, Lisp_Object value);
 338 void put_char_table (Lisp_Char_Table *ct, struct chartab_range *range,
 339                      Lisp_Object val);
 340 Lisp_Object get_char_table (Emchar, Lisp_Char_Table *);
 341 int map_char_table (Lisp_Char_Table *ct,
 342                     struct chartab_range *range,
 343                     int (*fn) (struct chartab_range *range,
 344                                Lisp_Object val, void *arg),
 345                     void *arg);
 346 void prune_syntax_tables (void);
 347
 348 EXFUN (Fcopy_char_table, 1);
 349 EXFUN (Fmake_char_table, 1);
 350 EXFUN (Fput_char_table, 3);
 351 EXFUN (Fget_char_table, 2);
 352
 353 extern Lisp_Object Vall_syntax_tables;
 354
 355 \f
 356 #ifdef UTF2000
 357
 358 INLINE_HEADER void
 359 put_char_id_table_0 (Lisp_Char_Table* cit, Emchar code, Lisp_Object value);
 360 INLINE_HEADER void
 361 put_char_id_table_0 (Lisp_Char_Table* cit, Emchar code, Lisp_Object value)
 362 {
 363   Lisp_Object table1, table2, table3, table4;
 364
 365   table1 = cit->table;
 366   table2 = get_byte_table (table1, (unsigned char)(code >> 24));
 367   table3 = get_byte_table (table2, (unsigned char)(code >> 16));
 368   table4 = get_byte_table (table3, (unsigned char)(code >>  8));
 369
 370   table4     = put_byte_table (table4, (unsigned char) code, value);
 371   table3     = put_byte_table (table3, (unsigned char)(code >>  8), table4);
 372   table2     = put_byte_table (table2, (unsigned char)(code >> 16), table3);
 373   cit->table = put_byte_table (table1, (unsigned char)(code >> 24), table2);
 374 }
 375
 376 #ifdef HAVE_CHISE
 377 Lisp_Object load_char_attribute_maybe (Lisp_Char_Table* cit, Emchar ch);
 378
 379 #ifndef HAVE_LIBCHISE
 380 extern Lisp_Object Qsystem_char_id;
 381
 382 Lisp_Object
 383 char_attribute_system_db_file (Lisp_Object key_type, Lisp_Object attribute,
 384                                int writing_mode);
 385 #endif /* not HAVE_LIBCHISE */
 386 #endif /* HAVE_CHISE */
 387
 388 INLINE_HEADER Lisp_Object
 389 get_char_id_table_0 (Lisp_Char_Table* cit, Emchar ch);
 390 INLINE_HEADER Lisp_Object
 391 get_char_id_table_0 (Lisp_Char_Table* cit, Emchar ch)
 392 {
 393   return get_byte_table (get_byte_table
 394                          (get_byte_table
 395                           (get_byte_table
 396                            (cit->table,
 397                             (unsigned char)(ch >> 24)),
 398                            (unsigned char) (ch >> 16)),
 399                           (unsigned char)  (ch >> 8)),
 400                          (unsigned char)    ch);
 401 }
 402
 403 INLINE_HEADER Lisp_Object
 404 get_char_id_table (Lisp_Char_Table* cit, Emchar ch);
 405 INLINE_HEADER Lisp_Object
 406 get_char_id_table (Lisp_Char_Table* cit, Emchar ch)
 407 {
 408   Lisp_Object val = get_char_id_table_0 (cit, ch);
 409
 410 #ifdef HAVE_CHISE
 411   if (EQ (val, Qunloaded))
 412     {
 413       val = load_char_attribute_maybe (cit, ch);
 414       put_char_id_table_0 (cit, ch, val);
 415     }
 416 #endif /* HAVE_CHISE */
 417   if (UNBOUNDP (val))
 418     return cit->default_value;
 419   else
 420     return val;
 421 }
 422
 423 void
 424 decode_char_table_range (Lisp_Object range, struct chartab_range *outrange);
 425
 426 INLINE_HEADER void
 427 put_char_id_table (Lisp_Char_Table* table,
 428                    Lisp_Object character, Lisp_Object value);
 429 INLINE_HEADER void
 430 put_char_id_table (Lisp_Char_Table* table,
 431                    Lisp_Object character, Lisp_Object value)
 432 {
 433   struct chartab_range range;
 434
 435   decode_char_table_range (character, &range);
 436   put_char_table (table, &range, value);
 437 }
 438
 439
 440 EXFUN (Fget_char_attribute, 3);
 441 EXFUN (Fchar_feature, 5);
 442
 443 #endif
 444 \f
 445
 446 #ifdef MULE
 447 int check_category_char(Emchar ch, Lisp_Object ctbl,
 448                         unsigned int designator, unsigned int not_p);
 449
 450 extern Lisp_Object Vstandard_category_table;
 451
 452 #define CATEGORY_DESIGNATORP(x) \
 453  (CHARP (x) && XCHAR (x) >= 32 && XCHAR (x) <= 126)
 454
 455 #define CHECK_CATEGORY_DESIGNATOR(x) do {                       \
 456   if (!CATEGORY_DESIGNATORP (x))                                \
 457     dead_wrong_type_argument (Qcategory_designator_p, x);       \
 458 } while (0)
 459
 460 #define CONCHECK_CATEGORY_DESIGNATOR(x) do {                    \
 461   if (!CATEGORY_DESIGNATORP (x))                                \
 462     x = wrong_type_argument (Qcategory_designator_p, x);        \
 463 } while (0)
 464
 465 #define CATEGORY_TABLE_VALUEP(x) \
 466  (NILP (x) || (BIT_VECTORP (x) && (bit_vector_length (XBIT_VECTOR (x)) == 95)))
 467
 468 #define CHECK_CATEGORY_TABLE_VALUE(x) do {                      \
 469   if (!CATEGORY_TABLE_VALUEP (x))                               \
 470     dead_wrong_type_argument (Qcategory_table_value_p, x);      \
 471 } while (0)
 472
 473 #define CONCHECK_CATEGORY_TABLE_VALUE(x) do {                   \
 474   if (!CATEGORY_TABLE_VALUEP (x))                               \
 475     x = wrong_type_argument (Qcategory_table_value_p, x);       \
 476 } while (0)
 477
 478 #endif /* MULE */
 479
 480 #endif /* INCLUDED_chartab_h_ */