Mercurial > hg > xemacs-beta

comparison src/fns.c @ 5374:d967d96ca043

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Conditionalise the old-* functions and byte codes at compile time. src/ChangeLog addition: 2011-03-15 Aidan Kehoe <kehoea@parhasard.net> * config.h.in (SUPPORT_CONFOUNDING_FUNCTIONS): New #define, equivalent NEED_TO_HANDLE_21_4_CODE by default, describing whether this XEmacs should support the old-eq, old-equal and related functions and byte codes. * bytecode.c (UNUSED): Only interpret old-eq, old-equal, old-memq if SUPPORT_CONFOUNDING_FUNCTIONS is defined. * data.c: Move Fold_eq to fns.c with the rest of the Fold_* functions. * fns.c: * fns.c (Fmemq): * fns.c (memq_no_quit): * fns.c (assoc_no_quit): * fns.c (Frassq): * fns.c (Fequal): * fns.c (Fold_equal): * fns.c (syms_of_fns): Group old-eq, old-equal, old-memq etc together, surround them with #ifdef SUPPORT_CONFOUNDING_FUNCTIONS. lisp/ChangeLog addition: 2011-03-15 Aidan Kehoe <kehoea@parhasard.net> * bytecomp.el: Don't generate the old-eq, old-memq, old-equal bytecodes any more, but keep the information about them around for the sake of the disassembler. man/ChangeLog addition: 2011-03-15 Aidan Kehoe <kehoea@parhasard.net> * lispref/objects.texi (Character Type): * lispref/objects.texi (Equality Predicates): No longer document `old-eq', `old-equal', they haven't been used in years. tests/ChangeLog addition: 2011-03-17 Aidan Kehoe <kehoea@parhasard.net> * automated/lisp-tests.el: Only test the various old-* function if old-eq is bound and a subr.
author Aidan Kehoe <kehoea@parhasard.net>
date Thu, 17 Mar 2011 20:13:00 +0000
parents 46b53e84ea7a
children e99b473303e3 ac37a5f7e5be
comparison
equal deleted inserted replaced
5372:6c3a695f54f5 5374:d967d96ca043
70 Lisp_Object Vpath_separator; 70 Lisp_Object Vpath_separator;
71 71
72 extern Fixnum max_lisp_eval_depth; 72 extern Fixnum max_lisp_eval_depth;
73 extern int lisp_eval_depth; 73 extern int lisp_eval_depth;
74 74
75 static int internal_old_equal (Lisp_Object, Lisp_Object, int);
76 Lisp_Object safe_copy_tree (Lisp_Object arg, Lisp_Object vecp, int depth); 75 Lisp_Object safe_copy_tree (Lisp_Object arg, Lisp_Object vecp, int depth);
77 76
78 static DOESNT_RETURN 77 static DOESNT_RETURN
79 mapping_interaction_error (Lisp_Object func, Lisp_Object object) 78 mapping_interaction_error (Lisp_Object func, Lisp_Object object)
80 { 79 {
2579 return tail; 2578 return tail;
2580 } 2579 }
2581 return Qnil; 2580 return Qnil;
2582 } 2581 }
2583 2582
2584 DEFUN ("old-member", Fold_member, 2, 2, 0, /*
2585 Return non-nil if ELT is an element of LIST. Comparison done with `old-equal'.
2586 The value is actually the tail of LIST whose car is ELT.
2587 This function is provided only for byte-code compatibility with v19.
2588 Do not use it.
2589 */
2590 (elt, list))
2591 {
2592 EXTERNAL_LIST_LOOP_3 (list_elt, list, tail)
2593 {
2594 if (internal_old_equal (elt, list_elt, 0))
2595 return tail;
2596 }
2597 return Qnil;
2598 }
2599
2600 DEFUN ("memq", Fmemq, 2, 2, 0, /* 2583 DEFUN ("memq", Fmemq, 2, 2, 0, /*
2601 Return non-nil if ELT is an element of LIST. Comparison done with `eq'. 2584 Return non-nil if ELT is an element of LIST. Comparison done with `eq'.
2602 The value is actually the tail of LIST whose car is ELT. 2585 The value is actually the tail of LIST whose car is ELT.
2603 */ 2586 */
2604 (elt, list)) 2587 (elt, list))
2605 { 2588 {
2606 EXTERNAL_LIST_LOOP_3 (list_elt, list, tail) 2589 EXTERNAL_LIST_LOOP_3 (list_elt, list, tail)
2607 { 2590 {
2608 if (EQ_WITH_EBOLA_NOTICE (elt, list_elt)) 2591 if (EQ_WITH_EBOLA_NOTICE (elt, list_elt))
2609 return tail;
2610 }
2611 return Qnil;
2612 }
2613
2614 DEFUN ("old-memq", Fold_memq, 2, 2, 0, /*
2615 Return non-nil if ELT is an element of LIST. Comparison done with `old-eq'.
2616 The value is actually the tail of LIST whose car is ELT.
2617 This function is provided only for byte-code compatibility with v19.
2618 Do not use it.
2619 */
2620 (elt, list))
2621 {
2622 EXTERNAL_LIST_LOOP_3 (list_elt, list, tail)
2623 {
2624 if (HACKEQ_UNSAFE (elt, list_elt))
2625 return tail; 2592 return tail;
2626 } 2593 }
2627 return Qnil; 2594 return Qnil;
2628 } 2595 }
2629 2596
2820 return elt; 2787 return elt;
2821 } 2788 }
2822 return Qnil; 2789 return Qnil;
2823 } 2790 }
2824 2791
2825 DEFUN ("old-assoc", Fold_assoc, 2, 2, 0, /*
2826 Return non-nil if KEY is `old-equal' to the car of an element of ALIST.
2827 The value is actually the element of ALIST whose car equals KEY.
2828 */
2829 (key, alist))
2830 {
2831 /* This function can GC. */
2832 EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, alist)
2833 {
2834 if (internal_old_equal (key, elt_car, 0))
2835 return elt;
2836 }
2837 return Qnil;
2838 }
2839
2840 Lisp_Object 2792 Lisp_Object
2841 assoc_no_quit (Lisp_Object key, Lisp_Object alist) 2793 assoc_no_quit (Lisp_Object key, Lisp_Object alist)
2842 { 2794 {
2843 int speccount = specpdl_depth (); 2795 int speccount = specpdl_depth ();
2844 specbind (Qinhibit_quit, Qt); 2796 specbind (Qinhibit_quit, Qt);
2853 (key, alist)) 2805 (key, alist))
2854 { 2806 {
2855 EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, alist) 2807 EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, alist)
2856 { 2808 {
2857 if (EQ_WITH_EBOLA_NOTICE (key, elt_car)) 2809 if (EQ_WITH_EBOLA_NOTICE (key, elt_car))
2858 return elt;
2859 }
2860 return Qnil;
2861 }
2862
2863 DEFUN ("old-assq", Fold_assq, 2, 2, 0, /*
2864 Return non-nil if KEY is `old-eq' to the car of an element of ALIST.
2865 The value is actually the element of ALIST whose car is KEY.
2866 Elements of ALIST that are not conses are ignored.
2867 This function is provided only for byte-code compatibility with v19.
2868 Do not use it.
2869 */
2870 (key, alist))
2871 {
2872 EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, alist)
2873 {
2874 if (HACKEQ_UNSAFE (key, elt_car))
2875 return elt; 2810 return elt;
2876 } 2811 }
2877 return Qnil; 2812 return Qnil;
2878 } 2813 }
2879 2814
2953 (value, alist)) 2888 (value, alist))
2954 { 2889 {
2955 EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, alist) 2890 EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, alist)
2956 { 2891 {
2957 if (internal_equal (value, elt_cdr, 0)) 2892 if (internal_equal (value, elt_cdr, 0))
2958 return elt;
2959 }
2960 return Qnil;
2961 }
2962
2963 DEFUN ("old-rassoc", Fold_rassoc, 2, 2, 0, /*
2964 Return non-nil if VALUE is `old-equal' to the cdr of an element of ALIST.
2965 The value is actually the element of ALIST whose cdr equals VALUE.
2966 */
2967 (value, alist))
2968 {
2969 EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, alist)
2970 {
2971 if (internal_old_equal (value, elt_cdr, 0))
2972 return elt; 2893 return elt;
2973 } 2894 }
2974 return Qnil; 2895 return Qnil;
2975 } 2896 }
2976 2897
3276 test, key, start, end, from_end, default_, Qposition); 3197 test, key, start, end, from_end, default_, Qposition);
3277 3198
3278 return object; 3199 return object;
3279 } 3200 }
3280 3201
3281 DEFUN ("old-delete", Fold_delete, 2, 2, 0, /*
3282 Delete by side effect any occurrences of ELT as a member of LIST.
3283 The modified LIST is returned. Comparison is done with `old-equal'.
3284 If the first member of LIST is ELT, there is no way to remove it by side
3285 effect; therefore, write `(setq foo (old-delete element foo))' to be sure
3286 of changing the value of `foo'.
3287 */
3288 (elt, list))
3289 {
3290 EXTERNAL_LIST_LOOP_DELETE_IF (list_elt, list,
3291 (internal_old_equal (elt, list_elt, 0)));
3292 return list;
3293 }
3294
3295 DEFUN ("old-delq", Fold_delq, 2, 2, 0, /*
3296 Delete by side effect any occurrences of ELT as a member of LIST.
3297 The modified LIST is returned. Comparison is done with `old-eq'.
3298 If the first member of LIST is ELT, there is no way to remove it by side
3299 effect; therefore, write `(setq foo (old-delq element foo))' to be sure of
3300 changing the value of `foo'.
3301 */
3302 (elt, list))
3303 {
3304 EXTERNAL_LIST_LOOP_DELETE_IF (list_elt, list,
3305 (HACKEQ_UNSAFE (elt, list_elt)));
3306 return list;
3307 }
3308
3309 /* Like Fdelq, but caller must ensure that LIST is properly 3202 /* Like Fdelq, but caller must ensure that LIST is properly
3310 nil-terminated and ebola-free. */ 3203 nil-terminated and ebola-free. */
3311 3204
3312 Lisp_Object 3205 Lisp_Object
3313 delq_no_quit (Lisp_Object elt, Lisp_Object list) 3206 delq_no_quit (Lisp_Object elt, Lisp_Object list)
6535 return internal_equalp (obj1, obj2, depth); 6428 return internal_equalp (obj1, obj2, depth);
6536 else 6429 else
6537 return internal_equal (obj1, obj2, depth); 6430 return internal_equal (obj1, obj2, depth);
6538 } 6431 }
6539 6432
6433 DEFUN ("equal", Fequal, 2, 2, 0, /*
6434 Return t if two Lisp objects have similar structure and contents.
6435 They must have the same data type.
6436 Conses are compared by comparing the cars and the cdrs.
6437 Vectors and strings are compared element by element.
6438 Numbers are compared by value. Symbols must match exactly.
6439 */
6440 (object1, object2))
6441 {
6442 return internal_equal (object1, object2, 0) ? Qt : Qnil;
6443 }
6444
6445 DEFUN ("equalp", Fequalp, 2, 2, 0, /*
6446 Return t if two Lisp objects have similar structure and contents.
6447
6448 This is like `equal', except that it accepts numerically equal
6449 numbers of different types (float, integer, bignum, bigfloat), and also
6450 compares strings and characters case-insensitively.
6451
6452 Type objects that are arrays (that is, strings, bit-vectors, and vectors)
6453 of the same length and with contents that are `equalp' are themselves
6454 `equalp', regardless of whether the two objects have the same type.
6455
6456 Other objects whose primary purpose is as containers of other objects are
6457 `equalp' if they would otherwise be equal (same length, type, etc.) and
6458 their contents are `equalp'. This goes for conses, weak lists,
6459 weak boxes, ephemerons, specifiers, hash tables, char tables and range
6460 tables. However, objects that happen to contain other objects but are not
6461 primarily designed for this purpose (e.g. compiled functions, events or
6462 display-related objects such as glyphs, faces or extents) are currently
6463 compared using `equalp' the same way as using `equal'.
6464
6465 More specifically, two hash tables are `equalp' if they have the same test
6466 (see `hash-table-test'), the same number of entries, and the same value for
6467 `hash-table-weakness', and if, for each entry in one hash table, its key is
6468 equivalent to a key in the other hash table using the hash table test, and
6469 its value is `equalp' to the other hash table's value for that key.
6470 */
6471 (object1, object2))
6472 {
6473 return internal_equalp (object1, object2, 0) ? Qt : Qnil;
6474 }
6475
6476 #ifdef SUPPORT_CONFOUNDING_FUNCTIONS
6477
6540 /* Note that we may be calling sub-objects that will use 6478 /* Note that we may be calling sub-objects that will use
6541 internal_equal() (instead of internal_old_equal()). Oh well. 6479 internal_equal() (instead of internal_old_equal()). Oh well.
6542 We will get an Ebola note if there's any possibility of confusion, 6480 We will get an Ebola note if there's any possibility of confusion,
6543 but that seems unlikely. */ 6481 but that seems unlikely. */
6544 6482
6555 return 0; 6493 return 0;
6556 6494
6557 return internal_equal (obj1, obj2, depth); 6495 return internal_equal (obj1, obj2, depth);
6558 } 6496 }
6559 6497
6560 DEFUN ("equal", Fequal, 2, 2, 0, /* 6498 DEFUN ("old-member", Fold_member, 2, 2, 0, /*
6561 Return t if two Lisp objects have similar structure and contents. 6499 Return non-nil if ELT is an element of LIST. Comparison done with `old-equal'.
6562 They must have the same data type. 6500 The value is actually the tail of LIST whose car is ELT.
6563 Conses are compared by comparing the cars and the cdrs. 6501 This function is provided only for byte-code compatibility with v19.
6564 Vectors and strings are compared element by element. 6502 Do not use it.
6565 Numbers are compared by value. Symbols must match exactly. 6503 */
6566 */ 6504 (elt, list))
6567 (object1, object2)) 6505 {
6568 { 6506 EXTERNAL_LIST_LOOP_3 (list_elt, list, tail)
6569 return internal_equal (object1, object2, 0) ? Qt : Qnil; 6507 {
6570 } 6508 if (internal_old_equal (elt, list_elt, 0))
6571 6509 return tail;
6572 DEFUN ("equalp", Fequalp, 2, 2, 0, /* 6510 }
6573 Return t if two Lisp objects have similar structure and contents. 6511 return Qnil;
6574 6512 }
6575 This is like `equal', except that it accepts numerically equal 6513
6576 numbers of different types (float, integer, bignum, bigfloat), and also 6514 DEFUN ("old-memq", Fold_memq, 2, 2, 0, /*
6577 compares strings and characters case-insensitively. 6515 Return non-nil if ELT is an element of LIST. Comparison done with `old-eq'.
6578 6516 The value is actually the tail of LIST whose car is ELT.
6579 Type objects that are arrays (that is, strings, bit-vectors, and vectors) 6517 This function is provided only for byte-code compatibility with v19.
6580 of the same length and with contents that are `equalp' are themselves 6518 Do not use it.
6581 `equalp', regardless of whether the two objects have the same type. 6519 */
6582 6520 (elt, list))
6583 Other objects whose primary purpose is as containers of other objects are 6521 {
6584 `equalp' if they would otherwise be equal (same length, type, etc.) and 6522 EXTERNAL_LIST_LOOP_3 (list_elt, list, tail)
6585 their contents are `equalp'. This goes for conses, weak lists, 6523 {
6586 weak boxes, ephemerons, specifiers, hash tables, char tables and range 6524 if (HACKEQ_UNSAFE (elt, list_elt))
6587 tables. However, objects that happen to contain other objects but are not 6525 return tail;
6588 primarily designed for this purpose (e.g. compiled functions, events or 6526 }
6589 display-related objects such as glyphs, faces or extents) are currently 6527 return Qnil;
6590 compared using `equalp' the same way as using `equal'. 6528 }
6591 6529
6592 More specifically, two hash tables are `equalp' if they have the same test 6530 DEFUN ("old-assoc", Fold_assoc, 2, 2, 0, /*
6593 (see `hash-table-test'), the same number of entries, and the same value for 6531 Return non-nil if KEY is `old-equal' to the car of an element of ALIST.
6594 `hash-table-weakness', and if, for each entry in one hash table, its key is 6532 The value is actually the element of ALIST whose car equals KEY.
6595 equivalent to a key in the other hash table using the hash table test, and 6533 */
6596 its value is `equalp' to the other hash table's value for that key. 6534 (key, alist))
6597 */ 6535 {
6598 (object1, object2)) 6536 /* This function can GC. */
6599 { 6537 EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, alist)
6600 return internal_equalp (object1, object2, 0) ? Qt : Qnil; 6538 {
6539 if (internal_old_equal (key, elt_car, 0))
6540 return elt;
6541 }
6542 return Qnil;
6543 }
6544
6545 DEFUN ("old-assq", Fold_assq, 2, 2, 0, /*
6546 Return non-nil if KEY is `old-eq' to the car of an element of ALIST.
6547 The value is actually the element of ALIST whose car is KEY.
6548 Elements of ALIST that are not conses are ignored.
6549 This function is provided only for byte-code compatibility with v19.
6550 Do not use it.
6551 */
6552 (key, alist))
6553 {
6554 EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, alist)
6555 {
6556 if (HACKEQ_UNSAFE (key, elt_car))
6557 return elt;
6558 }
6559 return Qnil;
6560 }
6561
6562 DEFUN ("old-rassoc", Fold_rassoc, 2, 2, 0, /*
6563 Return non-nil if VALUE is `old-equal' to the cdr of an element of ALIST.
6564 The value is actually the element of ALIST whose cdr equals VALUE.
6565 */
6566 (value, alist))
6567 {
6568 EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, alist)
6569 {
6570 if (internal_old_equal (value, elt_cdr, 0))
6571 return elt;
6572 }
6573 return Qnil;
6574 }
6575
6576 DEFUN ("old-delete", Fold_delete, 2, 2, 0, /*
6577 Delete by side effect any occurrences of ELT as a member of LIST.
6578 The modified LIST is returned. Comparison is done with `old-equal'.
6579 If the first member of LIST is ELT, there is no way to remove it by side
6580 effect; therefore, write `(setq foo (old-delete element foo))' to be sure
6581 of changing the value of `foo'.
6582 */
6583 (elt, list))
6584 {
6585 EXTERNAL_LIST_LOOP_DELETE_IF (list_elt, list,
6586 (internal_old_equal (elt, list_elt, 0)));
6587 return list;
6588 }
6589
6590 DEFUN ("old-delq", Fold_delq, 2, 2, 0, /*
6591 Delete by side effect any occurrences of ELT as a member of LIST.
6592 The modified LIST is returned. Comparison is done with `old-eq'.
6593 If the first member of LIST is ELT, there is no way to remove it by side
6594 effect; therefore, write `(setq foo (old-delq element foo))' to be sure of
6595 changing the value of `foo'.
6596 */
6597 (elt, list))
6598 {
6599 EXTERNAL_LIST_LOOP_DELETE_IF (list_elt, list,
6600 (HACKEQ_UNSAFE (elt, list_elt)));
6601 return list;
6601 } 6602 }
6602 6603
6603 DEFUN ("old-equal", Fold_equal, 2, 2, 0, /* 6604 DEFUN ("old-equal", Fold_equal, 2, 2, 0, /*
6604 Return t if two Lisp objects have similar structure and contents. 6605 Return t if two Lisp objects have similar structure and contents.
6605 They must have the same data type. 6606 They must have the same data type.
6611 */ 6612 */
6612 (object1, object2)) 6613 (object1, object2))
6613 { 6614 {
6614 return internal_old_equal (object1, object2, 0) ? Qt : Qnil; 6615 return internal_old_equal (object1, object2, 0) ? Qt : Qnil;
6615 } 6616 }
6617
6618 DEFUN ("old-eq", Fold_eq, 2, 2, 0, /*
6619 Return t if the two args are (in most cases) the same Lisp object.
6620
6621 Special kludge: A character is considered `old-eq' to its equivalent integer
6622 even though they are not the same object and are in fact of different
6623 types. This is ABSOLUTELY AND UTTERLY HORRENDOUS but is necessary to
6624 preserve byte-code compatibility with v19. This kludge is known as the
6625 \"char-int confoundance disease\" and appears in a number of other
6626 functions with `old-foo' equivalents.
6627
6628 Do not use this function!
6629 */
6630 (object1, object2))
6631 {
6632 /* #### blasphemy */
6633 return HACKEQ_UNSAFE (object1, object2) ? Qt : Qnil;
6634 }
6635
6636 #endif
6616 6637
6617 6638
6618 static Lisp_Object replace_string_range_1 (Lisp_Object dest, 6639 static Lisp_Object replace_string_range_1 (Lisp_Object dest,
6619 Lisp_Object start, 6640 Lisp_Object start,
6620 Lisp_Object end, 6641 Lisp_Object end,
11796 DEFSUBR (Felt); 11817 DEFSUBR (Felt);
11797 DEFSUBR (Flast); 11818 DEFSUBR (Flast);
11798 DEFSUBR (Fbutlast); 11819 DEFSUBR (Fbutlast);
11799 DEFSUBR (Fnbutlast); 11820 DEFSUBR (Fnbutlast);
11800 DEFSUBR (Fmember); 11821 DEFSUBR (Fmember);
11801 DEFSUBR (Fold_member);
11802 DEFSUBR (Fmemq); 11822 DEFSUBR (Fmemq);
11803 DEFSUBR (Fold_memq);
11804 DEFSUBR (FmemberX); 11823 DEFSUBR (FmemberX);
11805 DEFSUBR (Fadjoin); 11824 DEFSUBR (Fadjoin);
11806 DEFSUBR (Fassoc); 11825 DEFSUBR (Fassoc);
11807 DEFSUBR (Fold_assoc);
11808 DEFSUBR (Fassq); 11826 DEFSUBR (Fassq);
11809 DEFSUBR (Fold_assq);
11810 DEFSUBR (Frassoc); 11827 DEFSUBR (Frassoc);
11811 DEFSUBR (Fold_rassoc);
11812 DEFSUBR (Frassq); 11828 DEFSUBR (Frassq);
11813 DEFSUBR (Fold_rassq);
11814 11829
11815 DEFSUBR (Fposition); 11830 DEFSUBR (Fposition);
11816 DEFSUBR (Ffind); 11831 DEFSUBR (Ffind);
11817 11832
11818 DEFSUBR (Fold_delete);
11819 DEFSUBR (Fold_delq);
11820 DEFSUBR (FdeleteX); 11833 DEFSUBR (FdeleteX);
11821 DEFSUBR (FremoveX); 11834 DEFSUBR (FremoveX);
11822 DEFSUBR (Fremassoc); 11835 DEFSUBR (Fremassoc);
11823 DEFSUBR (Fremassq); 11836 DEFSUBR (Fremassq);
11824 DEFSUBR (Fremrassoc); 11837 DEFSUBR (Fremrassoc);
11851 DEFSUBR (Fremprop); 11864 DEFSUBR (Fremprop);
11852 DEFSUBR (Fobject_plist); 11865 DEFSUBR (Fobject_plist);
11853 DEFSUBR (Fobject_setplist); 11866 DEFSUBR (Fobject_setplist);
11854 DEFSUBR (Fequal); 11867 DEFSUBR (Fequal);
11855 DEFSUBR (Fequalp); 11868 DEFSUBR (Fequalp);
11869 DEFSUBR (Ffill);
11870
11871 #ifdef SUPPORT_CONFOUNDING_FUNCTIONS
11872 DEFSUBR (Fold_member);
11873 DEFSUBR (Fold_memq);
11874 DEFSUBR (Fold_assoc);
11875 DEFSUBR (Fold_assq);
11876 DEFSUBR (Fold_rassoc);
11877 DEFSUBR (Fold_rassq);
11878 DEFSUBR (Fold_delete);
11879 DEFSUBR (Fold_delq);
11856 DEFSUBR (Fold_equal); 11880 DEFSUBR (Fold_equal);
11857 DEFSUBR (Ffill); 11881 DEFSUBR (Fold_eq);
11882 #endif
11858 11883
11859 DEFSUBR (FassocX); 11884 DEFSUBR (FassocX);
11860 DEFSUBR (FrassocX); 11885 DEFSUBR (FrassocX);
11861 11886
11862 DEFSUBR (Fnconc); 11887 DEFSUBR (Fnconc);