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--2007 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 ("consists-end") == tag
 127            || ly_symbol2scm ("remove") == tag)
 128     {
 129       if (!get_translator (sym))
 130         error (_f ("program has no such type: `%s'",
 131                    ly_symbol2string (sym).c_str ()));
 132       else
 133         translator_mods_ = scm_cons (scm_list_2 (tag, sym), translator_mods_);
 134     }
 135   else if (ly_symbol2scm ("accepts") == tag
 136            || ly_symbol2scm ("denies") == tag)
 137     accept_mods_ = scm_cons (scm_list_2 (tag, sym), accept_mods_);
 138   else if (ly_symbol2scm ("pop") == tag
 139            || ly_symbol2scm ("push") == tag
 140            || ly_symbol2scm ("assign") == tag
 141            || ly_symbol2scm ("unset") == tag)
 142     property_ops_ = scm_cons (mod, property_ops_);
 143   else if (ly_symbol2scm ("alias") == tag)
 144     context_aliases_ = scm_cons (sym, context_aliases_);
 145   else if (ly_symbol2scm ("translator-type") == tag)
 146     translator_group_type_ = sym;
 147   else if (ly_symbol2scm ("context-name") == tag)
 148     context_name_ = sym;
 149   else
 150     programming_error ("unknown context mod tag");
 151 }
 152
 153 SCM
 154 Context_def::get_accepted (SCM user_mod) const
 155 {
 156   SCM mods = scm_reverse_x (scm_list_copy (accept_mods_), user_mod);
 157   SCM acc = SCM_EOL;
 158   for (SCM s = mods; scm_is_pair (s); s = scm_cdr (s))
 159     {
 160       SCM tag = scm_caar (s);
 161       SCM sym = scm_cadar (s);
 162       if (tag == ly_symbol2scm ("accepts"))
 163         acc = scm_cons (sym, acc);
 164       else if (tag == ly_symbol2scm ("denies"))
 165         acc = scm_delete_x (sym, acc);
 166     }
 167
 168   SCM def = get_default_child (user_mod);
 169   if (scm_is_symbol (def))
 170     {
 171       if (scm_memq (def, acc))
 172         acc = scm_delete_x (def, acc);
 173       acc = scm_cons (def, acc);
 174     }
 175
 176   return acc;
 177 }
 178
 179 SCM
 180 Context_def::get_default_child (SCM user_mod) const
 181 {
 182   SCM name = default_child_;
 183   for (SCM s = user_mod; scm_is_pair (s); s = scm_cdr (s))
 184     {
 185       SCM entry = scm_car (s);
 186       if (scm_car (entry) == ly_symbol2scm ("default-child"))
 187         {
 188           name = scm_cadr (entry);
 189           break;
 190         }
 191     }
 192
 193   return name;
 194 }
 195
 196 /*
 197   Given a name of a context that we want to create, finds a list of context
 198   definitions such that:
 199    - the first element in the list defines a context that is a valid child of
 200      the context defined by this Context_def
 201    - each subsequent element in the list defines a context that is a valid child
 202      of the the context defined by the preceding element in the list
 203    - the last element in the list defines a context with the given name
 204
 205   The ADDITIONAL_ACCEPTS parameter is a list of additional contexts that this
 206   specific context def (but not any of the child context defs) should accept.
 207 */
 208 vector<Context_def *>
 209 Context_def::path_to_acceptable_context (SCM type_sym,
 210                                          Output_def *odef,
 211                                          SCM additional_accepts) const
 212 {
 213   set<const Context_def *> seen;
 214   return internal_path_to_acceptable_context (type_sym, odef, additional_accepts, &seen);
 215 }
 216
 217 /*
 218 The SEEN parameter is a set which keeps track of visited contexts, allowing
 219 contexts of the same type to be nested.
 220 */
 221 vector<Context_def*>
 222 Context_def::internal_path_to_acceptable_context (SCM type_sym,
 223                                                   Output_def *odef,
 224                                                   SCM additional_accepts,
 225                                                   set<const Context_def *> *seen) const
 226 {
 227   assert (scm_is_symbol (type_sym));
 228
 229   SCM accepted = get_accepted (additional_accepts);
 230
 231   vector<Context_def*> accepteds;
 232   for (SCM s = accepted; scm_is_pair (s); s = scm_cdr (s))
 233     if (Context_def *t = unsmob_context_def (find_context_def (odef,
 234                                                                scm_car (s))))
 235       accepteds.push_back (t);
 236
 237   vector<Context_def*> best_result;
 238   for (vsize i = 0; i < accepteds.size (); i++)
 239     {
 240       /* do not check aliases, because \context Staff should not
 241          create RhythmicStaff. */
 242       if (ly_is_equal (accepteds[i]->get_context_name (), type_sym))
 243         {
 244           best_result.push_back (accepteds[i]);
 245           return best_result;
 246         }
 247     }
 248
 249   seen->insert (this);
 250   vsize best_depth = INT_MAX;
 251   for (vsize i = 0; i < accepteds.size (); i++)
 252     {
 253       Context_def *g = accepteds[i];
 254
 255       if (!seen->count (g))
 256         {
 257           vector<Context_def*> result
 258             = g->internal_path_to_acceptable_context (type_sym, odef, SCM_EOL, seen);
 259           if (result.size () && result.size () < best_depth)
 260             {
 261               best_depth = result.size ();
 262               result.insert (result.begin (), g);
 263               best_result = result;
 264             }
 265         }
 266     }
 267   seen->erase (this);
 268
 269   return best_result;
 270 }
 271
 272 SCM
 273 Context_def::get_translator_names (SCM user_mod) const
 274 {
 275   SCM l1 = SCM_EOL;
 276
 277   SCM mods = scm_reverse_x (scm_list_copy (translator_mods_), user_mod);
 278
 279   for (SCM s = mods; scm_is_pair (s); s = scm_cdr (s))
 280     {
 281       SCM tag = scm_caar (s);
 282       SCM arg = scm_cadar (s);
 283
 284       if (scm_is_string (arg))
 285         arg = scm_string_to_symbol (arg);
 286
 287       if (ly_symbol2scm ("consists") == tag)
 288         l1 = scm_cons (arg, l1);
 289       else if (ly_symbol2scm ("remove") == tag)
 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