1 /* Random utility Lisp functions.
2 Copyright (C) 1985, 86, 87, 93, 94, 95 Free Software Foundation, Inc.
3 Copyright (C) 1995, 1996 Ben Wing.
5 This file is part of SXEmacs
7 SXEmacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 SXEmacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* Synched up with: Mule 2.0, FSF 19.30. */
23 /* This file has been Mule-ized. */
25 /* Note: FSF 19.30 has bool vectors. We have bit vectors. */
27 /* Hacked on for Mule by Ben Wing, December 1994, January 1995. */
31 /* Note on some machines this defines `vector' as a typedef,
32 so make sure we don't use that name in this file. */
42 #include "ui/device.h"
43 #include "events/events.h"
47 #include "ui/insdel.h"
49 /* for the categorial views */
52 /* for all the map* funs */
56 /* NOTE: This symbol is also used in lread.c */
57 #define FEATUREP_SYNTAX
59 Lisp_Object Qstring_lessp, Qstring_greaterp;
60 Lisp_Object Qidentity;
62 static int internal_old_equal(Lisp_Object, Lisp_Object, int);
63 Lisp_Object safe_copy_tree(Lisp_Object arg, Lisp_Object vecp, int depth);
64 int internal_equalp(Lisp_Object, Lisp_Object, int);
66 static Lisp_Object mark_bit_vector(Lisp_Object obj)
72 print_bit_vector(Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
75 Lisp_Bit_Vector *v = XBIT_VECTOR(obj);
76 size_t len = bit_vector_length(v);
79 if (INTP(Vprint_length))
80 last = min((EMACS_INT) len, XINT(Vprint_length));
81 write_c_string("#*", printcharfun);
82 for (i = 0; i < last; i++) {
83 if (bit_vector_bit(v, i))
84 write_c_string("1", printcharfun);
86 write_c_string("0", printcharfun);
90 write_c_string("...", printcharfun);
93 static int bit_vector_equal(Lisp_Object obj1, Lisp_Object obj2, int depth)
95 Lisp_Bit_Vector *v1 = XBIT_VECTOR(obj1);
96 Lisp_Bit_Vector *v2 = XBIT_VECTOR(obj2);
98 return ((bit_vector_length(v1) == bit_vector_length(v2)) &&
99 !memcmp(v1->bits, v2->bits,
100 BIT_VECTOR_LONG_STORAGE(bit_vector_length(v1)) *
104 static unsigned long bit_vector_hash(Lisp_Object obj, int depth)
106 Lisp_Bit_Vector *v = XBIT_VECTOR(obj);
107 return HASH2(bit_vector_length(v),
109 BIT_VECTOR_LONG_STORAGE(bit_vector_length(v)) *
113 static size_t size_bit_vector(const void *lheader)
115 const Lisp_Bit_Vector *v = (const Lisp_Bit_Vector *) lheader;
116 return FLEXIBLE_ARRAY_STRUCT_SIZEOF(Lisp_Bit_Vector, unsigned long,
118 BIT_VECTOR_LONG_STORAGE
119 (bit_vector_length(v)));
122 static const struct lrecord_description bit_vector_description[] = {
123 {XD_LISP_OBJECT, offsetof(Lisp_Bit_Vector, next)},
127 DEFINE_BASIC_LRECORD_SEQUENCE_IMPLEMENTATION("bit-vector", bit_vector,
128 mark_bit_vector, print_bit_vector,
131 bit_vector_description,
132 size_bit_vector, Lisp_Bit_Vector);
134 DEFUN("identity", Fidentity, 1, 1, 0, /*
135 Return the argument unchanged.
142 extern long get_random(void);
143 extern void seed_random(long arg);
145 DEFUN("random", Frandom, 0, 1, 0, /*
146 Return a pseudo-random number.
147 All integers representable in Lisp are equally likely.
148 On most systems, this is 31 bits' worth.
150 With positive integer argument LIMIT, return random number
151 in interval [0,LIMIT). LIMIT can be a big integer, in which
152 case the range of possible values is extended.
154 With argument t, set the random number seed from the
155 current time and pid.
160 unsigned long denominator;
163 seed_random(getpid() + time(NULL));
164 if (NATNUMP(limit) && !ZEROP(limit)) {
165 /* Try to take our random number from the higher bits of VAL,
166 not the lower, since (says Gentzel) the low bits of `random'
167 are less random than the higher ones. We do this by using the
168 quotient rather than the remainder. At the high end of the RNG
169 it's possible to get a quotient larger than limit; discarding
170 these values eliminates the bias that would otherwise appear
171 when using a large limit. */
172 denominator = ((unsigned long)1 << INT_VALBITS) / XINT(limit);
174 val = get_random() / denominator;
175 while (val >= XINT(limit));
176 } else if (ZEROP(limit)) {
177 return wrong_type_argument(Qpositivep, limit);
178 #if defined HAVE_MPZ && defined WITH_GMP
179 } else if (BIGZP(limit)) {
183 if (bigz_sign(XBIGZ_DATA(limit)) <= 0)
184 return wrong_type_argument(Qpositivep, limit);
188 bigz_random(bz, XBIGZ_DATA(limit));
189 result = ent_mpz_downgrade_maybe(bz);
193 #endif /* HAVE_MPZ */
197 return make_int(val);
200 #if defined(WITH_GMP) && defined(HAVE_MPZ)
201 DEFUN("randomb", Frandomb, 1, 1, 0, /*
202 Return a uniform pseudo-random number in the range [0, 2^LIMIT).
210 CHECK_INTEGER(limit);
212 if (NILP(Fnonnegativep(limit)))
213 return wrong_type_argument(Qnonnegativep, limit);
214 else if (INTP(limit))
216 else if (BIGZP(limit) && bigz_fits_ulong_p(XBIGZ_DATA(limit)))
217 limui = bigz_to_ulong(XBIGZ_DATA(limit));
219 return wrong_type_argument(Qintegerp, limit);
223 mpz_urandomb(bz, random_state, limui);
224 result = make_bigz_bz(bz);
229 #endif /* HAVE_MPZ */
232 /* Random data-structure functions */
234 #ifdef LOSING_BYTECODE
236 /* #### Delete this shit */
238 /* Charcount is a misnomer here as we might be dealing with the
239 length of a vector or list, but emphasizes that we're not dealing
240 with Bytecounts in strings */
241 static Charcount length_with_bytecode_hack(Lisp_Object seq)
243 if (!COMPILED_FUNCTIONP(seq))
244 return XINT(Flength(seq));
246 Lisp_Compiled_Function *f = XCOMPILED_FUNCTION(seq);
248 return (f->flags.interactivep ? COMPILED_INTERACTIVE :
249 f->flags.domainp ? COMPILED_DOMAIN :
255 #endif /* LOSING_BYTECODE */
257 void check_losing_bytecode(const char *function, Lisp_Object seq)
259 if (COMPILED_FUNCTIONP(seq))
262 "As of 20.3, `%s' no longer works with compiled-function objects",
266 DEFUN("length", Flength, 1, 1, 0, /*
267 Return the length of vector, bit vector, list or string SEQUENCE.
272 /* that's whither we have to get */
273 if (LIKELY(!NILP(sequence))) {
274 return make_int(seq_length((seq_t)sequence));
280 if (LIKELY(STRINGP(sequence) ||
284 BIT_VECTORP(sequence))) {
285 return make_int(seq_length(sequence));
286 } else if (NILP(sequence)) {
289 check_losing_bytecode("length", sequence);
290 sequence = wrong_type_argument(Qsequencep, sequence);
295 if (STRINGP(sequence))
296 return make_int(XSTRING_CHAR_LENGTH(sequence));
297 else if (CONSP(sequence)) {
298 return make_int(seq_length(sequence));
299 } else if (VECTORP(sequence))
300 return make_int(seq_length(sequence));
301 else if (DLLISTP(sequence))
302 return make_int(XDLLIST_SIZE(sequence));
303 else if (NILP(sequence))
305 else if (BIT_VECTORP(sequence))
306 return make_int(bit_vector_length(XBIT_VECTOR(sequence)));
308 check_losing_bytecode("length", sequence);
309 sequence = wrong_type_argument(Qsequencep, sequence);
315 DEFUN("safe-length", Fsafe_length, 1, 1, 0, /*
316 Return the length of a list, but avoid error or infinite loop.
317 This function never gets an error. If LIST is not really a list,
318 it returns 0. If LIST is circular, it returns a finite value
319 which is at least the number of distinct elements.
323 Lisp_Object hare, tortoise;
326 for (hare = tortoise = list, len = 0;
327 CONSP(hare) && (!EQ(hare, tortoise) || len == 0);
328 hare = XCDR(hare), len++) {
330 tortoise = XCDR(tortoise);
333 return make_int(len);
336 /*** string functions. ***/
338 DEFUN("string-equal", Fstring_equal, 2, 2, 0, /*
339 Return t if two strings have identical contents.
340 Case is significant. Text properties are ignored.
341 \(Under SXEmacs, `equal' also ignores text properties and extents in
342 strings, but this is not the case under FSF Emacs 19. In FSF Emacs 20
343 `equal' is the same as in SXEmacs, in that respect.)
344 Symbols are also allowed; their print names are used instead.
349 Lisp_String *p1, *p2;
351 if (SYMBOLP(string1))
352 p1 = XSYMBOL(string1)->name;
354 CHECK_STRING(string1);
355 p1 = XSTRING(string1);
358 if (SYMBOLP(string2))
359 p2 = XSYMBOL(string2)->name;
361 CHECK_STRING(string2);
362 p2 = XSTRING(string2);
365 return (((len = string_length(p1)) == string_length(p2)) &&
366 !memcmp(string_data(p1), string_data(p2), len)) ? Qt : Qnil;
369 DEFUN("string-lessp", Fstring_lessp, 2, 2, 0, /*
370 Return t if first arg string is less than second in lexicographic order.
371 If I18N2 support (but not Mule support) was compiled in, ordering is
372 determined by the locale. (Case is significant for the default C locale.)
373 In all other cases, comparison is simply done on a character-by-
374 character basis using the numeric value of a character. (Note that
375 this may not produce particularly meaningful results under Mule if
376 characters from different charsets are being compared.)
378 Symbols are also allowed; their print names are used instead.
380 The reason that the I18N2 locale-specific collation is not used under
381 Mule is that the locale model of internationalization does not handle
382 multiple charsets and thus has no hope of working properly under Mule.
383 What we really should do is create a collation table over all built-in
384 charsets. This is extremely difficult to do from scratch, however.
386 Unicode is a good first step towards solving this problem. In fact,
387 it is quite likely that a collation table exists (or will exist) for
388 Unicode. When Unicode support is added to SXEmacs/Mule, this problem
393 Lisp_String *p1, *p2;
397 if (SYMBOLP(string1))
398 p1 = XSYMBOL(string1)->name;
400 CHECK_STRING(string1);
401 p1 = XSTRING(string1);
404 if (SYMBOLP(string2))
405 p2 = XSYMBOL(string2)->name;
407 CHECK_STRING(string2);
408 p2 = XSTRING(string2);
411 end = string_char_length(p1);
412 len2 = string_char_length(p2);
416 #if defined (I18N2) && !defined (MULE)
417 /* There is no hope of this working under Mule. Even if we converted
418 the data into an external format so that strcoll() processed it
419 properly, it would still not work because strcoll() does not
420 handle multiple locales. This is the fundamental flaw in the
423 Bytecount bcend = charcount_to_bytecount(string_data(p1), end);
424 /* Compare strings using collation order of locale. */
425 /* Need to be tricky to handle embedded nulls. */
427 for (i = 0; i < bcend;
428 i += strlen((char *)string_data(p1) + i) + 1) {
429 int val = strcoll((char *)string_data(p1) + i,
430 (char *)string_data(p2) + i);
437 #else /* not I18N2, or MULE */
439 Bufbyte *ptr1 = string_data(p1);
440 Bufbyte *ptr2 = string_data(p2);
442 /* #### It is not really necessary to do this: We could compare
443 byte-by-byte and still get a reasonable comparison, since this
444 would compare characters with a charset in the same way. With
445 a little rearrangement of the leading bytes, we could make most
446 inter-charset comparisons work out the same, too; even if some
447 don't, this is not a big deal because inter-charset comparisons
448 aren't really well-defined anyway. */
449 for (i = 0; i < end; i++) {
450 if (charptr_emchar(ptr1) != charptr_emchar(ptr2))
451 return charptr_emchar(ptr1) <
452 charptr_emchar(ptr2) ? Qt : Qnil;
457 #endif /* not I18N2, or MULE */
458 /* Can't do i < len2 because then comparison between "foo" and "foo^@"
459 won't work right in I18N2 case */
460 return end < len2 ? Qt : Qnil;
463 DEFUN("string-greaterp", Fstring_greaterp, 2, 2, 0, /*
464 Return t if first arg string is greater than second in lexicographic order.
465 If I18N2 support (but not Mule support) was compiled in, ordering is
466 determined by the locale. (Case is significant for the default C locale.)
467 In all other cases, comparison is simply done on a character-by-
468 character basis using the numeric value of a character. (Note that
469 this may not produce particularly meaningful results under Mule if
470 characters from different charsets are being compared.)
472 Symbols are also allowed; their print names are used instead.
474 The reason that the I18N2 locale-specific collation is not used under
475 Mule is that the locale model of internationalization does not handle
476 multiple charsets and thus has no hope of working properly under Mule.
477 What we really should do is create a collation table over all built-in
478 charsets. This is extremely difficult to do from scratch, however.
480 Unicode is a good first step towards solving this problem. In fact,
481 it is quite likely that a collation table exists (or will exist) for
482 Unicode. When Unicode support is added to SXEmacs/Mule, this problem
487 return Fstring_lessp(string2, string1);
490 DEFUN("string-modified-tick", Fstring_modified_tick, 1, 1, 0, /*
491 Return STRING's tick counter, incremented for each change to the string.
492 Each string has a tick counter which is incremented each time the contents
493 of the string are changed (e.g. with `aset'). It wraps around occasionally.
499 CHECK_STRING(string);
501 if (CONSP(s->plist) && INTP(XCAR(s->plist)))
502 return XCAR(s->plist);
507 void bump_string_modiff(Lisp_Object str)
509 Lisp_String *s = XSTRING(str);
510 Lisp_Object *ptr = &s->plist;
513 /* #### remove the `string-translatable' property from the string,
516 /* skip over extent info if it's there */
517 if (CONSP(*ptr) && EXTENT_INFOP(XCAR(*ptr)))
519 if (CONSP(*ptr) && INTP(XCAR(*ptr)))
520 XSETINT(XCAR(*ptr), 1 + XINT(XCAR(*ptr)));
522 *ptr = Fcons(make_int(1), *ptr);
525 enum concat_target_type { c_cons, c_string, c_vector, c_bit_vector, c_dllist };
526 static Lisp_Object concat(int nargs, Lisp_Object * args,
527 enum concat_target_type target_type,
530 Lisp_Object concat2(Lisp_Object string1, Lisp_Object string2)
535 return concat(2, args, c_string, 0);
539 concat3(Lisp_Object string1, Lisp_Object string2, Lisp_Object string3)
545 return concat(3, args, c_string, 0);
548 Lisp_Object vconcat2(Lisp_Object vec1, Lisp_Object vec2)
553 return concat(2, args, c_vector, 0);
556 Lisp_Object vconcat3(Lisp_Object vec1, Lisp_Object vec2, Lisp_Object vec3)
562 return concat(3, args, c_vector, 0);
565 DEFUN("append", Fappend, 0, MANY, 0, /*
566 Concatenate all the arguments and make the result a list.
567 The result is a list whose elements are the elements of all the arguments.
568 Each argument may be a list, vector, bit vector, or string.
569 The last argument is not copied, just used as the tail of the new list.
572 (int nargs, Lisp_Object * args))
574 return concat(nargs, args, c_cons, 1);
577 DEFUN("concat", Fconcat, 0, MANY, 0, /*
578 Concatenate all the arguments and make the result a string.
579 The result is a string whose elements are the elements of all the arguments.
580 Each argument may be a string or a list or vector of characters.
582 As of XEmacs 21.0, this function does NOT accept individual integers
583 as arguments. Old code that relies on, for example, (concat "foo" 50)
584 returning "foo50" will fail. To fix such code, either apply
585 `int-to-string' to the integer argument, or use `format'.
587 (int nargs, Lisp_Object * args))
589 return concat(nargs, args, c_string, 0);
592 DEFUN("vconcat", Fvconcat, 0, MANY, 0, /*
593 Concatenate all the arguments and make the result a vector.
594 The result is a vector whose elements are the elements of all the arguments.
595 Each argument may be a list, vector, bit vector, or string.
597 (int nargs, Lisp_Object * args))
599 return concat(nargs, args, c_vector, 0);
602 DEFUN("bvconcat", Fbvconcat, 0, MANY, 0, /*
603 Concatenate all the arguments and make the result a bit vector.
604 The result is a bit vector whose elements are the elements of all the
605 arguments. Each argument may be a list, vector, bit vector, or string.
607 (int nargs, Lisp_Object * args))
609 return concat(nargs, args, c_bit_vector, 0);
612 /* Copy a (possibly dotted) list. LIST must be a cons.
613 Can't use concat (1, &alist, c_cons, 0) - doesn't handle dotted lists. */
614 static Lisp_Object copy_list(Lisp_Object list)
616 Lisp_Object list_copy = Fcons(XCAR(list), XCDR(list));
617 Lisp_Object last = list_copy;
618 Lisp_Object hare, tortoise;
621 for (tortoise = hare = XCDR(list), len = 1;
622 CONSP(hare); hare = XCDR(hare), len++) {
623 XCDR(last) = Fcons(XCAR(hare), XCDR(hare));
626 if (len < CIRCULAR_LIST_SUSPICION_LENGTH)
629 tortoise = XCDR(tortoise);
630 if (EQ(tortoise, hare))
631 signal_circular_list_error(list);
637 DEFUN("copy-list", Fcopy_list, 1, 1, 0, /*
638 Return a copy of list LIST, which may be a dotted list.
639 The elements of LIST are not copied; they are shared
648 return copy_list(list);
650 list = wrong_type_argument(Qlistp, list);
654 DEFUN("copy-sequence", Fcopy_sequence, 1, 1, 0, /*
655 Return a copy of list, dllist, vector, bit vector or string SEQUENCE.
656 The elements of a list or vector are not copied; they are shared
657 with the original. SEQUENCE may be a dotted list.
665 return copy_list(sequence);
666 if (DLLISTP(sequence))
667 return Fcopy_dllist(sequence);
668 if (STRINGP(sequence))
669 return concat(1, &sequence, c_string, 0);
670 if (VECTORP(sequence))
671 return concat(1, &sequence, c_vector, 0);
672 if (BIT_VECTORP(sequence))
673 return concat(1, &sequence, c_bit_vector, 0);
675 check_losing_bytecode("copy-sequence", sequence);
676 sequence = wrong_type_argument(Qsequencep, sequence);
680 struct merge_string_extents_struct {
682 Bytecount entry_offset;
683 Bytecount entry_length;
687 concat(int nargs, Lisp_Object * args,
688 enum concat_target_type target_type, int last_special)
691 Lisp_Object tail = Qnil;
694 Lisp_Object last_tail;
696 struct merge_string_extents_struct *args_mse = 0;
697 Bufbyte *string_result = NULL;
698 Bufbyte *string_result_ptr = NULL;
700 int speccount = specpdl_depth();
701 Charcount total_length;
704 /* The modus operandi in Emacs is "caller gc-protects args".
705 However, concat is called many times in Emacs on freshly
706 created stuff. So we help those callers out by protecting
707 the args ourselves to save them a lot of temporary-variable
713 /* #### if the result is a string and any of the strings have a string
714 for the `string-translatable' property, then concat should also
715 concat the args but use the `string-translatable' strings, and store
716 the result in the returned string's `string-translatable' property. */
718 if (target_type == c_string)
719 XMALLOC_OR_ALLOCA(args_mse, nargs, struct merge_string_extents_struct);
721 /* In append, the last arg isn't treated like the others */
722 if (last_special && nargs > 0) {
724 last_tail = args[nargs];
728 /* Check and coerce the arguments. */
729 for (argnum = 0; argnum < nargs; argnum++) {
730 Lisp_Object seq = args[argnum];
731 if (LISTP(seq) || DLLISTP(seq)) ;
732 else if (VECTORP(seq) || STRINGP(seq) || BIT_VECTORP(seq)) ;
733 #ifdef LOSING_BYTECODE
734 else if (COMPILED_FUNCTIONP(seq))
735 /* Urk! We allow this, for "compatibility"... */
738 #if 0 /* removed for XEmacs 21 */
740 /* This is too revolting to think about but maintains
741 compatibility with FSF (and lots and lots of old code). */
742 args[argnum] = Fnumber_to_string(seq);
745 check_losing_bytecode("concat", seq);
746 args[argnum] = wrong_type_argument(Qsequencep, seq);
751 args_mse[argnum].string = seq;
753 args_mse[argnum].string = Qnil;
758 /* Charcount is a misnomer here as we might be dealing with the
759 length of a vector or list, but emphasizes that we're not dealing
760 with Bytecounts in strings */
761 /* Charcount total_length; */
763 for (argnum = 0, total_length = 0; argnum < nargs; argnum++) {
764 #ifdef LOSING_BYTECODE
766 length_with_bytecode_hack(args[argnum]);
768 Charcount thislen = XINT(Flength(args[argnum]));
770 total_length += thislen;
773 switch (target_type) {
775 if (total_length == 0) {
776 /* In append, if all but last arg are nil,
778 XMALLOC_UNBIND(args_mse, nargs, speccount);
779 RETURN_UNGCPRO(last_tail);
781 val = Fmake_list(make_int(total_length), Qnil);
784 if (total_length == 0) {
785 /* In append, if all but last arg are nil,
787 XMALLOC_UNBIND(args_mse, nargs, speccount);
788 RETURN_UNGCPRO(last_tail);
790 val = Fmake_list(make_int(total_length), Qnil);
793 val = make_vector(total_length, Qnil);
796 val = make_bit_vector(total_length, Qzero);
799 /* We don't make the string yet because we don't know
800 the actual number of bytes. This loop was formerly
801 written to call Fmake_string() here and then call
802 set_string_char() for each char. This seems logical
803 enough but is waaaaaaaay slow -- set_string_char()
804 has to scan the whole string up to the place where
805 the substitution is called for in order to find the
806 place to change, and may have to do some realloc()ing
807 in order to make the char fit properly. O(N^2)
810 XMALLOC_ATOMIC_OR_ALLOCA( string_result,
811 total_length * MAX_EMCHAR_LEN,
813 string_result_ptr = string_result;
822 tail = val, toindex = -1; /* -1 in toindex is flag we are
829 for (argnum = 0; argnum < nargs; argnum++) {
830 Charcount thisleni = 0;
831 Charcount thisindex = 0;
832 Lisp_Object seq = args[argnum];
833 Bufbyte *string_source_ptr = 0;
834 Bufbyte *string_prev_result_ptr = string_result_ptr;
837 #ifdef LOSING_BYTECODE
838 thisleni = length_with_bytecode_hack(seq);
840 thisleni = XINT(Flength(seq));
844 string_source_ptr = XSTRING_DATA(seq);
849 /* We've come to the end of this arg, so exit. */
853 /* Fetch next element of `seq' arg into `elt' */
858 if (thisindex >= thisleni)
863 make_char(charptr_emchar
864 (string_source_ptr));
865 INC_CHARPTR(string_source_ptr);
866 } else if (VECTORP(seq))
867 elt = XVECTOR_DATA(seq)[thisindex];
868 else if (BIT_VECTORP(seq))
870 make_int(bit_vector_bit
874 elt = Felt(seq, make_int(thisindex));
878 /* Store into result */
880 /* toindex negative means we are making a list */
884 } else if (VECTORP(val))
885 XVECTOR_DATA(val)[toindex++] = elt;
886 else if (BIT_VECTORP(val)) {
888 set_bit_vector_bit(XBIT_VECTOR(val), toindex++,
891 CHECK_CHAR_COERCE_INT(elt);
892 if(string_result_ptr != NULL) {
894 set_charptr_emchar(string_result_ptr,
902 args_mse[argnum].entry_offset =
903 string_prev_result_ptr - string_result;
904 args_mse[argnum].entry_length =
905 string_result_ptr - string_prev_result_ptr;
909 /* Now we finally make the string. */
910 if (target_type == c_string) {
912 make_string(string_result,
913 string_result_ptr - string_result);
914 if (args_mse != NULL) {
915 for (argnum = 0; argnum < nargs; argnum++) {
916 if (STRINGP(args_mse[argnum].string))
917 copy_string_extents(val,
918 args_mse[argnum].string,
924 XMALLOC_UNBIND(string_result,
925 total_length * MAX_EMCHAR_LEN, speccount);
926 XMALLOC_UNBIND(args_mse, nargs, speccount);
933 XCDR(prev) = last_tail;
938 DEFUN("copy-alist", Fcopy_alist, 1, 1, 0, /*
939 Return a copy of ALIST.
940 This is an alist which represents the same mapping from objects to objects,
941 but does not share the alist structure with ALIST.
942 The objects mapped (cars and cdrs of elements of the alist)
944 Elements of ALIST that are not conses are also shared.
954 alist = concat(1, &alist, c_cons, 0);
955 for (tail = alist; CONSP(tail); tail = XCDR(tail)) {
956 Lisp_Object car = XCAR(tail);
959 XCAR(tail) = Fcons(XCAR(car), XCDR(car));
964 DEFUN("copy-tree", Fcopy_tree, 1, 2, 0, /*
965 Return a copy of a list and substructures.
966 The argument is copied, and any lists contained within it are copied
967 recursively. Circularities and shared substructures are not preserved.
968 Second arg VECP causes vectors to be copied, too. Strings and bit vectors
973 return safe_copy_tree(arg, vecp, 0);
976 Lisp_Object safe_copy_tree(Lisp_Object arg, Lisp_Object vecp, int depth)
979 signal_simple_error("Stack overflow in copy-tree", arg);
983 rest = arg = Fcopy_sequence(arg);
984 while (CONSP(rest)) {
985 Lisp_Object elt = XCAR(rest);
987 if (CONSP(elt) || VECTORP(elt))
989 safe_copy_tree(elt, vecp, depth + 1);
990 if (VECTORP(XCDR(rest))) /* hack for (a b . [c d]) */
992 safe_copy_tree(XCDR(rest), vecp, depth + 1);
995 } else if (VECTORP(arg) && !NILP(vecp)) {
996 int i = XVECTOR_LENGTH(arg);
998 arg = Fcopy_sequence(arg);
999 for (j = 0; j < i; j++) {
1000 Lisp_Object elt = XVECTOR_DATA(arg)[j];
1002 if (CONSP(elt) || VECTORP(elt))
1003 XVECTOR_DATA(arg)[j] =
1004 safe_copy_tree(elt, vecp, depth + 1);
1010 DEFUN("substring", Fsubstring, 2, 3, 0, /*
1011 Return the substring of STRING starting at START and ending before END.
1012 END may be nil or omitted; then the substring runs to the end of STRING.
1013 If START or END is negative, it counts from the end.
1014 Relevant parts of the string-extent-data are copied to the new string.
1016 (string, start, end))
1018 Charcount ccstart, ccend;
1019 Bytecount bstart, blen;
1022 CHECK_STRING(string);
1024 get_string_range_char(string, start, end, &ccstart, &ccend,
1025 GB_HISTORICAL_STRING_BEHAVIOR);
1026 bstart = charcount_to_bytecount(XSTRING_DATA(string), ccstart);
1028 charcount_to_bytecount(XSTRING_DATA(string) + bstart,
1030 val = make_string(XSTRING_DATA(string) + bstart, blen);
1031 /* Copy any applicable extent information into the new string. */
1032 copy_string_extents(val, string, 0, bstart, blen);
1036 DEFUN("subseq", Fsubseq, 2, 3, 0, /*
1037 Return the subsequence of SEQUENCE starting at START and ending before END.
1038 END may be omitted; then the subsequence runs to the end of SEQUENCE.
1039 If START or END is negative, it counts from the end.
1040 The returned subsequence is always of the same type as SEQUENCE.
1041 If SEQUENCE is a string, relevant parts of the string-extent-data
1042 are copied to the new string.
1044 (sequence, start, end))
1046 EMACS_INT len, s, e;
1048 if (STRINGP(sequence))
1049 return Fsubstring(sequence, start, end);
1051 len = XINT(Flength(sequence));
1067 if (!(0 <= s && s <= e && e <= len))
1068 args_out_of_range_3(sequence, make_int(s), make_int(e));
1070 if (VECTORP(sequence)) {
1071 Lisp_Object result = make_vector(e - s, Qnil);
1073 Lisp_Object *in_elts = XVECTOR_DATA(sequence);
1074 Lisp_Object *out_elts = XVECTOR_DATA(result);
1076 for (i = s; i < e; i++)
1077 out_elts[i - s] = in_elts[i];
1079 } else if (LISTP(sequence)) {
1080 Lisp_Object result = Qnil;
1083 sequence = Fnthcdr(make_int(s), sequence);
1085 for (i = s; i < e; i++) {
1086 result = Fcons(Fcar(sequence), result);
1087 sequence = Fcdr(sequence);
1090 return Fnreverse(result);
1091 } else if (BIT_VECTORP(sequence)) {
1092 Lisp_Object result = make_bit_vector(e - s, Qzero);
1095 for (i = s; i < e; i++)
1096 set_bit_vector_bit(XBIT_VECTOR(result), i - s,
1097 bit_vector_bit(XBIT_VECTOR(sequence),
1101 abort(); /* unreachable, since Flength (sequence) did not get
1107 DEFUN("nthcdr", Fnthcdr, 2, 2, 0, /*
1108 Take cdr N times on LIST, and return the result.
1113 REGISTER Lisp_Object tail = list;
1115 for (i = XINT(n); i; i--) {
1118 else if (NILP(tail))
1121 tail = wrong_type_argument(Qlistp, tail);
1128 DEFUN("nth", Fnth, 2, 2, 0, /*
1129 Return the Nth element of LIST.
1130 N counts from zero. If LIST is not that long, nil is returned.
1134 return Fcar(Fnthcdr(n, list));
1137 DEFUN("elt", Felt, 2, 2, 0, /*
1138 Return element of SEQUENCE at index N.
1143 if (!(INTP(n) || CHARP(n))) {
1144 n = wrong_type_argument(Qinteger_or_char_p, n);
1148 if (LISTP(sequence)) {
1149 Lisp_Object tem = Fnthcdr(n, sequence);
1150 /* #### Utterly, completely, fucking disgusting.
1151 * #### The whole point of "elt" is that it operates on
1152 * #### sequences, and does error- (bounds-) checking.
1158 /* This is The Way It Has Always Been. */
1161 /* This is The Way Mly and Cltl2 say It Should Be. */
1162 args_out_of_range(sequence, n);
1164 } else if (DLLISTP(sequence)) {
1165 dllist_item_t elm = NULL;
1168 EMACS_INT rn = ent_int(n);
1171 args_out_of_range(sequence, n);
1175 if (rn * 2 < (EMACS_INT)XDLLIST_SIZE(sequence)) {
1176 /* start at the front */
1177 elm = XDLLIST_FIRST(sequence);
1180 /* start at the end */
1181 elm = XDLLIST_LAST(sequence);
1183 i = XDLLIST_SIZE(sequence) - rn - 1;
1186 for (; i > 0 && elm != NULL; i--)
1193 return (Lisp_Object)elm->item;
1197 } else if (STRINGP(sequence) ||
1198 VECTORP(sequence) || BIT_VECTORP(sequence))
1199 return Faref(sequence, n);
1200 #ifdef LOSING_BYTECODE
1201 else if (COMPILED_FUNCTIONP(sequence)) {
1202 EMACS_INT idx = ent_int(n);
1205 args_out_of_range(sequence, n);
1207 /* Utter perversity */
1209 Lisp_Compiled_Function *f =
1210 XCOMPILED_FUNCTION(sequence);
1212 case COMPILED_ARGLIST:
1213 return compiled_function_arglist(f);
1214 case COMPILED_INSTRUCTIONS:
1215 return compiled_function_instructions(f);
1216 case COMPILED_CONSTANTS:
1217 return compiled_function_constants(f);
1218 case COMPILED_STACK_DEPTH:
1219 return compiled_function_stack_depth(f);
1220 case COMPILED_DOC_STRING:
1221 return compiled_function_documentation(f);
1222 case COMPILED_DOMAIN:
1223 return compiled_function_domain(f);
1224 case COMPILED_INTERACTIVE:
1225 if (f->flags.interactivep)
1226 return compiled_function_interactive(f);
1227 /* if we return nil, can't tell interactive with no args
1228 from noninteractive. */
1235 #endif /* LOSING_BYTECODE */
1237 check_losing_bytecode("elt", sequence);
1238 sequence = wrong_type_argument(Qsequencep, sequence);
1243 DEFUN("last", Flast, 1, 2, 0, /*
1244 Return the tail of list LIST, of length N (default 1).
1245 LIST may be a dotted list, but not a circular list.
1246 Optional argument N must be a non-negative integer.
1247 If N is zero, then the atom that terminates the list is returned.
1248 If N is greater than the length of LIST, then LIST itself is returned.
1252 EMACS_INT int_n, count;
1253 Lisp_Object retval, tortoise, hare;
1256 return Fdllist_rac(list);
1267 for (retval = tortoise = hare = list, count = 0;
1270 (int_n-- <= 0 ? ((void)(retval = XCDR(retval))) : (void)0),
1272 if (count < CIRCULAR_LIST_SUSPICION_LENGTH)
1276 tortoise = XCDR(tortoise);
1277 if (EQ(hare, tortoise))
1278 signal_circular_list_error(list);
1284 DEFUN("nbutlast", Fnbutlast, 1, 2, 0, /*
1285 Modify LIST to remove the last N (default 1) elements.
1286 If LIST has N or fewer elements, nil is returned and LIST is unmodified.
1302 Lisp_Object last_cons = list;
1304 EXTERNAL_LIST_LOOP_1(list) {
1306 last_cons = XCDR(last_cons);
1312 XCDR(last_cons) = Qnil;
1317 DEFUN("butlast", Fbutlast, 1, 2, 0, /*
1318 Return a copy of LIST with the last N (default 1) elements removed.
1319 If LIST has N or fewer elements, nil is returned.
1335 Lisp_Object retval = Qnil;
1336 Lisp_Object tail = list;
1338 EXTERNAL_LIST_LOOP_1(list) {
1340 retval = Fcons(XCAR(tail), retval);
1345 return Fnreverse(retval);
1349 DEFUN("member", Fmember, 2, 2, 0, /*
1350 Return non-nil if ELT is an element of LIST. Comparison done with `equal'.
1351 The value is actually the tail of LIST whose car is ELT.
1355 EXTERNAL_LIST_LOOP_3(list_elt, list, tail) {
1356 if (internal_equal(elt, list_elt, 0))
1362 DEFUN("old-member", Fold_member, 2, 2, 0, /*
1363 Return non-nil if ELT is an element of LIST. Comparison done with `old-equal'.
1364 The value is actually the tail of LIST whose car is ELT.
1365 This function is provided only for byte-code compatibility with v19.
1370 EXTERNAL_LIST_LOOP_3(list_elt, list, tail) {
1371 if (internal_old_equal(elt, list_elt, 0))
1377 DEFUN("memq", Fmemq, 2, 2, 0, /*
1378 Return non-nil if ELT is an element of LIST. Comparison done with `eq'.
1379 The value is actually the tail of LIST whose car is ELT.
1383 EXTERNAL_LIST_LOOP_3(list_elt, list, tail) {
1384 if (EQ_WITH_EBOLA_NOTICE(elt, list_elt))
1390 DEFUN("old-memq", Fold_memq, 2, 2, 0, /*
1391 Return non-nil if ELT is an element of LIST. Comparison done with `old-eq'.
1392 The value is actually the tail of LIST whose car is ELT.
1393 This function is provided only for byte-code compatibility with v19.
1398 EXTERNAL_LIST_LOOP_3(list_elt, list, tail) {
1399 if (HACKEQ_UNSAFE(elt, list_elt))
1405 Lisp_Object memq_no_quit(Lisp_Object elt, Lisp_Object list)
1407 LIST_LOOP_3(list_elt, list, tail) {
1408 if (EQ_WITH_EBOLA_NOTICE(elt, list_elt))
1414 DEFUN("assoc", Fassoc, 2, 2, 0, /*
1415 Return non-nil if KEY is `equal' to the car of an element of ALIST.
1416 The value is actually the element of ALIST whose car equals KEY.
1420 /* This function can GC. */
1421 EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, alist) {
1422 if (internal_equal(key, elt_car, 0))
1428 DEFUN("old-assoc", Fold_assoc, 2, 2, 0, /*
1429 Return non-nil if KEY is `old-equal' to the car of an element of ALIST.
1430 The value is actually the element of ALIST whose car equals KEY.
1434 /* This function can GC. */
1435 EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, alist) {
1436 if (internal_old_equal(key, elt_car, 0))
1442 Lisp_Object assoc_no_quit(Lisp_Object key, Lisp_Object alist)
1444 int speccount = specpdl_depth();
1445 specbind(Qinhibit_quit, Qt);
1446 return unbind_to(speccount, Fassoc(key, alist));
1449 DEFUN("assq", Fassq, 2, 2, 0, /*
1450 Return non-nil if KEY is `eq' to the car of an element of ALIST.
1451 The value is actually the element of ALIST whose car is KEY.
1452 Elements of ALIST that are not conses are ignored.
1456 EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, alist) {
1457 if (EQ_WITH_EBOLA_NOTICE(key, elt_car))
1463 DEFUN("old-assq", Fold_assq, 2, 2, 0, /*
1464 Return non-nil if KEY is `old-eq' to the car of an element of ALIST.
1465 The value is actually the element of ALIST whose car is KEY.
1466 Elements of ALIST that are not conses are ignored.
1467 This function is provided only for byte-code compatibility with v19.
1472 EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, alist) {
1473 if (HACKEQ_UNSAFE(key, elt_car))
1479 /* Like Fassq but never report an error and do not allow quits.
1480 Use only on lists known never to be circular. */
1482 Lisp_Object assq_no_quit(Lisp_Object key, Lisp_Object alist)
1484 /* This cannot GC. */
1485 LIST_LOOP_2(elt, alist) {
1486 Lisp_Object elt_car = XCAR(elt);
1487 if (EQ_WITH_EBOLA_NOTICE(key, elt_car))
1493 DEFUN("rassoc", Frassoc, 2, 2, 0, /*
1494 Return non-nil if VALUE is `equal' to the cdr of an element of ALIST.
1495 The value is actually the element of ALIST whose cdr equals VALUE.
1499 EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, alist) {
1500 if (internal_equal(value, elt_cdr, 0))
1506 DEFUN("old-rassoc", Fold_rassoc, 2, 2, 0, /*
1507 Return non-nil if VALUE is `old-equal' to the cdr of an element of ALIST.
1508 The value is actually the element of ALIST whose cdr equals VALUE.
1512 EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, alist) {
1513 if (internal_old_equal(value, elt_cdr, 0))
1519 DEFUN("rassq", Frassq, 2, 2, 0, /*
1520 Return non-nil if VALUE is `eq' to the cdr of an element of ALIST.
1521 The value is actually the element of ALIST whose cdr is VALUE.
1525 EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, alist) {
1526 if (EQ_WITH_EBOLA_NOTICE(value, elt_cdr))
1532 DEFUN("old-rassq", Fold_rassq, 2, 2, 0, /*
1533 Return non-nil if VALUE is `old-eq' to the cdr of an element of ALIST.
1534 The value is actually the element of ALIST whose cdr is VALUE.
1538 EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, alist) {
1539 if (HACKEQ_UNSAFE(value, elt_cdr))
1545 /* Like Frassq, but caller must ensure that ALIST is properly
1546 nil-terminated and ebola-free. */
1547 Lisp_Object rassq_no_quit(Lisp_Object value, Lisp_Object alist)
1549 LIST_LOOP_2(elt, alist) {
1550 Lisp_Object elt_cdr = XCDR(elt);
1551 if (EQ_WITH_EBOLA_NOTICE(value, elt_cdr))
1557 DEFUN("delete", Fdelete, 2, 2, 0, /*
1558 Delete by side effect any occurrences of ELT as a member of LIST.
1559 The modified LIST is returned. Comparison is done with `equal'.
1560 If the first member of LIST is ELT, there is no way to remove it by side
1561 effect; therefore, write `(setq foo (delete element foo))' to be sure
1562 of changing the value of `foo'.
1567 EXTERNAL_LIST_LOOP_DELETE_IF(list_elt, list,
1568 (internal_equal(elt, list_elt, 0)));
1572 DEFUN("old-delete", Fold_delete, 2, 2, 0, /*
1573 Delete by side effect any occurrences of ELT as a member of LIST.
1574 The modified LIST is returned. Comparison is done with `old-equal'.
1575 If the first member of LIST is ELT, there is no way to remove it by side
1576 effect; therefore, write `(setq foo (old-delete element foo))' to be sure
1577 of changing the value of `foo'.
1581 EXTERNAL_LIST_LOOP_DELETE_IF(list_elt, list,
1582 (internal_old_equal(elt, list_elt, 0)));
1586 DEFUN("delq", Fdelq, 2, 2, 0, /*
1587 Delete by side effect any occurrences of ELT as a member of LIST.
1588 The modified LIST is returned. Comparison is done with `eq'.
1589 If the first member of LIST is ELT, there is no way to remove it by side
1590 effect; therefore, write `(setq foo (delq element foo))' to be sure of
1591 changing the value of `foo'.
1595 EXTERNAL_LIST_LOOP_DELETE_IF(list_elt, list,
1596 (EQ_WITH_EBOLA_NOTICE(elt, list_elt)));
1600 DEFUN("old-delq", Fold_delq, 2, 2, 0, /*
1601 Delete by side effect any occurrences of ELT as a member of LIST.
1602 The modified LIST is returned. Comparison is done with `old-eq'.
1603 If the first member of LIST is ELT, there is no way to remove it by side
1604 effect; therefore, write `(setq foo (old-delq element foo))' to be sure of
1605 changing the value of `foo'.
1609 EXTERNAL_LIST_LOOP_DELETE_IF(list_elt, list,
1610 (HACKEQ_UNSAFE(elt, list_elt)));
1614 /* Like Fdelq, but caller must ensure that LIST is properly
1615 nil-terminated and ebola-free. */
1617 Lisp_Object delq_no_quit(Lisp_Object elt, Lisp_Object list)
1619 LIST_LOOP_DELETE_IF(list_elt, list,
1620 (EQ_WITH_EBOLA_NOTICE(elt, list_elt)));
1624 /* Be VERY careful with this. This is like delq_no_quit() but
1625 also calls free_cons() on the removed conses. You must be SURE
1626 that no pointers to the freed conses remain around (e.g.
1627 someone else is pointing to part of the list). This function
1628 is useful on internal lists that are used frequently and where
1629 the actual list doesn't escape beyond known code bounds. */
1631 Lisp_Object delq_no_quit_and_free_cons(Lisp_Object elt, Lisp_Object list)
1633 REGISTER Lisp_Object tail = list;
1634 REGISTER Lisp_Object prev = Qnil;
1636 while (!NILP(tail)) {
1637 REGISTER Lisp_Object tem = XCAR(tail);
1639 Lisp_Object cons_to_free = tail;
1643 XCDR(prev) = XCDR(tail);
1645 free_cons(XCONS(cons_to_free));
1654 DEFUN("remassoc", Fremassoc, 2, 2, 0, /*
1655 Delete by side effect any elements of ALIST whose car is `equal' to KEY.
1656 The modified ALIST is returned. If the first member of ALIST has a car
1657 that is `equal' to KEY, there is no way to remove it by side effect;
1658 therefore, write `(setq foo (remassoc key foo))' to be sure of changing
1663 EXTERNAL_LIST_LOOP_DELETE_IF(elt, alist,
1665 internal_equal(key, XCAR(elt), 0)));
1669 Lisp_Object remassoc_no_quit(Lisp_Object key, Lisp_Object alist)
1671 int speccount = specpdl_depth();
1672 specbind(Qinhibit_quit, Qt);
1673 return unbind_to(speccount, Fremassoc(key, alist));
1676 DEFUN("remassq", Fremassq, 2, 2, 0, /*
1677 Delete by side effect any elements of ALIST whose car is `eq' to KEY.
1678 The modified ALIST is returned. If the first member of ALIST has a car
1679 that is `eq' to KEY, there is no way to remove it by side effect;
1680 therefore, write `(setq foo (remassq key foo))' to be sure of changing
1685 EXTERNAL_LIST_LOOP_DELETE_IF(elt, alist,
1687 EQ_WITH_EBOLA_NOTICE(key, XCAR(elt))));
1691 /* no quit, no errors; be careful */
1693 Lisp_Object remassq_no_quit(Lisp_Object key, Lisp_Object alist)
1695 LIST_LOOP_DELETE_IF(elt, alist,
1697 EQ_WITH_EBOLA_NOTICE(key, XCAR(elt))));
1701 DEFUN("remrassoc", Fremrassoc, 2, 2, 0, /*
1702 Delete by side effect any elements of ALIST whose cdr is `equal' to VALUE.
1703 The modified ALIST is returned. If the first member of ALIST has a car
1704 that is `equal' to VALUE, there is no way to remove it by side effect;
1705 therefore, write `(setq foo (remrassoc value foo))' to be sure of changing
1710 EXTERNAL_LIST_LOOP_DELETE_IF(elt, alist,
1712 internal_equal(value, XCDR(elt), 0)));
1716 DEFUN("remrassq", Fremrassq, 2, 2, 0, /*
1717 Delete by side effect any elements of ALIST whose cdr is `eq' to VALUE.
1718 The modified ALIST is returned. If the first member of ALIST has a car
1719 that is `eq' to VALUE, there is no way to remove it by side effect;
1720 therefore, write `(setq foo (remrassq value foo))' to be sure of changing
1725 EXTERNAL_LIST_LOOP_DELETE_IF(elt, alist,
1727 EQ_WITH_EBOLA_NOTICE(value, XCDR(elt))));
1731 /* Like Fremrassq, fast and unsafe; be careful */
1732 Lisp_Object remrassq_no_quit(Lisp_Object value, Lisp_Object alist)
1734 LIST_LOOP_DELETE_IF(elt, alist,
1736 EQ_WITH_EBOLA_NOTICE(value, XCDR(elt))));
1740 DEFUN("nreverse", Fnreverse, 1, 1, 0, /*
1741 Reverse LIST by destructively modifying cdr pointers.
1742 Return the beginning of the reversed list.
1743 Also see: `reverse'.
1747 struct gcpro gcpro1, gcpro2;
1748 REGISTER Lisp_Object prev = Qnil;
1749 REGISTER Lisp_Object tail = list;
1751 /* We gcpro our args; see `nconc' */
1753 while (!NILP(tail)) {
1754 REGISTER Lisp_Object next;
1755 CONCHECK_CONS(tail);
1765 DEFUN("reverse", Freverse, 1, 1, 0, /*
1766 Reverse LIST, copying. Return the beginning of the reversed list.
1767 See also the function `nreverse', which is used more often.
1771 Lisp_Object reversed_list = Qnil;
1772 EXTERNAL_LIST_LOOP_2(elt, list) {
1773 reversed_list = Fcons(elt, reversed_list);
1775 return reversed_list;
1778 static Lisp_Object list_merge(Lisp_Object org_l1, Lisp_Object org_l2,
1779 Lisp_Object lisp_arg,
1780 int (*pred_fn) (Lisp_Object, Lisp_Object,
1781 Lisp_Object lisp_arg));
1784 list_sort(Lisp_Object list,
1785 Lisp_Object lisp_arg,
1786 int (*pred_fn) (Lisp_Object, Lisp_Object, Lisp_Object lisp_arg))
1788 struct gcpro gcpro1, gcpro2, gcpro3;
1789 Lisp_Object back, tem;
1790 Lisp_Object front = list;
1791 Lisp_Object len = Flength(list);
1796 len = make_int(XINT(len) / 2 - 1);
1797 tem = Fnthcdr(len, list);
1801 GCPRO3(front, back, lisp_arg);
1802 front = list_sort(front, lisp_arg, pred_fn);
1803 back = list_sort(back, lisp_arg, pred_fn);
1805 return list_merge(front, back, lisp_arg, pred_fn);
1809 merge_pred_function(Lisp_Object obj1, Lisp_Object obj2, Lisp_Object pred)
1813 /* prevents the GC from happening in call2 */
1814 int speccount = specpdl_depth();
1815 /* Emacs' GC doesn't actually relocate pointers, so this probably
1816 isn't strictly necessary */
1817 record_unwind_protect(restore_gc_inhibit,
1818 make_int(gc_currently_forbidden));
1819 gc_currently_forbidden = 1;
1820 tmp = call2(pred, obj1, obj2);
1821 unbind_to(speccount, Qnil);
1829 DEFUN("sort", Fsort, 2, 2, 0, /*
1830 Sort LIST, stably, comparing elements using PREDICATE.
1831 Returns the sorted list. LIST is modified by side effects.
1832 PREDICATE is called with two elements of LIST, and should return T
1833 if the first element is "less" than the second.
1837 return list_sort(list, predicate, merge_pred_function);
1840 Lisp_Object merge(Lisp_Object org_l1, Lisp_Object org_l2, Lisp_Object pred)
1842 return list_merge(org_l1, org_l2, pred, merge_pred_function);
1846 list_merge(Lisp_Object org_l1, Lisp_Object org_l2,
1847 Lisp_Object lisp_arg,
1848 int (*pred_fn) (Lisp_Object, Lisp_Object, Lisp_Object lisp_arg))
1854 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1861 /* It is sufficient to protect org_l1 and org_l2.
1862 When l1 and l2 are updated, we copy the new values
1863 back into the org_ vars. */
1865 GCPRO4(org_l1, org_l2, lisp_arg, value);
1883 if (((*pred_fn) (Fcar(l2), Fcar(l1), lisp_arg)) < 0) {
1900 /************************************************************************/
1901 /* property-list functions */
1902 /************************************************************************/
1904 /* For properties of text, we need to do order-insensitive comparison of
1905 plists. That is, we need to compare two plists such that they are the
1906 same if they have the same set of keys, and equivalent values.
1907 So (a 1 b 2) would be equal to (b 2 a 1).
1909 NIL_MEANS_NOT_PRESENT is as in `plists-eq' etc.
1910 LAXP means use `equal' for comparisons.
1913 plists_differ(Lisp_Object a, Lisp_Object b, int nil_means_not_present,
1914 int laxp, int depth)
1916 int eqp = (depth == -1); /* -1 as depth means use eq, not equal. */
1917 int la, lb, m, i, fill;
1918 Lisp_Object *keys, *vals;
1921 int speccount = specpdl_depth();
1923 if (NILP(a) && NILP(b))
1926 Fcheck_valid_plist(a);
1927 Fcheck_valid_plist(b);
1929 la = XINT(Flength(a));
1930 lb = XINT(Flength(b));
1931 m = (la > lb ? la : lb);
1933 XMALLOC_OR_ALLOCA(keys, m, Lisp_Object);
1934 XMALLOC_OR_ALLOCA(vals, m, Lisp_Object);
1935 XMALLOC_ATOMIC_OR_ALLOCA(flags, m, char);
1937 /* First extract the pairs from A. */
1938 for (rest = a; !NILP(rest); rest = XCDR(XCDR(rest))) {
1939 Lisp_Object k = XCAR(rest);
1940 Lisp_Object v = XCAR(XCDR(rest));
1941 /* Maybe be Ebolified. */
1942 if (nil_means_not_present && NILP(v))
1949 /* Now iterate over B, and stop if we find something that's not in A,
1950 or that doesn't match. As we match, mark them. */
1951 for (rest = b; !NILP(rest); rest = XCDR(XCDR(rest))) {
1952 Lisp_Object k = XCAR(rest);
1953 Lisp_Object v = XCAR(XCDR(rest));
1954 /* Maybe be Ebolified. */
1955 if (nil_means_not_present && NILP(v))
1957 for (i = 0; i < fill; i++) {
1958 if (!laxp ? EQ(k, keys[i]) :
1959 internal_equal(k, keys[i], depth)) {
1961 /* We narrowly escaped being Ebolified
1963 ? !EQ_WITH_EBOLA_NOTICE(v, vals[i])
1964 : !internal_equal(v, vals[i], depth))
1965 /* a property in B has a different value
1973 /* there are some properties in B that are not in A */
1976 /* Now check to see that all the properties in A were also in B */
1977 for (i = 0; i < fill; i++)
1981 XMALLOC_UNBIND(flags, m, speccount);
1982 XMALLOC_UNBIND(vals, m, speccount);
1983 XMALLOC_UNBIND(keys, m, speccount);
1988 XMALLOC_UNBIND(flags, m, speccount);
1989 XMALLOC_UNBIND(vals, m, speccount);
1990 XMALLOC_UNBIND(keys, m, speccount);
1994 DEFUN("plists-eq", Fplists_eq, 2, 3, 0, /*
1995 Return non-nil if property lists A and B are `eq'.
1996 A property list is an alternating list of keywords and values.
1997 This function does order-insensitive comparisons of the property lists:
1998 For example, the property lists '(a 1 b 2) and '(b 2 a 1) are equal.
1999 Comparison between values is done using `eq'. See also `plists-equal'.
2000 If optional arg NIL-MEANS-NOT-PRESENT is non-nil, then a property with
2001 a nil value is ignored. This feature is a virus that has infected
2002 old Lisp implementations, but should not be used except for backward
2005 (a, b, nil_means_not_present))
2007 return (plists_differ(a, b, !NILP(nil_means_not_present), 0, -1)
2011 DEFUN("plists-equal", Fplists_equal, 2, 3, 0, /*
2012 Return non-nil if property lists A and B are `equal'.
2013 A property list is an alternating list of keywords and values. This
2014 function does order-insensitive comparisons of the property lists: For
2015 example, the property lists '(a 1 b 2) and '(b 2 a 1) are equal.
2016 Comparison between values is done using `equal'. See also `plists-eq'.
2017 If optional arg NIL-MEANS-NOT-PRESENT is non-nil, then a property with
2018 a nil value is ignored. This feature is a virus that has infected
2019 old Lisp implementations, but should not be used except for backward
2022 (a, b, nil_means_not_present))
2024 return (plists_differ(a, b, !NILP(nil_means_not_present), 0, 1)
2028 DEFUN("lax-plists-eq", Flax_plists_eq, 2, 3, 0, /*
2029 Return non-nil if lax property lists A and B are `eq'.
2030 A property list is an alternating list of keywords and values.
2031 This function does order-insensitive comparisons of the property lists:
2032 For example, the property lists '(a 1 b 2) and '(b 2 a 1) are equal.
2033 Comparison between values is done using `eq'. See also `plists-equal'.
2034 A lax property list is like a regular one except that comparisons between
2035 keywords is done using `equal' instead of `eq'.
2036 If optional arg NIL-MEANS-NOT-PRESENT is non-nil, then a property with
2037 a nil value is ignored. This feature is a virus that has infected
2038 old Lisp implementations, but should not be used except for backward
2041 (a, b, nil_means_not_present))
2043 return (plists_differ(a, b, !NILP(nil_means_not_present), 1, -1)
2047 DEFUN("lax-plists-equal", Flax_plists_equal, 2, 3, 0, /*
2048 Return non-nil if lax property lists A and B are `equal'.
2049 A property list is an alternating list of keywords and values. This
2050 function does order-insensitive comparisons of the property lists: For
2051 example, the property lists '(a 1 b 2) and '(b 2 a 1) are equal.
2052 Comparison between values is done using `equal'. See also `plists-eq'.
2053 A lax property list is like a regular one except that comparisons between
2054 keywords is done using `equal' instead of `eq'.
2055 If optional arg NIL-MEANS-NOT-PRESENT is non-nil, then a property with
2056 a nil value is ignored. This feature is a virus that has infected
2057 old Lisp implementations, but should not be used except for backward
2060 (a, b, nil_means_not_present))
2062 return (plists_differ(a, b, !NILP(nil_means_not_present), 1, 1)
2066 /* Return the value associated with key PROPERTY in property list PLIST.
2067 Return nil if key not found. This function is used for internal
2068 property lists that cannot be directly manipulated by the user.
2071 Lisp_Object internal_plist_get(Lisp_Object plist, Lisp_Object property)
2075 for (tail = plist; !NILP(tail); tail = XCDR(XCDR(tail))) {
2076 if (EQ(XCAR(tail), property))
2077 return XCAR(XCDR(tail));
2083 /* Set PLIST's value for PROPERTY to VALUE. Analogous to
2084 internal_plist_get(). */
2087 internal_plist_put(Lisp_Object * plist, Lisp_Object property, Lisp_Object value)
2091 for (tail = *plist; !NILP(tail); tail = XCDR(XCDR(tail))) {
2092 if (EQ(XCAR(tail), property)) {
2093 XCAR(XCDR(tail)) = value;
2098 *plist = Fcons(property, Fcons(value, *plist));
2101 int internal_remprop(Lisp_Object * plist, Lisp_Object property)
2103 Lisp_Object tail, prev;
2105 for (tail = *plist, prev = Qnil; !NILP(tail); tail = XCDR(XCDR(tail))) {
2106 if (EQ(XCAR(tail), property)) {
2108 *plist = XCDR(XCDR(tail));
2110 XCDR(XCDR(prev)) = XCDR(XCDR(tail));
2119 /* Called on a malformed property list. BADPLACE should be some
2120 place where truncating will form a good list -- i.e. we shouldn't
2121 result in a list with an odd length. */
2124 bad_bad_bunny(Lisp_Object * plist, Lisp_Object * badplace, Error_behavior errb)
2126 if (ERRB_EQ(errb, ERROR_ME))
2127 return Fsignal(Qmalformed_property_list,
2128 list2(*plist, *badplace));
2130 if (ERRB_EQ(errb, ERROR_ME_WARN)) {
2131 warn_when_safe_lispobj
2134 ("Malformed property list -- list has been truncated"),
2142 /* Called on a circular property list. BADPLACE should be some place
2143 where truncating will result in an even-length list, as above.
2144 If doesn't particularly matter where we truncate -- anywhere we
2145 truncate along the entire list will break the circularity, because
2146 it will create a terminus and the list currently doesn't have one.
2150 bad_bad_turtle(Lisp_Object * plist, Lisp_Object * badplace, Error_behavior errb)
2152 if (ERRB_EQ(errb, ERROR_ME))
2153 return Fsignal(Qcircular_property_list, list1(*plist));
2155 if (ERRB_EQ(errb, ERROR_ME_WARN)) {
2156 warn_when_safe_lispobj
2159 ("Circular property list -- list has been truncated"),
2167 /* Advance the tortoise pointer by two (one iteration of a property-list
2168 loop) and the hare pointer by four and verify that no malformations
2169 or circularities exist. If so, return zero and store a value into
2170 RETVAL that should be returned by the calling function. Otherwise,
2171 return 1. See external_plist_get().
2175 advance_plist_pointers(Lisp_Object * plist,
2176 Lisp_Object ** tortoise, Lisp_Object ** hare,
2177 Error_behavior errb, Lisp_Object * retval)
2180 Lisp_Object *tortsave = *tortoise;
2182 /* Note that our "fixing" may be more brutal than necessary,
2183 but it's the user's own problem, not ours, if they went in and
2184 manually fucked up a plist. */
2186 for (i = 0; i < 2; i++) {
2187 /* This is a standard iteration of a defensive-loop-checking
2188 loop. We just do it twice because we want to advance past
2189 both the property and its value.
2191 If the pointer indirection is confusing you, remember that
2192 one level of indirection on the hare and tortoise pointers
2193 is only due to pass-by-reference for this function. The other
2194 level is so that the plist can be fixed in place. */
2196 /* When we reach the end of a well-formed plist, **HARE is
2197 nil. In that case, we don't do anything at all except
2198 advance TORTOISE by one. Otherwise, we advance HARE
2199 by two (making sure it's OK to do so), then advance
2200 TORTOISE by one (it will always be OK to do so because
2201 the HARE is always ahead of the TORTOISE and will have
2202 already verified the path), then make sure TORTOISE and
2203 HARE don't contain the same non-nil object -- if the
2204 TORTOISE and the HARE ever meet, then obviously we're
2205 in a circularity, and if we're in a circularity, then
2206 the TORTOISE and the HARE can't cross paths without
2207 meeting, since the HARE only gains one step over the
2208 TORTOISE per iteration. */
2210 if (!NILP(**hare)) {
2211 Lisp_Object *haresave = *hare;
2212 if (!CONSP(**hare)) {
2213 *retval = bad_bad_bunny(plist, haresave, errb);
2216 *hare = &XCDR(**hare);
2217 /* In a non-plist, we'd check here for a nil value for
2218 **HARE, which is OK (it just means the list has an
2219 odd number of elements). In a plist, it's not OK
2220 for the list to have an odd number of elements. */
2221 if (!CONSP(**hare)) {
2222 *retval = bad_bad_bunny(plist, haresave, errb);
2225 *hare = &XCDR(**hare);
2228 *tortoise = &XCDR(**tortoise);
2229 if (!NILP(**hare) && EQ(**tortoise, **hare)) {
2230 *retval = bad_bad_turtle(plist, tortsave, errb);
2238 /* Return the value of PROPERTY from PLIST, or Qunbound if
2239 property is not on the list.
2241 PLIST is a Lisp-accessible property list, meaning that it
2242 has to be checked for malformations and circularities.
2244 If ERRB is ERROR_ME, an error will be signalled. Otherwise, the
2245 function will never signal an error; and if ERRB is ERROR_ME_WARN,
2246 on finding a malformation or a circularity, it issues a warning and
2247 attempts to silently fix the problem.
2249 A pointer to PLIST is passed in so that PLIST can be successfully
2250 "fixed" even if the error is at the beginning of the plist. */
2253 external_plist_get(Lisp_Object * plist, Lisp_Object property,
2254 int laxp, Error_behavior errb)
2256 Lisp_Object *tortoise = plist;
2257 Lisp_Object *hare = plist;
2259 while (!NILP(*tortoise)) {
2260 Lisp_Object *tortsave = tortoise;
2263 /* We do the standard tortoise/hare march. We isolate the
2264 grungy stuff to do this in advance_plist_pointers(), though.
2265 To us, all this function does is advance the tortoise
2266 pointer by two and the hare pointer by four and make sure
2267 everything's OK. We first advance the pointers and then
2268 check if a property matched; this ensures that our
2269 check for a matching property is safe. */
2271 if (!advance_plist_pointers
2272 (plist, &tortoise, &hare, errb, &retval))
2275 if (!laxp ? EQ(XCAR(*tortsave), property)
2276 : internal_equal(XCAR(*tortsave), property, 0))
2277 return XCAR(XCDR(*tortsave));
2283 /* Set PLIST's value for PROPERTY to VALUE, given a possibly
2284 malformed or circular plist. Analogous to external_plist_get(). */
2287 external_plist_put(Lisp_Object * plist, Lisp_Object property,
2288 Lisp_Object value, int laxp, Error_behavior errb)
2290 Lisp_Object *tortoise = plist;
2291 Lisp_Object *hare = plist;
2293 while (!NILP(*tortoise)) {
2294 Lisp_Object *tortsave = tortoise;
2298 if (!advance_plist_pointers
2299 (plist, &tortoise, &hare, errb, &retval))
2302 if (!laxp ? EQ(XCAR(*tortsave), property)
2303 : internal_equal(XCAR(*tortsave), property, 0)) {
2304 XCAR(XCDR(*tortsave)) = value;
2309 *plist = Fcons(property, Fcons(value, *plist));
2313 external_remprop(Lisp_Object * plist, Lisp_Object property,
2314 int laxp, Error_behavior errb)
2316 Lisp_Object *tortoise = plist;
2317 Lisp_Object *hare = plist;
2319 while (!NILP(*tortoise)) {
2320 Lisp_Object *tortsave = tortoise;
2324 if (!advance_plist_pointers
2325 (plist, &tortoise, &hare, errb, &retval))
2328 if (!laxp ? EQ(XCAR(*tortsave), property)
2329 : internal_equal(XCAR(*tortsave), property, 0)) {
2330 /* Now you see why it's so convenient to have that level
2332 *tortsave = XCDR(XCDR(*tortsave));
2340 DEFUN("plist-get", Fplist_get, 2, 3, 0, /*
2341 Extract a value from a property list.
2342 PLIST is a property list, which is a list of the form
2343 \(PROPERTY1 VALUE1 PROPERTY2 VALUE2...).
2344 PROPERTY is usually a symbol.
2345 This function returns the value corresponding to the PROPERTY,
2346 or DEFAULT if PROPERTY is not one of the properties on the list.
2348 (plist, property, default_))
2350 Lisp_Object value = external_plist_get(&plist, property, 0, ERROR_ME);
2351 return UNBOUNDP(value) ? default_ : value;
2354 DEFUN("plist-put", Fplist_put, 3, 3, 0, /*
2355 Change value in PLIST of PROPERTY to VALUE.
2356 PLIST is a property list, which is a list of the form
2357 \(PROPERTY1 VALUE1 PROPERTY2 VALUE2 ...).
2358 PROPERTY is usually a symbol and VALUE is any object.
2359 If PROPERTY is already a property on the list, its value is set to VALUE,
2360 otherwise the new PROPERTY VALUE pair is added.
2361 The new plist is returned; use `(setq x (plist-put x property value))'
2362 to be sure to use the new value. PLIST is modified by side effect.
2364 (plist, property, value))
2366 external_plist_put(&plist, property, value, 0, ERROR_ME);
2370 DEFUN("plist-remprop", Fplist_remprop, 2, 2, 0, /*
2371 Remove from PLIST the property PROPERTY and its value.
2372 PLIST is a property list, which is a list of the form
2373 \(PROPERTY1 VALUE1 PROPERTY2 VALUE2 ...).
2374 PROPERTY is usually a symbol.
2375 The new plist is returned; use `(setq x (plist-remprop x property))'
2376 to be sure to use the new value. PLIST is modified by side effect.
2380 external_remprop(&plist, property, 0, ERROR_ME);
2384 DEFUN("plist-member", Fplist_member, 2, 2, 0, /*
2385 Return t if PROPERTY has a value specified in PLIST.
2389 Lisp_Object value = Fplist_get(plist, property, Qunbound);
2390 return UNBOUNDP(value) ? Qnil : Qt;
2393 DEFUN("check-valid-plist", Fcheck_valid_plist, 1, 1, 0, /*
2394 Given a plist, signal an error if there is anything wrong with it.
2395 This means that it's a malformed or circular plist.
2399 Lisp_Object *tortoise;
2405 while (!NILP(*tortoise)) {
2409 if (!advance_plist_pointers(&plist, &tortoise, &hare, ERROR_ME,
2417 DEFUN("valid-plist-p", Fvalid_plist_p, 1, 1, 0, /*
2418 Given a plist, return non-nil if its format is correct.
2419 If it returns nil, `check-valid-plist' will signal an error when given
2420 the plist; that means it's a malformed or circular plist.
2424 Lisp_Object *tortoise;
2429 while (!NILP(*tortoise)) {
2433 if (!advance_plist_pointers
2434 (&plist, &tortoise, &hare, ERROR_ME_NOT, &retval))
2441 DEFUN("canonicalize-plist", Fcanonicalize_plist, 1, 2, 0, /*
2442 Destructively remove any duplicate entries from a plist.
2443 In such cases, the first entry applies.
2445 If optional arg NIL-MEANS-NOT-PRESENT is non-nil, then a property with
2446 a nil value is removed. This feature is a virus that has infected
2447 old Lisp implementations, but should not be used except for backward
2450 The new plist is returned. If NIL-MEANS-NOT-PRESENT is given, the
2451 return value may not be EQ to the passed-in value, so make sure to
2452 `setq' the value back into where it came from.
2454 (plist, nil_means_not_present))
2456 Lisp_Object head = plist;
2458 Fcheck_valid_plist(plist);
2460 while (!NILP(plist)) {
2461 Lisp_Object prop = Fcar(plist);
2462 Lisp_Object next = Fcdr(plist);
2464 CHECK_CONS(next); /* just make doubly sure we catch any errors */
2465 if (!NILP(nil_means_not_present) && NILP(Fcar(next))) {
2466 if (EQ(head, plist))
2471 /* external_remprop returns 1 if it removed any property.
2472 We have to loop till it didn't remove anything, in case
2473 the property occurs many times. */
2474 while (external_remprop(&XCDR(next), prop, 0, ERROR_ME))
2482 DEFUN("lax-plist-get", Flax_plist_get, 2, 3, 0, /*
2483 Extract a value from a lax property list.
2484 LAX-PLIST is a lax property list, which is a list of the form
2485 \(PROPERTY1 VALUE1 PROPERTY2 VALUE2...), where comparisons between
2486 properties is done using `equal' instead of `eq'.
2487 PROPERTY is usually a symbol.
2488 This function returns the value corresponding to PROPERTY,
2489 or DEFAULT if PROPERTY is not one of the properties on the list.
2491 (lax_plist, property, default_))
2494 external_plist_get(&lax_plist, property, 1, ERROR_ME);
2495 return UNBOUNDP(value) ? default_ : value;
2498 DEFUN("lax-plist-put", Flax_plist_put, 3, 3, 0, /*
2499 Change value in LAX-PLIST of PROPERTY to VALUE.
2500 LAX-PLIST is a lax property list, which is a list of the form
2501 \(PROPERTY1 VALUE1 PROPERTY2 VALUE2...), where comparisons between
2502 properties is done using `equal' instead of `eq'.
2503 PROPERTY is usually a symbol and VALUE is any object.
2504 If PROPERTY is already a property on the list, its value is set to
2505 VALUE, otherwise the new PROPERTY VALUE pair is added.
2506 The new plist is returned; use `(setq x (lax-plist-put x property value))'
2507 to be sure to use the new value. LAX-PLIST is modified by side effect.
2509 (lax_plist, property, value))
2511 external_plist_put(&lax_plist, property, value, 1, ERROR_ME);
2515 DEFUN("lax-plist-remprop", Flax_plist_remprop, 2, 2, 0, /*
2516 Remove from LAX-PLIST the property PROPERTY and its value.
2517 LAX-PLIST is a lax property list, which is a list of the form
2518 \(PROPERTY1 VALUE1 PROPERTY2 VALUE2...), where comparisons between
2519 properties is done using `equal' instead of `eq'.
2520 PROPERTY is usually a symbol.
2521 The new plist is returned; use `(setq x (lax-plist-remprop x property))'
2522 to be sure to use the new value. LAX-PLIST is modified by side effect.
2524 (lax_plist, property))
2526 external_remprop(&lax_plist, property, 1, ERROR_ME);
2530 DEFUN("lax-plist-member", Flax_plist_member, 2, 2, 0, /*
2531 Return t if PROPERTY has a value specified in LAX-PLIST.
2532 LAX-PLIST is a lax property list, which is a list of the form
2533 \(PROPERTY1 VALUE1 PROPERTY2 VALUE2...), where comparisons between
2534 properties is done using `equal' instead of `eq'.
2536 (lax_plist, property))
2538 return UNBOUNDP(Flax_plist_get(lax_plist, property, Qunbound)) ? Qnil :
2542 DEFUN("canonicalize-lax-plist", Fcanonicalize_lax_plist, 1, 2, 0, /*
2543 Destructively remove any duplicate entries from a lax plist.
2544 In such cases, the first entry applies.
2546 If optional arg NIL-MEANS-NOT-PRESENT is non-nil, then a property with
2547 a nil value is removed. This feature is a virus that has infected
2548 old Lisp implementations, but should not be used except for backward
2551 The new plist is returned. If NIL-MEANS-NOT-PRESENT is given, the
2552 return value may not be EQ to the passed-in value, so make sure to
2553 `setq' the value back into where it came from.
2555 (lax_plist, nil_means_not_present))
2557 Lisp_Object head = lax_plist;
2559 Fcheck_valid_plist(lax_plist);
2561 while (!NILP(lax_plist)) {
2562 Lisp_Object prop = Fcar(lax_plist);
2563 Lisp_Object next = Fcdr(lax_plist);
2565 CHECK_CONS(next); /* just make doubly sure we catch any errors */
2566 if (!NILP(nil_means_not_present) && NILP(Fcar(next))) {
2567 if (EQ(head, lax_plist))
2569 lax_plist = Fcdr(next);
2572 /* external_remprop returns 1 if it removed any property.
2573 We have to loop till it didn't remove anything, in case
2574 the property occurs many times. */
2575 while (external_remprop(&XCDR(next), prop, 1, ERROR_ME))
2577 lax_plist = Fcdr(next);
2583 /* In C because the frame props stuff uses it */
2585 DEFUN("destructive-alist-to-plist", Fdestructive_alist_to_plist, 1, 1, 0, /*
2586 Convert association list ALIST into the equivalent property-list form.
2587 The plist is returned. This converts from
2589 \((a . 1) (b . 2) (c . 3))
2595 The original alist is destroyed in the process of constructing the plist.
2596 See also `alist-to-plist'.
2600 Lisp_Object head = alist;
2601 while (!NILP(alist)) {
2602 /* remember the alist element. */
2603 Lisp_Object el = Fcar(alist);
2605 Fsetcar(alist, Fcar(el));
2606 Fsetcar(el, Fcdr(el));
2607 Fsetcdr(el, Fcdr(alist));
2609 alist = Fcdr(Fcdr(alist));
2615 DEFUN("get", Fget, 2, 3, 0, /*
2616 Return the value of OBJECT's PROPERTY property.
2617 This is the last VALUE stored with `(put OBJECT PROPERTY VALUE)'.
2618 If there is no such property, return optional third arg DEFAULT
2619 \(which defaults to `nil'). OBJECT can be a symbol, string, extent,
2620 face, or glyph. See also `put', `remprop', and `object-plist'.
2622 (object, property, default_))
2624 /* Various places in emacs call Fget() and expect it not to quit,
2628 if (LRECORDP(object) && XRECORD_LHEADER_IMPLEMENTATION(object)->getprop)
2630 XRECORD_LHEADER_IMPLEMENTATION(object)->getprop(object,
2633 signal_simple_error("Object type has no properties", object);
2635 return UNBOUNDP(val) ? default_ : val;
2638 DEFUN("put", Fput, 3, 3, 0, /*
2639 Set OBJECT's PROPERTY to VALUE.
2640 It can be subsequently retrieved with `(get OBJECT PROPERTY)'.
2641 OBJECT can be a symbol, face, extent, or string.
2642 For a string, no properties currently have predefined meanings.
2643 For the predefined properties for extents, see `set-extent-property'.
2644 For the predefined properties for faces, see `set-face-property'.
2645 See also `get', `remprop', and `object-plist'.
2647 (object, property, value))
2649 CHECK_LISP_WRITEABLE(object);
2651 if (LRECORDP(object) && XRECORD_LHEADER_IMPLEMENTATION(object)->putprop) {
2652 if (!XRECORD_LHEADER_IMPLEMENTATION(object)->putprop
2653 (object, property, value))
2654 signal_simple_error("Can't set property on object",
2657 signal_simple_error("Object type has no settable properties",
2663 DEFUN("remprop", Fremprop, 2, 2, 0, /*
2664 Remove, from OBJECT's property list, PROPERTY and its corresponding value.
2665 OBJECT can be a symbol, string, extent, face, or glyph. Return non-nil
2666 if the property list was actually modified (i.e. if PROPERTY was present
2667 in the property list). See also `get', `put', and `object-plist'.
2673 CHECK_LISP_WRITEABLE(object);
2675 if (LRECORDP(object) && XRECORD_LHEADER_IMPLEMENTATION(object)->remprop) {
2677 XRECORD_LHEADER_IMPLEMENTATION(object)->remprop(object,
2680 signal_simple_error("Can't remove property from object",
2683 signal_simple_error("Object type has no removable properties",
2686 return ret ? Qt : Qnil;
2689 DEFUN("object-plist", Fobject_plist, 1, 1, 0, /*
2690 Return a property list of OBJECT's properties.
2691 For a symbol, this is equivalent to `symbol-plist'.
2692 OBJECT can be a symbol, string, extent, face, or glyph.
2693 Do not modify the returned property list directly;
2694 this may or may not have the desired effects. Use `put' instead.
2698 if (LRECORDP(object) && XRECORD_LHEADER_IMPLEMENTATION(object)->plist)
2699 return XRECORD_LHEADER_IMPLEMENTATION(object)->plist(object);
2701 signal_simple_error("Object type has no properties", object);
2706 int internal_equal(Lisp_Object obj1, Lisp_Object obj2, int depth)
2709 error("Stack overflow in equal");
2711 if (EQ_WITH_EBOLA_NOTICE(obj1, obj2))
2713 /* Note that (equal 20 20.0) should be nil */
2714 if (XTYPE(obj1) != XTYPE(obj2))
2716 if (LRECORDP(obj1)) {
2717 const struct lrecord_implementation
2718 *imp1 = XRECORD_LHEADER_IMPLEMENTATION(obj1),
2719 *imp2 = XRECORD_LHEADER_IMPLEMENTATION(obj2);
2721 return (imp1 == imp2) &&
2722 /* EQ-ness of the objects was noticed above */
2723 (imp1->equal && (imp1->equal) (obj1, obj2, depth));
2730 internal_equalp (Lisp_Object obj1, Lisp_Object obj2, int depth)
2733 error ("Stack overflow in equalp");
2735 if (EQ_WITH_EBOLA_NOTICE (obj1, obj2))
2738 if (NUMBERP(obj1) && NUMBERP(obj2)) {
2739 return ent_binrel(ASE_BINARY_REL_EQUALP, obj1, obj2);
2742 if (CHARP(obj1) && CHARP(obj2))
2743 return XCHAR(obj1) == XCHAR(obj2);
2744 if (XTYPE(obj1) != XTYPE(obj2))
2746 if (LRECORDP(obj1)) {
2747 const struct lrecord_implementation
2748 *imp1 = XRECORD_LHEADER_IMPLEMENTATION (obj1),
2749 *imp2 = XRECORD_LHEADER_IMPLEMENTATION (obj2);
2751 /* #### not yet implemented properly, needs another flag to specify
2753 return (imp1 == imp2) &&
2754 /* EQ-ness of the objects was noticed above */
2755 (imp1->equal && (imp1->equal) (obj1, obj2, depth));
2762 /* Note that we may be calling sub-objects that will use
2763 internal_equal() (instead of internal_old_equal()). Oh well.
2764 We will get an Ebola note if there's any possibility of confusion,
2765 but that seems unlikely. */
2767 static int internal_old_equal(Lisp_Object obj1, Lisp_Object obj2, int depth)
2770 error("Stack overflow in equal");
2772 if (HACKEQ_UNSAFE(obj1, obj2))
2774 /* Note that (equal 20 20.0) should be nil */
2775 if (XTYPE(obj1) != XTYPE(obj2))
2778 return internal_equal(obj1, obj2, depth);
2781 DEFUN("equal", Fequal, 2, 2, 0, /*
2782 Return t if two Lisp objects have similar structure and contents.
2783 They must have the same data type.
2784 Conses are compared by comparing the cars and the cdrs.
2785 Vectors and strings are compared element by element.
2786 Numbers are compared by value. Symbols must match exactly.
2790 return internal_equal(object1, object2, 0) ? Qt : Qnil;
2793 DEFUN("old-equal", Fold_equal, 2, 2, 0, /*
2794 Return t if two Lisp objects have similar structure and contents.
2795 They must have the same data type.
2796 \(Note, however, that an exception is made for characters and integers;
2797 this is known as the "char-int confoundance disease." See `eq' and
2799 This function is provided only for byte-code compatibility with v19.
2804 return internal_old_equal(object1, object2, 0) ? Qt : Qnil;
2807 DEFUN("fillarray", Ffillarray, 2, 2, 0, /*
2808 Destructively modify ARRAY by replacing each element with ITEM.
2809 ARRAY is a vector, bit vector, or string.
2814 if (STRINGP(array)) {
2815 Lisp_String *s = XSTRING(array);
2816 Bytecount old_bytecount = string_length(s);
2817 Bytecount new_bytecount;
2818 Bytecount item_bytecount;
2819 Bufbyte item_buf[MAX_EMCHAR_LEN];
2823 CHECK_CHAR_COERCE_INT(item);
2824 CHECK_LISP_WRITEABLE(array);
2826 item_bytecount = set_charptr_emchar(item_buf, XCHAR(item));
2827 new_bytecount = item_bytecount * string_char_length(s);
2829 resize_string(s, -1, new_bytecount - old_bytecount);
2831 for (p = string_data(s), end = p + new_bytecount;
2832 p < end; p += item_bytecount)
2833 memcpy(p, item_buf, item_bytecount);
2836 bump_string_modiff(array);
2837 } else if (VECTORP(array)) {
2838 Lisp_Object *p = XVECTOR_DATA(array);
2839 size_t len = XVECTOR_LENGTH(array);
2840 CHECK_LISP_WRITEABLE(array);
2843 } else if (BIT_VECTORP(array)) {
2844 Lisp_Bit_Vector *v = XBIT_VECTOR(array);
2845 size_t len = bit_vector_length(v);
2849 CHECK_LISP_WRITEABLE(array);
2851 set_bit_vector_bit(v, len, bit);
2853 array = wrong_type_argument(Qarrayp, array);
2859 Lisp_Object nconc2(Lisp_Object arg1, Lisp_Object arg2)
2861 Lisp_Object args[2] = {arg1, arg2};
2862 struct gcpro gcpro1;
2864 GCPROn(args, countof(args));
2865 RETURN_UNGCPRO(bytecode_nconc2(args));
2868 Lisp_Object bytecode_nconc2(Lisp_Object * args)
2872 if (CONSP(args[0])) {
2873 /* (setcdr (last args[0]) args[1]) */
2874 Lisp_Object tortoise, hare;
2877 for (hare = tortoise = args[0], count = 0;
2878 CONSP(XCDR(hare)); hare = XCDR(hare), count++) {
2879 if (count < CIRCULAR_LIST_SUSPICION_LENGTH)
2883 tortoise = XCDR(tortoise);
2884 if (EQ(hare, tortoise))
2885 signal_circular_list_error(args[0]);
2887 XCDR(hare) = args[1];
2889 } else if (NILP(args[0])) {
2892 args[0] = wrong_type_argument(args[0], Qlistp);
2897 DEFUN("nconc", Fnconc, 0, MANY, 0, /*
2898 Concatenate any number of lists by altering them.
2899 Only the last argument is not altered, and need not be a list.
2901 If the first argument is nil, there is no way to modify it by side
2902 effect; therefore, write `(setq foo (nconc foo list))' to be sure of
2903 changing the value of `foo'.
2905 (int nargs, Lisp_Object * args))
2908 struct gcpro gcpro1;
2910 /* The modus operandi in Emacs is "caller gc-protects args".
2911 However, nconc (particularly nconc2 ()) is called many times
2912 in Emacs on freshly created stuff (e.g. you see the idiom
2913 nconc2 (Fcopy_sequence (foo), bar) a lot). So we help those
2914 callers out by protecting the args ourselves to save them
2915 a lot of temporary-variable grief. */
2917 GCPROn(args, nargs);
2919 while (argnum < nargs) {
2924 /* `val' is the first cons, which will be our return
2926 * `last_cons' will be the cons cell to mutate. */
2927 Lisp_Object last_cons = val;
2928 Lisp_Object tortoise = val;
2930 for (argnum++; argnum < nargs; argnum++) {
2931 Lisp_Object next = args[argnum];
2933 if (CONSP(next) || argnum == nargs - 1) {
2934 /* (setcdr (last val) next) */
2938 CONSP(XCDR(last_cons));
2940 XCDR(last_cons), count++) {
2942 CIRCULAR_LIST_SUSPICION_LENGTH)
2948 if (EQ(last_cons, tortoise))
2949 signal_circular_list_error
2952 XCDR(last_cons) = next;
2953 } else if (NILP(next)) {
2957 wrong_type_argument(Qlistp, next);
2961 RETURN_UNGCPRO(val);
2962 } else if (NILP(val))
2964 else if (argnum == nargs - 1) /* last arg? */
2965 RETURN_UNGCPRO(val);
2967 args[argnum] = wrong_type_argument(Qlistp, val);
2971 RETURN_UNGCPRO(Qnil); /* No non-nil args provided. */
2975 DEFUN("replace-list", Freplace_list, 2, 2, 0, /*
2976 Destructively replace the list OLD with NEW.
2977 This is like (copy-sequence NEW) except that it reuses the
2978 conses in OLD as much as possible. If OLD and NEW are the same
2979 length, no consing will take place.
2983 Lisp_Object tail, oldtail = old, prevoldtail = Qnil;
2985 EXTERNAL_LIST_LOOP(tail, new) {
2986 if (!NILP(oldtail)) {
2987 CHECK_CONS(oldtail);
2988 XCAR(oldtail) = XCAR(tail);
2989 } else if (!NILP(prevoldtail)) {
2990 XCDR(prevoldtail) = Fcons(XCAR(tail), Qnil);
2991 prevoldtail = XCDR(prevoldtail);
2993 old = oldtail = Fcons(XCAR(tail), Qnil);
2995 if (!NILP(oldtail)) {
2996 prevoldtail = oldtail;
2997 oldtail = XCDR(oldtail);
3001 if (!NILP(prevoldtail))
3002 XCDR(prevoldtail) = Qnil;
3009 /* #### this function doesn't belong in this file! */
3011 #ifdef HAVE_GETLOADAVG
3012 #ifdef HAVE_SYS_LOADAVG_H
3013 #include <sys/loadavg.h>
3016 int getloadavg(double loadavg[], int nelem); /* Defined in getloadavg.c */
3019 DEFUN("load-average", Fload_average, 0, 1, 0, /*
3020 Return list of 1 minute, 5 minute and 15 minute load averages.
3021 Each of the three load averages is multiplied by 100,
3022 then converted to integer.
3024 When USE-FLOATS is non-nil, floats will be used instead of integers.
3025 These floats are not multiplied by 100.
3027 If the 5-minute or 15-minute load averages are not available, return a
3028 shortened list, containing only those averages which are available.
3030 On some systems, this won't work due to permissions on /dev/kmem,
3031 in which case you can't use this.
3036 int loads = getloadavg(load_ave, countof(load_ave));
3037 Lisp_Object ret = Qnil;
3040 error("load-average not implemented for this operating system");
3042 signal_simple_error("Could not get load-average",
3043 lisp_strerror(errno));
3045 while (loads-- > 0) {
3046 Lisp_Object load = (NILP(use_floats) ?
3047 make_int((int)(100.0 * load_ave[loads]))
3048 : make_float(load_ave[loads]));
3049 ret = Fcons(load, ret);
3054 Lisp_Object Vfeatures;
3056 DEFUN("featurep", Ffeaturep, 1, 1, 0, /*
3057 Return non-nil if feature FEXP is present in this Emacs.
3058 Use this to conditionalize execution of lisp code based on the
3059 presence or absence of emacs or environment extensions.
3060 FEXP can be a symbol, a number, or a list.
3061 If it is a symbol, that symbol is looked up in the `features' variable,
3062 and non-nil will be returned if found.
3063 If it is a number, the function will return non-nil if this Emacs
3064 has an equal or greater version number than FEXP.
3065 If it is a list whose car is the symbol `and', it will return
3066 non-nil if all the features in its cdr are non-nil.
3067 If it is a list whose car is the symbol `or', it will return non-nil
3068 if any of the features in its cdr are non-nil.
3069 If it is a list whose car is the symbol `not', it will return
3070 non-nil if the feature is not present.
3075 => ; Non-nil on SXEmacs.
3077 (featurep '(and sxemacs gnus))
3078 => ; Non-nil on SXEmacs with Gnus loaded.
3080 (featurep '(or tty-frames (and emacs 19.30)))
3081 => ; Non-nil if this Emacs supports TTY frames.
3083 (featurep '(or (and xemacs 19.15) (and emacs 19.34)))
3084 => ; Non-nil on XEmacs 19.15 and later, or FSF Emacs 19.34 and later.
3086 (featurep '(and xemacs 21.02))
3087 => ; Non-nil on XEmacs 21.2 and later.
3089 NOTE: The advanced arguments of this function (anything other than a
3090 symbol) are not yet supported by FSF Emacs. If you feel they are useful
3091 for supporting multiple Emacs variants, lobby Richard Stallman at
3092 <bug-gnu-emacs@gnu.org>.
3096 #ifndef FEATUREP_SYNTAX
3098 return NILP(Fmemq(fexp, Vfeatures)) ? Qnil : Qt;
3099 #else /* FEATUREP_SYNTAX */
3100 static double featurep_emacs_version;
3102 /* Brute force translation from Erik Naggum's lisp function. */
3103 if (SYMBOLP(fexp)) {
3104 /* Original definition */
3105 return NILP(Fmemq(fexp, Vfeatures)) ? Qnil : Qt;
3106 } else if (INTP(fexp) || FLOATP(fexp)) {
3107 double d = extract_float(fexp);
3109 if (featurep_emacs_version == 0.0) {
3110 featurep_emacs_version = XINT(Vemacs_major_version) +
3111 (XINT(Vemacs_minor_version) / 100.0);
3113 return featurep_emacs_version >= d ? Qt : Qnil;
3114 } else if (CONSP(fexp)) {
3115 Lisp_Object tem = XCAR(fexp);
3116 if (EQ(tem, Qnot)) {
3122 return NILP(call1(Qfeaturep, negate)) ? Qt :
3125 return Fsignal(Qinvalid_read_syntax,
3127 } else if (EQ(tem, Qand)) {
3129 /* Use Fcar/Fcdr for error-checking. */
3130 while (!NILP(tem) && !NILP(call1(Qfeaturep, Fcar(tem)))) {
3133 return NILP(tem) ? Qt : Qnil;
3134 } else if (EQ(tem, Qor)) {
3136 /* Use Fcar/Fcdr for error-checking. */
3137 while (!NILP(tem) && NILP(call1(Qfeaturep, Fcar(tem)))) {
3140 return NILP(tem) ? Qnil : Qt;
3142 return Fsignal(Qinvalid_read_syntax, list1(XCDR(fexp)));
3145 return Fsignal(Qinvalid_read_syntax, list1(fexp));
3148 #endif /* FEATUREP_SYNTAX */
3150 DEFUN("provide", Fprovide, 1, 1, 0, /*
3151 Announce that FEATURE is a feature of the current Emacs.
3152 This function updates the value of the variable `features'.
3157 CHECK_SYMBOL(feature);
3158 if (!NILP(Vautoload_queue))
3160 Fcons(Fcons(Vfeatures, Qnil), Vautoload_queue);
3161 tem = Fmemq(feature, Vfeatures);
3163 Vfeatures = Fcons(feature, Vfeatures);
3164 LOADHIST_ATTACH(Fcons(Qprovide, feature));
3168 DEFUN("require", Frequire, 1, 2, 0, /*
3169 If feature FEATURE is not loaded, load it from FILENAME.
3170 If FEATURE is not a member of the list `features', then the feature
3171 is not loaded; so load the file FILENAME.
3172 If FILENAME is omitted, the printname of FEATURE is used as the file name.
3174 (feature, filename))
3178 CHECK_SYMBOL(feature);
3179 tem = Fmemq(feature, Vfeatures);
3180 LOADHIST_ATTACH(Fcons(Qrequire, feature));
3185 int speccount = specpdl_depth();
3187 /* Value saved here is to be restored into Vautoload_queue */
3188 record_unwind_protect(un_autoload, Vautoload_queue);
3189 Vautoload_queue = Qt;
3191 /* defined in code-files.el */
3192 call4(Qload, NILP(filename) ? Fsymbol_name(feature) : filename,
3195 tem = Fmemq(feature, Vfeatures);
3197 error("Required feature %s was not provided",
3198 string_data(XSYMBOL(feature)->name));
3200 /* Once loading finishes, don't undo it. */
3201 Vautoload_queue = Qt;
3202 return unbind_to(speccount, feature);
3206 DEFUN("revoke", Frevoke, 1, 1, 0, /*
3207 Announce that FEATURE is no longer a feature of the current Emacs.
3211 CHECK_SYMBOL(feature);
3212 if (!NILP(Vautoload_queue))
3214 Fcons(Fcons(Vfeatures, Qnil), Vautoload_queue);
3216 if (LIKELY(CONSP(Vfeatures) && EQ(XCAR(Vfeatures), feature))) {
3217 /* special case where feature is the head of 'features */
3218 Vfeatures = XCDR(Vfeatures);
3221 for (Lisp_Object tmp = Vfeatures;
3222 CONSP(tmp) && CONSP(XCDR(tmp));
3224 if (EQ(XCAR(XCDR(tmp)), feature)) {
3225 XCDR(tmp) = XCDR(XCDR(tmp));
3232 /* base64 encode/decode functions.
3234 Originally based on code from GNU recode. Ported to FSF Emacs by
3235 Lars Magne Ingebrigtsen and Karl Heuer. Ported to XEmacs and
3236 subsequently heavily hacked by Hrvoje Niksic. */
3238 #define MIME_LINE_LENGTH 72
3240 #define IS_ASCII(Character) \
3242 #define IS_BASE64(Character) \
3243 (IS_ASCII (Character) && base64_char_to_value[Character] >= 0)
3245 /* Table of characters coding the 64 values. */
3246 static char base64_value_to_char[64] = {
3247 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', /* 0- 9 */
3248 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', /* 10-19 */
3249 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', /* 20-29 */
3250 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', /* 30-39 */
3251 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', /* 40-49 */
3252 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', /* 50-59 */
3253 '8', '9', '+', '/' /* 60-63 */
3256 /* Table of base64 values for first 128 characters. */
3257 static short base64_char_to_value[128] = {
3258 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0- 9 */
3259 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 10- 19 */
3260 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 20- 29 */
3261 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 30- 39 */
3262 -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, /* 40- 49 */
3263 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, /* 50- 59 */
3264 -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, /* 60- 69 */
3265 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 70- 79 */
3266 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, /* 80- 89 */
3267 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, /* 90- 99 */
3268 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, /* 100-109 */
3269 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, /* 110-119 */
3270 49, 50, 51, -1, -1, -1, -1, -1 /* 120-127 */
3273 /* The following diagram shows the logical steps by which three octets
3274 get transformed into four base64 characters.
3276 .--------. .--------. .--------.
3277 |aaaaaabb| |bbbbcccc| |ccdddddd|
3278 `--------' `--------' `--------'
3280 .--------+--------+--------+--------.
3281 |00aaaaaa|00bbbbbb|00cccccc|00dddddd|
3282 `--------+--------+--------+--------'
3284 .--------+--------+--------+--------.
3285 |AAAAAAAA|BBBBBBBB|CCCCCCCC|DDDDDDDD|
3286 `--------+--------+--------+--------'
3288 The octets are divided into 6 bit chunks, which are then encoded into
3289 base64 characters. */
3291 #define ADVANCE_INPUT(c, stream) \
3292 ((ec = Lstream_get_emchar (stream)) == -1 ? 0 : \
3294 (signal_simple_error ("Non-ascii character in base64 input", \
3295 make_char (ec)), 0) \
3296 : (c = (Bufbyte)ec), 1))
3298 static Bytind base64_encode_1(Lstream * istream, Bufbyte * to, int line_break)
3300 EMACS_INT counter = 0;
3307 if (!ADVANCE_INPUT(c, istream))
3310 /* Wrap line every 76 characters. */
3312 if (counter < MIME_LINE_LENGTH / 4)
3320 /* Process first byte of a triplet. */
3321 *e++ = base64_value_to_char[0x3f & c >> 2];
3322 value = (0x03 & c) << 4;
3324 /* Process second byte of a triplet. */
3325 if (!ADVANCE_INPUT(c, istream)) {
3326 *e++ = base64_value_to_char[value];
3332 *e++ = base64_value_to_char[value | (0x0f & c >> 4)];
3333 value = (0x0f & c) << 2;
3335 /* Process third byte of a triplet. */
3336 if (!ADVANCE_INPUT(c, istream)) {
3337 *e++ = base64_value_to_char[value];
3342 *e++ = base64_value_to_char[value | (0x03 & c >> 6)];
3343 *e++ = base64_value_to_char[0x3f & c];
3349 #undef ADVANCE_INPUT
3351 /* Get next character from the stream, except that non-base64
3352 characters are ignored. This is in accordance with rfc2045. EC
3353 should be an Emchar, so that it can hold -1 as the value for EOF. */
3354 #define ADVANCE_INPUT_IGNORE_NONBASE64(ec, stream, streampos) do { \
3355 ec = Lstream_get_emchar (stream); \
3357 /* IS_BASE64 may not be called with negative arguments so check for \
3359 if (ec < 0 || IS_BASE64 (ec) || ec == '=') \
3363 #define STORE_BYTE(pos, val, ccnt) do { \
3364 pos += set_charptr_emchar (pos, (Emchar)((unsigned char)(val))); \
3369 base64_decode_1(Lstream * istream, Bufbyte * to, Charcount * ccptr)
3373 EMACS_INT streampos = 0;
3377 unsigned long value;
3379 /* Process first byte of a quadruplet. */
3380 ADVANCE_INPUT_IGNORE_NONBASE64(ec, istream, streampos);
3385 ("Illegal `=' character while decoding base64",
3386 make_int(streampos));
3387 value = base64_char_to_value[ec] << 18;
3389 /* Process second byte of a quadruplet. */
3390 ADVANCE_INPUT_IGNORE_NONBASE64(ec, istream, streampos);
3392 error("Premature EOF while decoding base64");
3395 ("Illegal `=' character while decoding base64",
3396 make_int(streampos));
3397 value |= base64_char_to_value[ec] << 12;
3398 STORE_BYTE(e, value >> 16, ccnt);
3400 /* Process third byte of a quadruplet. */
3401 ADVANCE_INPUT_IGNORE_NONBASE64(ec, istream, streampos);
3403 error("Premature EOF while decoding base64");
3406 ADVANCE_INPUT_IGNORE_NONBASE64(ec, istream, streampos);
3408 error("Premature EOF while decoding base64");
3411 ("Padding `=' expected but not found while decoding base64",
3412 make_int(streampos));
3416 value |= base64_char_to_value[ec] << 6;
3417 STORE_BYTE(e, 0xff & value >> 8, ccnt);
3419 /* Process fourth byte of a quadruplet. */
3420 ADVANCE_INPUT_IGNORE_NONBASE64(ec, istream, streampos);
3422 error("Premature EOF while decoding base64");
3426 value |= base64_char_to_value[ec];
3427 STORE_BYTE(e, 0xff & value, ccnt);
3434 #undef ADVANCE_INPUT
3435 #undef ADVANCE_INPUT_IGNORE_NONBASE64
3438 DEFUN("base64-encode-region", Fbase64_encode_region, 2, 3, "r", /*
3439 Base64-encode the region between START and END.
3440 Return the length of the encoded text.
3441 Optional third argument NO-LINE-BREAK means do not break long lines
3444 (start, end, no_line_break))
3447 Bytind encoded_length;
3448 Charcount allength, length;
3449 struct buffer *buf = current_buffer;
3450 Bufpos begv, zv, old_pt = BUF_PT(buf);
3452 int speccount = specpdl_depth();
3454 get_buffer_range_char(buf, start, end, &begv, &zv, 0);
3455 barf_if_buffer_read_only(buf, begv, zv);
3457 /* We need to allocate enough room for encoding the text.
3458 We need 33 1/3% more space, plus a newline every 76
3459 characters, and then we round up. */
3461 allength = length + length / 3 + 1;
3462 allength += allength / MIME_LINE_LENGTH + 1 + 6;
3464 input = make_lisp_buffer_input_stream(buf, begv, zv, 0);
3465 /* We needn't multiply allength with MAX_EMCHAR_LEN because all the
3466 base64 characters will be single-byte. */
3467 XMALLOC_ATOMIC_OR_ALLOCA(encoded, allength, Bufbyte);
3468 encoded_length = base64_encode_1(XLSTREAM(input), encoded,
3469 NILP(no_line_break));
3470 if (encoded_length > allength) {
3473 Lstream_delete(XLSTREAM(input));
3475 /* Now we have encoded the region, so we insert the new contents
3476 and delete the old. (Insert first in order to preserve markers.) */
3477 buffer_insert_raw_string_1(buf, begv, encoded, encoded_length, 0);
3478 XMALLOC_UNBIND(encoded, allength, speccount);
3479 buffer_delete_range(buf, begv + encoded_length, zv + encoded_length, 0);
3481 /* Simulate FSF Emacs implementation of this function: if point was
3482 in the region, place it at the beginning. */
3483 if (old_pt >= begv && old_pt < zv) {
3484 BUF_SET_PT(buf, begv);
3487 /* We return the length of the encoded text. */
3488 return make_int(encoded_length);
3491 DEFUN("base64-encode-string", Fbase64_encode_string, 1, 2, 0, /*
3492 Base64 encode STRING and return the result.
3493 Optional argument NO-LINE-BREAK means do not break long lines
3496 (string, no_line_break))
3498 Charcount allength, length;
3499 Bytind encoded_length;
3501 Lisp_Object input, result;
3502 int speccount = specpdl_depth();
3504 CHECK_STRING(string);
3506 length = XSTRING_CHAR_LENGTH(string);
3507 allength = length + length / 3 + 1;
3508 allength += allength / MIME_LINE_LENGTH + 1 + 6;
3510 input = make_lisp_string_input_stream(string, 0, -1);
3511 XMALLOC_ATOMIC_OR_ALLOCA(encoded, allength, Bufbyte);
3512 encoded_length = base64_encode_1(XLSTREAM(input), encoded,
3513 NILP(no_line_break));
3514 if (encoded_length > allength) {
3517 Lstream_delete(XLSTREAM(input));
3518 result = make_string(encoded, encoded_length);
3519 XMALLOC_UNBIND(encoded, allength, speccount);
3523 DEFUN("base64-decode-region", Fbase64_decode_region, 2, 2, "r", /*
3524 Base64-decode the region between START and END.
3525 Return the length of the decoded text.
3526 If the region can't be decoded, return nil and don't modify the buffer.
3527 Characters out of the base64 alphabet are ignored.
3531 struct buffer *buf = current_buffer;
3532 Bufpos begv, zv, old_pt = BUF_PT(buf);
3534 Bytind decoded_length;
3535 Charcount length, cc_decoded_length;
3537 int speccount = specpdl_depth();
3539 get_buffer_range_char(buf, start, end, &begv, &zv, 0);
3540 barf_if_buffer_read_only(buf, begv, zv);
3544 input = make_lisp_buffer_input_stream(buf, begv, zv, 0);
3545 /* We need to allocate enough room for decoding the text. */
3546 XMALLOC_ATOMIC_OR_ALLOCA(decoded, length * MAX_EMCHAR_LEN, Bufbyte);
3548 base64_decode_1(XLSTREAM(input), decoded, &cc_decoded_length);
3549 if (decoded_length > length * MAX_EMCHAR_LEN) {
3552 Lstream_delete(XLSTREAM(input));
3554 /* Now we have decoded the region, so we insert the new contents
3555 and delete the old. (Insert first in order to preserve markers.) */
3556 BUF_SET_PT(buf, begv);
3557 buffer_insert_raw_string_1(buf, begv, decoded, decoded_length, 0);
3558 XMALLOC_UNBIND(decoded, length * MAX_EMCHAR_LEN, speccount);
3559 buffer_delete_range(buf, begv + cc_decoded_length,
3560 zv + cc_decoded_length, 0);
3562 /* Simulate FSF Emacs implementation of this function: if point was
3563 in the region, place it at the beginning. */
3564 if (old_pt >= begv && old_pt < zv) {
3565 BUF_SET_PT(buf, begv);
3568 return make_int(cc_decoded_length);
3571 DEFUN("base64-decode-string", Fbase64_decode_string, 1, 1, 0, /*
3572 Base64-decode STRING and return the result.
3573 Characters out of the base64 alphabet are ignored.
3578 Bytind decoded_length;
3579 Charcount length, cc_decoded_length;
3580 Lisp_Object input, result;
3581 int speccount = specpdl_depth();
3583 CHECK_STRING(string);
3585 length = XSTRING_CHAR_LENGTH(string);
3586 /* We need to allocate enough room for decoding the text. */
3587 XMALLOC_ATOMIC_OR_ALLOCA(decoded, length * MAX_EMCHAR_LEN, Bufbyte);
3589 input = make_lisp_string_input_stream(string, 0, -1);
3590 decoded_length = base64_decode_1(XLSTREAM(input), decoded,
3591 &cc_decoded_length);
3592 if (decoded_length > length * MAX_EMCHAR_LEN) {
3595 Lstream_delete(XLSTREAM(input));
3597 result = make_string(decoded, decoded_length);
3598 XMALLOC_UNBIND(decoded, length * MAX_EMCHAR_LEN, speccount);
3602 /* base16 encode/decode functions. */
3604 base16_encode_1(Lstream * istream, int length, Bufbyte * to, int max)
3609 for (i=0; i < length; i++) {
3610 ec = Lstream_get_emchar (istream);
3611 sz = snprintf((char *)to+2*i, 3, "%02x", ec);
3612 assert( sz >= 0 && sz < 3);
3620 base16_decode_1(Lstream * istream, int length, Bufbyte * to)
3623 Emchar high = 0, low = 0;
3624 int high_set_p = 0, ignore_p = 0;
3627 /* high and low perform flip flop operation */
3629 ec = Lstream_get_emchar (istream);
3634 else if (isupper(ec))
3635 low = ec - 'A' + 10;
3636 else if (islower(ec))
3637 low = ec - 'a' + 10;
3641 if (low < 0 || low >= 16)
3649 to[i] = high*16+low;
3659 DEFUN("base16-encode-string", Fbase16_encode_string, 1, 1, 0, /*
3660 Base16 encode (i.e. hex dump) STRING and return the result.
3661 Optional argument NO-LINE-BREAK means do not break long lines
3668 Lisp_Object input, result;
3670 int speccount = specpdl_depth();
3672 CHECK_STRING(string);
3674 length = XSTRING_CHAR_LENGTH(string);
3676 input = make_lisp_string_input_stream(string, 0, -1);
3677 XMALLOC_ATOMIC_OR_ALLOCA(encoded, sz+1, Bufbyte);
3678 base16_encode_1(XLSTREAM(input), length, encoded, sz);
3679 Lstream_delete(XLSTREAM(input));
3680 result = make_string(encoded, sz);
3681 XMALLOC_UNBIND(encoded, sz+1, speccount);
3683 XSTRING(result)->plist = XSTRING(string)->plist;
3688 DEFUN("base16-decode-string", Fbase16_decode_string, 1, 1, 0, /*
3689 Base16-decode (i.e. read hex data from) STRING and return the result.
3690 Characters out of the base16 alphabet are ignored.
3695 Bytind decoded_length;
3697 Lisp_Object input, result;
3698 int speccount = specpdl_depth();
3700 CHECK_STRING(string);
3702 length = XSTRING_CHAR_LENGTH(string);
3703 /* We need to allocate enough room for decoding the text. */
3704 XMALLOC_ATOMIC_OR_ALLOCA(decoded, length, Bufbyte);
3706 input = make_lisp_string_input_stream(string, 0, -1);
3707 decoded_length = base16_decode_1(XLSTREAM(input), length, decoded);
3708 Lstream_delete(XLSTREAM(input));
3710 /* this result might be raw, we declare it binary */
3711 result = make_ext_string((char *)decoded, decoded_length, Qbinary);
3712 XMALLOC_UNBIND(decoded, length, speccount);
3714 XSTRING(result)->plist = XSTRING(string)->plist;
3719 Lisp_Object Qyes_or_no_p;
3721 DEFUN("foobar", Ffoobar, 2, 2, 0, /*
3725 return make_int(__nbits_right_of(XINT(n), XINT(b)));
3728 void syms_of_fns(void)
3730 INIT_LRECORD_IMPLEMENTATION(bit_vector);
3732 defsymbol(&Qstring_lessp, "string-lessp");
3733 defsymbol(&Qstring_greaterp, "string-greaterp");
3734 defsymbol(&Qidentity, "identity");
3735 defsymbol(&Qyes_or_no_p, "yes-or-no-p");
3741 #if defined(WITH_GMP) && defined(HAVE_MPZ)
3745 DEFSUBR(Fsafe_length);
3746 DEFSUBR(Fstring_equal);
3747 DEFSUBR(Fstring_lessp);
3748 DEFSUBR(Fstring_greaterp);
3749 DEFSUBR(Fstring_modified_tick);
3754 DEFSUBR(Fcopy_list);
3755 DEFSUBR(Fcopy_sequence);
3756 DEFSUBR(Fcopy_alist);
3757 DEFSUBR(Fcopy_tree);
3758 DEFSUBR(Fsubstring);
3767 DEFSUBR(Fold_member);
3771 DEFSUBR(Fold_assoc);
3775 DEFSUBR(Fold_rassoc);
3777 DEFSUBR(Fold_rassq);
3779 DEFSUBR(Fold_delete);
3784 DEFSUBR(Fremrassoc);
3789 DEFSUBR(Fplists_eq);
3790 DEFSUBR(Fplists_equal);
3791 DEFSUBR(Flax_plists_eq);
3792 DEFSUBR(Flax_plists_equal);
3793 DEFSUBR(Fplist_get);
3794 DEFSUBR(Fplist_put);
3795 DEFSUBR(Fplist_remprop);
3796 DEFSUBR(Fplist_member);
3797 DEFSUBR(Fcheck_valid_plist);
3798 DEFSUBR(Fvalid_plist_p);
3799 DEFSUBR(Fcanonicalize_plist);
3800 DEFSUBR(Flax_plist_get);
3801 DEFSUBR(Flax_plist_put);
3802 DEFSUBR(Flax_plist_remprop);
3803 DEFSUBR(Flax_plist_member);
3804 DEFSUBR(Fcanonicalize_lax_plist);
3805 DEFSUBR(Fdestructive_alist_to_plist);
3809 DEFSUBR(Fobject_plist);
3811 DEFSUBR(Fold_equal);
3812 DEFSUBR(Ffillarray);
3814 DEFSUBR(Freplace_list);
3815 DEFSUBR(Fload_average);
3820 DEFSUBR(Fbase64_encode_region);
3821 DEFSUBR(Fbase64_encode_string);
3822 DEFSUBR(Fbase64_decode_region);
3823 DEFSUBR(Fbase64_decode_string);
3824 DEFSUBR(Fbase16_encode_string);
3825 DEFSUBR(Fbase16_decode_string);
3832 void init_provide_once(void)
3834 DEFVAR_LISP("features", &Vfeatures /*
3835 A list of symbols which are the features of the executing emacs.
3836 Used by `featurep' and `require', and altered by `provide'.
3840 Fprovide(intern("base64"));
3841 Fprovide(intern("base16"));
3843 #if defined HAVE_BDWGC && defined EF_USE_BDWGC
3844 /* it's fuck ugly to define that here :( */
3845 Fprovide(intern("bdwgc"));