X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Finclude%2Fsmobs.hh;h=95e5ba1a11b1e7962e43e5df999867321105c5f0;hb=e223f29418201d07dc1637e54a47e9757f91e86a;hp=cbf956b578ad2d09aaa144bec55f13505504f686;hpb=629586f4cd85758ba4d4b5c7517e81becdf9bb1a;p=lilypond.git diff --git a/lily/include/smobs.hh b/lily/include/smobs.hh index cbf956b578..95e5ba1a11 100644 --- a/lily/include/smobs.hh +++ b/lily/include/smobs.hh @@ -1,7 +1,7 @@ /* This file is part of LilyPond, the GNU music typesetter. - Copyright (C) 1999--2010 Han-Wen Nienhuys + Copyright (C) 1999--2014 Han-Wen Nienhuys LilyPond is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -40,13 +40,27 @@ Simple smobs are created by adding the DECLARE_SIMPLE_SMOBS(Classname) to the declaration + A simple smob is only optionally under the reign of the GUILE + garbage collector: its usual life time is that of a normal C++ + object. While a smobbed_copy () is fully under control of the + garbage collector and will have its mark_smob function called during + garbage collection, an automatic variable of this type will not have + mark_smob called, but rather have its memory image in the call stack + scanned for contained non-immediate SCM values. Anything requiring + more complex mark_smob behavior is not suitable for a simple smob. + + When you create a smobbed_copy, the _copy_ is fully managed by the + GUILE memory system. As a corollary, multiple smobbed_copy calls + yield multiple GUILE objects generally not eq? to each other. + 2. Complex smobs are objects that have an identity. These objects carry this identity in the form of a self_scm () method, which is a - SCM pointer to the object itself. + SCM pointer to the object itself. Complex smobs are always under + control of the GUILE memory system. The constructor for a complex smob should have 3 steps: - * initialize all SCM members to a non-immediate value (like SCM_EOL) + * initialize all SCM members to an immediate value (like SCM_EOL) * call smobify_self () @@ -67,7 +81,13 @@ Complex_smob *p = new Complex_smob; list = scm_cons (p->self_scm (), list); - scm_gc_unprotect_object (p->self_scm ()); + p->unprotect (); + + Since unprotect returns the SCM object itself, this particular case + can be written as + + Complex_smob *p = new Complex_smob; + list = scm_cons (p->unprotect (), list); Complex smobs are made with DECLARE_SMOBS (Classname) in the class declaration. @@ -99,73 +119,86 @@ from file "ly-smobs.icc" */ -#define DECLARE_SIMPLE_SMOBS(CL) \ - public: \ - SCM smobbed_copy () const; \ +#define DECLARE_SIMPLE_SMOBS(CL) \ + public: \ + SCM smobbed_copy () const; \ DECLARE_BASE_SMOBS (CL) -#define DECLARE_BASE_SMOBS(CL) \ - friend class Non_existent_class; \ - private: \ +#define DECLARE_BASE_SMOBS(CL) \ + friend class Non_existent_class; \ + private: \ static const char* smob_name_; \ - static scm_t_bits smob_tag_; \ - static SCM mark_smob (SCM); \ - static size_t free_smob (SCM s); \ - static int print_smob (SCM s, SCM p, scm_print_state*); \ - public: \ - static SCM equal_p (SCM a, SCM b); \ - static CL *unsmob (SCM s) __attribute__((pure)) \ - { \ - if (SCM_NIMP (s) && SCM_CELL_TYPE (s) == smob_tag_) \ - return (CL *) SCM_CELL_WORD_1 (s); \ - else \ - return 0; \ - } \ - static SCM smob_p (SCM); \ - static void init_smobs (); \ + static scm_t_bits smob_tag_; \ + static SCM mark_smob (SCM); \ + static size_t free_smob (SCM s); \ + static int print_smob (SCM s, SCM p, scm_print_state*); \ + public: \ + static SCM equal_p (SCM a, SCM b); \ + static CL *unsmob (SCM s) __attribute__((pure)) \ + { \ + if (SCM_NIMP (s) && SCM_CELL_TYPE (s) == smob_tag_) \ + return (CL *) SCM_CELL_WORD_1 (s); \ + else \ + return 0; \ + } \ + static SCM smob_p (SCM); \ + static void init_smobs (); \ private: -#define DECLARE_SMOBS(CL) \ - DECLARE_BASE_SMOBS (CL) \ - protected: \ - virtual ~CL (); \ - SCM unprotected_smobify_self (); \ - private: \ - void smobify_self (); \ - SCM self_scm_; \ - SCM protection_cons_; \ - public: \ - SCM unprotect (); \ - void protect (); \ - SCM self_scm () const { return self_scm_; } \ +#define DECLARE_SMOBS(CL) \ + DECLARE_BASE_SMOBS (CL) \ + protected: \ + virtual ~CL (); \ + SCM unprotected_smobify_self (); \ + private: \ + void smobify_self (); \ + SCM self_scm_; \ + SCM protection_cons_; \ + public: \ + SCM unprotect (); \ + void protect (); \ + SCM self_scm () const { return self_scm_; } \ private: -#define DECLARE_UNSMOB(CL, name) \ - inline CL * \ - unsmob_ ## name (SCM s) \ - { \ - return CL::unsmob (s); \ +#define DECLARE_UNSMOB(CL, name) \ + inline CL * \ + unsmob_ ## name (SCM s) \ + { \ + return CL::unsmob (s); \ } -#define DECLARE_TYPE_P(CL) extern SCM CL ## _type_p_proc - void protect_smob (SCM smob, SCM *prot_cons); void unprotect_smob (SCM smob, SCM *prot_cons); extern bool parsed_objects_should_be_dead; +class parsed_dead +{ + static vector elements; + SCM data; + SCM readout_one () + { + SCM res = data; + data = SCM_UNDEFINED; + return res; + } +public: + parsed_dead () : data (SCM_UNDEFINED) + { + elements.push_back (this); + } + void checkin (SCM arg) { data = arg; } + static SCM readout (); +}; #ifndef NDEBUG -#define ASSERT_LIVE_IS_ALLOWED() \ - do { \ - static bool passed_here_once;\ - if (parsed_objects_should_be_dead && !passed_here_once) { \ - ::programming_error (string ("Parsed object should be dead: ") + __PRETTY_FUNCTION__ ); \ - passed_here_once = true;\ - } \ - } \ - while (0) +#define ASSERT_LIVE_IS_ALLOWED(arg) \ + do { \ + static parsed_dead pass_here; \ + if (parsed_objects_should_be_dead) \ + pass_here.checkin (arg); \ + } while (0) #else -#define ASSERT_LIVE_IS_ALLOWED() do { } \ +#define ASSERT_LIVE_IS_ALLOWED(arg) do { (void)(arg); } \ while (0) #endif