Mercurial > hg > xemacs-beta
annotate src/chartab.h @ 5908:6174848f3e6c
Use parse_integer() in read_atom(); support bases with ratios like integers
src/ChangeLog addition:
2015-05-08 Aidan Kehoe <kehoea@parhasard.net>
* data.c (init_errors_once_early):
Move the Qunsupported_type here from numbers.c, so it's available
when the majority of our types are not supported.
* general-slots.h: Add it here, too.
* number.c: Remove the definition of Qunsupported_type from here.
* lread.c (read_atom):
Check if the first character could reflect a rational, if so, call
parse_integer(), don't check the syntax of the other
characters. This allows us to accept the non-ASCII digit
characters too.
If that worked partially, but not completely, and the next char is
a slash, try to parse as a ratio.
If that fails, try isfloat_string(), but only if the first
character could plausibly be part of a float.
Otherwise, treat as a symbol.
* lread.c (read_rational):
Rename from read_integer. Handle ratios with the same radix
specification as was used for integers.
* lread.c (read1):
Rename read_integer in this function. Support the Common Lisp
#NNNrMMM syntax for parsing a number MMM of arbitrary radix NNN.
man/ChangeLog addition:
2015-05-08 Aidan Kehoe <kehoea@parhasard.net>
* lispref/numbers.texi (Numbers):
Describe the newly-supported arbitrary-base syntax for rationals
(integers and ratios). Describe that ratios can take the same base
specification as integers, something also new.
tests/ChangeLog addition:
2015-05-08 Aidan Kehoe <kehoea@parhasard.net>
* automated/lisp-reader-tests.el:
Check the arbitrary-base integer reader syntax support, just
added. Check the reader base support for ratios, just added.
Check the non-ASCII-digit support in the reader, just added.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Sat, 09 May 2015 00:40:57 +0100 |
| parents | 4d5a5a80aba2 |
| children |
| 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 |
|
5902
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
143 #ifdef ERROR_CHECK_TYPES |
|
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
144 DECLARE_INLINE_HEADER ( |
|
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
145 Lisp_Object |
|
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
146 get_char_table_1 (Ichar ch, Lisp_Object table, Boolint mirrors_allowed) |
|
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
147 ) |
|
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
148 #else |
| 826 | 149 DECLARE_INLINE_HEADER ( |
| 150 Lisp_Object | |
| 1296 | 151 get_char_table_1 (Ichar ch, Lisp_Object table) |
| 826 | 152 ) |
|
5902
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
153 #endif |
| 428 | 154 { |
| 826 | 155 Lisp_Object retval; |
| 156 Lisp_Char_Table *ct = XCHAR_TABLE (table); | |
|
5902
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
157 |
|
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
158 #ifdef ERROR_CHECK_TYPES |
|
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
159 if (!mirrors_allowed) |
|
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
160 { |
|
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
161 assert (!ct->mirror_table_p); |
|
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
162 } |
|
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
163 #endif |
|
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
164 |
| 826 | 165 #ifdef MULE |
| 166 if (ch < NUM_ASCII_CHARS) | |
| 167 retval = ct->ascii[ch]; | |
| 428 | 168 else |
| 826 | 169 { |
| 867 | 170 unsigned char lb = ichar_leading_byte (ch); |
| 826 | 171 if (!CHAR_TABLE_ENTRYP (ct->level1[lb - MIN_LEADING_BYTE])) |
| 172 retval = ct->level1[lb - MIN_LEADING_BYTE]; | |
| 173 else | |
| 174 retval = get_non_ascii_char_table_value (ct, lb, ch); | |
| 175 } | |
| 176 #else /* not MULE */ | |
| 177 retval = ct->ascii[(unsigned char) ch]; | |
| 178 #endif /* not MULE */ | |
| 179 if (!UNBOUNDP (retval)) | |
| 180 return retval; | |
| 181 else | |
| 182 return ct->default_; | |
| 428 | 183 } |
| 184 | |
| 1296 | 185 #ifdef ERROR_CHECK_TYPES |
|
5902
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
186 #define get_char_table(ch, table) get_char_table_1 (ch, table, 0) |
|
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
187 #define get_char_table_mirrors_ok(ch, table) get_char_table_1 (ch, table, 1) |
| 1296 | 188 #else |
|
5902
2dc8711af537
Make get_char_table in loop bodies more tolerable without optimization.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5402
diff
changeset
|
189 #define get_char_table get_char_table_1 |
|
5906
4d5a5a80aba2
chartab.h, #define get_char_table_mirrors_ok correctly sans ERROR_CHECK_TYPES
Aidan Kehoe <kehoea@parhasard.net>
parents:
5902
diff
changeset
|
190 #define get_char_table_mirrors_ok get_char_table_1 |
| 1296 | 191 #endif |
| 192 | |
| 428 | 193 enum chartab_range_type |
| 194 { | |
| 195 CHARTAB_RANGE_ALL, | |
| 196 #ifdef MULE | |
| 197 CHARTAB_RANGE_CHARSET, | |
| 198 CHARTAB_RANGE_ROW, | |
| 199 #endif | |
| 200 CHARTAB_RANGE_CHAR | |
| 201 }; | |
| 202 | |
| 203 struct chartab_range | |
| 204 { | |
| 205 enum chartab_range_type type; | |
| 867 | 206 Ichar ch; |
| 428 | 207 Lisp_Object charset; |
| 208 int row; | |
| 209 }; | |
| 210 | |
| 826 | 211 void set_char_table_default (Lisp_Object table, Lisp_Object value); |
| 212 void put_char_table (Lisp_Object table, struct chartab_range *range, | |
| 428 | 213 Lisp_Object val); |
| 826 | 214 int map_char_table (Lisp_Object table, |
| 428 | 215 struct chartab_range *range, |
| 216 int (*fn) (struct chartab_range *range, | |
| 826 | 217 Lisp_Object table, |
| 428 | 218 Lisp_Object val, void *arg), |
| 219 void *arg); | |
| 220 void prune_syntax_tables (void); | |
| 826 | 221 Lisp_Object get_range_char_table (struct chartab_range *range, |
| 222 Lisp_Object table, Lisp_Object multi); | |
| 1296 | 223 #ifdef ERROR_CHECK_TYPES |
| 224 Lisp_Object updating_mirror_get_range_char_table (struct chartab_range *range, | |
| 225 Lisp_Object table, | |
| 226 Lisp_Object multi); | |
| 227 #else | |
| 228 #define updating_mirror_get_range_char_table get_range_char_table | |
| 229 #endif | |
| 826 | 230 void copy_char_table_range (Lisp_Object from, Lisp_Object to, |
| 231 struct chartab_range *range); | |
| 867 | 232 int word_boundary_p (Ichar c1, Ichar c2); |
| 428 | 233 |
| 234 EXFUN (Fcopy_char_table, 1); | |
| 235 EXFUN (Fmake_char_table, 1); | |
| 236 EXFUN (Fput_char_table, 3); | |
| 237 EXFUN (Fget_char_table, 2); | |
| 238 | |
| 239 extern Lisp_Object Vall_syntax_tables; | |
| 240 | |
| 241 | |
| 242 | |
| 243 #ifdef MULE | |
| 867 | 244 int check_category_char (Ichar ch, Lisp_Object ctbl, int designator, |
| 826 | 245 int not_p); |
| 428 | 246 |
| 247 extern Lisp_Object Vstandard_category_table; | |
| 248 | |
| 249 #define CATEGORY_DESIGNATORP(x) \ | |
| 250 (CHARP (x) && XCHAR (x) >= 32 && XCHAR (x) <= 126) | |
| 251 | |
| 252 #define CHECK_CATEGORY_DESIGNATOR(x) do { \ | |
| 253 if (!CATEGORY_DESIGNATORP (x)) \ | |
| 254 dead_wrong_type_argument (Qcategory_designator_p, x); \ | |
| 255 } while (0) | |
| 256 | |
| 257 #define CONCHECK_CATEGORY_DESIGNATOR(x) do { \ | |
| 258 if (!CATEGORY_DESIGNATORP (x)) \ | |
| 259 x = wrong_type_argument (Qcategory_designator_p, x); \ | |
| 260 } while (0) | |
| 261 | |
| 262 #define CATEGORY_TABLE_VALUEP(x) \ | |
| 263 (NILP (x) || (BIT_VECTORP (x) && (bit_vector_length (XBIT_VECTOR (x)) == 95))) | |
| 264 | |
| 265 #define CHECK_CATEGORY_TABLE_VALUE(x) do { \ | |
| 266 if (!CATEGORY_TABLE_VALUEP (x)) \ | |
| 267 dead_wrong_type_argument (Qcategory_table_value_p, x); \ | |
| 268 } while (0) | |
| 269 | |
| 270 #define CONCHECK_CATEGORY_TABLE_VALUE(x) do { \ | |
| 271 if (!CATEGORY_TABLE_VALUEP (x)) \ | |
| 272 x = wrong_type_argument (Qcategory_table_value_p, x); \ | |
| 273 } while (0) | |
| 274 | |
| 275 #endif /* MULE */ | |
| 276 | |
| 440 | 277 #endif /* INCLUDED_chartab_h_ */ |