+};
+
+template <class Super>
+class Smob_base
+{
+ static scm_t_bits smob_tag_;
+ static Scm_init scm_init_;
+ static void init (void);
+ static string smob_name_;
+ static Super *unchecked_unsmob (SCM s)
+ {
+ return reinterpret_cast<Super *> (SCM_SMOB_DATA (s));
+ }
+protected:
+ // reference scm_init_ in smob_tag which is sure to be called. The
+ // constructor, in contrast, may not be called at all in classes
+ // like Smob1.
+ static scm_t_bits smob_tag () { (void) scm_init_; return smob_tag_; }
+ Smob_base () { }
+ static SCM register_ptr (Super *p);
+ static Super *unregister_ptr (SCM obj);
+private:
+ // Those fallbacks are _only_ for internal use by Smob_base. They
+ // are characterized by no knowledge about the implemented type
+ // apart from the type's name. Overriding them as a template
+ // specialization is _not_ intended since a type-dependent
+ // implementation will in general need access to possibly private
+ // parts of the Super class. So any class-dependent override should
+ // be done by redefining the respective function in the Super class
+ // (where it will mask the private template member) rather than
+ // specializing a different template function/pointer.
+ //
+ // Most default functions are do-nothings. void init() will
+ // recognize their address when not overriden and will then refrain
+ // altogether from passing the the respective callbacks to GUILE.
+ SCM mark_smob (void);
+ static SCM mark_trampoline (SCM); // Used for calling mark_smob
+ static size_t free_smob (SCM obj);
+ static SCM equal_p (SCM, SCM);
+ int print_smob (SCM, scm_print_state *);
+ static int print_trampoline (SCM, SCM, scm_print_state *);
+
+ // type_p_name_ can be overriden in the Super class with a static
+ // const char [] string. This requires both a declaration in the
+ // class as well as a single instantiation outside. Using a
+ // template specialization for supplying a different string name
+ // right in Smob_base<Super> itself seems tempting, but the C++
+ // rules would then require a specialization declaration at the
+ // class definition site as well as a specialization instantiation
+ // in a single compilation unit. That requires just as much source
+ // code maintenance while being harder to understand and quite
+ // trickier in its failure symptoms when things go wrong. So we
+ // just use a static zero as "not here" indication.
+ static const int type_p_name_ = 0;
+
+ // LY_DECLARE_SMOB_PROC is used in the Super class definition for
+ // making a smob callable like a function. Declaration has to be
+ // public. It may be either be completed with a semicolon in which
+ // case a definition of the member function smob_proc has to be done
+ // outside of the class body, or the semicolon is left off and an
+ // inline function body is added immediately below. It would be
+ // nice if this were a non-static member function but it would seem
+ // tricky to do the required trampolining for unsmobbing the first
+ // argument of the callback and using it as a this pointer.
+#define LY_DECLARE_SMOB_PROC(REQ, OPT, VAR, ARGLIST) \
+ static const int smob_proc_signature_ = ((REQ)<<8)|((OPT)<<4)|(VAR); \
+ static SCM smob_proc ARGLIST
+
+ // a separate LY_DEFINE_SMOB_PROC seems sort of pointless as it
+ // would just result in SCM CLASS::smob_proc ARGLIST
+ //
+ // The default case without function functionality is recognized by
+ // smob_proc_signature being -1.
+ static const int smob_proc = 0;
+ static const int smob_proc_signature_ = -1;
+
+public:
+ static bool is_smob (SCM s)
+ {
+ return SCM_SMOB_PREDICATE (smob_tag (), s);
+ }
+ static SCM smob_p (SCM s)
+ {
+ return is_smob (s) ? SCM_BOOL_T : SCM_BOOL_F;
+ }
+ static Super *unsmob (SCM s)
+ {
+ return is_smob (s) ? Super::unchecked_unsmob (s) : 0;
+ }
+};
+
+// Simple smobs
+template <class Super>
+class Simple_smob : public Smob_base<Super> {
+public:
+ static size_t free_smob (SCM obj)
+ {
+ delete Smob_base<Super>::unregister_ptr (obj);
+ return 0;
+ }
+ SCM smobbed_copy () const
+ {
+ Super *p = new Super(*static_cast<const Super *> (this));
+ return Smob_base<Super>::register_ptr (p);
+ }
+};