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--2002 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 "translator-def.hh"
  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_gc_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
  36   //assert (removable_b ());
  37 }
  38
  39
  40 Translator_group::Translator_group ()
  41 {
  42   iterator_count_  = 0;
  43   Scheme_hash_table *tab = new Scheme_hash_table ;
  44   properties_scm_ = tab->self_scm ();
  45
  46   scm_gc_unprotect_object (tab->self_scm ());
  47 }
  48
  49 void
  50 Translator_group::check_removal ()
  51 {
  52   SCM next = SCM_EOL;
  53   for (SCM p = trans_group_list_; gh_pair_p (p); p = next)
  54     {
  55       next = ly_cdr (p);
  56
  57       Translator_group *trg =  dynamic_cast<Translator_group*> (unsmob_translator (ly_car (p)));
  58
  59       trg->check_removal ();
  60       if (trg->removable_b ())
  61         terminate_translator (trg);
  62     }
  63 }
  64
  65 SCM
  66 Translator_group::add_translator (SCM list, Translator *t)
  67 {
  68   /*
  69     Must append, since list ordering must be preserved.
  70    */
  71   list = gh_append2 (list, gh_cons (t->self_scm (), SCM_EOL));
  72   t->daddy_trans_l_ = this;
  73   t->output_def_l_ = output_def_l_;
  74
  75   return list;
  76 }
  77
  78 void
  79 Translator_group::add_fresh_simple_translator (Translator*t)
  80 {
  81   simple_trans_list_ = add_translator (simple_trans_list_, t);
  82   t->initialize ();
  83 }
  84
  85 void
  86 Translator_group::add_used_group_translator (Translator *t)
  87 {
  88   trans_group_list_ = add_translator (trans_group_list_,t);
  89 }
  90
  91
  92 void
  93 Translator_group::add_fresh_group_translator (Translator*t)
  94 {
  95   Translator_group*tg = dynamic_cast<Translator_group*> (t);
  96   assert (tg);
  97
  98   trans_group_list_ = add_translator (trans_group_list_,t);
  99   unsmob_translator_def (tg->definition_)->apply_property_operations (tg);
 100   t->initialize ();
 101
 102 }
 103
 104
 105 bool
 106 Translator_group::removable_b () const
 107 {
 108   return trans_group_list_ == SCM_EOL && ! iterator_count_;
 109 }
 110
 111 Translator_group *
 112 Translator_group::find_existing_translator_l (String n, String id)
 113 {
 114   if (is_alias_b (n) && (id_str_ == id || id.empty_b ()))
 115     return this;
 116
 117   Translator_group* r = 0;
 118   for (SCM p = trans_group_list_; !r && gh_pair_p (p); p = ly_cdr (p))
 119     {
 120       Translator *  t = unsmob_translator (ly_car (p));
 121
 122       r = dynamic_cast<Translator_group*> (t)->find_existing_translator_l (n, id);
 123     }
 124
 125   return r;
 126 }
 127
 128
 129
 130
 131 Translator_group*
 132 Translator_group::find_create_translator_l (String n, String id)
 133 {
 134   Translator_group * existing = find_existing_translator_l (n,id);
 135   if (existing)
 136     return existing;
 137
 138   Link_array<Translator_def> path
 139     = unsmob_translator_def (definition_)->path_to_acceptable_translator (ly_str02scm ((char*)n.ch_C ()), output_def_l ());
 140
 141   if (path.size ())
 142     {
 143       Translator_group * current = this;
 144
 145       // start at 1.  The first one (index 0) will be us.
 146       for (int i=0; i < path.size (); i++)
 147         {
 148           Translator_group * new_group = path[i]->instantiate (output_def_l_);
 149
 150           if (i == path.size () -1)
 151             new_group->id_str_ = id;
 152           current->add_fresh_group_translator (new_group);
 153           current = new_group;
 154         }
 155
 156       return current;
 157     }
 158
 159   Translator_group *ret = 0;
 160   if (daddy_trans_l_)
 161     ret = daddy_trans_l_->find_create_translator_l (n,id);
 162   else
 163     {
 164       warning (_f ("can't find or create `%s' called `%s'", n, id));
 165       ret =0;
 166     }
 167   return ret;
 168 }
 169
 170 bool
 171 Translator_group::try_music_on_nongroup_children (Music *m)
 172 {
 173   bool hebbes_b =false;
 174
 175   for (SCM p = simple_trans_list_; !hebbes_b && gh_pair_p (p); p = ly_cdr (p))
 176     {
 177       hebbes_b = unsmob_translator (ly_car (p))->try_music (m);
 178     }
 179   return hebbes_b;
 180 }
 181
 182 bool
 183 Translator_group::try_music (Music* m)
 184 {
 185   bool hebbes_b = try_music_on_nongroup_children (m);
 186
 187   if (!hebbes_b && daddy_trans_l_)
 188     hebbes_b = daddy_trans_l_->try_music (m);
 189   return hebbes_b ;
 190 }
 191
 192 int
 193 Translator_group::depth_i () const
 194 {
 195   return (daddy_trans_l_) ? daddy_trans_l_->depth_i ()  + 1 : 0;
 196 }
 197
 198 Translator_group*
 199 Translator_group::ancestor_l (int level)
 200 {
 201   if (!level || !daddy_trans_l_)
 202     return this;
 203
 204   return daddy_trans_l_->ancestor_l (level-1);
 205 }
 206
 207 void
 208 Translator_group::terminate_translator (Translator*r_l)
 209 {
 210   r_l->removal_processing ();
 211   /*
 212     Return value ignored. GC does the rest.
 213    */
 214   remove_translator_p (r_l);
 215 }
 216
 217
 218 /**
 219    Remove a translator from the hierarchy.
 220  */
 221 Translator *
 222 Translator_group::remove_translator_p (Translator*trans_l)
 223 {
 224   assert (trans_l);
 225
 226   trans_group_list_ = scm_delq_x (trans_l->self_scm (), trans_group_list_);
 227   trans_l->daddy_trans_l_ = 0;
 228   return trans_l;
 229 }
 230
 231 bool
 232 Translator_group::is_bottom_translator_b () const
 233 {
 234   return !gh_string_p (unsmob_translator_def (definition_)->default_child_context_name ());
 235
 236 }
 237
 238 Translator_group*
 239 Translator_group::get_default_interpreter ()
 240 {
 241   if (!is_bottom_translator_b ())
 242     {
 243       SCM nm = unsmob_translator_def (definition_)->default_child_context_name ();
 244       SCM st = output_def_l ()->find_translator_l (nm);
 245
 246       Translator_def *t = unsmob_translator_def (st);
 247       if (!t)
 248         {
 249           warning (_f ("can't find or create: `%s'", ly_scm2string (nm).ch_C ()));
 250           t = unsmob_translator_def (this->definition_);
 251         }
 252       Translator_group *tg = t->instantiate (output_def_l_);
 253       add_fresh_group_translator (tg);
 254
 255       if (!tg->is_bottom_translator_b ())
 256         return tg->get_default_interpreter ();
 257       else
 258         return tg;
 259     }
 260   return this;
 261 }
 262
 263 static void
 264 static_each (SCM list, Method_pointer method)
 265 {
 266   for (SCM p = list; gh_pair_p (p); p = ly_cdr (p))
 267     (unsmob_translator (ly_car (p))->*method) ();
 268
 269 }
 270
 271 void
 272 Translator_group::each (Method_pointer method)
 273 {
 274   static_each (simple_trans_list_, method);
 275   static_each (trans_group_list_, method);
 276 }
 277
 278
 279 /*
 280   PROPERTIES
 281  */
 282 Translator_group*
 283 Translator_group::where_defined (SCM sym) const
 284 {
 285   if (properties_dict ()->elem_b (sym))
 286     {
 287       return (Translator_group*)this;
 288     }
 289
 290   return (daddy_trans_l_) ? daddy_trans_l_->where_defined (sym) : 0;
 291 }
 292
 293 /*
 294   return SCM_EOL when not found.
 295 */
 296 SCM
 297 Translator_group::internal_get_property (SCM sym) const
 298 {
 299   SCM val =SCM_EOL;
 300   if (properties_dict ()->try_retrieve (sym, &val))
 301     return val;
 302
 303   if (daddy_trans_l_)
 304     return daddy_trans_l_->internal_get_property (sym);
 305
 306   return val;
 307 }
 308
 309
 310 void
 311 Translator_group::internal_set_property (SCM sym, SCM val)
 312 {
 313   properties_dict ()->set (sym, val);
 314 }
 315
 316 /*
 317   TODO: look up to check whether we have inherited var?
 318  */
 319 void
 320 Translator_group::unset_property (SCM sym)
 321 {
 322   properties_dict ()->remove (sym);
 323 }
 324
 325
 326 /*
 327   Push or pop (depending on value of VAL) a single entry (ELTPROP . VAL)
 328   entry from a translator property list by name of PROP
 329 */
 330 void
 331 Translator_group::execute_single_pushpop_property (SCM prop, SCM eltprop, SCM val)
 332 {
 333   if (gh_symbol_p (prop))
 334     {
 335       if (val != SCM_UNDEFINED)
 336         {
 337           SCM prev = internal_get_property (prop);
 338
 339           if (gh_pair_p (prev) || prev == SCM_EOL)
 340             {
 341               bool ok = type_check_assignment (val, eltprop, ly_symbol2scm ("backend-type?"));
 342
 343               if (ok)
 344                 {
 345                   prev = gh_cons (gh_cons (eltprop, val), prev);
 346                   internal_set_property (prop, prev);
 347                 }
 348             }
 349           else
 350             {
 351               // warning here.
 352             }
 353
 354         }
 355       else
 356         {
 357           SCM prev = internal_get_property (prop);
 358
 359           SCM newprops= SCM_EOL ;
 360           while (gh_pair_p (prev) && ly_caar (prev) != eltprop)
 361             {
 362               newprops = gh_cons (ly_car (prev), newprops);
 363               prev = ly_cdr (prev);
 364             }
 365
 366           if (gh_pair_p (prev))
 367             {
 368               newprops = scm_reverse_x (newprops, ly_cdr (prev));
 369               internal_set_property (prop, newprops);
 370             }
 371         }
 372     }
 373 }
 374
 375
 376
 377
 378
 379 /*
 380   STUBS
 381 */
 382 void
 383 Translator_group::stop_translation_timestep ()
 384 {
 385   each (&Translator::stop_translation_timestep);
 386 }
 387
 388 void
 389 Translator_group::start_translation_timestep ()
 390 {
 391   each (&Translator::start_translation_timestep);
 392 }
 393
 394 void
 395 Translator_group::do_announces ()
 396 {
 397   each (&Translator::announces);
 398 }
 399
 400 void
 401 Translator_group::initialize ()
 402 {
 403   each (&Translator::initialize);
 404 }
 405
 406 void
 407 Translator_group::finalize ()
 408 {
 409   each (&Translator::removal_processing);
 410 }
 411
 412
 413 bool
 414 type_check_assignment (SCM val, SCM sym,  SCM type_symbol)
 415 {
 416   bool ok = true;
 417   SCM type_p = SCM_EOL;
 418
 419   if (gh_symbol_p (sym))
 420     type_p = scm_object_property (sym, type_symbol);
 421
 422   if (type_p != SCM_EOL && !gh_procedure_p (type_p))
 423       {
 424         warning (_f ("Can't find property type-check for `%s'.  Perhaps you made a typing error? Doing assignment anyway.",
 425                      ly_symbol2string (sym).ch_C ()));
 426       }
 427   else
 428     {
 429       if (val != SCM_EOL
 430           && gh_procedure_p (type_p)
 431           && gh_call1 (type_p, val) == SCM_BOOL_F)
 432         {
 433           SCM errport = scm_current_error_port ();
 434           ok = false;
 435           SCM typefunc = scm_primitive_eval (ly_symbol2scm ("type-name"));
 436           SCM type_name = gh_call1 (typefunc, type_p);
 437
 438           scm_puts (_f ("Type check for `%s' failed; value `%s' must be of type `%s'",
 439                         ly_symbol2string (sym).ch_C (),
 440                         ly_scm2string (ly_write2scm (val)).ch_C (),
 441                         ly_scm2string (type_name).ch_C ()).ch_C (),
 442                     errport);
 443           scm_puts ("\n", errport);
 444         }
 445     }
 446   return ok;
 447 }
 448
 449 SCM
 450 ly_get_trans_property (SCM context, SCM name)
 451 {
 452   Translator *t = unsmob_translator (context);
 453   Translator_group* tr=   dynamic_cast<Translator_group*> (t);
 454   if (!t || !tr)
 455     {
 456       /* programming_error? */
 457       warning (_ ("ly-get-trans-property: expecting a Translator_group argument"));
 458       return SCM_EOL;
 459     }
 460   return tr->internal_get_property (name);
 461
 462 }
 463 SCM
 464 ly_set_trans_property (SCM context, SCM name, SCM val)
 465 {
 466
 467   Translator *t = unsmob_translator (context);
 468   Translator_group* tr=   dynamic_cast<Translator_group*> (t);
 469   if (tr)
 470     {
 471       tr->internal_set_property (name, val);
 472     }
 473   return SCM_UNSPECIFIED;
 474 }
 475
 476
 477
 478
 479 void
 480 add_trans_scm_funcs ()
 481 {
 482   scm_c_define_gsubr ("ly-get-trans-property", 2, 0, 0, (Scheme_function_unknown)ly_get_trans_property);
 483   scm_c_define_gsubr ("ly-set-trans-property", 3, 0, 0, (Scheme_function_unknown)ly_set_trans_property);
 484 }
 485
 486 ADD_SCM_INIT_FUNC (trans_scm, add_trans_scm_funcs);