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--2003 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 "warn.hh"
  13 #include "moment.hh"
  14 #include "scm-hash.hh"
  15 #include "translator-def.hh"
  16 #include "main.hh"
  17 #include "music.hh"
  18
  19 Translator_group::Translator_group (Translator_group const&s)
  20   : Translator (s)
  21 {
  22   iterator_count_ =0;
  23
  24   Scheme_hash_table * tab =  new Scheme_hash_table (*s.properties_dict ());
  25   properties_scm_ = tab->self_scm ();
  26   scm_gc_unprotect_object (tab->self_scm ());
  27 }
  28
  29 Scheme_hash_table*
  30 Translator_group::properties_dict () const
  31 {
  32   return Scheme_hash_table::unsmob (properties_scm_);
  33 }
  34
  35 Translator_group::~Translator_group ()
  36 {
  37
  38   //assert (removable_b ());
  39 }
  40
  41
  42 Translator_group::Translator_group ()
  43 {
  44   iterator_count_  = 0;
  45   Scheme_hash_table *tab = new Scheme_hash_table ;
  46   properties_scm_ = tab->self_scm ();
  47
  48   scm_gc_unprotect_object (tab->self_scm ());
  49 }
  50
  51 void
  52 Translator_group::check_removal ()
  53 {
  54   SCM next = SCM_EOL;
  55   for (SCM p = trans_group_list_; gh_pair_p (p); p = next)
  56     {
  57       next = ly_cdr (p);
  58
  59       Translator_group *trg =  dynamic_cast<Translator_group*> (unsmob_translator (ly_car (p)));
  60
  61       trg->check_removal ();
  62       if (trg->removable_b ())
  63         terminate_translator (trg);
  64     }
  65 }
  66
  67 SCM
  68 Translator_group::add_translator (SCM list, Translator *t)
  69 {
  70   /*
  71     Must append, since list ordering must be preserved.
  72    */
  73   list = gh_append2 (list, gh_cons (t->self_scm (), SCM_EOL));
  74   t->daddy_trans_ = this;
  75   t->output_def_ = output_def_;
  76
  77   return list;
  78 }
  79
  80
  81 void
  82 Translator_group::add_used_group_translator (Translator *t)
  83 {
  84   trans_group_list_ = add_translator (trans_group_list_,t);
  85 }
  86
  87
  88 void
  89 Translator_group::add_fresh_group_translator (Translator*t)
  90 {
  91   Translator_group*tg = dynamic_cast<Translator_group*> (t);
  92   assert (tg);
  93
  94   trans_group_list_ = add_translator (trans_group_list_,t);
  95   unsmob_translator_def (tg->definition_)->apply_property_operations (tg);
  96   t->initialize ();
  97
  98 }
  99
 100
 101 bool
 102 Translator_group::removable_b () const
 103 {
 104   return trans_group_list_ == SCM_EOL && ! iterator_count_;
 105 }
 106
 107 Translator_group *
 108 Translator_group::find_existing_translator (SCM n, String id)
 109 {
 110   if ((is_alias_b (n) && (id_string_ == id || id.empty_b ())) || n == ly_symbol2scm ("Current"))
 111     return this;
 112
 113   Translator_group* r = 0;
 114   for (SCM p = trans_group_list_; !r && gh_pair_p (p); p = ly_cdr (p))
 115     {
 116       Translator *  t = unsmob_translator (ly_car (p));
 117
 118       r = dynamic_cast<Translator_group*> (t)->find_existing_translator (n, id);
 119     }
 120
 121   return r;
 122 }
 123
 124
 125 Translator_group*
 126 Translator_group::find_create_translator (SCM n, String id)
 127 {
 128   Translator_group * existing = find_existing_translator (n,id);
 129   if (existing)
 130     return existing;
 131
 132   Link_array<Translator_def> path
 133     = unsmob_translator_def (definition_)->path_to_acceptable_translator (n, get_output_def ());
 134
 135   if (path.size ())
 136     {
 137       Translator_group * current = this;
 138
 139       // start at 1.  The first one (index 0) will be us.
 140       for (int i=0; i < path.size (); i++)
 141         {
 142           Translator_group * new_group = path[i]->instantiate (output_def_);
 143
 144           if (i == path.size () -1)
 145             new_group->id_string_ = id;
 146           current->add_fresh_group_translator (new_group);
 147           current = new_group;
 148         }
 149
 150       return current;
 151     }
 152
 153   Translator_group *ret = 0;
 154   if (daddy_trans_)
 155     ret = daddy_trans_->find_create_translator (n,id);
 156   else
 157     {
 158       warning (_f ("can't find or create `%s' called `%s'", ly_symbol2string (n).to_str0 (), id));
 159       ret =0;
 160     }
 161   return ret;
 162 }
 163
 164 bool
 165 Translator_group::try_music (Music* m)
 166 {
 167   bool hebbes_b = try_music_on_nongroup_children (m);
 168
 169   if (!hebbes_b && daddy_trans_)
 170     hebbes_b = daddy_trans_->try_music (m);
 171   return hebbes_b ;
 172 }
 173
 174 int
 175 Translator_group::get_depth () const
 176 {
 177   return (daddy_trans_) ? daddy_trans_->get_depth ()  + 1 : 0;
 178 }
 179
 180 Translator_group*
 181 Translator_group::get_ancestor (int level)
 182 {
 183   if (!level || !daddy_trans_)
 184     return this;
 185
 186   return daddy_trans_->get_ancestor (level-1);
 187 }
 188
 189 void
 190 Translator_group::terminate_translator (Translator*r)
 191 {
 192   r->removal_processing ();
 193   /*
 194     Return value ignored. GC does the rest.
 195    */
 196   remove_translator (r);
 197 }
 198
 199
 200 /**
 201    Remove a translator from the hierarchy.
 202  */
 203 Translator *
 204 Translator_group::remove_translator (Translator*trans)
 205 {
 206   assert (trans);
 207
 208   trans_group_list_ = scm_delq_x (trans->self_scm (), trans_group_list_);
 209   trans->daddy_trans_ = 0;
 210   return trans;
 211 }
 212
 213 bool
 214 Translator_group::is_bottom_translator_b () const
 215 {
 216   return !gh_symbol_p (unsmob_translator_def (definition_)->default_child_context_name ());
 217 }
 218
 219 Translator_group*
 220 Translator_group::get_default_interpreter ()
 221 {
 222   if (!is_bottom_translator_b ())
 223     {
 224       SCM nm = unsmob_translator_def (definition_)->default_child_context_name ();
 225       SCM st = get_output_def ()->find_translator (nm);
 226
 227       Translator_def *t = unsmob_translator_def (st);
 228       if (!t)
 229         {
 230           warning (_f ("can't find or create: `%s'", ly_scm2string (nm).to_str0 ()));
 231           t = unsmob_translator_def (this->definition_);
 232         }
 233       Translator_group *tg = t->instantiate (output_def_);
 234       add_fresh_group_translator (tg);
 235
 236       if (!tg->is_bottom_translator_b ())
 237         return tg->get_default_interpreter ();
 238       else
 239         return tg;
 240     }
 241   return this;
 242 }
 243
 244 static void
 245 static_each (SCM list, Method_pointer method)
 246 {
 247   for (SCM p = list; gh_pair_p (p); p = ly_cdr (p))
 248     (unsmob_translator (ly_car (p))->*method) ();
 249
 250 }
 251
 252 void
 253 Translator_group::each (Method_pointer method)
 254 {
 255   static_each (simple_trans_list_, method);
 256   static_each (trans_group_list_, method);
 257 }
 258
 259
 260 /*
 261   PROPERTIES
 262  */
 263 Translator_group*
 264 Translator_group::where_defined (SCM sym) const
 265 {
 266   if (properties_dict ()->elem_b (sym))
 267     {
 268       return (Translator_group*)this;
 269     }
 270
 271   return (daddy_trans_) ? daddy_trans_->where_defined (sym) : 0;
 272 }
 273
 274 /*
 275   return SCM_EOL when not found.
 276 */
 277 SCM
 278 Translator_group::internal_get_property (SCM sym) const
 279 {
 280   SCM val =SCM_EOL;
 281   if (properties_dict ()->try_retrieve (sym, &val))
 282     return val;
 283
 284   if (daddy_trans_)
 285     return daddy_trans_->internal_get_property (sym);
 286
 287   return val;
 288 }
 289
 290 void
 291 Translator_group::internal_set_property (SCM sym, SCM val)
 292 {
 293 #ifndef NDEBUG
 294   if (internal_type_checking_global_b)
 295     assert (type_check_assignment (sym, val, ly_symbol2scm ("translation-type?")));
 296 #endif
 297
 298   properties_dict ()->set (sym, val);
 299 }
 300
 301 /*
 302   TODO: look up to check whether we have inherited var?
 303  */
 304 void
 305 Translator_group::unset_property (SCM sym)
 306 {
 307   properties_dict ()->remove (sym);
 308 }
 309
 310
 311 /*
 312   Push or pop (depending on value of VAL) a single entry (ELTPROP . VAL)
 313   entry from a translator property list by name of PROP
 314 */
 315 void
 316 Translator_group::execute_pushpop_property (SCM prop, SCM eltprop, SCM val)
 317 {
 318   if (gh_symbol_p (prop))
 319     {
 320       if (val != SCM_UNDEFINED)
 321         {
 322           SCM prev = internal_get_property (prop);
 323
 324           if (gh_pair_p (prev) || prev == SCM_EOL)
 325             {
 326               bool ok = type_check_assignment (eltprop, val, ly_symbol2scm ("backend-type?"));
 327
 328               if (ok)
 329                 {
 330                   prev = gh_cons (gh_cons (eltprop, val), prev);
 331                   internal_set_property (prop, prev);
 332                 }
 333             }
 334           else
 335             {
 336               // warning here.
 337             }
 338
 339         }
 340       else
 341         {
 342           SCM prev = internal_get_property (prop);
 343
 344           /*
 345             TODO: should have scm_equal_something () for reverting
 346             autobeam properties.
 347            */
 348           SCM newprops= SCM_EOL ;
 349           while (gh_pair_p (prev) && ly_caar (prev) != eltprop)
 350             {
 351               newprops = gh_cons (ly_car (prev), newprops);
 352               prev = ly_cdr (prev);
 353             }
 354
 355           if (gh_pair_p (prev))
 356             {
 357               newprops = scm_reverse_x (newprops, ly_cdr (prev));
 358               internal_set_property (prop, newprops);
 359             }
 360         }
 361     }
 362 }
 363
 364
 365
 366 /*
 367   STUBS
 368 */
 369 void
 370 Translator_group::stop_translation_timestep ()
 371 {
 372   each (&Translator::stop_translation_timestep);
 373 }
 374
 375 void
 376 Translator_group::start_translation_timestep ()
 377 {
 378   each (&Translator::start_translation_timestep);
 379 }
 380
 381 void
 382 Translator_group::do_announces ()
 383 {
 384   each (&Translator::do_announces);
 385 }
 386
 387 void
 388 Translator_group::initialize ()
 389 {
 390   SCM tab = scm_make_vector (gh_int2scm (19), SCM_BOOL_F);
 391   set_property ("acceptHashTable", tab);
 392   each (&Translator::initialize);
 393 }
 394
 395 void
 396 Translator_group::finalize ()
 397 {
 398   each (&Translator::removal_processing);
 399 }
 400
 401
 402
 403 bool translator_accepts_any_of (Translator*tr, SCM ifaces)
 404 {
 405   SCM ack_ifs = scm_assoc (ly_symbol2scm ("events-accepted"),
 406                            tr->translator_description());
 407   ack_ifs = gh_cdr (ack_ifs);
 408   for (SCM s = ifaces; ly_pair_p (s); s = ly_cdr (s))
 409     if (scm_memq (ly_car (s), ack_ifs) != SCM_BOOL_F)
 410       return true;
 411   return false;
 412 }
 413
 414 SCM
 415 find_accept_translators (SCM gravlist, SCM ifaces)
 416 {
 417   SCM l = SCM_EOL;
 418   for (SCM s = gravlist; ly_pair_p (s);  s = ly_cdr (s))
 419     {
 420       Translator* tr = unsmob_translator (ly_car (s));
 421       if (translator_accepts_any_of (tr, ifaces))
 422         l = scm_cons (tr->self_scm (), l);
 423     }
 424   l = scm_reverse_x (l, SCM_EOL);
 425
 426   return l;
 427 }
 428
 429 bool
 430 Translator_group::try_music_on_nongroup_children (Music *m )
 431 {
 432   SCM tab = get_property ("acceptHashTable");
 433   SCM name = scm_sloppy_assq (ly_symbol2scm ("name"),
 434                               m->get_property_alist (false));
 435
 436   if (!gh_pair_p (name))
 437     return false;
 438
 439   name = gh_cdr (name);
 440   SCM accept_list = scm_hashq_ref (tab, name, SCM_UNDEFINED);
 441   if (accept_list == SCM_BOOL_F)
 442     {
 443       accept_list = find_accept_translators (simple_trans_list_,
 444                                              m->get_mus_property ("types"));
 445       scm_hashq_set_x (tab, name, accept_list);
 446     }
 447
 448   for (SCM p = accept_list; gh_pair_p (p); p = ly_cdr (p))
 449     {
 450       Translator * t = unsmob_translator (ly_car (p));
 451       if (t && t->try_music (m))
 452         return true;
 453     }
 454   return false;
 455 }
 456
 457 SCM
 458 Translator_group::properties_as_alist () const
 459 {
 460   return properties_dict()->to_alist();
 461 }
 462
 463 String
 464 Translator_group::context_name () const
 465 {
 466   Translator_def * td = unsmob_translator_def (definition_ );
 467   return ly_symbol2string (td->type_name_);
 468 }