Those are for callbacks with 0 and 2 SCM arguments, respectively. The former are needed mainly for translator callbacks, the second for acknowledgers. --- lily/callback.cc | 2 ++ lily/include/callback.hh | 81 +++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 82 insertions(+), 1 deletion(-)
diff --git a/lily/callback.cc b/lily/callback.cc index 5310295..fac40a0 100644 --- a/lily/callback.cc +++ b/lily/callback.cc @@ -20,3 +20,5 @@ #include "callback.hh" const char * const Callback_wrapper::type_p_name_ = 0; +const char * const Callback2_wrapper::type_p_name_ = 0; +const char * const Callback0_wrapper::type_p_name_ = 0; diff --git a/lily/include/callback.hh b/lily/include/callback.hh index b797baf..7151d04 100644 --- a/lily/include/callback.hh +++ b/lily/include/callback.hh @@ -44,7 +44,8 @@ class Callback_wrapper : public Simple_smob<Callback_wrapper> // this involves an adjustment of the this pointer from Smob_core to // the scope containing the callback. SCM (*trampoline_) (SCM, SCM); - Callback_wrapper (SCM (*trampoline) (SCM, SCM)) : trampoline_ (trampoline) + Callback_wrapper (SCM (*trampoline) (SCM, SCM)) + : trampoline_ (trampoline) { } // Private constructor, use only in make_smob public: static const char * const type_p_name_; // = 0 @@ -66,5 +67,83 @@ public: } }; +class Callback2_wrapper : public Simple_smob<Callback2_wrapper> +{ + // See Callback_wrapper for the details. Callback2_wrapper just + // supports an additional SCM argument as compared to + // Callback_wrapper but is otherwise identical. + SCM (*trampoline_) (SCM, SCM, SCM); + Callback2_wrapper (SCM (*trampoline) (SCM, SCM, SCM)) + : trampoline_ (trampoline) + { } // Private constructor, use only in make_smob +public: + static const char * const type_p_name_; // = 0 + LY_DECLARE_SMOB_PROC (&Callback2_wrapper::call, 3, 0, 0) + SCM call (SCM target, SCM arg1, SCM arg2) + { + return trampoline_ (target, arg1, arg2); + } + + template <SCM (*trampoline) (SCM, SCM, SCM)> + static SCM make_smob () + { + static SCM res = + scm_permanent_object (Callback2_wrapper (trampoline).smobbed_copy ()); + return res; + } +}; + +class Callback0_wrapper : public Simple_smob<Callback0_wrapper> +{ + // See Callback_wrapper for the details. Callback0_wrapper does not + // pass arguments but is otherwise identical to Callback_wrapper. + SCM (*trampoline_) (SCM); + Callback0_wrapper (SCM (*trampoline) (SCM)) + : trampoline_ (trampoline) + { } // Private constructor, use only in make_smob +public: + static const char * const type_p_name_; // = 0 + LY_DECLARE_SMOB_PROC (&Callback0_wrapper::call, 1, 0, 0) + SCM call (SCM target) + { + return trampoline_ (target); + } + + template <SCM (*trampoline) (SCM)> + static SCM make_smob () + { + static SCM res = + scm_permanent_object (Callback0_wrapper (trampoline).smobbed_copy ()); + return res; + } + // Since there are no arguments at all, we might as well provide + // default trampolines + template <class T, SCM (T::*p)()> + static SCM trampoline (SCM target) + { + T *t = LY_ASSERT_SMOB (T, target, 1); + return (t->*p) (); + } + + template <class T, void (T::*p)()> + static SCM trampoline (SCM target) + { + T *t = LY_ASSERT_SMOB (T, target, 1); + (t->*p) (); + return SCM_UNSPECIFIED; + } + + template <class T, SCM (T::*p)()> + static SCM make_smob () + { + return make_smob<trampoline<T, p> > (); + } + + template <class T, void (T::*p)()> + static SCM make_smob () + { + return make_smob<trampoline<T, p> > (); + } +}; #endif -- 2.7.4 _______________________________________________ lilypond-devel mailing list lilypond-devel@gnu.org https://lists.gnu.org/mailman/listinfo/lilypond-devel