lily/lily-modules.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 2015 by David Kastrup <dak@gnu.org>
   5
   6   LilyPond is free software: you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published by
   8   the Free Software Foundation, either version 3 of the License, or
   9   (at your option) any later version.
  10
  11   LilyPond is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   GNU General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "lily-modules.hh"
  21 #include "lily-imports.hh"
  22
  23 struct Scm_module::Variable_record
  24 {
  25   const char *name_;
  26   Scm_variable *var_;
  27   Variable_record *next_;
  28   Variable_record (const char *name, Scm_variable *var, Variable_record *next_)
  29     : name_ (name), var_ (var), next_ (next_)
  30   { }
  31 };
  32
  33 void
  34 Scm_module::register_variable (const char *name, Scm_variable *var)
  35 {
  36   variables_ = new Variable_record (name, var, variables_);
  37 }
  38
  39 Scm_module::Scm_module (const char *name)
  40   : name_ (name), module_ (SCM_UNDEFINED), variables_ (0)
  41 {
  42 }
  43
  44 void
  45 Scm_module::boot_init (void *arg)
  46 {
  47   Scm_module *self = static_cast<Scm_module *> (arg);
  48
  49   // Establish variables first
  50   for (Variable_record *p = self->variables_; p;)
  51     {
  52       Variable_record *next = p->next_;
  53       p->var_->boot (p->name_);
  54       delete p;
  55       p = next;
  56     }
  57   self->variables_ = 0;
  58 }
  59
  60 void
  61 Scm_module::boot ()
  62 {
  63   assert (SCM_UNBNDP (module_));
  64   module_ = scm_c_define_module (name_, boot_init, static_cast <void *> (this));
  65 }
  66
  67 void
  68 Scm_module::import ()
  69 {
  70   assert (SCM_UNBNDP (module_));
  71   SCM intrface = scm_c_resolve_module (name_);
  72   // Using only the public interface is a voluntary form of access
  73   // control in GUILE.  It would be cumbersome to do so until
  74   // Guile_user itself is imported.
  75   if (SCM_MODULEP (Guile_user::module.module_))
  76     intrface = Guile_user::module_public_interface (intrface);
  77   for (Variable_record *p = variables_; p;)
  78     {
  79       Variable_record *next = p->next_;
  80       p->var_->import (intrface, p->name_);
  81       delete p;
  82       p = next;
  83     }
  84   variables_ = 0;
  85   module_ = intrface;
  86 }
  87
  88 void
  89 Scm_variable::boot (const char *name)
  90 {
  91   assert (!SCM_VARIABLEP (var_));
  92   var_ = scm_c_define (name, var_);
  93 }
  94
  95 void
  96 Scm_variable::import (SCM module, const char *name)
  97 {
  98   assert (SCM_UNBNDP (var_));
  99   var_ = scm_c_module_lookup (module, name);
 100 }
 101
 102
 103 Scm_variable::Scm_variable (Scm_module &m, const char *name, SCM value)
 104   : var_ (value)
 105 {
 106   assert (SCM_IMP (value));
 107   m.register_variable (name, this);
 108 }