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
  17 Translator_group::Translator_group (Translator_group const&s)
  18   : Translator(s)
  19 {
  20   iterator_count_ =0;
  21
  22   Scheme_hash_table * tab =  new Scheme_hash_table (*s.properties_dict ());
  23   properties_scm_ = tab->self_scm ();
  24   scm_unprotect_object (tab->self_scm( ));
  25 }
  26
  27 Scheme_hash_table*
  28 Translator_group::properties_dict () const
  29 {
  30   return Scheme_hash_table::unsmob (properties_scm_);
  31 }
  32
  33 Translator_group::~Translator_group ()
  34 {
  35   assert (removable_b());
  36 }
  37
  38
  39 Translator_group::Translator_group()
  40 {
  41   iterator_count_  = 0;
  42   Scheme_hash_table *tab = new Scheme_hash_table ;
  43   properties_scm_ = tab->self_scm ();
  44
  45   scm_unprotect_object (tab->self_scm ());
  46 }
  47
  48 void
  49 Translator_group::check_removal()
  50 {
  51   SCM next = SCM_EOL;
  52   for (SCM p = trans_group_list_; gh_pair_p (p); p = next)
  53     {
  54       next = gh_cdr (p);
  55
  56       Translator_group *trg =  dynamic_cast<Translator_group*> (unsmob_translator (gh_car (p)));
  57
  58       trg->check_removal ();
  59       if (trg->removable_b())
  60         terminate_translator (trg);
  61     }
  62 }
  63
  64
  65 SCM
  66 Translator_group::add_translator (SCM list, Translator *t)
  67 {
  68   list = gh_append2 (list, gh_cons (t->self_scm (), SCM_EOL));
  69   t->daddy_trans_l_ = this;
  70   t->output_def_l_ = output_def_l_;
  71   t->add_processing ();
  72
  73   return list;
  74 }
  75 void
  76 Translator_group::add_group_translator (Translator *t)
  77 {
  78   trans_group_list_ = add_translator (trans_group_list_,t);
  79 }
  80
  81
  82
  83 bool
  84 Translator_group::removable_b() const
  85 {
  86   return trans_group_list_ == SCM_EOL && ! iterator_count_;
  87 }
  88
  89 Translator_group *
  90 Translator_group::find_existing_translator_l (String n, String id)
  91 {
  92   if (is_alias_b (n) && (id_str_ == id || id.empty_b ()))
  93     return this;
  94
  95   Translator_group* r = 0;
  96   for (SCM p = trans_group_list_; !r && gh_pair_p (p); p = gh_cdr (p))
  97     {
  98       Translator *  t = unsmob_translator (gh_car (p));
  99
 100       r = dynamic_cast<Translator_group*> (t)->find_existing_translator_l (n, id);
 101     }
 102
 103   return r;
 104 }
 105
 106 Link_array<Translator_group>
 107 Translator_group::path_to_acceptable_translator (String type, Music_output_def* odef) const
 108 {
 109   Link_array<Translator_group> accepted_arr;
 110   for (SCM s = accepts_name_list_; gh_pair_p (s); s = gh_cdr (s))
 111     {
 112
 113       Translator *t = odef->find_translator_l (ly_scm2string (gh_car (s)));
 114       if (!t || !dynamic_cast <Translator_group *> (t))
 115         continue;
 116       accepted_arr.push (dynamic_cast <Translator_group *> (t));
 117     }
 118
 119
 120  for (int i=0; i < accepted_arr.size (); i++)
 121     if (accepted_arr[i]->type_str_ == type)
 122       {
 123         Link_array<Translator_group> retval;
 124         retval.push (accepted_arr[i]);
 125         return retval;
 126       }
 127
 128   Link_array<Translator_group> best_result;
 129   int best_depth= INT_MAX;
 130   for (int i=0; i < accepted_arr.size (); i++)
 131     {
 132       Translator_group * g = accepted_arr[i];
 133
 134       Link_array<Translator_group> result
 135         = g->path_to_acceptable_translator (type, odef);
 136       if (result.size () && result.size () < best_depth)
 137         {
 138           result.insert (g,0);
 139           best_result = result;
 140         }
 141     }
 142
 143   return best_result;
 144 }
 145
 146 Translator_group*
 147 Translator_group::find_create_translator_l (String n, String id)
 148 {
 149   Translator_group * existing = find_existing_translator_l (n,id);
 150   if (existing)
 151     return existing;
 152
 153   Link_array<Translator_group> path
 154     = path_to_acceptable_translator (n, output_def_l ());
 155
 156   if (path.size ())
 157     {
 158       Translator_group * current = this;
 159
 160       // start at 1.  The first one (index 0) will be us.
 161       for (int i=0; i < path.size (); i++)
 162         {
 163           Translator_group * new_group = dynamic_cast<Translator_group*>(path[i]->clone ());
 164
 165           current->add_group_translator (new_group);
 166           current = new_group;
 167         }
 168       current->id_str_ = id;
 169       return current;
 170     }
 171
 172   Translator_group *ret = 0;
 173   if (daddy_trans_l_)
 174     ret = daddy_trans_l_->find_create_translator_l (n,id);
 175   else
 176     {
 177       warning (_f ("can't find or create `%s' called `%s'", n, id));
 178       ret =0;
 179     }
 180   return ret;
 181 }
 182
 183 bool
 184 Translator_group::try_music_on_nongroup_children (Music *m)
 185 {
 186   bool hebbes_b =false;
 187
 188
 189   for (SCM p = simple_trans_list_; !hebbes_b && gh_pair_p (p); p = gh_cdr (p))
 190     {
 191       hebbes_b = unsmob_translator (gh_car (p))->try_music (m);
 192     }
 193   return hebbes_b;
 194 }
 195
 196 bool
 197 Translator_group::do_try_music (Music* m)
 198 {
 199   bool hebbes_b = try_music_on_nongroup_children (m);
 200
 201   if (!hebbes_b && daddy_trans_l_)
 202     hebbes_b = daddy_trans_l_->try_music (m);
 203   return hebbes_b ;
 204 }
 205
 206 int
 207 Translator_group::depth_i() const
 208 {
 209   return (daddy_trans_l_) ? daddy_trans_l_->depth_i()  + 1 : 0;
 210 }
 211
 212 Translator_group*
 213 Translator_group::ancestor_l (int level)
 214 {
 215   if (!level || !daddy_trans_l_)
 216     return this;
 217
 218   return daddy_trans_l_->ancestor_l (level-1);
 219 }
 220
 221 void
 222 Translator_group::terminate_translator (Translator*r_l)
 223 {
 224   r_l->removal_processing();
 225   Translator * trans_p =remove_translator_p (r_l);
 226   /*
 227     forget trans_p, GC does the rest.
 228    */
 229 }
 230
 231
 232 /**
 233    Remove a translator from the hierarchy.
 234  */
 235 Translator *
 236 Translator_group::remove_translator_p (Translator*trans_l)
 237 {
 238   assert (trans_l);
 239
 240   trans_group_list_ = scm_delq_x (trans_l->self_scm (), trans_group_list_);
 241   trans_l->daddy_trans_l_ = 0;
 242   return trans_l;
 243 }
 244
 245 #if 0
 246 /*
 247   should not use, instead: use properties to communicate between engravers.
 248  */
 249 Translator*
 250 Translator_group::get_simple_translator (String type) const
 251 {
 252   for (SCM p = simple_trans_list_;  gh_pair_p (p); p =gh_cdr (p))
 253     {
 254       if (classname (unsmob_translator (gh_car (p))) == type)
 255         return unsmob_translator (gh_car (p));
 256     }
 257   if (daddy_trans_l_)
 258     return daddy_trans_l_->get_simple_translator (type);
 259   return 0;
 260 }
 261 #endif
 262
 263 bool
 264 Translator_group::is_bottom_translator_b () const
 265 {
 266   return accepts_name_list_ == SCM_EOL;
 267 }
 268
 269
 270
 271 Translator_group*
 272 Translator_group::get_default_interpreter()
 273 {
 274   if (gh_pair_p (accepts_name_list_))
 275     {
 276       String str = ly_scm2string (gh_car (accepts_name_list_));
 277       Translator*t = output_def_l ()->find_translator_l (str);
 278       if (!t)
 279         {
 280           warning (_f ("can't find or create: `%s'", str));
 281           t = this;
 282         }
 283       Translator_group * g= dynamic_cast <Translator_group*>(t->clone ());
 284       add_group_translator (g);
 285
 286       if (!g->is_bottom_translator_b ())
 287         return g->get_default_interpreter ();
 288       else
 289         return g;
 290     }
 291   return this;
 292 }
 293
 294 static void
 295 static_each (SCM list, Method_pointer method)
 296 {
 297   for (SCM p = list; gh_pair_p (p); p = gh_cdr(p))
 298     (unsmob_translator (gh_car (p))->*method) ();
 299
 300 }
 301
 302 void
 303 Translator_group::each (Method_pointer method)
 304 {
 305   static_each (simple_trans_list_, method);
 306   static_each (trans_group_list_, method);
 307 }
 308
 309 void
 310 Translator_group::do_print() const
 311 {
 312 #ifndef NPRINT
 313 #endif
 314 }
 315
 316 static SCM
 317 trans_list (SCM namelist, Music_output_def *mdef)
 318 {
 319   SCM l = SCM_EOL;
 320   for (SCM s = namelist; gh_pair_p (s) ; s = gh_cdr (s))
 321     {
 322       Translator * t = mdef->find_translator_l (ly_scm2string (gh_car (s)));
 323       if (!t)
 324         warning (_f ("can't find: `%s'", s));
 325       else
 326         {
 327           Translator * tr = t->clone ();
 328           SCM str = tr->self_scm ();
 329           l = gh_cons (str, l);
 330           scm_unprotect_object (str);
 331         }
 332     }
 333   return l;
 334 }
 335
 336
 337 void
 338 Translator_group::do_add_processing ()
 339 {
 340   assert (simple_trans_list_== SCM_EOL);
 341
 342   SCM correct_order = scm_reverse (property_pushes_); // pity of the mem.
 343   for (SCM s = correct_order; gh_pair_p (s); s = gh_cdr (s))
 344     {
 345       SCM entry = gh_car (s);
 346       SCM val = gh_cddr (entry);
 347       val = gh_pair_p (val) ? gh_car (val) : SCM_UNDEFINED;
 348
 349       Translator_group_initializer::apply_pushpop_property (this, gh_car (entry),
 350                                                             gh_cadr (entry),
 351                                                             val);
 352     }
 353
 354   SCM l1 = trans_list (consists_name_list_, output_def_l ());
 355   SCM l2 =trans_list (end_consists_name_list_, output_def_l ());
 356   l1 = scm_reverse_x (l1, l2);
 357
 358   simple_trans_list_ = l1;
 359   for (SCM s = l1; gh_pair_p (s) ; s = gh_cdr (s))
 360     {
 361       Translator * t = unsmob_translator (gh_car (s));
 362
 363       t->daddy_trans_l_ = this;
 364       t->output_def_l_ = output_def_l_;
 365       t->add_processing ();
 366     }
 367
 368
 369 }
 370
 371 /*
 372   PROPERTIES
 373  */
 374 Translator_group*
 375 Translator_group::where_defined (SCM sym) const
 376 {
 377   if (properties_dict ()->elem_b (sym))
 378     {
 379       return (Translator_group*)this;
 380     }
 381
 382   return (daddy_trans_l_) ? daddy_trans_l_->where_defined (sym) : 0;
 383 }
 384
 385 SCM
 386 Translator_group::get_property (SCM sym) const
 387 {
 388   if (properties_dict ()->elem_b (sym))
 389     {
 390       return properties_dict ()->get (sym);
 391     }
 392
 393   if (daddy_trans_l_)
 394     return daddy_trans_l_->get_property (sym);
 395
 396   return SCM_UNDEFINED;
 397 }
 398
 399 void
 400 Translator_group::set_property (String id, SCM val)
 401 {
 402   set_property (ly_symbol2scm (id.ch_C()), val);
 403 }
 404
 405 void
 406 Translator_group::set_property (SCM sym, SCM val)
 407 {
 408   properties_dict ()->set (sym, val);
 409 }
 410
 411 /*
 412   Push or pop (depending on value of VAL) a single entry (ELTPROP . VAL)
 413   entry from a translator property list by name of PROP
 414 */
 415 void
 416 Translator_group::execute_single_pushpop_property (SCM prop, SCM eltprop, SCM val)
 417 {
 418   if (gh_symbol_p(prop))
 419     {
 420       if (val != SCM_UNDEFINED)
 421         {
 422           SCM prev = get_property (prop);
 423
 424           prev = gh_cons (gh_cons (eltprop, val), prev);
 425           set_property (prop, prev);
 426         }
 427       else
 428         {
 429           SCM prev = get_property (prop);
 430
 431           SCM newprops= SCM_EOL ;
 432           while (gh_pair_p (prev) && gh_caar (prev) != eltprop)
 433             {
 434               newprops = gh_cons (gh_car (prev), newprops);
 435               prev = gh_cdr (prev);
 436             }
 437
 438           if (gh_pair_p (prev))
 439             {
 440               newprops = scm_reverse_x (newprops, gh_cdr (prev));
 441               set_property (prop, newprops);
 442             }
 443         }
 444     }
 445 }
 446
 447
 448
 449
 450
 451 /*
 452   STUBS
 453 */
 454 void
 455 Translator_group::do_pre_move_processing ()
 456 {
 457   each (&Translator::pre_move_processing);
 458 }
 459
 460 void
 461 Translator_group::do_post_move_processing ()
 462 {
 463   each (&Translator::post_move_processing);
 464 }
 465
 466 void
 467 Translator_group::do_process_music ()
 468 {
 469   each (&Translator::process_music);
 470 }
 471
 472 void
 473 Translator_group::do_creation_processing ()
 474 {
 475   each (&Translator::creation_processing);
 476 }
 477
 478 void
 479 Translator_group::do_removal_processing ()
 480 {
 481   each (&Translator::removal_processing);
 482 }