use guile subrs
[bpt/emacs.git] / src / lisp.h
index 0143506..e0a4cdf 100644 (file)
@@ -440,7 +440,6 @@ enum pvec_type
   PVEC_HASH_TABLE,
   PVEC_TERMINAL,
   PVEC_WINDOW_CONFIGURATION,
-  PVEC_SUBR,
   PVEC_OTHER,
   /* These should be last, check internal_equal to see why.  */
   PVEC_COMPILED,
@@ -566,7 +565,6 @@ INLINE void set_sub_char_table_contents (Lisp_Object, ptrdiff_t,
                                              Lisp_Object);
 INLINE bool STRINGP (Lisp_Object);
 INLINE bool SUB_CHAR_TABLE_P (Lisp_Object);
-INLINE bool SUBRP (Lisp_Object);
 INLINE bool (SYMBOLP) (Lisp_Object);
 INLINE bool (VECTORLIKEP) (Lisp_Object);
 INLINE bool WINDOWP (Lisp_Object);
@@ -685,13 +683,6 @@ XTERMINAL (Lisp_Object a)
   return SMOB_PTR (a);
 }
 
-INLINE struct Lisp_Subr *
-XSUBR (Lisp_Object a)
-{
-  eassert (SUBRP (a));
-  return SMOB_PTR (a);
-}
-
 INLINE struct buffer *
 XBUFFER (Lisp_Object a)
 {
@@ -1240,32 +1231,6 @@ CHAR_TABLE_SET (Lisp_Object ct, int idx, Lisp_Object val)
     char_table_set (ct, idx, val);
 }
 
-/* This structure describes a built-in function.
-   It is generated by the DEFUN macro only.
-   defsubr makes it into a Lisp object.  */
-
-struct Lisp_Subr
-  {
-    struct vectorlike_header header;
-    union {
-      Lisp_Object (*a0) (void);
-      Lisp_Object (*a1) (Lisp_Object);
-      Lisp_Object (*a2) (Lisp_Object, Lisp_Object);
-      Lisp_Object (*a3) (Lisp_Object, Lisp_Object, Lisp_Object);
-      Lisp_Object (*a4) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
-      Lisp_Object (*a5) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
-      Lisp_Object (*a6) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
-      Lisp_Object (*a7) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
-      Lisp_Object (*a8) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
-      Lisp_Object (*aUNEVALLED) (Lisp_Object args);
-      Lisp_Object (*aMANY) (ptrdiff_t, Lisp_Object *);
-    } function;
-    short min_args, max_args;
-    const char *symbol_name;
-    const char *intspec;
-    const char *doc;
-  };
-
 /* This is the number of slots that every char table must have.  This
    counts the ordinary slots and the top, defalt, parent, and purpose
    slots.  */
@@ -2134,12 +2099,6 @@ TERMINALP (Lisp_Object a)
   return PSEUDOVECTORP (a, PVEC_TERMINAL);
 }
 
-INLINE bool
-SUBRP (Lisp_Object a)
-{
-  return PSEUDOVECTORP (a, PVEC_SUBR);
-}
-
 INLINE bool
 COMPILEDP (Lisp_Object a)
 {
@@ -2350,28 +2309,71 @@ CHECK_NUMBER_CDR (Lisp_Object x)
 
 /* This version of DEFUN declares a function prototype with the right
    arguments, so we can catch errors with maxargs at compile-time.  */
-#ifdef _MSC_VER
-#define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc)    \
-   SCM_SNARF_INIT (defsubr (&sname);)                                   \
-   Lisp_Object fnname DEFUN_ARGS_ ## maxargs ;                         \
-   static struct Lisp_Subr alignas (GCALIGNMENT) sname =               \
-   { { NULL,                                                            \
-       (PVEC_SUBR << PSEUDOVECTOR_AREA_BITS)                            \
-       | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)) },           \
-     { (Lisp_Object (__cdecl *)(void))fnname },                         \
-     minargs, maxargs, lname, intspec, 0};                             \
-   Lisp_Object fnname
-#else  /* not _MSC_VER */
 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc)    \
