Mercurial > hg > xemacs-beta

comparison src/chartab.c @ 5495:1f0b15040456

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge.
author Aidan Kehoe <kehoea@parhasard.net>
date Sun, 01 May 2011 18:44:03 +0100
parents 6506fcb40fcf
children 58b38d5b32d0
comparison
equal deleted inserted replaced
5494:861f2601a38b 5495:1f0b15040456
5 Copyright (C) 1995, 1997, 1999 Electrotechnical Laboratory, JAPAN. 5 Copyright (C) 1995, 1997, 1999 Electrotechnical Laboratory, JAPAN.
6 Licensed to the Free Software Foundation. 6 Licensed to the Free Software Foundation.
7 7
8 This file is part of XEmacs. 8 This file is part of XEmacs.
9 9
10 XEmacs is free software; you can redistribute it and/or modify it 10 XEmacs is free software: you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by the 11 under the terms of the GNU General Public License as published by the
12 Free Software Foundation; either version 2, or (at your option) any 12 Free Software Foundation, either version 3 of the License, or (at your
13 later version. 13 option) any later version.
14 14
15 XEmacs is distributed in the hope that it will be useful, but WITHOUT 15 XEmacs is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 for more details. 18 for more details.
19 19
20 You should have received a copy of the GNU General Public License 20 You should have received a copy of the GNU General Public License
21 along with XEmacs; see the file COPYING. If not, write to 21 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. */
22 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
24 22
25 /* Synched up with: Mule 2.3. Not synched with FSF. 23 /* Synched up with: Mule 2.3. Not synched with FSF.
26 24
27 This file was written independently of the FSF implementation, 25 This file was written independently of the FSF implementation,
28 and is not compatible. */ 26 and is not compatible. */
126 124
127 return 1; 125 return 1;
128 } 126 }
129 127
130 static Hashcode 128 static Hashcode
131 char_table_entry_hash (Lisp_Object obj, int depth) 129 char_table_entry_hash (Lisp_Object obj, int depth, Boolint equalp)
132 { 130 {
133 Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj); 131 Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj);
134 132
135 return internal_array_hash (cte->level2, 96, depth + 1); 133 return internal_array_hash (cte->level2, 96, depth + 1, equalp);
136 } 134 }
137 135
138 static const struct memory_description char_table_entry_description[] = { 136 static const struct memory_description char_table_entry_description[] = {
139 { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Char_Table_Entry, level2), 96 }, 137 { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Char_Table_Entry, level2), 96 },
140 { XD_END } 138 { XD_END }
141 }; 139 };
142 140
143 DEFINE_LRECORD_IMPLEMENTATION ("char-table-entry", char_table_entry, 141 DEFINE_DUMPABLE_LISP_OBJECT ("char-table-entry", char_table_entry,
144 1, /* dumpable flag */ 142 mark_char_table_entry, internal_object_printer,
145 mark_char_table_entry, internal_object_printer, 143 0, char_table_entry_equal,
146 0, char_table_entry_equal, 144 char_table_entry_hash,
147 char_table_entry_hash, 145 char_table_entry_description,
148 char_table_entry_description, 146 Lisp_Char_Table_Entry);
149 Lisp_Char_Table_Entry);
150 147
151 #endif /* MULE */ 148 #endif /* MULE */
152 149
153 static Lisp_Object 150 static Lisp_Object
154 mark_char_table (Lisp_Object obj) 151 mark_char_table (Lisp_Object obj)
256 case CHARSET_TYPE_94: 253 case CHARSET_TYPE_94:
257 case CHARSET_TYPE_96: 254 case CHARSET_TYPE_96:
258 sferror ("Charset in row vector must be multi-byte", 255 sferror ("Charset in row vector must be multi-byte",
259 outrange->charset); 256 outrange->charset);
260 case CHARSET_TYPE_94X94: 257 case CHARSET_TYPE_94X94:
261 check_int_range (outrange->row, 33, 126); 258 check_integer_range (make_int (outrange->row), make_int (33),
259 make_int (126));
262 break; 260 break;
263 case CHARSET_TYPE_96X96: 261 case CHARSET_TYPE_96X96:
264 check_int_range (outrange->row, 32, 127); 262 check_integer_range (make_int (outrange->row), make_int (32),
263 make_int (127));
265 break; 264 break;
266 default: 265 default:
267 ABORT (); 266 ABORT ();
268 } 267 }
269 } 268 }
298 return make_char (range->ch); 297 return make_char (range->ch);
299 default: 298 default:
300 ABORT (); 299 ABORT ();
301 } 300 }
302 return Qnil; /* not reached */ 301 return Qnil; /* not reached */
302 }
303
304 static Lisp_Object
305 char_table_default_for_type (enum char_table_type type)
306 {
307 switch (type)
308 {
309 case CHAR_TABLE_TYPE_CHAR:
310 return make_char (0);
311 break;
312 case CHAR_TABLE_TYPE_DISPLAY:
313 case CHAR_TABLE_TYPE_GENERIC:
314 #ifdef MULE
315 case CHAR_TABLE_TYPE_CATEGORY:
316 #endif /* MULE */
317 return Qnil;
318 break;
319
320 case CHAR_TABLE_TYPE_SYNTAX:
321 return make_integer (Sinherit);
322 break;
323 }
324 ABORT();
325 return Qzero;
303 } 326 }
304 327
305 struct ptemap 328 struct ptemap
306 { 329 {
307 Lisp_Object printcharfun; 330 Lisp_Object printcharfun;
335 358
336 range.type = CHARTAB_RANGE_ALL; 359 range.type = CHARTAB_RANGE_ALL;
337 arg.printcharfun = printcharfun; 360 arg.printcharfun = printcharfun;
338 arg.first = 1; 361 arg.first = 1;
339 362
340 write_fmt_string_lisp (printcharfun, "#s(char-table type %s data (", 363 write_fmt_string_lisp (printcharfun,
341 1, char_table_type_to_symbol (ct->type)); 364 "#s(char-table :type %s", 1,
365 char_table_type_to_symbol (ct->type));
366 if (!(EQ (ct->default_, char_table_default_for_type (ct->type))))
367 {
368 write_fmt_string_lisp (printcharfun, " :default %S", 1, ct->default_);
369 }
370
371 write_ascstring (printcharfun, " :data (");
342 map_char_table (obj, &range, print_table_entry, &arg); 372 map_char_table (obj, &range, print_table_entry, &arg);
343 write_ascstring (printcharfun, "))"); 373 write_ascstring (printcharfun, "))");
344 374
345 /* #### need to print and read the default; but that will allow the 375 /* #### need to print and read the default; but that will allow the
346 default to be modified, which we don't (yet) support -- but FSF does */ 376 default to be modified, which we don't (yet) support -- but FSF does */
368 398
369 return internal_equal_0 (ct1->default_, ct2->default_, depth + 1, foldcase); 399 return internal_equal_0 (ct1->default_, ct2->default_, depth + 1, foldcase);
370 } 400 }
371 401
372 static Hashcode 402 static Hashcode
373 char_table_hash (Lisp_Object obj, int depth) 403 char_table_hash (Lisp_Object obj, int depth, Boolint equalp)
374 { 404 {
375 Lisp_Char_Table *ct = XCHAR_TABLE (obj); 405 Lisp_Char_Table *ct = XCHAR_TABLE (obj);
376 Hashcode hashval = internal_array_hash (ct->ascii, NUM_ASCII_CHARS, 406 Hashcode hashval = internal_array_hash (ct->ascii, NUM_ASCII_CHARS,
377 depth + 1); 407 depth + 1, equalp);
378 #ifdef MULE 408 #ifdef MULE
379 hashval = HASH2 (hashval, 409 hashval = HASH2 (hashval,
380 internal_array_hash (ct->level1, NUM_LEADING_BYTES, 410 internal_array_hash (ct->level1, NUM_LEADING_BYTES,
381 depth + 1)); 411 depth + 1, equalp));
382 #endif /* MULE */ 412 #endif /* MULE */
383 return HASH2 (hashval, internal_hash (ct->default_, depth + 1)); 413 return HASH2 (hashval, internal_hash (ct->default_, depth + 1, equalp));
384 } 414 }
385 415
386 static const struct memory_description char_table_description[] = { 416 static const struct memory_description char_table_description[] = {
387 { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Char_Table, ascii), NUM_ASCII_CHARS }, 417 { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Char_Table, ascii), NUM_ASCII_CHARS },
388 #ifdef MULE 418 #ifdef MULE
393 { XD_LISP_OBJECT, offsetof (Lisp_Char_Table, mirror_table) }, 423 { XD_LISP_OBJECT, offsetof (Lisp_Char_Table, mirror_table) },
394 { XD_LO_LINK, offsetof (Lisp_Char_Table, next_table) }, 424 { XD_LO_LINK, offsetof (Lisp_Char_Table, next_table) },
395 { XD_END } 425 { XD_END }
396 }; 426 };
397 427
398 DEFINE_LRECORD_IMPLEMENTATION ("char-table", char_table, 428 DEFINE_DUMPABLE_LISP_OBJECT ("char-table", char_table,
399 1, /*dumpable-flag*/ 429 mark_char_table, print_char_table, 0,
400 mark_char_table, print_char_table, 0, 430 char_table_equal, char_table_hash,
401 char_table_equal, char_table_hash, 431 char_table_description,
402 char_table_description, 432 Lisp_Char_Table);
403 Lisp_Char_Table);
404 433
405 DEFUN ("char-table-p", Fchar_table_p, 1, 1, 0, /* 434 DEFUN ("char-table-p", Fchar_table_p, 1, 1, 0, /*
406 Return non-nil if OBJECT is a char table. 435 Return non-nil if OBJECT is a char table.
407 */ 436 */
408 (object)) 437 (object))
477 /* Don't get stymied when initting the table, or when trying to 506 /* Don't get stymied when initting the table, or when trying to
478 free a pdump object. */ 507 free a pdump object. */
479 if (!EQ (ct->level1[i], Qnull_pointer) && 508 if (!EQ (ct->level1[i], Qnull_pointer) &&
480 CHAR_TABLE_ENTRYP (ct->level1[i]) && 509 CHAR_TABLE_ENTRYP (ct->level1[i]) &&
481 !OBJECT_DUMPED_P (ct->level1[1])) 510 !OBJECT_DUMPED_P (ct->level1[1]))
482 FREE_LCRECORD (ct->level1[i]); 511 free_normal_lisp_object (ct->level1[i]);
483 ct->level1[i] = value; 512 ct->level1[i] = value;
484 } 513 }
485 #endif /* MULE */ 514 #endif /* MULE */
486 515
487 if (ct->type == CHAR_TABLE_TYPE_SYNTAX) 516 if (ct->type == CHAR_TABLE_TYPE_SYNTAX)
492 Reset CHAR-TABLE to its default state. 521 Reset CHAR-TABLE to its default state.
493 */ 522 */
494 (char_table)) 523 (char_table))
495 { 524 {
496 Lisp_Char_Table *ct; 525 Lisp_Char_Table *ct;
497 Lisp_Object def;
498 526
499 CHECK_CHAR_TABLE (char_table); 527 CHECK_CHAR_TABLE (char_table);
500 ct = XCHAR_TABLE (char_table); 528 ct = XCHAR_TABLE (char_table);
501 529
502 switch (ct->type)
503 {
504 case CHAR_TABLE_TYPE_CHAR:
505 def = make_char (0);
506 break;
507 case CHAR_TABLE_TYPE_DISPLAY:
508 case CHAR_TABLE_TYPE_GENERIC:
509 #ifdef MULE
510 case CHAR_TABLE_TYPE_CATEGORY:
511 #endif /* MULE */
512 def = Qnil;
513 break;
514
515 case CHAR_TABLE_TYPE_SYNTAX:
516 def = make_int (Sinherit);
517 break;
518
519 default:
520 ABORT ();
521 def = Qnil;
522 break;
523 }
524
525 /* Avoid doubly updating the syntax table by setting the default ourselves, 530 /* Avoid doubly updating the syntax table by setting the default ourselves,
526 since set_char_table_default() also updates. */ 531 since set_char_table_default() also updates. */
527 ct->default_ = def; 532 ct->default_ = char_table_default_for_type (ct->type);
528 fill_char_table (ct, Qunbound); 533 fill_char_table (ct, Qunbound);
529 534
530 return Qnil; 535 return Qnil;
531 } 536 }
532 537
596 default result given by `get-char-table' is the syntax code for 601 default result given by `get-char-table' is the syntax code for
597 `inherit'. 602 `inherit'.
598 */ 603 */
599 (type)) 604 (type))
600 { 605 {
601 Lisp_Char_Table *ct; 606 Lisp_Object obj = ALLOC_NORMAL_LISP_OBJECT (char_table);
602 Lisp_Object obj; 607 Lisp_Char_Table *ct = XCHAR_TABLE (obj);
603 enum char_table_type ty = symbol_to_char_table_type (type); 608 enum char_table_type ty = symbol_to_char_table_type (type);
604 609
605 ct = ALLOC_LCRECORD_TYPE (Lisp_Char_Table, &lrecord_char_table);
606 ct->type = ty; 610 ct->type = ty;
607 obj = wrap_char_table (ct);
608 if (ty == CHAR_TABLE_TYPE_SYNTAX) 611 if (ty == CHAR_TABLE_TYPE_SYNTAX)
609 { 612 {
610 /* Qgeneric not Qsyntax because a syntax table has a mirror table 613 /* Qgeneric not Qsyntax because a syntax table has a mirror table
611 and we don't want infinite recursion */ 614 and we don't want infinite recursion */
612 ct->mirror_table = Fmake_char_table (Qgeneric); 615 ct->mirror_table = Fmake_char_table (Qgeneric);
632 635
633 static Lisp_Object 636 static Lisp_Object
634 make_char_table_entry (Lisp_Object initval) 637 make_char_table_entry (Lisp_Object initval)
635 { 638 {
636 int i; 639 int i;
637 Lisp_Char_Table_Entry *cte = 640 Lisp_Object obj = ALLOC_NORMAL_LISP_OBJECT (char_table_entry);
638 ALLOC_LCRECORD_TYPE (Lisp_Char_Table_Entry, &lrecord_char_table_entry); 641 Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj);
639 642
640 for (i = 0; i < 96; i++) 643 for (i = 0; i < 96; i++)
641 cte->level2[i] = initval; 644 cte->level2[i] = initval;
642 645
643 return wrap_char_table_entry (cte); 646 return obj;
644 } 647 }
645 648
646 static Lisp_Object 649 static Lisp_Object
647 copy_char_table_entry (Lisp_Object entry) 650 copy_char_table_entry (Lisp_Object entry)
648 { 651 {
649 Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (entry); 652 Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (entry);
650 int i; 653 int i;
651 Lisp_Char_Table_Entry *ctenew = 654 Lisp_Object obj = ALLOC_NORMAL_LISP_OBJECT (char_table_entry);
652 ALLOC_LCRECORD_TYPE (Lisp_Char_Table_Entry, &lrecord_char_table_entry); 655 Lisp_Char_Table_Entry *ctenew = XCHAR_TABLE_ENTRY (obj);
653 656
654 for (i = 0; i < 96; i++) 657 for (i = 0; i < 96; i++)
655 { 658 {
656 Lisp_Object new_ = cte->level2[i]; 659 Lisp_Object new_ = cte->level2[i];
657 if (CHAR_TABLE_ENTRYP (new_)) 660 if (CHAR_TABLE_ENTRYP (new_))
658 ctenew->level2[i] = copy_char_table_entry (new_); 661 ctenew->level2[i] = copy_char_table_entry (new_);
659 else 662 else
660 ctenew->level2[i] = new_; 663 ctenew->level2[i] = new_;
661 } 664 }
662 665
663 return wrap_char_table_entry (ctenew); 666 return obj;
664 } 667 }
665 668
666 #endif /* MULE */ 669 #endif /* MULE */
667 670
668 DEFUN ("copy-char-table", Fcopy_char_table, 1, 1, 0, /* 671 DEFUN ("copy-char-table", Fcopy_char_table, 1, 1, 0, /*
677 int i; 680 int i;
678 681
679 CHECK_CHAR_TABLE (char_table); 682 CHECK_CHAR_TABLE (char_table);
680 ct = XCHAR_TABLE (char_table); 683 ct = XCHAR_TABLE (char_table);
681 assert(!ct->mirror_table_p); 684 assert(!ct->mirror_table_p);
682 ctnew = ALLOC_LCRECORD_TYPE (Lisp_Char_Table, &lrecord_char_table); 685 obj = ALLOC_NORMAL_LISP_OBJECT (char_table);
686 ctnew = XCHAR_TABLE (obj);
683 ctnew->type = ct->type; 687 ctnew->type = ct->type;
684 ctnew->parent = ct->parent; 688 ctnew->parent = ct->parent;
685 ctnew->default_ = ct->default_; 689 ctnew->default_ = ct->default_;
686 ctnew->mirror_table_p = 0; 690 ctnew->mirror_table_p = 0;
687 obj = wrap_char_table (ctnew);
688 691
689 for (i = 0; i < NUM_ASCII_CHARS; i++) 692 for (i = 0; i < NUM_ASCII_CHARS; i++)
690 { 693 {
691 Lisp_Object new_ = ct->ascii[i]; 694 Lisp_Object new_ = ct->ascii[i];
692 #ifdef MULE 695 #ifdef MULE
1073 else 1076 else
1074 { 1077 {
1075 int lb = XCHARSET_LEADING_BYTE (range->charset) - MIN_LEADING_BYTE; 1078 int lb = XCHARSET_LEADING_BYTE (range->charset) - MIN_LEADING_BYTE;
1076 if (CHAR_TABLE_ENTRYP (ct->level1[lb]) && 1079 if (CHAR_TABLE_ENTRYP (ct->level1[lb]) &&
1077 !OBJECT_DUMPED_P (ct->level1[lb])) 1080 !OBJECT_DUMPED_P (ct->level1[lb]))
1078 FREE_LCRECORD (ct->level1[lb]); 1081 free_normal_lisp_object (ct->level1[lb]);
1079 ct->level1[lb] = val; 1082 ct->level1[lb] = val;
1080 } 1083 }
1081 break; 1084 break;
1082 1085
1083 case CHARTAB_RANGE_ROW: 1086 case CHARTAB_RANGE_ROW:
1545 } 1548 }
1546 1549
1547 return 1; 1550 return 1;
1548 } 1551 }
1549 1552
1553 static int
1554 chartab_default_validate (Lisp_Object UNUSED (keyword),
1555 Lisp_Object UNUSED (value),
1556 Error_Behavior UNUSED (errb))
1557 {
1558 /* We can't yet validate this, since we don't know what the type of the
1559 char table is. We do the validation below in chartab_instantiate(). */
1560 return 1;
1561 }
1562
1550 static Lisp_Object 1563 static Lisp_Object
1551 chartab_instantiate (Lisp_Object data) 1564 chartab_instantiate (Lisp_Object plist)
1552 { 1565 {
1553 Lisp_Object chartab; 1566 Lisp_Object chartab;
1554 Lisp_Object type = Qgeneric; 1567 Lisp_Object type = Qgeneric;
1555 Lisp_Object dataval = Qnil; 1568 Lisp_Object dataval = Qnil, default_ = Qunbound;
1556 1569
1557 while (!NILP (data)) 1570 if (KEYWORDP (Fcar (plist)))
1558 { 1571 {
1559 Lisp_Object keyw = Fcar (data); 1572 PROPERTY_LIST_LOOP_3 (key, value, plist)
1560 Lisp_Object valw; 1573 {
1561 1574 if (EQ (key, Q_data))
1562 data = Fcdr (data); 1575 {
1563 valw = Fcar (data); 1576 dataval = value;
1564 data = Fcdr (data); 1577 }
1565 if (EQ (keyw, Qtype)) 1578 else if (EQ (key, Q_type))
1566 type = valw; 1579 {
1567 else if (EQ (keyw, Qdata)) 1580 type = value;
1568 dataval = valw; 1581 }
1569 } 1582 else if (EQ (key, Q_default_))
1583 {
1584 default_ = value;
1585 }
1586 else if (!KEYWORDP (key))
1587 {
1588 signal_error
1589 (Qinvalid_read_syntax,
1590 "can't mix keyword and non-keyword structure syntax",
1591 key);
1592 }
1593 else
1594 ABORT ();
1595 }
1596 }
1597 #ifdef NEED_TO_HANDLE_21_4_CODE
1598 else
1599 {
1600 PROPERTY_LIST_LOOP_3 (key, value, plist)
1601 {
1602 if (EQ (key, Qdata))
1603 {
1604 dataval = value;
1605 }
1606 else if (EQ (key, Qtype))
1607 {
1608 type = value;
1609 }
1610 else if (KEYWORDP (key))
1611 signal_error
1612 (Qinvalid_read_syntax,
1613 "can't mix keyword and non-keyword structure syntax",
1614 key);
1615 else
1616 ABORT ();
1617 }
1618 }
1619 #endif /* NEED_TO_HANDLE_21_4_CODE */
1570 1620
1571 chartab = Fmake_char_table (type); 1621 chartab = Fmake_char_table (type);
1572 1622 if (!UNBOUNDP (default_))
1573 data = dataval; 1623 {
1574 while (!NILP (data)) 1624 check_valid_char_table_value (default_, XCHAR_TABLE_TYPE (chartab),
1575 { 1625 ERROR_ME);
1576 Lisp_Object range = Fcar (data); 1626 set_char_table_default (chartab, default_);
1577 Lisp_Object val = Fcar (Fcdr (data)); 1627 if (!NILP (XCHAR_TABLE (chartab)->mirror_table))
1578 1628 {
1579 data = Fcdr (Fcdr (data)); 1629 set_char_table_default (XCHAR_TABLE (chartab)->mirror_table,
1630 default_);
1631 }
1632 }
1633
1634 while (!NILP (dataval))
1635 {
1636 Lisp_Object range = Fcar (dataval);
1637 Lisp_Object val = Fcar (Fcdr (dataval));
1638
1639 dataval = Fcdr (Fcdr (dataval));
1580 if (CONSP (range)) 1640 if (CONSP (range))
1581 { 1641 {
1582 if (CHAR_OR_CHAR_INTP (XCAR (range))) 1642 if (CHAR_OR_CHAR_INTP (XCAR (range)))
1583 { 1643 {
1584 Ichar first = XCHAR_OR_CHAR_INT (Fcar (range)); 1644 Ichar first = XCHAR_OR_CHAR_INT (Fcar (range));
1830 1890
1831 1891
1832 void 1892 void
1833 syms_of_chartab (void) 1893 syms_of_chartab (void)
1834 { 1894 {
1835 INIT_LRECORD_IMPLEMENTATION (char_table); 1895 INIT_LISP_OBJECT (char_table);
1836 1896
1837 #ifdef MULE 1897 #ifdef MULE
1838 INIT_LRECORD_IMPLEMENTATION (char_table_entry); 1898 INIT_LISP_OBJECT (char_table_entry);
1839 1899
1840 DEFSYMBOL (Qcategory_table_p); 1900 DEFSYMBOL (Qcategory_table_p);
1841 DEFSYMBOL (Qcategory_designator_p); 1901 DEFSYMBOL (Qcategory_designator_p);
1842 DEFSYMBOL (Qcategory_table_value_p); 1902 DEFSYMBOL (Qcategory_table_value_p);
1843 #endif /* MULE */ 1903 #endif /* MULE */
1889 { 1949 {
1890 struct structure_type *st; 1950 struct structure_type *st;
1891 1951
1892 st = define_structure_type (Qchar_table, 0, chartab_instantiate); 1952 st = define_structure_type (Qchar_table, 0, chartab_instantiate);
1893 1953
1954 #ifdef NEED_TO_HANDLE_21_4_CODE
1894 define_structure_type_keyword (st, Qtype, chartab_type_validate); 1955 define_structure_type_keyword (st, Qtype, chartab_type_validate);
1895 define_structure_type_keyword (st, Qdata, chartab_data_validate); 1956 define_structure_type_keyword (st, Qdata, chartab_data_validate);
1957 #endif /* NEED_TO_HANDLE_21_4_CODE */
1958
1959 define_structure_type_keyword (st, Q_type, chartab_type_validate);
1960 define_structure_type_keyword (st, Q_data, chartab_data_validate);
1961 define_structure_type_keyword (st, Q_default_, chartab_default_validate);
1896 } 1962 }
1897 1963
1898 void 1964 void
1899 complex_vars_of_chartab (void) 1965 complex_vars_of_chartab (void)
1900 { 1966 {