Imported Upstream version 2.16.0

[lilypond.git] / lily / include / smobs.hh

diff --git a/lily/include/smobs.hh b/lily/include/smobs.hh
index cf6ffcc9a3fb2f5f4754ffe875b17025885973df..fb4fa530ee3fd6ef93090a6d50fa4cb3da27315f 100644 (file)
--- 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--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
+  Copyright (C) 1999--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
 
   LilyPond is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -46,7 +46,7 @@
 
   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 +67,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,52 +105,52 @@
   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
@@ -153,19 +159,34 @@ 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<parsed_dead *> 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 { } \
   while (0)
 #endif