lily/context-def.cc

   1 /*
   2   context-def.cc -- implement Context_def
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 2000--2009 Han-Wen Nienhuys <hanwen@xs4all.nl>
   7 */
   8
   9 /* TODO: should junk this class an replace by
  10    a single list of context modifications?  */
  11
  12 #include "context-def.hh"
  13
  14 #include "context.hh"
  15 #include "international.hh"
  16 #include "output-def.hh"
  17 #include "translator.hh"
  18 #include "warn.hh"
  19
  20 Context_def::Context_def ()
  21 {
  22   context_aliases_ = SCM_EOL;
  23   translator_group_type_ = SCM_EOL;
  24   accept_mods_ = SCM_EOL;
  25   translator_mods_ = SCM_EOL;
  26   property_ops_ = SCM_EOL;
  27   context_name_ = SCM_EOL;
  28   default_child_ = SCM_EOL;
  29   description_ = SCM_EOL;
  30   input_location_ = SCM_EOL;
  31
  32   smobify_self ();
  33
  34   input_location_ = make_input (Input ());
  35   context_name_ = ly_symbol2scm ("");
  36 }
  37
  38 Input *
  39 Context_def::origin () const
  40 {
  41   return unsmob_input (input_location_);
  42 }
  43
  44 Context_def::Context_def (Context_def const &s)
  45 {
  46   context_aliases_ = SCM_EOL;
  47   translator_group_type_ = SCM_EOL;
  48   accept_mods_ = SCM_EOL;
  49   translator_mods_ = SCM_EOL;
  50   property_ops_ = SCM_EOL;
  51   context_name_ = SCM_EOL;
  52   description_ = SCM_EOL;
  53   default_child_ = SCM_EOL;
  54   input_location_ = SCM_EOL;
  55   smobify_self ();
  56
  57   description_ = s.description_;
  58   input_location_ = make_input (*s.origin ());
  59   default_child_ = s.default_child_;
  60   accept_mods_ = s.accept_mods_;
  61   property_ops_ = s.property_ops_;
  62   translator_mods_ = s.translator_mods_;
  63   context_aliases_ = s.context_aliases_;
  64   translator_group_type_ = s.translator_group_type_;
  65   context_name_ = s.context_name_;
  66 }
  67
  68 Context_def::~Context_def ()
  69 {
  70 }
  71
  72 #include "ly-smobs.icc"
  73 IMPLEMENT_SMOBS (Context_def);
  74 IMPLEMENT_DEFAULT_EQUAL_P (Context_def);
  75
  76 int
  77 Context_def::print_smob (SCM smob, SCM port, scm_print_state*)
  78 {
  79   Context_def *me = (Context_def *) SCM_CELL_WORD_1 (smob);
  80
  81   scm_puts ("#<Context_def ", port);
  82   scm_display (me->context_name_, port);
  83   scm_puts (">", port);
  84   return 1;
  85 }
  86
  87 SCM
  88 Context_def::mark_smob (SCM smob)
  89 {
  90   ASSERT_LIVE_IS_ALLOWED ();
  91
  92   Context_def *me = (Context_def *) SCM_CELL_WORD_1 (smob);
  93
  94   scm_gc_mark (me->description_);
  95   scm_gc_mark (me->context_aliases_);
  96   scm_gc_mark (me->accept_mods_);
  97   scm_gc_mark (me->translator_mods_);
  98   scm_gc_mark (me->property_ops_);
  99   scm_gc_mark (me->translator_group_type_);
 100   scm_gc_mark (me->default_child_);
 101   scm_gc_mark (me->input_location_);
 102
 103   return me->context_name_;
 104 }
 105
 106 void
 107 Context_def::add_context_mod (SCM mod)
 108 {
 109   SCM tag = scm_car (mod);
 110   if (ly_symbol2scm ("description") == tag)
 111     {
 112       description_ = scm_cadr (mod);
 113       return;
 114     }
 115
 116   /*
 117     other modifiers take symbols as argument.
 118   */
 119   SCM sym = scm_cadr (mod);
 120   if (scm_is_string (sym))
 121     sym = scm_string_to_symbol (sym);
 122
 123   if (ly_symbol2scm ("default-child") == tag)
 124     default_child_ = sym;
 125   else if (ly_symbol2scm ("consists") == tag
 126            || ly_symbol2scm ("remove") == tag)
 127     {
 128       if (!get_translator (sym))
 129         warning (_f ("program has no such type: `%s'",
 130                      ly_symbol2string (sym).c_str ()));
 131       else
 132         translator_mods_ = scm_cons (scm_list_2 (tag, sym), translator_mods_);
 133     }
 134   else if (ly_symbol2scm ("accepts") == tag
 135            || ly_symbol2scm ("denies") == tag)
 136     accept_mods_ = scm_cons (scm_list_2 (tag, sym), accept_mods_);
 137   else if (ly_symbol2scm ("pop") == tag
 138            || ly_symbol2scm ("push") == tag
 139            || ly_symbol2scm ("assign") == tag
 140            || ly_symbol2scm ("unset") == tag)
 141     property_ops_ = scm_cons (mod, property_ops_);
 142   else if (ly_symbol2scm ("alias") == tag)
 143     context_aliases_ = scm_cons (sym, context_aliases_);
 144   else if (ly_symbol2scm ("translator-type") == tag)
 145     translator_group_type_ = sym;
 146   else if (ly_symbol2scm ("context-name") == tag)
 147     context_name_ = sym;
 148   else
 149     programming_error ("unknown context mod tag");
 150 }
 151
 152 SCM
 153 Context_def::get_accepted (SCM user_mod) const
 154 {
 155   SCM mods = scm_reverse_x (scm_list_copy (accept_mods_), user_mod);
 156   SCM acc = SCM_EOL;
 157   for (SCM s = mods; scm_is_pair (s); s = scm_cdr (s))
 158     {
 159       SCM tag = scm_caar (s);
 160       SCM sym = scm_cadar (s);
 161       if (tag == ly_symbol2scm ("accepts"))
 162         acc = scm_cons (sym, acc);
 163       else if (tag == ly_symbol2scm ("denies"))
 164         acc = scm_delete_x (sym, acc);
 165     }
 166
 167   SCM def = get_default_child (user_mod);
 168   if (scm_is_symbol (def))
 169     {
 170       if (scm_memq (def, acc))
 171         acc = scm_delete_x (def, acc);
 172       acc = scm_cons (def, acc);
 173     }
 174
 175   return acc;
 176 }
 177
 178 SCM
 179 Context_def::get_default_child (SCM user_mod) const
 180 {
 181   SCM name = default_child_;
 182   for (SCM s = user_mod; scm_is_pair (s); s = scm_cdr (s))
 183     {
 184       SCM entry = scm_car (s);
 185       if (scm_car (entry) == ly_symbol2scm ("default-child"))
 186         {
 187           name = scm_cadr (entry);
 188           break;
 189         }
 190     }
 191
 192   return name;
 193 }
 194
 195 /*
 196   Given a name of a context that we want to create, finds a list of context
 197   definitions such that:
 198    - the first element in the list defines a context that is a valid child of
 199      the context defined by this Context_def
 200    - each subsequent element in the list defines a context that is a valid child
 201      of the the context defined by the preceding element in the list
 202    - the last element in the list defines a context with the given name
 203
 204   The ADDITIONAL_ACCEPTS parameter is a list of additional contexts that this
 205   specific context def (but not any of the child context defs) should accept.
 206 */
 207 vector<Context_def *>
 208 Context_def::path_to_acceptable_context (SCM type_sym,
 209                                          Output_def *odef,
 210                                          SCM additional_accepts) const
 211 {
 212   set<const Context_def *> seen;
 213   return internal_path_to_acceptable_context (type_sym, odef, additional_accepts, &seen);
 214 }
 215
 216 /*
 217 The SEEN parameter is a set which keeps track of visited contexts, allowing
 218 contexts of the same type to be nested.
 219 */
 220 vector<Context_def*>
 221 Context_def::internal_path_to_acceptable_context (SCM type_sym,
 222                                                   Output_def *odef,
 223                                                   SCM additional_accepts,
 224                                                   set<const Context_def *> *seen) const
 225 {
 226   assert (scm_is_symbol (type_sym));
 227
 228   SCM accepted = get_accepted (additional_accepts);
 229
 230   vector<Context_def*> accepteds;
 231   for (SCM s = accepted; scm_is_pair (s); s = scm_cdr (s))
 232     if (Context_def *t = unsmob_context_def (find_context_def (odef,
 233                                                                scm_car (s))))
 234       accepteds.push_back (t);
 235
 236   vector<Context_def*> best_result;
 237   for (vsize i = 0; i < accepteds.size (); i++)
 238     {
 239       /* do not check aliases, because \context Staff should not
 240          create RhythmicStaff. */
 241       if (ly_is_equal (accepteds[i]->get_context_name (), type_sym))
 242         {
 243           best_result.push_back (accepteds[i]);
 244           return best_result;
 245         }
 246     }
 247
 248   seen->insert (this);
 249   vsize best_depth = INT_MAX;
 250   for (vsize i = 0; i < accepteds.size (); i++)
 251     {
 252       Context_def *g = accepteds[i];
 253
 254       if (!seen->count (g))
 255         {
 256           vector<Context_def*> result
 257             = g->internal_path_to_acceptable_context (type_sym, odef, SCM_EOL, seen);
 258           if (result.size () && result.size () < best_depth)
 259             {
 260               best_depth = result.size ();
 261               result.insert (result.begin (), g);
 262               best_result = result;
 263             }
 264         }
 265     }
 266   seen->erase (this);
 267
 268   return best_result;
 269 }
 270
 271 SCM
 272 Context_def::get_translator_names (SCM user_mod) const
 273 {
 274   SCM l1 = SCM_EOL;
 275
 276   SCM mods = scm_reverse_x (scm_list_copy (translator_mods_), user_mod);
 277
 278   for (SCM s = mods; scm_is_pair (s); s = scm_cdr (s))
 279     {
 280       SCM tag = scm_caar (s);
 281       SCM arg = scm_cadar (s);
 282
 283       if (scm_is_string (arg))
 284         arg = scm_string_to_symbol (arg);
 285
 286       if (ly_symbol2scm ("consists") == tag)
 287         l1 = scm_cons (arg, l1);
 288       else if (ly_symbol2scm ("remove") == tag
 289                && get_translator (arg))
 290         l1 = scm_delete_x (arg, l1);
 291     }
 292
 293   return l1;
 294 }
 295
 296 Context *
 297 Context_def::instantiate (SCM ops)
 298 {
 299   Context *context = new Context ();
 300
 301   context->definition_ = self_scm ();
 302   context->definition_mods_ = ops;
 303   context->aliases_ = context_aliases_;
 304   context->accepts_list_ = get_accepted (ops);
 305
 306   return context;
 307 }
 308
 309 SCM
 310 Context_def::make_scm ()
 311 {
 312   Context_def *t = new Context_def;
 313   return t->unprotect ();
 314 }
 315
 316 void
 317 Context_def::apply_default_property_operations (Context *tg)
 318 {
 319   apply_property_operations (tg, property_ops_);
 320 }
 321
 322 SCM
 323 Context_def::to_alist () const
 324 {
 325   SCM ell = SCM_EOL;
 326
 327   ell = scm_cons (scm_cons (ly_symbol2scm ("consists"),
 328                             get_translator_names (SCM_EOL)), ell);
 329   ell = scm_cons (scm_cons (ly_symbol2scm ("description"), description_), ell);
 330   ell = scm_cons (scm_cons (ly_symbol2scm ("aliases"), context_aliases_), ell);
 331   ell = scm_cons (scm_cons (ly_symbol2scm ("accepts"), get_accepted (SCM_EOL)),
 332                   ell);
 333   ell = scm_cons (scm_cons (ly_symbol2scm ("property-ops"), property_ops_),
 334                   ell);
 335   ell = scm_cons (scm_cons (ly_symbol2scm ("context-name"), context_name_),
 336                   ell);
 337
 338   if (scm_is_symbol (translator_group_type_))
 339     ell = scm_cons (scm_cons (ly_symbol2scm ("group-type"),
 340                               translator_group_type_), ell);
 341   return ell;
 342 }
 343