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--1999 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 "dictionary-iter.hh"
  15
  16 #include "killing-cons.tcc"
  17
  18 Translator_group::Translator_group (Translator_group const&s)
  19   : Translator(s)
  20 {
  21   consists_str_arr_ = s.consists_str_arr_;
  22   consists_end_str_arr_ = s.consists_end_str_arr_;
  23   accepts_str_arr_ = s.accepts_str_arr_;
  24   iterator_count_ =0;
  25   properties_dict_ = s.properties_dict_;
  26 }
  27
  28 Translator_group::~Translator_group ()
  29 {
  30   assert (removable_b());
  31   trans_p_list_.junk ();
  32 }
  33
  34
  35 Translator_group::Translator_group()
  36 {
  37   iterator_count_  = 0;
  38 }
  39
  40 void
  41 Translator_group::check_removal()
  42 {
  43   Link_array<Translator_group> groups (group_l_arr ());
  44
  45   for (int i =0; i < groups.size(); i++)
  46     {
  47       groups[i]->check_removal();
  48       if (groups[i]->removable_b())
  49         terminate_translator (groups[i]);
  50     }
  51 }
  52
  53 void
  54 Translator_group::add_translator (Translator *trans_p)
  55 {
  56   trans_p_list_.append (new Killing_cons<Translator> (trans_p,0));
  57
  58   trans_p->daddy_trans_l_ = this;
  59   trans_p->output_def_l_ = output_def_l_;
  60   trans_p->add_processing ();
  61 }
  62
  63 void
  64 Translator_group::set_acceptor (String accepts, bool add)
  65 {
  66   if (add)
  67     accepts_str_arr_.push (accepts);
  68   else
  69     for (int i=accepts_str_arr_.size (); i--; )
  70       if (accepts_str_arr_[i] == accepts)
  71         accepts_str_arr_.del (i);
  72 }
  73
  74 void
  75 Translator_group::add_last_element (String s)
  76 {
  77   if (!get_translator_l (s))
  78     error (_ ("Program has no such type"));
  79
  80   for (int i=consists_end_str_arr_.size (); i--; )
  81     if (consists_end_str_arr_[i] == s)
  82       warning (_f ("Already contains: `%s'", s));
  83
  84   consists_end_str_arr_.push (s);
  85 }
  86
  87 void
  88 Translator_group::set_element (String s, bool add)
  89 {
  90   if (!get_translator_l (s))
  91     error (_ ("Program has no such type"));
  92
  93   if (add)
  94     {
  95       for (int i=consists_str_arr_.size (); i--; )
  96         if (consists_str_arr_[i] == s)
  97           warning (_f("Already contains: `%s'", s));
  98
  99       consists_str_arr_.push (s);
 100     }
 101   else
 102     {
 103       for (int i=consists_str_arr_.size (); i--; )
 104         if (consists_str_arr_[i] == s)
 105           consists_str_arr_.del (i);
 106       for (int i=consists_end_str_arr_.size (); i--; )
 107         if (consists_end_str_arr_[i] == s)
 108           consists_end_str_arr_.del (i);
 109     }
 110 }
 111 bool
 112 Translator_group::removable_b() const
 113 {
 114   for (Cons<Translator> *p = trans_p_list_.head_; p; p = p->next_)
 115     {
 116       if (dynamic_cast <Translator_group *> (p->car_))
 117         return false;
 118     }
 119
 120   return !iterator_count_;
 121 }
 122
 123 Translator_group *
 124 Translator_group::find_existing_translator_l (String n, String id)
 125 {
 126   if (is_alias_b (n) && (id_str_ == id || id.empty_b ()))
 127     return this;
 128
 129   Link_array<Translator_group> groups (group_l_arr ());
 130   Translator_group* r = 0;
 131   for (int i =0; !r && i < groups.size(); i++)
 132     {
 133       r = groups[i]->find_existing_translator_l (n,id);
 134     }
 135
 136   return r;
 137 }
 138
 139 Link_array<Translator_group>
 140 Translator_group::path_to_acceptable_translator (String type) const
 141 {
 142  Link_array<Translator_group> accepted_arr;
 143   for (int i=0; i < accepts_str_arr_.size (); i++)
 144     {
 145       Translator *t = output_def_l ()->find_translator_l (accepts_str_arr_[i]);
 146       if (!t || !dynamic_cast <Translator_group *> (t))
 147         continue;
 148       accepted_arr.push (dynamic_cast <Translator_group *> (t));
 149     }
 150
 151
 152  for (int i=0; i < accepted_arr.size (); i++)
 153     if (accepted_arr[i]->type_str_ == type)
 154       {
 155         Link_array<Translator_group> retval;
 156         retval.push (accepted_arr[i]);
 157         return retval;
 158       }
 159
 160   Link_array<Translator_group> best_result;
 161   int best_depth= INT_MAX;
 162   for (int i=0; i < accepted_arr.size (); i++)
 163     {
 164       Translator_group * g = accepted_arr[i];
 165
 166       Link_array<Translator_group> result
 167         = g->path_to_acceptable_translator (type);
 168       if (result.size () && result.size () < best_depth)
 169         {
 170           result.insert (g,0);
 171           best_result = result;
 172         }
 173     }
 174
 175   return best_result;
 176 }
 177
 178 Translator_group*
 179 Translator_group::find_create_translator_l (String n, String id)
 180 {
 181   Translator_group * existing = find_existing_translator_l (n,id);
 182   if (existing)
 183     return existing;
 184
 185   Link_array<Translator_group> path = path_to_acceptable_translator (n);
 186
 187   if (path.size ())
 188     {
 189       Translator_group * current = this;
 190
 191       // start at 1.  The first one (index 0) will be us.
 192       for (int i=0; i < path.size (); i++)
 193         {
 194           Translator_group * new_group = dynamic_cast<Translator_group*>(path[i]->clone ());
 195           current->add_translator (new_group);
 196           current = new_group;
 197         }
 198       current->id_str_ = id;
 199       return current;
 200     }
 201
 202   Translator_group *ret = 0;
 203   if (daddy_trans_l_)
 204     ret = daddy_trans_l_->find_create_translator_l (n,id);
 205   else
 206     {
 207       warning (_f ("Can't find or create `%s' called `%s'", n, id));
 208       ret =0;
 209     }
 210   return ret;
 211 }
 212
 213 bool
 214 Translator_group::try_music_on_nongroup_children (Music *m)
 215 {
 216   bool hebbes_b =false;
 217
 218   Link_array<Translator> nongroups (nongroup_l_arr ());
 219
 220   for (int i =0; !hebbes_b && i < nongroups.size() ; i++)
 221     hebbes_b =nongroups[i]->try_music (m);
 222   return hebbes_b;
 223 }
 224
 225 bool
 226 Translator_group::do_try_music (Music* m)
 227 {
 228   bool hebbes_b = try_music_on_nongroup_children (m);
 229
 230   if (!hebbes_b && daddy_trans_l_)
 231     hebbes_b = daddy_trans_l_->try_music (m);
 232   return hebbes_b ;
 233 }
 234
 235 int
 236 Translator_group::depth_i() const
 237 {
 238   return (daddy_trans_l_) ? daddy_trans_l_->depth_i()  + 1 : 0;
 239 }
 240
 241 Translator_group*
 242 Translator_group::ancestor_l (int level)
 243 {
 244   if (!level || !daddy_trans_l_)
 245     return this;
 246
 247   return daddy_trans_l_->ancestor_l (level-1);
 248 }
 249
 250 Link_array<Translator_group>
 251 Translator_group::group_l_arr () const
 252 {
 253   Link_array<Translator_group> groups;
 254   for (Cons<Translator> *p = trans_p_list_.head_; p; p = p->next_)
 255     {
 256       if (dynamic_cast <Translator_group *> (p->car_))
 257         groups.push (dynamic_cast <Translator_group *> (p->car_));
 258     }
 259   return groups;
 260 }
 261
 262 Link_array<Translator>
 263 Translator_group::nongroup_l_arr () const
 264 {
 265   Link_array<Translator> groups;
 266   for (Cons<Translator> *p = trans_p_list_.head_; p; p = p->next_)
 267     {
 268       if (!dynamic_cast <Translator_group *> (p->car_))
 269         groups.push (p->car_);
 270     }
 271   return groups;
 272 }
 273 /**
 274    End translator: call "destructor", remove from hierarchy, and delete
 275  */
 276
 277 void
 278 Translator_group::terminate_translator (Translator*r_l)
 279 {
 280   DEBUG_OUT << "Removing " << classname (r_l) << " at " << now_mom () << '\n';
 281   r_l->removal_processing();
 282   Translator * trans_p =remove_translator_p (r_l);
 283
 284   delete trans_p;
 285 }
 286
 287
 288 /**
 289    Remove a translator from the hierarchy.
 290  */
 291 Translator *
 292 Translator_group::remove_translator_p (Translator*trans_l)
 293 {
 294   assert (trans_l);
 295
 296   for (Cons<Translator> **pp = &trans_p_list_.head_; *pp; pp = &(*pp)->next_)
 297     if ((*pp)->car_ == trans_l)
 298       {
 299         Cons<Translator> *r = trans_p_list_.remove_cons (pp);
 300         r->car_ =0;
 301         trans_l->daddy_trans_l_ =0;
 302         delete r;
 303         return trans_l;
 304       }
 305
 306   return 0;
 307 }
 308
 309
 310 Translator*
 311 Translator_group::get_simple_translator (String type) const
 312 {
 313   Link_array<Translator> nongroups (nongroup_l_arr ());
 314   for (int i=0; i < nongroups.size(); i++)
 315     {
 316       if (classname (nongroups[i]) == type)
 317         return nongroups[i];
 318     }
 319   if (daddy_trans_l_)
 320     return daddy_trans_l_->get_simple_translator (type);
 321   return 0;
 322 }
 323
 324
 325 bool
 326 Translator_group::is_bottom_translator_b () const
 327 {
 328   return !accepts_str_arr_.size ();
 329 }
 330
 331
 332
 333 Translator_group*
 334 Translator_group::get_default_interpreter()
 335 {
 336   if (accepts_str_arr_.size())
 337     {
 338       Translator*t = output_def_l ()->find_translator_l (accepts_str_arr_[0]);
 339       if (!t)
 340         {
 341           warning (_f ("Can't find or create: `%s'", accepts_str_arr_[0]));
 342           t = this;
 343         }
 344       Translator_group * g= dynamic_cast <Translator_group*>(t->clone ());
 345       add_translator (g);
 346
 347       if (!g->is_bottom_translator_b ())
 348         return g->get_default_interpreter ();
 349       else
 350         return g;
 351     }
 352   return this;
 353 }
 354
 355 void
 356 Translator_group::each (Method_pointer method)
 357 {
 358   for (Cons<Translator> *p = trans_p_list_.head_; p; p = p->next_)
 359     (p->car_->*method) ();
 360 }
 361
 362
 363 void
 364 Translator_group::each (Const_method_pointer method) const
 365 {
 366   for (Cons<Translator> *p = trans_p_list_.head_; p; p = p->next_)
 367     (p->car_->*method) ();
 368 }
 369
 370 void
 371 Translator_group::do_print() const
 372 {
 373 #ifndef NPRINT
 374   if (!flower_dstream)
 375     return ;
 376
 377   gh_display (properties_dict_.self_scm_);
 378   if (status == ORPHAN)
 379     {
 380       DEBUG_OUT << "consists of: ";
 381       for (int i=0; i < consists_str_arr_.size (); i++)
 382         DEBUG_OUT << consists_str_arr_[i] << ", ";
 383       DEBUG_OUT << "\naccepts: ";
 384       for (int i=0; i < accepts_str_arr_.size (); i++)
 385         DEBUG_OUT << accepts_str_arr_[i] << ", ";
 386     }
 387   else
 388     {
 389       if (id_str_.length_i ())
 390         DEBUG_OUT << "ID: " << id_str_ ;
 391       DEBUG_OUT << " iterators: " << iterator_count_<< '\n';
 392     }
 393   each (&Translator::print);
 394 #endif
 395 }
 396
 397 void
 398 Translator_group::do_pre_move_processing ()
 399 {
 400   each (&Translator::pre_move_processing);
 401 }
 402
 403 void
 404 Translator_group::do_post_move_processing ()
 405 {
 406   each (&Translator::post_move_processing);
 407 }
 408
 409 void
 410 Translator_group::do_process_requests ()
 411 {
 412   each (&Translator::process_requests);
 413 }
 414
 415 void
 416 Translator_group::do_creation_processing ()
 417 {
 418   each (&Translator::creation_processing);
 419 }
 420
 421 void
 422 Translator_group::do_removal_processing ()
 423 {
 424   each (&Translator::removal_processing);
 425 }
 426
 427 void
 428 Translator_group::do_add_processing ()
 429 {
 430    for (int i=0; i < consists_str_arr_.size(); i++)
 431     {
 432       String s = consists_str_arr_[i];
 433       Translator * t = output_def_l ()->find_translator_l (s);
 434       if (!t)
 435         warning (_f ("Can't find: `%s'", s));
 436       else
 437         add_translator (t->clone ());
 438     }
 439    for (int i=0; i-- < consists_end_str_arr_.size (); i++)
 440      {
 441        String s = consists_end_str_arr_[i];
 442        Translator * t = output_def_l ()->find_translator_l (s);
 443        if (!t)
 444          warning (_f ("Can't find: `%s'", s));
 445        else
 446          add_translator (t->clone ());
 447     }
 448 }
 449
 450 SCM
 451 Translator_group::get_property (String id,
 452                                 Translator_group **where_l) const
 453 {
 454   SCM  sym = ly_symbol (id);
 455   if (properties_dict_.elem_b (sym))
 456     {
 457       if (where_l)
 458         *where_l = (Translator_group*) this; // ugh
 459       return properties_dict_[sym];
 460     }
 461
 462   if (daddy_trans_l_)
 463     return daddy_trans_l_->get_property (id, where_l);
 464
 465   if (where_l)
 466     *where_l = 0;
 467
 468   return SCM_UNDEFINED;
 469 }
 470
 471 void
 472 Translator_group::set_property (String id, SCM val)
 473 {
 474   properties_dict_[ly_symbol (id)] = val;
 475 }