Mercurial > hg > xemacs-beta
annotate src/chartab.h @ 5464:e79916901603 r21-5-30
XEmacs 21.5.30 "garlic" is released.
| author | Stephen J. Turnbull <stephen@xemacs.org> |
|---|---|
| date | Wed, 27 Apr 2011 01:24:28 +0900 |
| parents | a9c41067dd88 |
| children | 308d34e9f07d |
| rev | line source |
|---|---|
| 428 | 1 /* Declarations having to do with Mule char tables. |
| 2 Copyright (C) 1992 Free Software Foundation, Inc. | |
| 3 Copyright (C) 1995 Sun Microsystems, Inc. | |
| 1296 | 4 Copyright (C) 2002, 2003 Ben Wing. |
| 428 | 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 | |
| 440 | 28 #ifndef INCLUDED_chartab_h_ |
| 29 #define INCLUDED_chartab_h_ | |
| 428 | 30 |
| 771 | 31 #include "charset.h" |
| 32 | |
| 428 | 33 /************************************************************************/ |
| 34 /* Char Tables */ | |
| 35 /************************************************************************/ | |
| 36 | |
| 37 /* Under Mule, we use a complex representation (see below). | |
| 38 When not under Mule, there are only 256 possible characters | |
| 39 so we just represent them directly. */ | |
| 40 | |
| 41 #ifdef MULE | |
| 42 | |
| 43 struct Lisp_Char_Table_Entry | |
| 44 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
45 NORMAL_LISP_OBJECT_HEADER header; |
| 428 | 46 |
| 47 /* In the interests of simplicity, we just use a fixed 96-entry | |
| 48 table. If we felt like being smarter, we could make this | |
| 49 variable-size and add an offset value into this structure. */ | |
| 50 Lisp_Object level2[96]; | |
| 51 }; | |
| 440 | 52 typedef struct Lisp_Char_Table_Entry Lisp_Char_Table_Entry; |
| 53 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
3017
diff
changeset
|
54 DECLARE_LISP_OBJECT (char_table_entry, Lisp_Char_Table_Entry); |
| 440 | 55 #define XCHAR_TABLE_ENTRY(x) \ |
| 56 XRECORD (x, char_table_entry, Lisp_Char_Table_Entry) | |
| 617 | 57 #define wrap_char_table_entry(p) wrap_record (p, char_table_entry) |
| 440 | 58 #define CHAR_TABLE_ENTRYP(x) RECORDP (x, char_table_entry) |
| 59 /* #define CHECK_CHAR_TABLE_ENTRY(x) CHECK_RECORD (x, char_table_entry) | |
| 60 char table entries should never escape to Lisp */ | |
| 428 | 61 |
| 62 #endif /* MULE */ | |
| 63 | |
| 64 enum char_table_type | |
| 65 { | |
| 66 CHAR_TABLE_TYPE_GENERIC, | |
| 67 #ifdef MULE | |
| 68 CHAR_TABLE_TYPE_CATEGORY, | |
| 69 #endif | |
| 70 CHAR_TABLE_TYPE_SYNTAX, | |
| 71 CHAR_TABLE_TYPE_DISPLAY, | |
| 72 CHAR_TABLE_TYPE_CHAR | |
| 73 }; | |
| 74 | |
| 75 #ifdef MULE | |
| 76 #define NUM_ASCII_CHARS 160 | |
| 77 #else | |
| 78 #define NUM_ASCII_CHARS 256 | |
| 79 #endif | |
| 80 | |
| 81 struct Lisp_Char_Table | |
| 82 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
83 NORMAL_LISP_OBJECT_HEADER header; |
| 428 | 84 |
| 85 Lisp_Object ascii[NUM_ASCII_CHARS]; | |
| 826 | 86 Lisp_Object default_; |
| 793 | 87 Lisp_Object parent; /* #### not yet implemented */ |
| 88 | |
| 428 | 89 #ifdef MULE |
| 90 /* We basically duplicate the Mule vectors-of-vectors implementation. | |
| 91 We can do this because we know a great deal about the sorts of | |
| 92 things we are going to be indexing. | |
| 93 | |
| 94 The current implementation is as follows: | |
| 95 | |
| 96 ascii[0-159] is used for ASCII and Control-1 characters. | |
| 97 | |
| 98 level1[0 .. (NUM_LEADING_BYTES-1)] indexes charsets by leading | |
| 99 byte (subtract MIN_LEADING_BYTE from the leading byte). If the | |
| 100 value of this is not an opaque, then it specifies a value for all | |
| 101 characters in the charset. Otherwise, it will be a | |
| 102 96-Lisp-Object opaque that we created, specifying a value for | |
| 103 each row. If the value of this is not an opaque, then it | |
| 104 specifies a value for all characters in the row. Otherwise, it | |
| 105 will be a 96-Lisp-Object opaque that we created, specifying a | |
| 106 value for each character. | |
| 107 | |
| 108 NOTE: 1) This will fail if some C routine passes an opaque to | |
| 109 Fput_char_table(). Currently this is not a problem | |
| 110 since all char tables that are created are Lisp-visible | |
| 111 and thus no one should ever be putting an opaque in | |
| 112 a char table. Another possibility is to consider | |
| 113 adding a type to */ | |
| 114 | |
| 115 Lisp_Object level1[NUM_LEADING_BYTES]; | |
| 116 | |
| 117 #endif /* MULE */ | |
| 118 | |
| 119 enum char_table_type type; | |
| 120 | |
| 121 /* stuff used for syntax tables */ | |
| 1296 | 122 Lisp_Object mirror_table; /* points to mirror table for this table |
| 123 (a cache for quicker access), or a back | |
| 124 pointer if MIRROR_TABLE_P. */ | |
| 428 | 125 Lisp_Object next_table; /* DO NOT mark through this. */ |
| 1296 | 126 char dirty; /* nonzero if mirror dirty and needs updating. */ |
| 127 char mirror_table_p; /* nonzero if this is a mirror table. */ | |
| 428 | 128 }; |
| 440 | 129 typedef struct Lisp_Char_Table Lisp_Char_Table; |
| 130 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
3017
diff
changeset
|
131 DECLARE_LISP_OBJECT (char_table, Lisp_Char_Table); |
| 440 | 132 #define XCHAR_TABLE(x) XRECORD (x, char_table, Lisp_Char_Table) |
| 617 | 133 #define wrap_char_table(p) wrap_record (p, char_table) |
| 440 | 134 #define CHAR_TABLEP(x) RECORDP (x, char_table) |
| 135 #define CHECK_CHAR_TABLE(x) CHECK_RECORD (x, char_table) | |
| 136 #define CONCHECK_CHAR_TABLE(x) CONCHECK_RECORD (x, char_table) | |
| 137 | |
| 138 #define CHAR_TABLE_TYPE(ct) ((ct)->type) | |
| 139 #define XCHAR_TABLE_TYPE(ct) CHAR_TABLE_TYPE (XCHAR_TABLE (ct)) | |
| 428 | 140 |
| 440 | 141 Lisp_Object get_non_ascii_char_table_value (Lisp_Char_Table *ct, |
| 142 int leading_byte, | |
| 867 | 143 Ichar c); |
| 428 | 144 |
| 826 | 145 DECLARE_INLINE_HEADER ( |
| 146 Lisp_Object | |
| 1296 | 147 get_char_table_1 (Ichar ch, Lisp_Object table) |
| 826 | 148 ) |
| 428 | 149 { |
| 826 | 150 Lisp_Object retval; |
| 151 Lisp_Char_Table *ct = XCHAR_TABLE (table); | |
| 152 #ifdef MULE | |
| 153 if (ch < NUM_ASCII_CHARS) | |
| 154 retval = ct->ascii[ch]; | |
| 428 | 155 else |
| 826 | 156 { |
| 867 | 157 unsigned char lb = ichar_leading_byte (ch); |
| 826 | 158 if (!CHAR_TABLE_ENTRYP (ct->level1[lb - MIN_LEADING_BYTE])) |
| 159 retval = ct->level1[lb - MIN_LEADING_BYTE]; | |
| 160 else | |
| 161 retval = get_non_ascii_char_table_value (ct, lb, ch); | |
| 162 } | |
| 163 #else /* not MULE */ | |
| 164 retval = ct->ascii[(unsigned char) ch]; | |
| 165 #endif /* not MULE */ | |
| 166 if (!UNBOUNDP (retval)) | |
| 167 return retval; | |
| 168 else | |
| 169 return ct->default_; | |
| 428 | 170 } |
| 171 | |
| 1296 | 172 #ifdef ERROR_CHECK_TYPES |
| 173 DECLARE_INLINE_HEADER ( | |
| 174 Lisp_Object | |
| 175 get_char_table (Ichar ch, Lisp_Object table) | |
| 176 ) | |
| 177 { | |
| 178 assert (!XCHAR_TABLE (table)->mirror_table_p); | |
| 179 return get_char_table_1 (ch, table); | |
| 180 } | |
| 181 #else | |
| 182 #define get_char_table(ch, table) get_char_table_1 (ch, table) | |
| 183 #endif | |
| 184 | |
| 428 | 185 enum chartab_range_type |
| 186 { | |
| 187 CHARTAB_RANGE_ALL, | |
| 188 #ifdef MULE | |
| 189 CHARTAB_RANGE_CHARSET, | |
| 190 CHARTAB_RANGE_ROW, | |
| 191 #endif | |
| 192 CHARTAB_RANGE_CHAR | |
| 193 }; | |
| 194 | |
| 195 struct chartab_range | |
| 196 { | |
| 197 enum chartab_range_type type; | |
| 867 | 198 Ichar ch; |
| 428 | 199 Lisp_Object charset; |
| 200 int row; | |
| 201 }; | |
| 202 | |
| 826 | 203 void set_char_table_default (Lisp_Object table, Lisp_Object value); |
| 204 void put_char_table (Lisp_Object table, struct chartab_range *range, | |
| 428 | 205 Lisp_Object val); |
| 826 | 206 int map_char_table (Lisp_Object table, |
| 428 | 207 struct chartab_range *range, |
| 208 int (*fn) (struct chartab_range *range, | |
| 826 | 209 Lisp_Object table, |
| 428 | 210 Lisp_Object val, void *arg), |
| 211 void *arg); | |
| 212 void prune_syntax_tables (void); | |
| 826 | 213 Lisp_Object get_range_char_table (struct chartab_range *range, |
| 214 Lisp_Object table, Lisp_Object multi); | |
| 1296 | 215 #ifdef ERROR_CHECK_TYPES |
| 216 Lisp_Object updating_mirror_get_range_char_table (struct chartab_range *range, | |
| 217 Lisp_Object table, | |
| 218 Lisp_Object multi); | |
| 219 #else | |
| 220 #define updating_mirror_get_range_char_table get_range_char_table | |
| 221 #endif | |
| 826 | 222 void copy_char_table_range (Lisp_Object from, Lisp_Object to, |
| 223 struct chartab_range *range); | |
| 867 | 224 int word_boundary_p (Ichar c1, Ichar c2); |
| 428 | 225 |
| 226 EXFUN (Fcopy_char_table, 1); | |
| 227 EXFUN (Fmake_char_table, 1); | |
| 228 EXFUN (Fput_char_table, 3); | |
| 229 EXFUN (Fget_char_table, 2); | |
| 230 | |
| 231 extern Lisp_Object Vall_syntax_tables; | |
| 232 | |
| 233 | |
| 234 | |
| 235 #ifdef MULE | |
| 867 | 236 int check_category_char (Ichar ch, Lisp_Object ctbl, int designator, |
| 826 | 237 int not_p); |
| 428 | 238 |
| 239 extern Lisp_Object Vstandard_category_table; | |
| 240 | |
| 241 #define CATEGORY_DESIGNATORP(x) \ | |
| 242 (CHARP (x) && XCHAR (x) >= 32 && XCHAR (x) <= 126) | |
| 243 | |
| 244 #define CHECK_CATEGORY_DESIGNATOR(x) do { \ | |
| 245 if (!CATEGORY_DESIGNATORP (x)) \ | |
| 246 dead_wrong_type_argument (Qcategory_designator_p, x); \ | |
| 247 } while (0) | |
| 248 | |
| 249 #define CONCHECK_CATEGORY_DESIGNATOR(x) do { \ | |
| 250 if (!CATEGORY_DESIGNATORP (x)) \ | |
| 251 x = wrong_type_argument (Qcategory_designator_p, x); \ | |
| 252 } while (0) | |
| 253 | |
| 254 #define CATEGORY_TABLE_VALUEP(x) \ | |
| 255 (NILP (x) || (BIT_VECTORP (x) && (bit_vector_length (XBIT_VECTOR (x)) == 95))) | |
| 256 | |
| 257 #define CHECK_CATEGORY_TABLE_VALUE(x) do { \ | |
| 258 if (!CATEGORY_TABLE_VALUEP (x)) \ | |
| 259 dead_wrong_type_argument (Qcategory_table_value_p, x); \ | |
| 260 } while (0) | |
| 261 | |
| 262 #define CONCHECK_CATEGORY_TABLE_VALUE(x) do { \ | |
| 263 if (!CATEGORY_TABLE_VALUEP (x)) \ | |
| 264 x = wrong_type_argument (Qcategory_table_value_p, x); \ | |
| 265 } while (0) | |
| 266 | |
| 267 #endif /* MULE */ | |
| 268 | |
| 440 | 269 #endif /* INCLUDED_chartab_h_ */ |