-   SCM_SNARF_INIT (defsubr (&sname);)                                   \
+  SCM_SNARF_INIT (defsubr (lname, gsubr_ ## fnname, minargs, maxargs, intspec)) \
    Lisp_Object fnname DEFUN_ARGS_ ## maxargs ;                         \
-   static struct Lisp_Subr alignas (GCALIGNMENT) sname =               \
-   { { .self = NULL,                                                    \
-       .size = PVEC_SUBR << PSEUDOVECTOR_AREA_BITS },                   \
-     { .a ## maxargs = fnname },                                        \
-     minargs, maxargs, lname, intspec, 0};                             \
+   DEFUN_GSUBR_ ## maxargs (lname, fnname, minargs, maxargs)            \
    Lisp_Object fnname
-#endif
+
+#define GSUBR_ARGS_1(f) f (arg1)
+#define GSUBR_ARGS_2(f) GSUBR_ARGS_1 (f), f (arg2)
+#define GSUBR_ARGS_3(f) GSUBR_ARGS_2 (f), f (arg3)
+#define GSUBR_ARGS_4(f) GSUBR_ARGS_3 (f), f (arg4)
+#define GSUBR_ARGS_5(f) GSUBR_ARGS_4 (f), f (arg5)
+#define GSUBR_ARGS_6(f) GSUBR_ARGS_5 (f), f (arg6)
+#define GSUBR_ARGS_7(f) GSUBR_ARGS_6 (f), f (arg7)
+#define GSUBR_ARGS_8(f) GSUBR_ARGS_7 (f), f (arg8)
+
+#define GSUBR_ARGS(n) GSUBR_ARGS_PASTE (GSUBR_ARGS_, n)
+#define GSUBR_ARGS_PASTE(a, b) a ## b
+
+#define DEFUN_GSUBR_N(fn, maxargs)                              \
+  Lisp_Object                                                   \
+  gsubr_ ## fn                                                  \
+  (GSUBR_ARGS (maxargs) (Lisp_Object))                          \
+  {                                                             \
+    return fn (GSUBR_ARGS (maxargs) (GSUBR_ARG));               \
+  }
+#define GSUBR_ARG(x) (SCM_UNBNDP (x) ? Qnil : x)
+
+#define DEFUN_GSUBR_0(lname, fn, minargs, maxargs)       \
+  Lisp_Object gsubr_ ## fn (void) { return fn (); }
+#define DEFUN_GSUBR_1(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
+#define DEFUN_GSUBR_2(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
+#define DEFUN_GSUBR_3(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
+#define DEFUN_GSUBR_4(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
+#define DEFUN_GSUBR_5(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
+#define DEFUN_GSUBR_6(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
+#define DEFUN_GSUBR_7(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
+#define DEFUN_GSUBR_8(lname, fn, min, max) DEFUN_GSUBR_N(fn, max)
+
+#define DEFUN_GSUBR_UNEVALLED(lname, fn, minargs, maxargs)  \
+  Lisp_Object                                               \
+  gsubr_ ## fn (Lisp_Object rest)                           \
+  {                                                         \
+    Lisp_Object len = Flength (rest);                       \
+    if (XINT (len) < minargs)                               \
+      xsignal2 (Qwrong_number_of_arguments,                 \
+                intern (lname), len);                       \
+    return fn (rest);                                       \
+  }
+#define DEFUN_GSUBR_MANY(lname, fn, minargs, maxargs)        \
+  Lisp_Object                                               \
+  gsubr_ ## fn (Lisp_Object rest)                           \
+  {                                                         \
+    int len = scm_to_int (scm_length (rest));               \
+    Lisp_Object *args;                                      \
+    SAFE_ALLOCA_LISP (args, len);                           \
+    int i;                                                  \
+    for (i = 0;                                             \
+         i < len && scm_is_pair (rest);                     \
+         i++, rest = SCM_CDR (rest))                        \
+      args[i] = SCM_CAR (rest);                             \
+    if (i < minargs)                                        \
+      xsignal2 (Qwrong_number_of_arguments,                 \
+                intern (lname), make_number (i));           \
+    return fn (i, args);                                    \
+  }
 
 /* Note that the weird token-substitution semantics of ANSI C makes
    this work for MANY and UNEVALLED.  */
@@ -2400,7 +2402,7 @@ FUNCTIONP (Lisp_Object obj)
 
 /* defsubr (Sname);
    is how we define the symbol for function `name' at start-up time.  */
-extern void defsubr (struct Lisp_Subr *);
+extern void defsubr (const char *, scm_t_subr, short, short, const char *);
 
 enum maxargs
   {
@@ -2850,6 +2852,7 @@ extern Lisp_Object Qcircular_list;
 extern Lisp_Object Qsequencep;
 extern Lisp_Object Qchar_or_string_p, Qinteger_or_marker_p;
 extern Lisp_Object Qfboundp;
+extern Lisp_Object Qspecial_operator;
 
 extern Lisp_Object Qcdr;
 
@@ -3996,8 +3999,8 @@ functionp (Lisp_Object object)
        }
     }
 
-  if (SUBRP (object))
-    return XSUBR (object)->max_args != UNEVALLED;
+  if (scm_is_true (scm_procedure_p (object)))
+    return 1;
   else if (COMPILEDP (object))
     return true;
   else if (CONSP (object))
@@ -4005,8 +4008,6 @@ functionp (Lisp_Object object)
       Lisp_Object car = XCAR (object);
       return EQ (car, Qlambda) || EQ (car, Qclosure);
     }
-  else
-    return scm_is_true (scm_procedure_p (object));
 }
 
 INLINE_HEADER_END