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