lily/translator-group.cc

   1 /*
   2   Translator_group.cc -- implement Translator_group
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c)  1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7 */
   8
   9 #include "music-output-def.hh"
  10 #include "translator-group.hh"
  11 #include "translator.hh"
  12 #include "debug.hh"
  13 #include "moment.hh"
  14 #include "scm-hash.hh"
  15 #include "killing-cons.tcc"
  16 #include "translator-def.hh"
  17
  18 Translator_group::Translator_group (Translator_group const&s)
  19   : Translator(s)
  20 {
  21   iterator_count_ =0;
  22
  23   Scheme_hash_table * tab =  new Scheme_hash_table (*s.properties_dict ());
  24   properties_scm_ = tab->self_scm ();
  25   scm_unprotect_object (tab->self_scm( ));
  26 }
  27
  28 Scheme_hash_table*
  29 Translator_group::properties_dict () const
  30 {
  31   return Scheme_hash_table::unsmob (properties_scm_);
  32 }
  33
  34 Translator_group::~Translator_group ()
  35 {
  36   assert (removable_b());
  37 }
  38
  39
  40 Translator_group::Translator_group()
  41 {
  42   iterator_count_  = 0;
  43   Scheme_hash_table *tab = new Scheme_hash_table ;
  44   properties_scm_ = tab->self_scm ();
  45
  46   scm_unprotect_object (tab->self_scm ());
  47 }
  48
  49 void
  50 Translator_group::check_removal()
  51 {
  52   SCM next = SCM_EOL;
  53   for (SCM p = trans_group_list_; gh_pair_p (p); p = next)
  54     {
  55       next = gh_cdr (p);
  56
  57       Translator_group *trg =  dynamic_cast<Translator_group*> (unsmob_translator (gh_car (p)));
  58
  59       trg->check_removal ();
  60       if (trg->removable_b())
  61         terminate_translator (trg);
  62     }
  63 }
  64
  65
  66 SCM
  67 Translator_group::add_translator (SCM list, Translator *t)
  68 {
  69   list = gh_append2 (list, gh_cons (t->self_scm (), SCM_EOL));
  70   t->daddy_trans_l_ = this;
  71   t->output_def_l_ = output_def_l_;
  72   t->add_processing ();
  73
  74   return list;
  75 }
  76 void
  77 Translator_group::add_group_translator (Translator *t)
  78 {
  79   trans_group_list_ = add_translator (trans_group_list_,t);
  80 }
  81
  82
  83
  84 bool
  85 Translator_group::removable_b() const
  86 {
  87   return trans_group_list_ == SCM_EOL && ! iterator_count_;
  88 }
  89
  90 Translator_group *
  91 Translator_group::find_existing_translator_l (String n, String id)
  92 {
  93   if (is_alias_b (n) && (id_str_ == id || id.empty_b ()))
  94     return this;
  95
  96   Translator_group* r = 0;
  97   for (SCM p = trans_group_list_; !r && gh_pair_p (p); p = gh_cdr (p))
  98     {
  99       Translator *  t = unsmob_translator (gh_car (p));
 100
 101       r = dynamic_cast<Translator_group*> (t)->find_existing_translator_l (n, id);
 102     }
 103
 104   return r;
 105 }
 106
 107
 108
 109
 110 Translator_group*
 111 Translator_group::find_create_translator_l (String n, String id)
 112 {
 113   Translator_group * existing = find_existing_translator_l (n,id);
 114   if (existing)
 115     return existing;
 116
 117   Link_array<Translator_def> path
 118     = unsmob_translator_def (definition_)->path_to_acceptable_translator (ly_str02scm ((char*)n.ch_C()), output_def_l ());
 119
 120   if (path.size ())
 121     {
 122       Translator_group * current = this;
 123
 124       // start at 1.  The first one (index 0) will be us.
 125       for (int i=0; i < path.size (); i++)
 126         {
 127           Translator_group * new_group = path[i]->instantiate (output_def_l_);
 128
 129           current->add_group_translator (new_group);
 130           current = new_group;
 131         }
 132       current->id_str_ = id;
 133       return current;
 134     }
 135
 136   Translator_group *ret = 0;
 137   if (daddy_trans_l_)
 138     ret = daddy_trans_l_->find_create_translator_l (n,id);
 139   else
 140     {
 141       warning (_f ("can't find or create `%s' called `%s'", n, id));
 142       ret =0;
 143     }
 144   return ret;
 145 }
 146
 147 bool
 148 Translator_group::try_music_on_nongroup_children (Music *m)
 149 {
 150   bool hebbes_b =false;
 151
 152
 153   for (SCM p = simple_trans_list_; !hebbes_b && gh_pair_p (p); p = gh_cdr (p))
 154     {
 155       hebbes_b = unsmob_translator (gh_car (p))->try_music (m);
 156     }
 157   return hebbes_b;
 158 }
 159
 160 bool
 161 Translator_group::do_try_music (Music* m)
 162 {
 163   bool hebbes_b = try_music_on_nongroup_children (m);
 164
 165   if (!hebbes_b && daddy_trans_l_)
 166     hebbes_b = daddy_trans_l_->try_music (m);
 167   return hebbes_b ;
 168 }
 169
 170 int
 171 Translator_group::depth_i() const
 172 {
 173   return (daddy_trans_l_) ? daddy_trans_l_->depth_i()  + 1 : 0;
 174 }
 175
 176 Translator_group*
 177 Translator_group::ancestor_l (int level)
 178 {
 179   if (!level || !daddy_trans_l_)
 180     return this;
 181
 182   return daddy_trans_l_->ancestor_l (level-1);
 183 }
 184
 185 void
 186 Translator_group::terminate_translator (Translator*r_l)
 187 {
 188   r_l->removal_processing();
 189   /*
 190     Return value ignored. GC does the rest.
 191    */
 192   remove_translator_p (r_l);
 193 }
 194
 195
 196 /**
 197    Remove a translator from the hierarchy.
 198  */
 199 Translator *
 200 Translator_group::remove_translator_p (Translator*trans_l)
 201 {
 202   assert (trans_l);
 203
 204   trans_group_list_ = scm_delq_x (trans_l->self_scm (), trans_group_list_);
 205   trans_l->daddy_trans_l_ = 0;
 206   return trans_l;
 207 }
 208
 209 #if 0
 210 /*
 211   should not use, instead: use properties to communicate between engravers.
 212  */
 213 Translator*
 214 Translator_group::get_simple_translator (String type) const
 215 {
 216   for (SCM p = simple_trans_list_;  gh_pair_p (p); p =gh_cdr (p))
 217     {
 218       if (classname (unsmob_translator (gh_car (p))) == type)
 219         return unsmob_translator (gh_car (p));
 220     }
 221   if (daddy_trans_l_)
 222     return daddy_trans_l_->get_simple_translator (type);
 223   return 0;
 224 }
 225 #endif
 226
 227 bool
 228 Translator_group::is_bottom_translator_b () const
 229 {
 230   return unsmob_translator_def (definition_)->accepts_name_list_ == SCM_EOL;
 231 }
 232
 233 Translator_group*
 234 Translator_group::get_default_interpreter()
 235 {
 236   if (!is_bottom_translator_b ())
 237     {
 238       SCM nm = unsmob_translator_def (definition_)->accepts_name_list_;
 239       SCM st = output_def_l ()->find_translator_l (gh_car (nm));
 240
 241       Translator_def *t = unsmob_translator_def (st);
 242       if (!t)
 243         {
 244           warning (_f ("can't find or create: `%s'", ly_scm2string (nm).ch_C()));
 245           t = unsmob_translator_def (this->definition_);
 246         }
 247       Translator_group *tg = t->instantiate (output_def_l_);
 248       add_group_translator (tg);
 249
 250       if (!tg->is_bottom_translator_b ())
 251         return tg->get_default_interpreter ();
 252       else
 253         return tg;
 254     }
 255   return this;
 256 }
 257
 258 static void
 259 static_each (SCM list, Method_pointer method)
 260 {
 261   for (SCM p = list; gh_pair_p (p); p = gh_cdr(p))
 262     (unsmob_translator (gh_car (p))->*method) ();
 263
 264 }
 265
 266 void
 267 Translator_group::each (Method_pointer method)
 268 {
 269   static_each (simple_trans_list_, method);
 270   static_each (trans_group_list_, method);
 271 }
 272
 273 void
 274 Translator_group::do_print() const
 275 {
 276 #ifndef NPRINT
 277 #endif
 278 }
 279
 280 void
 281 Translator_group::do_add_processing ()
 282 {
 283   for (SCM s = simple_trans_list_; gh_pair_p (s) ; s = gh_cdr (s))
 284     {
 285       Translator * t = unsmob_translator (gh_car (s));
 286       t->add_processing ();
 287     }
 288 }
 289
 290 /*
 291   PROPERTIES
 292  */
 293 Translator_group*
 294 Translator_group::where_defined (SCM sym) const
 295 {
 296   if (properties_dict ()->elem_b (sym))
 297     {
 298       return (Translator_group*)this;
 299     }
 300
 301   return (daddy_trans_l_) ? daddy_trans_l_->where_defined (sym) : 0;
 302 }
 303
 304 SCM
 305 Translator_group::get_property (SCM sym) const
 306 {
 307   if (properties_dict ()->elem_b (sym))
 308     {
 309       return properties_dict ()->get (sym);
 310     }
 311
 312   if (daddy_trans_l_)
 313     return daddy_trans_l_->get_property (sym);
 314
 315   return SCM_UNDEFINED;
 316 }
 317
 318 void
 319 Translator_group::set_property (String id, SCM val)
 320 {
 321   set_property (ly_symbol2scm (id.ch_C()), val);
 322 }
 323
 324 void
 325 Translator_group::set_property (SCM sym, SCM val)
 326 {
 327   properties_dict ()->set (sym, val);
 328 }
 329
 330 /*
 331   Push or pop (depending on value of VAL) a single entry (ELTPROP . VAL)
 332   entry from a translator property list by name of PROP
 333 */
 334 void
 335 Translator_group::execute_single_pushpop_property (SCM prop, SCM eltprop, SCM val)
 336 {
 337   if (gh_symbol_p(prop))
 338     {
 339       if (val != SCM_UNDEFINED)
 340         {
 341           SCM prev = get_property (prop);
 342
 343           prev = gh_cons (gh_cons (eltprop, val), prev);
 344           set_property (prop, prev);
 345         }
 346       else
 347         {
 348           SCM prev = get_property (prop);
 349
 350           SCM newprops= SCM_EOL ;
 351           while (gh_pair_p (prev) && gh_caar (prev) != eltprop)
 352             {
 353               newprops = gh_cons (gh_car (prev), newprops);
 354               prev = gh_cdr (prev);
 355             }
 356
 357           if (gh_pair_p (prev))
 358             {
 359               newprops = scm_reverse_x (newprops, gh_cdr (prev));
 360               set_property (prop, newprops);
 361             }
 362         }
 363     }
 364 }
 365
 366
 367
 368
 369
 370 /*
 371   STUBS
 372 */
 373 void
 374 Translator_group::do_pre_move_processing ()
 375 {
 376   each (&Translator::pre_move_processing);
 377 }
 378
 379 void
 380 Translator_group::do_post_move_processing ()
 381 {
 382   each (&Translator::post_move_processing);
 383 }
 384
 385 void
 386 Translator_group::do_process_music ()
 387 {
 388   each (&Translator::process_music);
 389 }
 390
 391 void
 392 Translator_group::do_creation_processing ()
 393 {
 394   each (&Translator::creation_processing);
 395 }
 396
 397 void
 398 Translator_group::do_removal_processing ()
 399 {
 400   each (&Translator::removal_processing);
 401 }