lily/moment.cc

   1 /*
   2   moment.cc -- implement Moment
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1999--2007 Han-Wen Nienhuys <hanwen@xs4all.nl>
   7 */
   8
   9 #include "moment.hh"
  10
  11 #include "warn.hh"
  12
  13 Moment::Moment ()
  14 {
  15 }
  16
  17 Moment::Moment (int m)
  18 {
  19   main_part_ = Rational (m);
  20   grace_part_ = Rational (0);
  21 }
  22
  23 Moment::Moment (Rational m, Rational g)
  24 {
  25   main_part_ = m;
  26   grace_part_ = g;
  27 }
  28
  29 Moment::Moment (Rational m)
  30 {
  31   main_part_ = m;
  32   grace_part_ = Rational (0);
  33 }
  34
  35 #include "ly-smobs.icc"
  36
  37 IMPLEMENT_SIMPLE_SMOBS (Moment);
  38 IMPLEMENT_TYPE_P (Moment, "ly:moment?");
  39
  40 SCM
  41 Moment::mark_smob (SCM)
  42 {
  43   return SCM_EOL;
  44 }
  45
  46 int
  47 Moment::print_smob (SCM s, SCM port, scm_print_state *)
  48 {
  49   Moment *r = (Moment *) SCM_CELL_WORD_1 (s);
  50
  51   scm_puts ("#<Mom ", port);
  52   string str = r->to_string ();
  53   scm_puts ((char *)str.c_str (), port);
  54   scm_puts (">", port);
  55
  56   return 1;
  57 }
  58
  59 SCM
  60 Moment::as_scheme () const
  61 {
  62   return scm_list_5 (ly_symbol2scm ("ly:make-moment"),
  63                      scm_from_int (main_part_.num ()),
  64                      scm_from_int (main_part_.den ()),
  65                      scm_from_int (grace_part_.num ()),
  66                      scm_from_int (grace_part_.den ()));
  67 }
  68
  69 SCM
  70 Moment::equal_p (SCM a, SCM b)
  71 {
  72   Moment *m1 = unsmob_moment (a);
  73   Moment *m2 = unsmob_moment (b);
  74
  75   return (*m1 == *m2) ? SCM_BOOL_T : SCM_BOOL_F;
  76 }
  77
  78 int
  79 compare (Moment const &a, Moment const &b)
  80 {
  81   return Moment::compare (a, b);
  82 }
  83
  84 int
  85 Moment::compare (Moment const &a, Moment const &b)
  86 {
  87   int c = Rational::compare (a.main_part_, b.main_part_);
  88   if (c)
  89     return c;
  90
  91   return Rational::compare (a.grace_part_, b.grace_part_);
  92 }
  93
  94 void
  95 Moment::operator += (Moment const &src)
  96 {
  97   main_part_ += src.main_part_;
  98   grace_part_ += src.grace_part_;
  99 }
 100
 101 void
 102 Moment::operator -= (Moment const &src)
 103 {
 104   main_part_ -= src.main_part_;
 105   grace_part_ -= src.grace_part_;
 106 }
 107
 108 /* Only take the main part of SRC for multiplication.  */
 109 void
 110 Moment::operator *= (Moment const &src)
 111 {
 112   main_part_ *= src.main_part_;
 113   grace_part_ *= src.main_part_;
 114 }
 115
 116 /* Only take the main part of SRC for division.  */
 117 void
 118 Moment::operator /= (Moment const &src)
 119 {
 120   main_part_ /= src.main_part_;
 121   grace_part_ /= src.main_part_;
 122 }
 123
 124 /* Only take the main part of SRC for division.  */
 125 void
 126 Moment::operator %= (Moment const &src)
 127 {
 128   main_part_ %= src.main_part_;
 129   grace_part_ %= src.main_part_;
 130 }
 131
 132 int
 133 Moment::den () const
 134 {
 135   return main_part_.den ();
 136 }
 137
 138 int
 139 Moment::num () const
 140 {
 141   return main_part_.num ();
 142 }
 143
 144 bool
 145 Moment::to_bool () const
 146 {
 147   return main_part_ || grace_part_;
 148 }
 149
 150 void
 151 Moment::set_infinite (int k)
 152 {
 153   main_part_.set_infinite (k);
 154 }
 155
 156 string
 157 Moment::to_string () const
 158 {
 159   string s = main_part_.to_string ();
 160   if (grace_part_)
 161     s += "G" + grace_part_.to_string ();
 162   return s;
 163 }
 164
 165 Moment
 166 Moment::operator - () const
 167 {
 168   Moment m;
 169   m.grace_part_ = -grace_part_;
 170   m.main_part_ = -main_part_;
 171   return m;
 172 }
 173
 174 #ifdef STREAM_SUPPORT
 175 ostream &
 176 operator << (ostream &os, Moment const &m)
 177 {
 178   os << m.to_string ();
 179   return os;
 180 }
 181 #endif
 182
 183 Moment
 184 robust_scm2moment (SCM m, Moment d)
 185 {
 186   Moment *p = unsmob_moment (m);
 187   if (!p)
 188     return d;
 189   else
 190     return *p;
 191 }
 192
 193 bool
 194 moment_less (SCM a, SCM b)
 195 {
 196   return *unsmob_moment (a) < *unsmob_moment (b);
 197 }
 198