#include "lisp.h"
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <errno.h>
+#include "sysfile.h"
#include "buffer.h"
#include "bytecode.h"
size_bit_vector (const void *lheader)
{
Lisp_Bit_Vector *v = (Lisp_Bit_Vector *) lheader;
- return offsetof (Lisp_Bit_Vector,
- bits[BIT_VECTOR_LONG_STORAGE (bit_vector_length (v))]);
+ return FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Bit_Vector, bits,
+ BIT_VECTOR_LONG_STORAGE (bit_vector_length (v)));
}
static const struct lrecord_description bit_vector_description[] = {
string_result_ptr = string_result;
break;
default:
+ val = Qnil;
abort ();
}
}
return result;
}
else
- abort (); /* unreachable, since Flength (sequence) did not get an error */
+ {
+ abort (); /* unreachable, since Flength (sequence) did not get
+ an error */
+ return Qnil;
+ }
}
\f
*/
(elt, list))
{
- Lisp_Object list_elt, tail;
EXTERNAL_LIST_LOOP_3 (list_elt, list, tail)
{
if (internal_equal (elt, list_elt, 0))
*/
(elt, list))
{
- Lisp_Object list_elt, tail;
EXTERNAL_LIST_LOOP_3 (list_elt, list, tail)
{
if (internal_old_equal (elt, list_elt, 0))
*/
(elt, list))
{
- Lisp_Object list_elt, tail;
EXTERNAL_LIST_LOOP_3 (list_elt, list, tail)
{
if (EQ_WITH_EBOLA_NOTICE (elt, list_elt))
*/
(elt, list))
{
- Lisp_Object list_elt, tail;
EXTERNAL_LIST_LOOP_3 (list_elt, list, tail)
{
if (HACKEQ_UNSAFE (elt, list_elt))
Lisp_Object
memq_no_quit (Lisp_Object elt, Lisp_Object list)
{
- Lisp_Object list_elt, tail;
LIST_LOOP_3 (list_elt, list, tail)
{
if (EQ_WITH_EBOLA_NOTICE (elt, list_elt))
(key, list))
{
/* This function can GC. */
- Lisp_Object elt, elt_car, elt_cdr;
EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, list)
{
if (internal_equal (key, elt_car, 0))
(key, list))
{
/* This function can GC. */
- Lisp_Object elt, elt_car, elt_cdr;
EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, list)
{
if (internal_old_equal (key, elt_car, 0))
*/
(key, list))
{
- Lisp_Object elt, elt_car, elt_cdr;
EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, list)
{
if (EQ_WITH_EBOLA_NOTICE (key, elt_car))
*/
(key, list))
{
- Lisp_Object elt, elt_car, elt_cdr;
EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, list)
{
if (HACKEQ_UNSAFE (key, elt_car))
assq_no_quit (Lisp_Object key, Lisp_Object list)
{
/* This cannot GC. */
- Lisp_Object elt;
LIST_LOOP_2 (elt, list)
{
Lisp_Object elt_car = XCAR (elt);
*/
(key, list))
{
- Lisp_Object elt, elt_car, elt_cdr;
EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, list)
{
if (internal_equal (key, elt_cdr, 0))
*/
(key, list))
{
- Lisp_Object elt, elt_car, elt_cdr;
EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, list)
{
if (internal_old_equal (key, elt_cdr, 0))
*/
(key, list))
{
- Lisp_Object elt, elt_car, elt_cdr;
EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, list)
{
if (EQ_WITH_EBOLA_NOTICE (key, elt_cdr))
*/
(key, list))
{
- Lisp_Object elt, elt_car, elt_cdr;
EXTERNAL_ALIST_LOOP_4 (elt, elt_car, elt_cdr, list)
{
if (HACKEQ_UNSAFE (key, elt_cdr))
Lisp_Object
rassq_no_quit (Lisp_Object key, Lisp_Object list)
{
- Lisp_Object elt;
LIST_LOOP_2 (elt, list)
{
Lisp_Object elt_cdr = XCDR (elt);
*/
(elt, list))
{
- Lisp_Object list_elt;
EXTERNAL_LIST_LOOP_DELETE_IF (list_elt, list,
(internal_equal (elt, list_elt, 0)));
return list;
*/
(elt, list))
{
- Lisp_Object list_elt;
EXTERNAL_LIST_LOOP_DELETE_IF (list_elt, list,
(internal_old_equal (elt, list_elt, 0)));
return list;
*/
(elt, list))
{
- Lisp_Object list_elt;
EXTERNAL_LIST_LOOP_DELETE_IF (list_elt, list,
(EQ_WITH_EBOLA_NOTICE (elt, list_elt)));
return list;
*/
(elt, list))
{
- Lisp_Object list_elt;
EXTERNAL_LIST_LOOP_DELETE_IF (list_elt, list,
(HACKEQ_UNSAFE (elt, list_elt)));
return list;
Lisp_Object
delq_no_quit (Lisp_Object elt, Lisp_Object list)
{
- Lisp_Object list_elt;
LIST_LOOP_DELETE_IF (list_elt, list,
(EQ_WITH_EBOLA_NOTICE (elt, list_elt)));
return list;
*/
(key, list))
{
- Lisp_Object elt;
EXTERNAL_LIST_LOOP_DELETE_IF (elt, list,
(CONSP (elt) &&
internal_equal (key, XCAR (elt), 0)));
*/
(key, list))
{
- Lisp_Object elt;
EXTERNAL_LIST_LOOP_DELETE_IF (elt, list,
(CONSP (elt) &&
EQ_WITH_EBOLA_NOTICE (key, XCAR (elt))));
Lisp_Object
remassq_no_quit (Lisp_Object key, Lisp_Object list)
{
- Lisp_Object elt;
LIST_LOOP_DELETE_IF (elt, list,
(CONSP (elt) &&
EQ_WITH_EBOLA_NOTICE (key, XCAR (elt))));
*/
(value, list))
{
- Lisp_Object elt;
EXTERNAL_LIST_LOOP_DELETE_IF (elt, list,
(CONSP (elt) &&
internal_equal (value, XCDR (elt), 0)));
*/
(value, list))
{
- Lisp_Object elt;
EXTERNAL_LIST_LOOP_DELETE_IF (elt, list,
(CONSP (elt) &&
EQ_WITH_EBOLA_NOTICE (value, XCDR (elt))));
Lisp_Object
remrassq_no_quit (Lisp_Object value, Lisp_Object list)
{
- Lisp_Object elt;
LIST_LOOP_DELETE_IF (elt, list,
(CONSP (elt) &&
EQ_WITH_EBOLA_NOTICE (value, XCDR (elt))));
(list))
{
Lisp_Object reversed_list = Qnil;
- Lisp_Object elt;
EXTERNAL_LIST_LOOP_2 (elt, list)
{
reversed_list = Fcons (elt, reversed_list);
bad_bad_turtle (Lisp_Object *plist, Lisp_Object *badplace, Error_behavior errb)
{
if (ERRB_EQ (errb, ERROR_ME))
- /* #### Eek, this will probably result in another error
- when PLIST is printed out */
return Fsignal (Qcircular_property_list, list1 (*plist));
else
{
if (vals == 0) we don't have any free space available and
don't want to eat up any more stack with alloca().
- So we use EXTERNAL_LIST_LOOP_3 and GCPRO the tail. */
+ So we use EXTERNAL_LIST_LOOP_3_NO_DECLARE and GCPRO the tail. */
if (vals)
{
Lisp_Object *val = vals;
- Lisp_Object elt;
LIST_LOOP_2 (elt, sequence)
*val++ = elt;
else
{
Lisp_Object elt, tail;
+ EMACS_INT len_unused;
struct gcpro ngcpro1;
NGCPRO1 (tail);
{
- EXTERNAL_LIST_LOOP_3 (elt, sequence, tail)
+ EXTERNAL_LIST_LOOP_4_NO_DECLARE (elt, sequence, tail, len_unused)
{
args[1] = elt;
Ffuncall (2, args);
}
\f
+
+
+DEFUN ("replace-list", Freplace_list, 2, 2, 0, /*
+Destructively replace the list OLD with NEW.
+This is like (copy-sequence NEW) except that it reuses the
+conses in OLD as much as possible. If OLD and NEW are the same
+length, no consing will take place.
+*/
+ (old, new))
+{
+ Lisp_Object tail, oldtail = old, prevoldtail = Qnil;
+
+ EXTERNAL_LIST_LOOP (tail, new)
+ {
+ if (!NILP (oldtail))
+ {
+ CHECK_CONS (oldtail);
+ XCAR (oldtail) = XCAR (tail);
+ }
+ else if (!NILP (prevoldtail))
+ {
+ XCDR (prevoldtail) = Fcons (XCAR (tail), Qnil);
+ prevoldtail = XCDR (prevoldtail);
+ }
+ else
+ old = oldtail = Fcons (XCAR (tail), Qnil);
+
+ if (!NILP (oldtail))
+ {
+ prevoldtail = oldtail;
+ oldtail = XCDR (oldtail);
+ }
+ }
+
+ if (!NILP (prevoldtail))
+ XCDR (prevoldtail) = Qnil;
+ else
+ old = Qnil;
+
+ return old;
+}
+
+\f
/* #### this function doesn't belong in this file! */
+#ifdef HAVE_GETLOADAVG
+#ifdef HAVE_SYS_LOADAVG_H
+#include <sys/loadavg.h>
+#endif
+#else
+int getloadavg (double loadavg[], int nelem); /* Defined in getloadavg.c */
+#endif
+
DEFUN ("load-average", Fload_average, 0, 1, 0, /*
Return list of 1 minute, 5 minute and 15 minute load averages.
Each of the three load averages is multiplied by 100,
(featurep '(or (and xemacs 19.15) (and emacs 19.34)))
=> ; Non-nil on XEmacs 19.15 and later, or FSF Emacs 19.34 and later.
+ (featurep '(and xemacs 21.02))
+ => ; Non-nil on XEmacs 21.2 and later.
+
NOTE: The advanced arguments of this function (anything other than a
symbol) are not yet supported by FSF Emacs. If you feel they are useful
for supporting multiple Emacs variants, lobby Richard Stallman at
-<bug-gnu-emacs@prep.ai.mit.edu>.
+<bug-gnu-emacs@gnu.org>.
*/
(fexp))
{
DEFSUBR (Fmapvector);
DEFSUBR (Fmapc_internal);
DEFSUBR (Fmapconcat);
+ DEFSUBR (Freplace_list);
DEFSUBR (Fload_average);
DEFSUBR (Ffeaturep);
DEFSUBR (Frequire);