X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fmusic-output-def.cc;h=95ca70953327a714f47d2958b458d80a15d09be2;hb=ed011726ca0dbc44d5394dad366842b1454b1709;hp=394ca287b375e26bc3865580b761b2f755cf8fca;hpb=74e65211d6cda3818a6d4891f1f1c31f457e94cd;p=lilypond.git diff --git a/lily/music-output-def.cc b/lily/music-output-def.cc index 394ca287b3..95ca709533 100644 --- a/lily/music-output-def.cc +++ b/lily/music-output-def.cc @@ -1,112 +1,226 @@ /* - music-output-def.cc -- implement Music_output_def + music-output-def.cc -- implement Output_def source file of the GNU LilyPond music typesetter - (c) 1997--1999 Han-Wen Nienhuys + (c) 1997--2004 Han-Wen Nienhuys */ -#include "scope.hh" -#include "debug.hh" -#include "music-output-def.hh" -#include "global-translator.hh" -#include "dictionary-iter.hh" -#include "identifier.hh" -#include "main.hh" +#include "book-paper-def.hh" +#include "context-def.hh" +#include "file-path.hh" +#include "global-context.hh" #include "lily-guile.hh" +#include "ly-module.hh" +#include "main.hh" +#include "output-def.hh" +#include "output-def.hh" +#include "scm-hash.hh" +#include "warn.hh" -int -Music_output_def::get_next_default_count () const -{ - return 0; -} +#include "ly-smobs.icc" +Output_def::Output_def () +{ + scope_ = SCM_EOL; + parent_ = 0; + smobify_self (); + scope_ = ly_make_anonymous_module (false); +} -Music_output_def::Music_output_def () +Output_def::~Output_def () { - scope_p_ = new Scope; - translator_p_dict_p_ = new Scope; } -Music_output_def::~Music_output_def () +Output_def::Output_def (Output_def const &s) { - delete scope_p_; - delete translator_p_dict_p_; + scope_ = SCM_EOL; + parent_ = 0; + smobify_self (); + + scope_= ly_make_anonymous_module (false); + if (is_module (s.scope_)) + ly_import_module (scope_, s.scope_); } -Music_output_def::Music_output_def (Music_output_def const &s) + +IMPLEMENT_SMOBS (Output_def); +IMPLEMENT_DEFAULT_EQUAL_P (Output_def); + + +SCM +Output_def::mark_smob (SCM m) { - scope_p_ = new Scope (*s.scope_p_); - translator_p_dict_p_ = new Scope (*s.translator_p_dict_p_); + Output_def * mo = (Output_def*) SCM_CELL_WORD_1 (m); + + /* + FIXME: why is this necessary? + all bookpaper_ should be protected by themselves. + */ + if (mo->parent_) + scm_gc_mark (mo->parent_->self_scm ()); - for (Scope_iter i (*translator_p_dict_p_); i.ok (); i++) - { - Translator * t = i.val ()->access_content_Translator (false); - t-> output_def_l_ = this; - } + + mo->derived_mark (); + return mo->scope_; } void -Music_output_def::assign_translator (Translator*tp) +Output_def::derived_mark () {} + +void +assign_context_def (Output_def * m, SCM transdef) { - String s =tp->type_str_; - if (s.empty_b ()) + Context_def *tp = unsmob_context_def (transdef); + assert (tp); + + if (tp) { - tp->warning (_("Interpretation context with empty type")); - } - if (translator_p_dict_p_->elem_b (s)) - delete translator_p_dict_p_->elem (s); - - translator_p_dict_p_->elem (s) = new Translator_identifier (tp, 0); - tp ->output_def_l_ = this; + SCM sym = tp->get_context_name (); + scm_module_define (m->scope_, sym, transdef); + } } -Translator* -Music_output_def::find_translator_l (String name) const -{ - if (translator_p_dict_p_->elem_b (name)) - return translator_p_dict_p_->elem (name)->access_content_Translator (false); +/* + find the translator for NAME. NAME must be a symbol. +*/ +SCM +find_context_def (Output_def const *m, SCM name) +{ + Context_def *cd = unsmob_context_def (m->lookup_variable (name)); + return cd ? cd->self_scm () : SCM_EOL; +} - if (global_translator_dict_p->elem_b (name)) - return global_translator_dict_p->elem(name); +int +Output_def::print_smob (SCM s, SCM p, scm_print_state *) +{ + Output_def * def = unsmob_output_def (s); + scm_puts ("#< ", p); + scm_puts (classname (def), p); + + (void)def; + scm_puts (">", p); + return 1; +} - return 0; +Real +Output_def::get_dimension (SCM s) const +{ + SCM val = lookup_variable (s); + return ly_scm2double (val); } -Global_translator * -Music_output_def::get_global_translator_p () +SCM +Output_def::lookup_variable (SCM sym) const { - Translator * t = find_translator_l ("Score"); - if (!t) - error (_("Can't find Score context")); - t = t->clone (); - Global_translator *g = dynamic_cast (t); - t->add_processing (); + SCM var = ly_module_lookup (scope_, sym); + if (SCM_VARIABLEP (var)) + return SCM_VARIABLE_REF (var); + + if (parent_) + return parent_->lookup_variable (sym); - return g; + return SCM_EOL; +} + +SCM +Output_def::c_variable (String s) const +{ + return lookup_variable (ly_symbol2scm (s.to_str0 ())); } void -Music_output_def::print () const +Output_def::set_variable (SCM sym, SCM val) +{ + scm_module_define (scope_, sym, val); +} + +LY_DEFINE (ly_paper_lookup, "ly:output-def-lookup", + 2, 0, 0, (SCM pap, SCM sym), + "Lookup @var{sym} in @var{pap}. " + "Return the value or @code{'()} if undefined.") +{ + Output_def *op = unsmob_output_def (pap); + SCM_ASSERT_TYPE (op, pap, SCM_ARG1, __FUNCTION__, "Output_def"); + SCM_ASSERT_TYPE (ly_c_symbol_p (sym), sym, SCM_ARG2, __FUNCTION__, "symbol"); + + return op->lookup_variable (sym); +} + +LY_DEFINE (ly_output_def_scope, "ly:output-def-scope", + 1, 0,0, (SCM def), + "Get the variable scope inside @var{def}.") +{ + Output_def *op = unsmob_output_def (def); + SCM_ASSERT_TYPE (op, def, SCM_ARG1, __FUNCTION__, "Output definition"); + return op->scope_; +} + + +LY_DEFINE (ly_output_def_parent, "ly:output-def-parent", + 1, 0, 0, (SCM def), + "Get the parent output-def of @var{def}.") +{ + Output_def *op = unsmob_output_def (def); + SCM_ASSERT_TYPE (op, def, SCM_ARG1, __FUNCTION__, "Output definition"); + return op->parent_ ? op->parent_->self_scm () : SCM_EOL; +} + + +LY_DEFINE (ly_output_def_clone, "ly:output-def-clone", + 1, 0, 0, (SCM def), + "Clone @var{def}.") { -#ifndef NPRINT - translator_p_dict_p_->print (); - scope_p_->print( ); -#endif + Output_def *op = unsmob_output_def (def); + SCM_ASSERT_TYPE (op, def, SCM_ARG1, __FUNCTION__, "Output definition"); + SCM s = op->clone ()->self_scm (); + scm_gc_unprotect_object (s); + return s; } -String -Music_output_def::get_default_output () const +LY_DEFINE(ly_output_description, "ly:output-description", + 1,0,0, + (SCM output_def), + "Return the description of translators in @var{output-def}.") { - static SCM output_sym; - if (!output_sym) - output_sym = scm_protect_object (output_scm_sym); - if (safe_global_b || !scope_p_->elem_b (output_sym)) - return ""; - Identifier * id = scope_p_->elem (output_sym); + Output_def *id = unsmob_output_def (output_def); + + SCM al =ly_module_to_alist (id->scope_); + + SCM l = SCM_EOL; + for (SCM s = al ; ly_c_pair_p (s); s = ly_cdr (s)) + { + Context_def * td = unsmob_context_def (ly_cdar (s)); + SCM key = ly_caar (s); + if (td && key == td->get_context_name ()) + { + + l = scm_cons (scm_cons (key, td->to_alist ()), l); + } + } + return l; +} + - String *p = id->access_content_String (false); - return p ? *p : String (""); + +#include "interval.hh" + +/* FIXME. This is broken until we have a generic way of + putting lists inside the \paper block. */ +Interval +line_dimensions_int (Output_def *def, int n) +{ + Real lw = def->get_dimension (ly_symbol2scm ("linewidth")); + Real ind = n ? 0.0 : def->get_dimension (ly_symbol2scm ("indent")); + + return Interval (ind, lw); +} + +LY_DEFINE (ly_paper_def_p, "ly:paper-def?", + 1, 0, 0, (SCM def), + "Is @var{def} a paper definition?") +{ + return ly_bool2scm (unsmob_output_def (def)); }