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