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