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--2006 Han-Wen Nienhuys <hanwen@xs4all.nl>,
   7                  Erik Sandberg <mandolaerik@gmail.com>
   8 */
   9
  10 #include "translator-group.hh"
  11
  12 #include "context-def.hh"
  13 #include "context.hh"
  14 #include "dispatcher.hh"
  15 #include "engraver-group.hh"
  16 #include "international.hh"
  17 #include "main.hh"
  18 #include "music.hh"
  19 #include "output-def.hh"
  20 #include "performer-group.hh"
  21 #include "scm-hash.hh"
  22 #include "stream-event.hh"
  23 #include "warn.hh"
  24
  25 Translator_group *
  26 Translator_group::get_daddy_translator () const
  27 {
  28   return context ()->get_parent_context ()->implementation ();
  29 }
  30
  31 void
  32 translator_each (SCM list, Translator_method method)
  33 {
  34   for (SCM p = list; scm_is_pair (p); p = scm_cdr (p))
  35     (unsmob_translator (scm_car (p))->*method) ();
  36 }
  37
  38 void
  39 Translator_group::initialize ()
  40 {
  41   precompute_method_bindings ();
  42 }
  43
  44 void
  45 Translator_group::connect_to_context (Context *c)
  46 {
  47   if (context_)
  48     {
  49       programming_error ("translator group is already connected to context "
  50                          +  context_->context_name ());
  51     }
  52
  53   context_ = c;
  54   c->event_source ()->add_listener (GET_LISTENER (eat_event),
  55                                     ly_symbol2scm ("OldMusicEvent"));
  56   c->event_source ()->add_listener (GET_LISTENER (create_child_translator),
  57                                     ly_symbol2scm ("AnnounceNewContext"));
  58   for (SCM tr_list = simple_trans_list_; scm_is_pair (tr_list); tr_list = scm_cdr (tr_list))
  59     {
  60       Translator *tr = unsmob_translator (scm_car (tr_list));
  61       tr->connect_to_context (c);
  62     }
  63 }
  64
  65 void
  66 Translator_group::disconnect_from_context ()
  67 {
  68   for (SCM tr_list = simple_trans_list_; scm_is_pair (tr_list); tr_list = scm_cdr (tr_list))
  69     {
  70       Translator *tr = unsmob_translator (scm_car (tr_list));
  71       tr->disconnect_from_context (context_);
  72     }
  73   context_->event_source ()->remove_listener (GET_LISTENER (eat_event),
  74                                               ly_symbol2scm ("OldMusicEvent"));
  75   context_->event_source ()->remove_listener (GET_LISTENER (create_child_translator),
  76                                               ly_symbol2scm ("AnnounceNewContext"));
  77   context_ = 0;
  78   protected_events_ = SCM_EOL;
  79 }
  80
  81 void
  82 Translator_group::finalize ()
  83 {
  84 }
  85
  86 bool
  87 translator_accepts_any_of (Translator *tr, SCM ifaces)
  88 {
  89   SCM ack_ifs = scm_assoc (ly_symbol2scm ("events-accepted"),
  90                            tr->translator_description ());
  91   ack_ifs = scm_cdr (ack_ifs);
  92   for (SCM s = ifaces; scm_is_pair (s); s = scm_cdr (s))
  93     if (scm_c_memq (scm_car (s), ack_ifs) != SCM_BOOL_F)
  94       return true;
  95   return false;
  96 }
  97
  98 SCM
  99 find_accept_translators (SCM gravlist, SCM ifaces)
 100 {
 101   SCM l = SCM_EOL;
 102   for (SCM s = gravlist; scm_is_pair (s); s = scm_cdr (s))
 103     {
 104       Translator *tr = unsmob_translator (scm_car (s));
 105       if (translator_accepts_any_of (tr, ifaces))
 106         l = scm_cons (tr->self_scm (), l);
 107     }
 108   l = scm_reverse_x (l, SCM_EOL);
 109
 110   return l;
 111 }
 112
 113 SCM
 114 filter_performers (SCM ell)
 115 {
 116   SCM *tail = &ell;
 117   for (SCM p = ell; scm_is_pair (p); p = scm_cdr (p))
 118     {
 119       if (dynamic_cast<Performer *> (unsmob_translator (scm_car (*tail))))
 120         *tail = scm_cdr (*tail);
 121       else
 122         tail = SCM_CDRLOC (*tail);
 123     }
 124   return ell;
 125 }
 126
 127 SCM
 128 filter_engravers (SCM ell)
 129 {
 130   SCM *tail = &ell;
 131   for (SCM p = ell; scm_is_pair (p); p = scm_cdr (p))
 132     {
 133       if (dynamic_cast<Engraver *> (unsmob_translator (scm_car (*tail))))
 134         *tail = scm_cdr (*tail);
 135       else
 136         tail = SCM_CDRLOC (*tail);
 137     }
 138   return ell;
 139 }
 140
 141 /*
 142   Protects the parameter from being garbage collected. The object is
 143   protected until the next disconnect_from_context call.
 144
 145   Whenever a child translator hears an event, the event is added to
 146   this list. This eliminates the need for derived_mark methods in most
 147   translators; all incoming events are instead protected by the
 148   translator group.
 149
 150   TODO: Should the list also be flushed at the beginning of each new
 151   moment?
 152  */
 153 void
 154 Translator_group::protect_event (SCM ev)
 155 {
 156   protected_events_ = scm_cons (ev, protected_events_);
 157 }
 158
 159 /*
 160   Create a new translator for a newly created child context. Triggered
 161   by AnnounceNewContext events.
 162  */
 163 IMPLEMENT_LISTENER (Translator_group, create_child_translator);
 164 void
 165 Translator_group::create_child_translator (SCM sev)
 166 {
 167   Stream_event *ev = unsmob_stream_event (sev);
 168   // get from AnnounceNewContext
 169   SCM cs = ev->get_property ("context");
 170   Context *new_context = unsmob_context (cs);
 171   Context_def *def = unsmob_context_def (new_context->get_definition ());
 172   SCM ops = new_context->get_definition_mods ();
 173
 174   SCM trans_names = def->get_translator_names (ops);
 175
 176   Translator_group *g = get_translator_group (def->get_translator_group_type ());
 177   SCM trans_list = SCM_EOL;
 178
 179   for (SCM s = trans_names; scm_is_pair (s); s = scm_cdr (s))
 180     {
 181       Translator *type = get_translator (scm_car (s));
 182       if (!type)
 183         warning (_f ("can't find: `%s'", ly_symbol2string (scm_car (s)).c_str ()));
 184       else
 185         {
 186           Translator *tr = type->clone ();
 187           SCM str = tr->self_scm ();
 188
 189           if (tr->must_be_last ())
 190             {
 191               SCM cons = scm_cons (str, SCM_EOL);
 192               if (scm_is_pair (trans_list))
 193                 scm_set_cdr_x (scm_last_pair (trans_list), cons);
 194               else
 195                 trans_list = cons;
 196             }
 197           else
 198             trans_list = scm_cons (str, trans_list);
 199
 200           tr->daddy_context_ = new_context;
 201           tr->unprotect ();
 202         }
 203     }
 204
 205   /* Filter unwanted translator types. Required to make
 206      \with {\consists "..."} work. */
 207   if (dynamic_cast<Engraver_group *> (g))
 208     g->simple_trans_list_ = filter_performers (trans_list);
 209   else if (dynamic_cast<Performer_group *> (g))
 210     g->simple_trans_list_ = filter_engravers (trans_list);
 211
 212   // TODO: scrap Context::implementation
 213   new_context->implementation_ = g;
 214
 215   g->connect_to_context (new_context);
 216   g->unprotect ();
 217
 218   recurse_over_translators (new_context,
 219                             &Translator::initialize,
 220                             &Translator_group::initialize,
 221                             DOWN);
 222 }
 223
 224 IMPLEMENT_LISTENER (Translator_group, eat_event);
 225 void
 226 Translator_group::eat_event (SCM sev)
 227 {
 228   Stream_event *ev = unsmob_stream_event (sev);
 229   SCM sm = ev->get_property ("music");
 230   Music *m = unsmob_music (sm);
 231   try_music (m);
 232 }
 233
 234 bool
 235 Translator_group::try_music (Music *m)
 236 {
 237   SCM name = scm_sloppy_assq (ly_symbol2scm ("name"),
 238                               m->get_property_alist (false));
 239
 240   if (!scm_is_pair (name))
 241     return false;
 242
 243   name = scm_cdr (name);
 244   SCM accept_list = scm_hashq_ref (accept_hash_table_, name, SCM_UNDEFINED);
 245   if (accept_list == SCM_BOOL_F)
 246     {
 247       accept_list = find_accept_translators (get_simple_trans_list (),
 248                                              m->get_property ("types"));
 249       scm_hashq_set_x (accept_hash_table_, name, accept_list);
 250     }
 251
 252   for (SCM p = accept_list; scm_is_pair (p); p = scm_cdr (p))
 253     {
 254       Translator *t = unsmob_translator (scm_car (p));
 255       if (t && t->try_music (m))
 256         return true;
 257     }
 258
 259   // We couldn't swallow the event in this context. Try parent.
 260   Context *p = context ()->get_parent_context ();
 261   // Global context's translator group is a dummy, so don't try it.
 262   if (p->get_parent_context())
 263     // ES todo: Make Translators listeners directly instead.
 264     return p->implementation ()->try_music (m);
 265   // 'junking event' warning is temporarily disabled during translator cleanup
 266   /*
 267   else
 268     // We have tried all possible contexts. Give up.
 269     m->origin ()->warning (_f ("junking event: `%s'", m->name ()));
 270   */
 271   return false;
 272 }
 273
 274 SCM
 275 Translator_group::get_simple_trans_list ()
 276 {
 277   return simple_trans_list_;
 278 }
 279
 280 void
 281 precomputed_recurse_over_translators (Context *c, Translator_precompute_index idx, Direction dir)
 282 {
 283   Translator_group *tg
 284     = dynamic_cast<Translator_group *> (c->implementation ());
 285
 286   if (dir == DOWN)
 287     {
 288       tg->precomputed_translator_foreach (idx);
 289       tg->call_precomputed_self_method (idx);
 290     }
 291
 292   for (SCM s = c->children_contexts (); scm_is_pair (s);
 293        s = scm_cdr (s))
 294     precomputed_recurse_over_translators (unsmob_context (scm_car (s)), idx, dir);
 295
 296   if (dir == UP)
 297     {
 298       tg->precomputed_translator_foreach (idx);
 299       tg->call_precomputed_self_method (idx);
 300     }
 301 }
 302
 303 void
 304 recurse_over_translators (Context *c, Translator_method ptr, Translator_group_method tg_ptr, Direction dir)
 305 {
 306   Translator_group *tg
 307     = dynamic_cast<Translator_group *> (c->implementation ());
 308
 309   if (dir == DOWN)
 310     {
 311       (tg->*tg_ptr) ();
 312       translator_each (tg->get_simple_trans_list (), ptr);
 313     }
 314
 315   for (SCM s = c->children_contexts (); scm_is_pair (s);
 316        s = scm_cdr (s))
 317     recurse_over_translators (unsmob_context (scm_car (s)), ptr, tg_ptr, dir);
 318
 319   if (dir == UP)
 320     {
 321       translator_each (tg->get_simple_trans_list (),
 322                        ptr);
 323
 324       (tg->*tg_ptr) ();
 325     }
 326 }
 327
 328 Translator_group::Translator_group ()
 329 {
 330   simple_trans_list_ = SCM_EOL;
 331   accept_hash_table_ = SCM_EOL;
 332   protected_events_ = SCM_EOL;
 333   context_ = 0;
 334   smobify_self ();
 335
 336   accept_hash_table_ = scm_c_make_hash_table (19);
 337 }
 338
 339 void
 340 Translator_group::derived_mark () const
 341 {
 342 }
 343
 344 void
 345 Translator_group::precompute_method_bindings ()
 346 {
 347   for (SCM s = simple_trans_list_; scm_is_pair (s); s = scm_cdr (s))
 348     {
 349       Translator *tr = unsmob_translator (scm_car (s));
 350       Translator_void_method_ptr ptrs[TRANSLATOR_METHOD_PRECOMPUTE_COUNT];
 351       tr->fetch_precomputable_methods (ptrs);
 352
 353       assert (tr);
 354       for (int i = 0; i < TRANSLATOR_METHOD_PRECOMPUTE_COUNT; i++)
 355         {
 356           if (ptrs[i])
 357             precomputed_method_bindings_[i].push_back (Translator_method_binding (tr, ptrs[i]));
 358         }
 359     }
 360
 361   fetch_precomputable_methods (precomputed_self_method_bindings_);
 362 }
 363
 364 void
 365 Translator_group::precomputed_translator_foreach (Translator_precompute_index idx)
 366 {
 367   vector<Translator_method_binding> &bindings (precomputed_method_bindings_[idx]);
 368   for (vsize i = 0; i < bindings.size (); i++)
 369     bindings[i].invoke ();
 370 }
 371
 372 void
 373 Translator_group::fetch_precomputable_methods (Translator_group_void_method ptrs[])
 374 {
 375   for (int i = 0; i < TRANSLATOR_METHOD_PRECOMPUTE_COUNT; i++)
 376     ptrs[i] = 0;
 377 }
 378
 379 void
 380 Translator_group::call_precomputed_self_method (Translator_precompute_index idx)
 381 {
 382   if (precomputed_self_method_bindings_[idx])
 383     (*precomputed_self_method_bindings_[idx]) (this);
 384 }
 385
 386 Translator_group::~Translator_group ()
 387 {
 388 }
 389
 390 #include "ly-smobs.icc"
 391
 392 IMPLEMENT_SMOBS (Translator_group);
 393 IMPLEMENT_DEFAULT_EQUAL_P (Translator_group);
 394 IMPLEMENT_TYPE_P (Translator_group, "ly:translator-group?");
 395
 396 int
 397 Translator_group::print_smob (SCM s, SCM port, scm_print_state *)
 398 {
 399   Translator_group *me = (Translator_group *) SCM_CELL_WORD_1 (s);
 400   scm_puts ("#<Translator_group ", port);
 401   scm_puts (me->class_name (), port);
 402   scm_display (me->simple_trans_list_, port);
 403   scm_puts (" >", port);
 404   return 1;
 405 }
 406
 407 SCM
 408 Translator_group::mark_smob (SCM smob)
 409 {
 410   Translator_group *me = (Translator_group *)SCM_CELL_WORD_1 (smob);
 411
 412   me->derived_mark ();
 413   scm_gc_mark (me->accept_hash_table_);
 414   scm_gc_mark (me->protected_events_);
 415   return me->simple_trans_list_;
 416 }