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