SUBDIRS=man tex pictures topdocs ntweb
STEPMAKE_TEMPLATES=documentation
README_TOP_FILES=NEWS DEDICATION TODO ANNOUNCE-0.1
-# INFO_FILES = $(wildcard $(outdir)/$(package).info*)
+INFO_FILES = $(wildcard $(outdir)/$(package).info*)
EXTRA_DIST_FILES = gnu-music-history TODO
\end{center}
\end{figure}
-Another clearly visible example of music typography is visible in
-collisions. When chords or separate voices are printed, the notes
-that start at the same time should be printed aligned (ie., with the
-same $x$ position). If the pitches are close to each other, the note
-heads would collide. To prevent this, some notes (or note heads) have
-to be shifted horizontally. An example of this is given in Figure~\ref{fig:collision}.
+Another example of music typography is clearly visible in collisions.
+When chords or separate voices are printed, the notes that start at
+the same time should be printed aligned (ie., with the same $x$
+position). If the pitches are close to each other, the note heads
+would collide. To prevent this, some notes (or note heads) have to be
+shifted horizontally. An example of this is given in
+Figure~\ref{fig:collision}.
\begin{figure}[h]
\begin{center}
- \begin{mudela}
- c4
- \end{mudela}
+ [todo]
\caption{Collisions}
\label{fig:collision}
\end{center}
\bibliographystyle{hw-plain}
\bibliography{engraving,boeken,colorado,computer-notation,other-packages}
+\section{Requirements}
+
+\section{Approach}
+
+\subsection{Input}
+
+\section{Discussion}
+
\end{document}
+pl 31.hwn2
+ - be somewhat lazy in break/object multiplication.
+ - print # elements for memory usage impression (try -t)
+ - Paper_score cleanup
+ - junked various Pointer_list instances. Executable now is smaller.
+ - junked various cruft
+ - merged do_substitute_dependen{t,cy} to
+do_substitute_element_pointer ()
+ - more parser cleanup
+ - Interval uses Drul_array
+ - bf: I've been drinking too much
+ - delete break helpers before object breaking/multiplication. Try
+to save some memory.
+
+pl 31.jcn4
+ - bf: toplevel install, kpsewhich
+ - sm 71, require yodl-1.31.11
+ - fix: slur macros
+ - bf: info in rpm, if available
+ - fix: rat != float
+ - bf: slur-follow-music
+
+pl 31.uu1
+ - config.make: include GUILE_LDFLAGS
+
+******
+pl 31 (feb 16)
pl 30.jcn1
- sm fixes, intl/ fixes
mentioned here. This is an assorted collection of stuff that will be
done, might be done, or is an idea that I want to think about
-Most of the items are marked in the code as well, with full explanation.
-grep for TODO and ugh/ugr/urg
+Most of the items are marked in the code as well
+Grep for TODO and ugh/ugr/urg.
.* BUGS
. * .ly files
. * fix singleStaffBracket
. * \shape 1st dim skipped?
. * turn slope-damping on/off
-. * c4 \! \> c4
. * tremolo stuff
. * fix height of / collisions with lyrics (chords),
see input/test/vertical-text.ly; input/test/repeat.ly
. * We need feta-din*.mf files for more sizes than 10.
. * latex bla.tex broken (titles / \lilyfooter stuff?)
. * fix dynamics decently, ie. use kerning & ligatures.
-. * fix "I've been drinking too much"
. * support_l_arr_ empty in staff-margin's G_staff_side_item
. * minVerticalAlign for StaffGroups.
. * declaring \score
-. * is \break broken? input/test/hara-kiri.ly
. * fix OrchestralScore and Hara-kiri (i.e., fix Coriolan)
. * Phrasing: Indicating the textual underlay of a piece, or
otherwise dividing a piece into phrases.
. * Check gcc 2.8.1 compatibility
. * make "in-between" engraver (Tie, Extender)
. * use Drul_array for Interval.
+. * compulsory hshift
. * ties to tie only notes of the same pitch, so that
< a~ a,> a
works as you'd expect it to.
. * do --safe for PS output?
. * convert-mudela --output
. * Staff_margin (with a partial measure.)
-. * fix "I've been drinking too much"
. * fix pletvisibility properties:
. * bracket on/off/no-bracket-when-beam
. * num on/off/no-num-when-beam
. * capitalization/use of underscores in property names
. * fix SkipBars -> skipBars
-. * fix marks/barnumbers/marginal notes
. * broken scripts:
lbheel = \script { "bheel" 0 0 -1 0 0 }
rbheel = \script { "bheel" 0 0 1 0 0 }
. * deps for ly2dvi
.* STUFF
. * check out legal/(c) matters for scores.
-. * check out GCC signatures?
. * Align_element::padding ?
. * uniformise property names...
. * ydirection <-> yDirection
{\voicetwo cis,4 r r | r2. | r1 }> |
}
. * try to use template<Type> iso MACRO(Type)
-. * NEWS: ... Musical_pitch (analogous to Duration and Rhythmic_req)
+. * Musical_pitch (analogous to Duration and Rhythmic_req)
think about, analogous to pitch:
* { a4 a16 } c <-- duration of c?
* < a4 b8 > c <-- duration of c?
in the middle:
. * the bracket is ugly (wings are too parabolic, should be more circular)
. * better hshift (dots, distance, head dependent)
- * clefs (AG): The "8" should appear closer to the actual clef,
- touching it.
+. * clefs (AG): The "8" should appear closer to the actual clef,
+touching it.
. * put errorlevel in Input class
. * junk nesting slurs
. * integrate midi-elts from mi2mu and lily?
.* 3RD PARTY BUGS
. * GNU diff 2.7: diff -rN does not see a new directory with empty file
+. * check out GCC signatures?
. * glibc 2.0:
f = fopen ("/dev/null", "r")
assert (feof (f))
. * fontlock: \melodic \melodic
. * use properties for:
-. * plet?
. * Staff_sym size
. * default tempo.
-. * font size
-. * bartypes (get rid of derived Span_bar_engravers)
. * cadenza mode?
. * page handling:
. * quiet/ignore-version options
. * logfile output
-. * elaborate Staff_side baseclass:
-. * scripts
-. * text
-. * slur start/end
-
. * PS
. * speed up PS code.
. * PS lines to .eps files
. * write custom prolog
-. * Output an output format independent (ofi) typeset file; and
- make ofi2 TeX, MusiXTex, Display PostScript, PostScript,
- Ascii... interpreters. (difficult)
-
. * NIFF ?
. * Common Music Notation
. * PostScript output (esp. Beams, Slurs, etc)
. * Rewrite Stem, Beam and Rhythmic_grouping (hairy)
. * [c8. c32 c32]
- **** doc on Rhythmic_grouping
+. * doc on Rhythmic_grouping
. * general shaving on Beam and Stem
. * use plet grouping
. * separate visual from rhythmic info even more
. * beams over bars
. * lines:
-. * Ledger lines, should be separate item: Ledger_lines, Ledger_lines
+. * Ledger lines, should be separate item: Ledger_lines
. * set different line sizes / thicknesses
. * beam stem showthrough, inter beam sizes (french vs german style)
. * caching breakpoints
. * saving them
. * specify number of lines
+
.* INPUTLANGUAGE
. * c4 4 4 4 for c4 c4 c4 c4?
-. * neatly (and readably) expressing concurrent
- voices
. * <c f a>4 ?
. * Viola mode?
@A c g e g
for
cis gis e gis
-. * relative mode for pitch entering
. * configure pitch_byte
. * rest name configurable
.* SMALLISH PROJECTS
-. * limit memory usage; the full coriolan takes up too much resources.
-
. * fix confusing naming in Engraver vs Engraver_group_engraver (context)
. * progress when creating MIDI elts.
. * handle EOF graciously in error messages.
-. * declare notenametab?
-
. * midi esp.: use I32 iso int where 32 bits are needed (or assumed...)
. * stafftypes: voice names/ instrument names.
. * lily \tempo
-. * C meter iso 4/4, idem for alla breve, etc.
-
-. * textspanner: center position
-
- * % toe to bheel four to five
+. * % toe to bheel four to five
% ^_u 4_5
% -
% --|x-- --|x--
. * clean solution for staffsize in items.
. * revise calcideal
+
.* IDEAS
. * Output data structures of Mudela in XML/SGML.
. * create libmudela, or liblily_frontend
. * caching breakpoints
. * used fixedpoint arithmetic for min. energy.
. * move towards incremental algorithms.
-. * far fetched language ideas
-. * design meta-language like TeX and Metafont
-. * programming/macros input
. * versioning stuff (cvt mudela, mudela, etc.)
-. * Klavarskribo?
. * dynamic loading of engravers?
.* SMOBS
Han-Wen Nienhuys <hanwen@cs.uu.nl> writes:
-dnl WARNING WARNING WARNING WARNING
-dnl do not edit! this is aclocal.m4, generated from stepmake/aclocal.m4
dnl aclocal.m4 -*-shell-script-*-
dnl StepMake subroutines for configure.in
])
AC_DEFUN(AC_STEPMAKE_MAN, [
+ AC_CHECK_PROGS(GROFF, groff ditroff, -echo no groff)
AC_CHECK_PROGS(TROFF, troff, -echo no troff)
AC_CHECK_PROGS(TBL, tbl, cat)
])
TFMDIR=`kpsewhich cmr10.tfm`
ln -sf `dirname $TFMDIR` tfm
mkdir -p $prefix/share/
-ln -sf $prefix/lilypond/ $sources/lilypond
-
+if [ ! -x $prefix/share/lilypond ]; then
+ echo ln -sf $sources/lilypond $prefix/share
+ ln -sf $sources/lilypond $prefix/
+fi
if [ -f ../.gdbinit ];
then
ln ../.gdbinit .
AC_CHECK_SEARCH_RESULT($YODL2TEXINFO, yodl,
You should install Yodl 1.30.2 or newer)
+
+AC_MSG_CHECKING(Checking TFM directory)
+CMR10=`kpsewhich tfm cmr10.tfm`
+TEX_TFMDIR=`dirname $CMR10`
+AC_MSG_RESULT($TEX_TFMDIR)
+
+AC_SUBST(TEX_TFMDIR)
AC_STEPMAKE_END
+
--- /dev/null
+/*
+ direction.hh -- declare Direction
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+*/
+
+
+#ifndef DIRECTION_HH
+#define DIRECTION_HH
+
+#include "axes.hh"
+
+enum Direction
+{
+ UP=1,
+ DOWN=-1,
+ LEFT=-1,
+ RIGHT=1,
+ MIN=-1,
+ MAX=1,
+ CENTER=0,
+ SMALLER=-1,
+ BIGGER=1,
+ START = -1,
+ STOP = 1
+};
+
+inline Direction
+other_dir (Direction const d)
+{
+ return (Direction)(-d);
+}
+
+inline Direction
+operator - (Direction const d)
+{
+ return other_dir (d);
+}
+
+// huh?
+inline Direction
+flip (Direction *i) {
+ if (*i == (Direction)1)
+ *i = (Direction)-1;
+ else if (*i == (Direction)-1)
+ *i = (Direction)1;
+ return *i;
+}
+
+/**
+ if d > 0: the max operator
+ if d < 0: the min operator
+ */
+template<class T> T minmax (Direction d, T, T);
+
+// String direction_str (Direction, Axis);
+
+#endif // DIRECTION_HH
--- /dev/null
+/*
+ drul-array.hh -- declare Drul_array
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+*/
+
+
+#ifndef DRUL_ARRAY_HH
+#define DRUL_ARRAY_HH
+
+#include "direction.hh"
+
+#include <assert.h>
+
+/**
+ Left/right or Up/down arrays. Drul is nicer sounding than udlr
+ */
+template<class T>
+struct Drul_array
+{
+ T array_[2];
+ T &elem (Direction d)
+ {
+ assert (d==1 || d== -1);
+ return array_[(d+1)/2];
+
+ }
+ T &operator[] (Direction d)
+ {
+ return elem (d);
+ }
+ T elem (Direction d) const
+ {
+ assert (d==1 || d== -1);
+ return array_[(d+1)/2];
+ }
+
+ T operator[] (Direction d) const
+ {
+ return elem (d);
+ }
+ Drul_array ()
+ {}
+ Drul_array (T t1, T t2)
+ {
+ array_[0] = t1;
+ array_[1] = t2;
+ }
+};
+
+#endif // DRUL_ARRAY_HH
#include <assert.h>
#include "fproto.hh"
#include "real.hh"
-
+#include "drul-array.hh"
/** a T interval. this represents the closed interval [left,right].
No invariants. T must be a totally ordered ring (with division, anyway ..)
*/
template<class T>
-struct Interval_t {
- T left, right;
+struct Interval_t : public Drul_array<T> {
/* ************** */
static T infinity() ;
static String T_to_str (T arg);
- // ugh, egcs 1.02 ices on this
-// T center() { return (left + right) / T(2);}
- // and can't handle this either
- // anyone want to make a bug report?
- // better make one soon, egcs in rh5.1 barfs on this!
- T center() {
- T two (2);
-// return (left + right) / two;
- T result ((left + right) / two);
- return result;
- }
- void translate (T t) {
- left += t;
- right += t;
- }
- T& idx (int j) {
- if (j==-1)
- return left;
- else if (j==1)
- return right;
- else
- assert (false);
- return left;
- }
- T& operator[](int j) {
- return idx (j);
- }
- T operator[](int j) const {
- return ((Interval_t<T> *)this)->idx (j);
- }
- T &max() { return right;}
- T max() const { return right;}
- T min() const{ return left; }
- T &min(){ return left; }
+ /*
+ ugh, egcs 1.02 ices on this
+ */
+ T center() { return (elem (LEFT) + elem (RIGHT)) / T(2);}
+ void translate (T t)
+ {
+ elem (LEFT) += t;
+ elem (RIGHT) += t;
+ }
+
+ /*
+ junk us
+ */
+ T &max() { return elem (RIGHT);}
+ T max() const { return elem (RIGHT);}
+ T min() const{ return elem (LEFT); }
+ T &min(){ return elem (LEFT); }
/**
PRE
*this and h are comparable
T length() const;
void set_empty() ;
- bool empty_b() const { return left > right; }
+ bool empty_b() const { return elem (LEFT) > elem (RIGHT); }
bool contains_b (Interval_t<T> const&) const;
Interval_t() {
set_empty();
}
- Interval_t (T m, T M) {
- left =m;
- right = M;
- }
+ Interval_t (T m, T M) : Drul_array<T> (m,M)
+ {}
Interval_t<T> &operator -= (T r) {
*this += -r;
return *this;
}
Interval_t<T> &operator += (T r) {
- left += r;
- right +=r;
+ elem (LEFT) += r;
+ elem (RIGHT) +=r;
return *this;
}
Interval_t<T> &operator *=(T r) {
- left *= r;
- right *= r;
+ elem (LEFT) *= r;
+ elem (RIGHT) *= r;
if (r < T(0)) {
- T t = left;
- left = right;
- right = t;
+ T t = elem (LEFT);
+ elem (LEFT) = elem (RIGHT);
+ elem (RIGHT) = t;
}
return *this;
}
void print () const;
bool elem_b (T r);
void negate () {
- T r = -left;
- T l = -right;
- left = l;
- right =r;
+ T r = -elem (LEFT);
+ T l = -elem (RIGHT);
+ elem (LEFT) = l;
+ elem (RIGHT) =r;
}
};
// again? see fproto.hh
typedef Interval_t<Real> Interval;
-typedef Interval_t<int> Slice;
+typedef Interval_t<int> Slice; // weird name
#endif // INTERVAL_HH
int
_Interval__compare (const Interval_t<T>&a,Interval_t<T> const&b)
{
- if (a.left == b.left && a.right == b.right)
+ if (a.elem (LEFT) == b.elem (LEFT) && a.elem (RIGHT) == b.elem (RIGHT))
return 0;
- if (a.left <= b.left && a.right >= b.right)
+ if (a.elem (LEFT) <= b.elem (LEFT) && a.elem (RIGHT) >= b.elem (RIGHT))
return 1;
- if (a.left >= b.left && a.right <= b.right)
+ if (a.elem (LEFT) >= b.elem (LEFT) && a.elem (RIGHT) <= b.elem (RIGHT))
return -1;
return -2;
void
Interval_t<T>::set_empty()
{
- left = (T) infinity();
- right = (T) -infinity();
+ elem (LEFT) = (T) infinity();
+ elem (RIGHT) = (T) -infinity();
}
template<class T>
T
Interval_t<T>::length() const
{
- if (right < left)
+ if (elem (RIGHT) < elem (LEFT))
return 0;
else
- return right-left;
+ return elem (RIGHT)-elem (LEFT);
}
+/**
+ smallest Interval which includes *this and #h#
+ */
template<class T>
void
Interval_t<T>::unite (Interval_t<T> h)
{
- if (h.left<left)
- left = h.left;
- if (h.right>right)
- right = h.right;
+ elem (LEFT) = h.elem (LEFT) <? elem (LEFT);
+ elem (RIGHT) = h.elem (RIGHT) >?elem (RIGHT);
+
+#if 0
+ if (h.elem (LEFT)<elem (LEFT))
+ elem (LEFT) = h.elem (LEFT);
+ if (h.elem (RIGHT)>elem (RIGHT))
+ elem (RIGHT) = h.elem (RIGHT);
+#endif
}
-/**
- smallest Interval which includes *this and #h#
- */
template<class T>
void
Interval_t<T>::intersect (Interval_t<T> h)
{
#if defined (__GNUG__) && ! defined (__STRICT_ANSI__)
- left = h.left >? left;
- right = h.right <?right;
+ elem (LEFT) = h.elem (LEFT) >? elem (LEFT);
+ elem (RIGHT) = h.elem (RIGHT) <?elem (RIGHT);
#else
- left = max (h.left, left);
- right = min (h.right, right);
+ elem (LEFT) = max (h.elem (LEFT), elem (LEFT));
+ elem (RIGHT) = min (h.elem (RIGHT), elem (RIGHT));
#endif
}
return "[empty]";
String s ("[");
- return s + T_to_str (left) + String ("," ) + T_to_str (right ) + String ("]" );
+ return s + T_to_str (elem (LEFT)) + String ("," ) + T_to_str (elem (RIGHT) ) + String ("]" );
}
template<class T>
bool
Interval_t<T>::elem_b (T r)
{
- return r >= left && r <= right;
+ return r >= elem (LEFT) && r <= elem (RIGHT);
}
--- /dev/null
+%{
+do a memory stress test.
+%}
+
+
+bla = \notes {
+ c1(((( c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break c1 \break ))))c1}
+
+\score { \type Score <
+ \bla \bla \bla \bla \bla \bla \bla
+ >
+ \paper { Gourlay_maxmeaures = 2.; }
+}
}
void
-Abbreviation::do_substitute_dependent (Score_element*o, Score_element*n)
+Abbreviation::do_substitute_element_pointer (Score_element*o, Score_element*n)
{
if (stem_l_ == o)
stem_l_ = dynamic_cast<Stem*> (n);
}
void
-Align_element::do_substitute_dependency (Score_element*o,
+Align_element::do_substitute_element_pointer (Score_element*o,
Score_element*n)
{
int i;
/* this piece doesn't know where it belongs.
Find out if it was broken, and use the broken remains
*/
- Spanner * sp =dynamic_cast <Spanner *> (elt);
+
Item *it = dynamic_cast <Item *> (elt) ;
- if (sp)
+ if (Spanner * sp =dynamic_cast <Spanner *> (elt))
{
- for (int j =0; j < broken_into_l_arr_.size(); j++)
+ for (int j =0; j < sp->broken_info_.size(); j++)
{
+ Line_of_score *l = sp->broken_info_[j].line_l_;
+
Axis_group_spanner * my_broken_l
- = dynamic_cast<Axis_group_spanner*>(broken_into_l_arr_[j]);
-
+ = dynamic_cast<Axis_group_spanner*>(find_broken_piece (l));
+
Spanner * broken_span_l
- = sp->find_broken_piece (dynamic_cast<Score_element*>(my_broken_l)->line_l());
+ = sp->find_broken_piece (l);
if (broken_span_l)
my_broken_l->add_element (broken_span_l);
-
}
}
else if (it && it->breakable_b_ && it->break_status_dir () == 0)
{
if (text_p_)
{
- text_p_->breakable_b_ = true; // ugh
typeset_element (text_p_);
text_p_ =0;
}
if (staff_side_p_)
{
- staff_side_p_->breakable_b_ = true; // ugh
typeset_element (staff_side_p_);
staff_side_p_ = 0;
}
staff_side_p_ = new G_staff_side_item;
staff_side_p_->axis_ = axis_;
+ staff_side_p_->breakable_b_ = true; // ugh
+
text_p_ = new G_text_item;
+ text_p_->breakable_b_ = true; // ugh
Scalar prop = get_property (type_ + "Direction", 0);
if (prop.isnum_b ())
}
void
-Beam::do_substitute_dependent (Score_element*o,Score_element*n)
+Beam::do_substitute_element_pointer (Score_element*o,Score_element*n)
{
if (Stem * os = dynamic_cast<Stem*> (o))
stems_.substitute (os,
{
static int i = 1;
cout << "******" << i++ << "******" << endl;
- // gcc 2.7.2: ices
-// cout << "c0.y: " << c[0].y << endl;
cout << "c0.y: " << c[0].y () << endl;
cout << "c3.y: " << c[3].y () << endl;
cout << "dy: " << dy << endl;
/*
-
- ugh . Control points are too crude measures.
+ Ugh. Control points are too crude measures.
*/
Interval
Bow::do_height () const
return iv;
}
-#if 0
-Interval
-Bow::do_width () const
-{
- Interval i = Spanner::do_width ();
- Real dx = i.length();
- return Interval (0, dx);
-}
-#endif
Array<Offset>
Bow::get_controls () const
/* **************************************************************** */
-Line_of_cols
-Break_algorithm::all_cols () const
-{
- Line_of_cols retval;
- for (PCursor<Paper_column*> c (pscore_l_->col_p_list_.top ());
- c.ok (); c++)
- {
-
- retval.push (c);
- }
- return retval;
-}
Array<int>
Break_algorithm::find_break_indices () const
{
- Line_of_cols all (all_cols ());
+ Line_of_cols all (pscore_l_->col_l_arr_);
Array<int> retval;
for (int i=0; i < all.size (); i++)
Line_of_cols
Break_algorithm::find_breaks () const
{
- Line_of_cols all (all_cols ());
+ Line_of_cols all (pscore_l_->col_l_arr_);
Line_of_cols retval;
for (int i=0; i < all.size (); i++)
void
Break_algorithm::problem_OK () const
{
- if (!pscore_l_->col_p_list_.size ())
+ if (pscore_l_->col_l_arr_.empty ())
error (_("score does not have any columns"));
OK ();
}
Break_algorithm::OK () const
{
#ifndef NDEBUG
- iter_top (pscore_l_->col_p_list_,start);
+ #if 0
+ iter_top (pscore_l_->col_p_list_,start);
PCursor<Paper_column *> end (pscore_l_->col_p_list_.bottom ());
assert (start->breakable_b_);
assert (end->breakable_b_);
+ #endif
#endif
}
void
-Collision::do_substitute_dependency (Score_element*o_l,Score_element*n_l)
+Collision::do_substitute_element_pointer (Score_element*o_l,Score_element*n_l)
{
if (o_l)
{
#include "direction.hh"
+#if 0
String direction_str (Direction d, Axis a)
{
String s("center");
}
return s;
}
+#endif
}
void
-Dot_column::do_substitute_dependency (Score_element*o,Score_element*n)
+Dot_column::do_substitute_element_pointer (Score_element*o,Score_element*n)
{
Item *oi =dynamic_cast <Item *> (o);
*/
#include "proto.hh"
-#include "plist.hh"
#include "engraver-group.hh"
#include "engraver.hh"
#include "debug.hh"
}
void
-Extender_spanner::do_substitute_dependency (Score_element* o, Score_element* n)
+Extender_spanner::do_substitute_element_pointer (Score_element* o, Score_element* n)
{
Item* new_l = n ? dynamic_cast<Item *> (n) : 0;
if (dynamic_cast <Item *> (o) == item_l_drul_[LEFT])
void
-G_staff_side_item::do_substitute_dependency (Score_element*o, Score_element*n)
+G_staff_side_item::do_substitute_element_pointer (Score_element*o, Score_element*n)
{
if (o == to_position_l_)
to_position_l_ = n;
#include "p-score.hh"
#include "paper-def.hh"
+#include "killing-cons.tcc"
+
+/// How often to print operator pacification marks?
const int HAPPY_DOTS_I = 3;
/**
};
/**
- This algorithms is adapted from
+ This algorithms is adapted from the OSU Tech report on breaking lines.
+
*/
Array<Column_x_positions>
Gourlay_breaking::do_solve () const
{
Array<Break_node> optimal_paths;
- Line_of_cols all = all_cols ();
+ Line_of_cols all = pscore_l_->col_l_arr_ ;
Array<int> breaks = find_break_indices ();
optimal_paths.set_size (breaks.size ());
{
Array<int> candidates;
Array<Column_x_positions> candidate_lines;
- Pointer_list<Line_spacer*> spacer_p_list;
+ Cons_list<Line_spacer> spacer_p_list;
/*
start with a short line, add measures. At some point
approx.spacer_l_ = generate_spacing_problem (line,
pscore_l_->paper_l_->line_dimensions_int (optimal_paths[start_idx].line_i_));
- spacer_p_list.bottom ().add (approx.spacer_l_);
+ spacer_p_list.append (new Killing_cons<Line_spacer> (approx.spacer_l_,0));
( (Break_algorithm*)this)->approx_stats_.add (approx.cols);
approx.approximate_solve_line ();
if (! (break_idx % HAPPY_DOTS_I))
*mlog << "[" << break_idx << "]" << flush;
+
+ spacer_p_list.junk ();
}
if (break_idx % HAPPY_DOTS_I)
}
void
-Hara_kiri_vertical_group_spanner::do_substitute_dependency (Score_element*o, Score_element*n)
+Hara_kiri_vertical_group_spanner::do_substitute_element_pointer (Score_element*o, Score_element*n)
{
if (Item *it = dynamic_cast<Item *> (o))
interesting_items_.substitute (it, dynamic_cast<Item *> (n));
protected:
virtual void do_print () const;
virtual Molecule *do_brew_molecule_p () const;
- virtual void do_substitute_dependent (Score_element*, Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*, Score_element*);
public:
int abbrev_flags_i_;
Abbreviation ();
protected:
virtual void do_print() const;
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
virtual void do_post_processing() ;
virtual void do_pre_processing ();
virtual void do_side_processing ();
#include "lily-proto.hh"
#include "lily-guile.hh"
+
#ifdef ATOM_SMOB
/// a symbol which can be translated, and freely copied
#include "item.hh"
/**
A vertical bar.
-
- TODO: connections with pre and postbreak
*/
class Bar:public Item {
public:
void set_steminfo ();
virtual void do_pre_processing ();
virtual void do_post_processing ();
- virtual void do_substitute_dependent (Score_element*, Score_element*);
-
+ virtual void do_substitute_element_pointer (Score_element*, Score_element*);
virtual void do_print() const;
-
virtual void quantise_left_y (bool extend_b);
virtual Molecule stem_beams (Stem *here, Stem *next, Stem *prev) const;
virtual void calculate_slope ();
Bow ();
Offset center () const;
-
-
int dash_i_;
Real interstaff_f_;
Drul_array<Real> vertical_align_drul_;
/// search all pcols which are breakable.
Line_of_cols find_breaks() const;
- Line_of_cols all_cols() const;
Array<int> find_break_indices() const;
*/
class Collision : public Horizontal_vertical_group_item {
protected:
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
virtual void do_pre_processing();
public:
Link_array<Note_column> clash_l_arr_;
#ifndef CONS_HH
#define CONS_HH
-#if 0
-template<class T, class U>
-class NCons
-{
-public:
- T car_;
- U cdr_;
- NCons (T t, U u) : car_ (t), cdr_ (u) {}
- virtual ~NCons () {}
-};
-
-template<class T>
-class Pointer_cons : public NCons<T, NCons*>
-{
- Pointer_cons () : Cons<T, Cons*> (0,0){}
- Pointer_cons (T t, Pointer_cons<T>*c)
- : Cons<T, Cons*> (t,c)
- {
- car_ = t;
- next_ = c;
- }
-};
-#endif
template<class T>
public:
T * car_;
Cons * next_;
- Cons () {
- car_=0;
- next_ =0;
- }
+ Cons ()
+ {
+ car_=0;
+ next_ =0;
+ }
Cons (T*t, Cons<T>*c)
{
car_ = t;
};
+/// remove the link pointed to by *p.
+template<class T>
+Cons<T> *remove_cons (Cons<T> **pp)
+{
+ Cons<T> *knip = *pp;
+ *pp = (*pp)->next_;
+ knip->next_ = 0;
+ return knip;
+}
+
+
template<class T>
class Cons_list
{
Cons<T> * head_;
Cons<T> ** tail_;
Cons_list () { head_ =0; tail_ = &head_; }
+ void append (Cons<T> *c)
+ {
+ assert (!c->next_);
+ *tail_ = c;
+ while (*tail_)
+ tail_ = &(*tail_)->next_;
+ }
+ Cons<T> *remove_cons (Cons<T> **pp)
+ {
+ if (&(*pp)->next_ == tail_)
+ tail_ = pp;
+
+ return ::remove_cons (pp);
+ }
+ void junk ()
+ {
+ delete head_;
+ head_ =0;
+ }
+ ~Cons_list () { junk (); }
};
template<class T>
-Cons_list<T> copy_killing_cons_list (Cons<T> *src);
+void copy_killing_cons_list (Cons_list<T>&, Cons<T> *src);
template<class T>
-Cons_list<T> clone_killing_cons_list (Cons<T> *src);
+void
+clone_killing_cons_list (Cons_list<T>&, Cons<T> *src);
#endif /* CONS_HH */
protected:
virtual void do_pre_processing ();
- virtual void do_substitute_dependency (Score_element *o, Score_element*n);
+ virtual void do_substitute_element_pointer (Score_element *o, Score_element*n);
};
#endif // DOT_COLUMN_HH
virtual Molecule* do_brew_molecule_p () const;
void do_add_processing ();
Interval do_height () const;
- void do_substitute_dependency (Score_element* o, Score_element* n);
+ void do_substitute_element_pointer (Score_element* o, Score_element* n);
void do_post_processing ();
VIRTUAL_COPY_CONS (Score_element);
virtual void set_default_direction ();
VIRTUAL_COPY_CONS(Score_element);
protected:
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
virtual void do_pre_processing ();
virtual void do_post_processing ();
};
protected:
VIRTUAL_COPY_CONS(Score_element);
- virtual void do_substitute_dependency (Score_element*, Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*, Score_element*);
virtual void do_print ()const;
Link_array<Item> interesting_items_;
#ifndef KILLING_CONS_TCC
#define KILLING_CONS_TCC
+#include "cons.hh"
template<class T>
Killing_cons<T>::~Killing_cons ()
}
template<class T>
-Cons_list<T>
-copy_killing_cons_list (Cons<T> *src)
+void
+copy_killing_cons_list (Cons_list<T> &dest, Cons<T> *src)
{
- Cons_list<T> kl;
-
for (; src; src = src->next_)
{
T *t = new T(*src->car_);
- *kl.tail_ = new Killing_cons<T> (t, 0);
- kl.tail_ = &(*kl.tail_)->next_;
+ dest.append ( new Killing_cons<T> (t, 0));
}
-
- return kl;
}
template<class T>
-Cons_list<T>
-clone_killing_cons_list (Cons<T> *src)
+void
+clone_killing_cons_list (Cons_list<T> & dest, Cons<T> *src)
{
- Cons_list<T> kl;
-
for (; src; src = src->next_)
{
T *t = src->car_->clone ();
- *kl.tail_ = new Killing_cons<T> (t, 0);
- kl.tail_ = &(*kl.pp)->next_;
+ dest.append (new Killing_cons<T> (t, 0));
}
-
- return kl;
}
void add (Musical_pitch);
protected:
virtual void do_pre_processing();
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
virtual Molecule* do_brew_molecule_p() const;
};
#endif // LOCALKEYITEM_HH
virtual void do_add_processing ();
virtual void do_post_processing ();
virtual void do_print () const;
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
};
#endif /* MULTI_MEASURE_REST_HH */
#include "interpretation-context-handle.hh"
/** Walk through music and deliver music to translation units, synced
- in time. This classa provides both the implementation of the shared
+ in time. This class provides both the implementation of the shared
code, and the public interface.
Derived classes should only have a public constructor.
protected:
virtual void do_pre_processing();
virtual void do_print () const;
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
public:
/** The relative position of the "voice" containing this
chord. Normally this would be the same as the stem direction,
#include "colhpos.hh"
#include "parray.hh"
#include "lily-proto.hh"
-#include "plist.hh"
#include "music-output.hh"
/** all stuff which goes onto paper. notes, signs, symbols in a score
class Paper_score : public Music_output
{
+ /// crescs etc; no particular order
+ Link_array<Spanner> span_p_arr_;
+
+ /// other elements
+ Link_array<Score_element> elem_p_arr_;
+
+
public:
Paper_def *paper_l_;
/// the columns, ordered left to right
- Link_list<Paper_column *> col_p_list_;
-
- /// crescs etc; no particular order
- Pointer_list<Spanner *> span_p_list_;
+ Link_array<Paper_column> col_l_arr_;
- /// other elements
- Pointer_list<Score_element*> elem_p_list_;
-
Paper_outputter *outputter_l_;
Line_of_score * line_l_;
void add_column (Paper_column*);
/**
- @return argument as a cursor of the list
+ @return index of argument.
*/
- PCursor<Paper_column *> find_col (Paper_column const *) const;
+ int find_col_idx (Paper_column const *) const;
- Link_array<Paper_column> col_range (Paper_column *left_l, Paper_column *right_l) const;
- Link_array<Paper_column> breakable_col_range (Paper_column*,Paper_column*) const;
Link_array<Item> broken_col_range (Item const*,Item const*) const;
/* MAIN ROUTINES */
virtual void process();
-// can't instantiate template with cygnus' gcc...
-// virtual ~Paper_score();
private:
- void remove_line (Line_of_score*);
+
+ Link_array<Score_element> remove_line (Line_of_score*);
+ Link_array<Score_element> remove_break_helpers ();
+
/// before calc_breaking
void preprocess();
/// after calc_breaking
void postprocess();
-
- /// delete unused columns
- void clean_cols();
+ Paper_score (Paper_score const &);
};
#endif
virtual void do_post_processing();
virtual void do_pre_processing();
virtual void do_print() const;
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
};
#endif // REST_COLLISION_HH
protected:
virtual void do_add_processing ();
virtual void do_print () const;
- virtual void do_substitute_dependent (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
};
#endif // RHYTHMIC_HEAD_HH
/*
- score-element.hh -- part of GNU LilyPond
+ score-element.hh -- declare Score_element
- (c) 1996,97 Han-Wen Nienhuys
+ (c) 1996-1999 Han-Wen Nienhuys
*/
#ifndef STAFFELEM_HH
(elem) */
class Score_element : private Directed_graph_node, public virtual Graphical_element {
public:
+ /// delete after linebreak calculation.
+ bool break_helper_only_b_;
Paper_score *pscore_l_;
Molecule * output_p_;
Score_element ();
/// do calculations after determining horizontal spacing
virtual void do_post_processing ();
- virtual void do_substitute_dependency (Score_element * , Score_element *);
- virtual void do_substitute_dependent (Score_element *, Score_element *);
+ virtual void do_substitute_element_pointer (Score_element * , Score_element *);
virtual void do_break_processing ();
virtual void handle_broken_dependencies ();
virtual void handle_prebroken_dependencies ();
virtual Link_array<Score_element> get_extra_dependencies () const;
virtual void do_unlink ();
virtual void do_junk_links ();
-
};
protected:
virtual void do_print() const;
- virtual void do_substitute_dependency (Score_element*, Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*, Score_element*);
virtual void do_pre_processing() ;
public:
Link_array<Script> script_l_arr_;
protected:
Molecule *do_brew_molecule_p() const;
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
virtual void do_print() const;
virtual Interval symbol_height() const;
virtual void do_pre_processing();
/*
- separating-group-spanner.hh -- declare
+ separating-group-spanner.hh -- declare Separating_group_spanner
source file of the GNU LilyPond music typesetter
{
Link_array<Single_malt_grouping_item> spacing_unit_l_arr_;
public:
-
+ Separating_group_spanner ();
void add_spacing_unit (Single_malt_grouping_item*);
protected:
VIRTUAL_COPY_CONS(Score_element);
virtual Array<Rod> get_rods () const;
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
};
#endif /* SEPARATING_GROUP_SPANNER_HH */
#ifndef SIMULTANEOUS_MUSIC_ITERATOR_HH
#define SIMULTANEOUS_MUSIC_ITERATOR_HH
+#include "cons.hh"
#include "music-list-iterator.hh"
class Simultaneous_music_iterator : public Music_list_iterator
virtual void do_process_and_next (Moment);
private:
- Pointer_list<Music_iterator*> children_p_list_;
+ Cons_list<Music_iterator> children_p_list_;
};
#endif // SIMULTANEOUS_MUSIC_ITERATOR_HH
#include "item.hh"
/** Calc dimensions for the Separating_group_spanner; this has to be
- an itme to get dependencies correct. It can't be an element_group
- since these usually are in a different X_group
+ an item to get dependencies correct. It can't be an element_group
+ since these usually are in a different X_group
- It's 1 30 am. Naming suggestions appreciated. */
+ It's 1:30 am. Naming suggestions appreciated.
+*/
class Single_malt_grouping_item : public Item
{
VIRTUAL_COPY_CONS(Score_element);
void add_item (Item*);
protected:
- virtual void do_substitute_dependency (Score_element*, Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*, Score_element*);
virtual void do_print () const;
};
/*
- slur.hh -- part of GNU LilyPond
+ slur.hh -- declare Slur
(c) 1996--1999 Han-Wen Nienhuys
*/
virtual void do_post_processing ();
virtual void do_add_processing ();
virtual void do_pre_processing ();
- virtual void do_substitute_dependency (Score_element*, Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*, Score_element*);
Array<Rod> get_rods () const;
};
#include "bar.hh"
-class Span_bar : public virtual Bar
+class Span_bar : public Bar
{
Link_array<Score_element> spanning_l_arr_;
Interval get_spanned_interval () const;
virtual void do_pre_processing();
virtual void do_post_processing();
virtual Interval do_height () const;
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
virtual Molecule * do_brew_molecule_p() const;
};
#include "drul-array.hh"
#include "rod.hh"
+struct Breaking_information
+{
+ Line_of_score *line_l_;
+ Spanner * broken_spanner_l_;
+ Drul_array<Item*> bounds_;
+ Breaking_information ()
+ {
+ line_l_ =0;
+ broken_spanner_l_ =0;
+ bounds_[LEFT] = bounds_[RIGHT] =0;
+ }
+};
+
+class Axis_group_spanner;
/** A symbol which is attached between two columns. A spanner is a
symbol which spans across several columns, so its final appearance
can only be calculated after the breaking problem is solved.
Spanner (Spanner const &);
bool broken_b () const;
virtual Array<Rod> get_rods () const;
- Spanner* find_broken_piece (Line_of_score*) const;
+ virtual Spanner* find_broken_piece (Line_of_score*) const;
protected:
void set_my_columns ();
VIRTUAL_COPY_CONS(Score_element);
*/
virtual void break_into_pieces ();
- Link_array<Spanner> broken_into_l_arr_;
+ Array<Breaking_information> broken_info_;
+ friend Axis_group_spanner; // UGH
+
Spanner * unbroken_original_l_;
virtual void do_unlink ();
#define SPRING_SPACER_HH
#include "line-spacer.hh"
-#include "plist.hh"
+#include "cons.hh"
#include "col-info.hh"
#include "colhpos.hh"
#include "moment.hh"
class Spring_spacer : public Line_spacer {
friend class Durations_iter;
- Pointer_list<Idealspacing *> ideal_p_list_;
+ Cons<Idealspacing> *ideal_p_list_;
Array<Column_info> cols_;
Array<Column_info> loose_col_arr_;
virtual Interval symbol_height () const;
Interval symbol_extent () const;
virtual Real get_position_f () const;
- virtual void do_substitute_dependency (Score_element *, Score_element*);
+ virtual void do_substitute_element_pointer (Score_element *, Score_element*);
virtual void do_pre_processing ();
virtual void do_post_processing ();
Interval support_extent () const;
Interval_t<int> head_positions() const;
virtual ~Stem ();
protected:
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
virtual void do_pre_processing();
virtual Interval do_width() const;
virtual Molecule* do_brew_molecule_p() const;
VIRTUAL_COPY_CONS(Score_element);
~Text_spanner();
virtual void do_add_processing ();
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
virtual void do_pre_processing();
virtual void do_post_processing();
virtual Interval height() const ;
virtual void do_add_processing ();
virtual void do_post_processing ();
virtual void set_default_dir();
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
virtual Array<Rod> get_rods () const;
Array<Offset> get_controls () const;
#include "lily-proto.hh"
#include "virtual-methods.hh"
#include "translator.hh"
-#include "plist.hh"
+#include "cons.hh"
#include "parray.hh"
// egcs
int iterator_count_;
friend class Interpretation_context_handle;
+ Cons_list<Translator> trans_p_list_;
public:
Scalar get_property (String type_str, Translator_group **where_found_l) const;
void set_property (String var_name, Scalar value);
- Pointer_list<Translator *> trans_p_list_;
String id_str_;
virtual void do_add_processing ();
virtual void do_post_processing ();
virtual void set_default_dir ();
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
};
#endif // Tuplet_spanner_HH
virtual void do_add_processing ();
virtual Interval do_height () const;
virtual void do_post_processing ();
- virtual void do_substitute_dependency (Score_element*,Score_element*);
+ virtual void do_substitute_element_pointer (Score_element*,Score_element*);
};
#endif // VOLTA_SPANNER_HH
Item::breakable_b () const
{
return !unbroken_original_l_
- && dynamic_cast<Item*>(parent_l (X_AXIS))->breakable_b ();
+ && dynamic_cast<Item*> (parent_l (X_AXIS))->breakable_b ();
}
void
{
Score_element * dolly = clone();
Item * item_p = dynamic_cast<Item*>(dolly);
-
+ item_p->unbroken_original_l_ = this;
item_p->break_status_dir_ = i;
pscore_l_->typeset_element (item_p);
new_copies[i] =item_p;
}
Item*
-Item::find_prebroken_piece (Direction breakstatus) const
+Item::find_prebroken_piece (Direction d) const
{
- if (!breakstatus)
+ if (!d)
return (Item *) (this); // ugh
else
- return dynamic_cast<Item*> (broken_to_drul_[breakstatus]);
+ return dynamic_cast<Item*> (broken_to_drul_[d]);
}
void
Item::Item (Item const &s)
: Score_element (s)
{
- unbroken_original_l_ = &s;
+ unbroken_original_l_ = 0;
/* do not copy attached_span_l_arr_ */
breakable_b_ = s.breakable_b_;
visibility_lambda_ = s.visibility_lambda_;
void
-Local_key_item::do_substitute_dependency (Score_element*o,Score_element*n)
+Local_key_item::do_substitute_element_pointer (Score_element*o,Score_element*n)
{
Item* o_l = dynamic_cast <Item *> (o);
Item* n_l = n?dynamic_cast <Item *> (n):0;
{0,0}
};
-// Magic numbers from Knuths plain.tex:
+/**
+ Magnification steps. These are powers of 1.2. The numbers are
+ taken from Knuth's plain.tex: */
static Real mag_steps[] = {1, 1, 1.200, 1.440, 1.7280, 2.074, 2.488};
static Dictionary<char const *> cmr_dict (cmr_init);
#include "all-fonts.hh"
#include "proto.hh"
#include "dimensions.hh"
-#include "plist.hh"
#include "getopt-long.hh"
#include "misc.hh"
#include "string.hh"
void
Molecule::add_molecule (Molecule const &m)
{
- Cons_list<Atom> al (copy_killing_cons_list (m.atom_list_));
+ Cons_list<Atom> al;
+ copy_killing_cons_list (al, m.atom_list_);
if (al.head_)
{
*al.tail_ = atom_list_;
atom_list_ = al.head_;
+ al.head_ =0;
}
dim_.unite (m.dim_);
}
}
void
-Multi_measure_rest::do_substitute_dependency (Score_element* o, Score_element* n)
+Multi_measure_rest::do_substitute_element_pointer (Score_element* o, Score_element* n)
{
if (Bar* c = dynamic_cast <Bar*> (o))
column_arr_.substitute (c, dynamic_cast<Bar*> (n));
}
void
-Note_column::do_substitute_dependency (Score_element*o, Score_element*n)
+Note_column::do_substitute_element_pointer (Score_element*o, Score_element*n)
{
if (stem_l_ == o)
{
head_l_arr_.substitute (dynamic_cast<Note_head *> (o),
(n)? dynamic_cast<Note_head *> (n) : 0);
}
- Script_column::do_substitute_dependency (o,n);
+ Script_column::do_substitute_element_pointer (o,n);
if (dynamic_cast<Rest *> (o))
{
rest_l_arr_.substitute (dynamic_cast<Rest *> (o),
Paper_column::set_rank (int i)
{
rank_i_ = i;
- if (prebreak_l())
- prebreak_l()->rank_i_ = i;
- if (postbreak_l())
- postbreak_l()->rank_i_ = i;
}
void
#include "spanner.hh"
#include "paper-def.hh"
#include "line-of-score.hh"
-#include "pcursor.hh"
-#include "plist.hh"
#include "p-col.hh"
#include "p-score.hh"
#include "p-col.hh"
#include "file-results.hh"
#include "misc.hh"
-#if 1 // has w32 advanced?
- // nope (cygwin-b20)
-
-// sucking Cygnus egcs - w32
-#include "list.tcc"
-#include "cursor.tcc"
-
-#endif
-
Paper_score::Paper_score ()
{
outputter_l_ =0;
line_l_ = line_p;
}
+Paper_score::Paper_score (Paper_score const &s)
+ : Music_output (s)
+{
+ assert (false);
+}
+
Paper_score::~Paper_score ()
{
+ for (int i=0; i < span_p_arr_.size (); i++)
+ delete span_p_arr_[i];
+ for (int i=0; i < elem_p_arr_.size (); i++)
+ delete elem_p_arr_[i];
}
void
Paper_score::typeset_element (Score_element * elem_p)
{
- elem_p_list_.bottom ().add (elem_p);
+ elem_p_arr_.push (elem_p);
elem_p->pscore_l_ = this;
elem_p->add_processing ();
}
-void
-Paper_score::typeset_broken_spanner (Spanner*span_p)
-{
- typeset_element (span_p);
-}
-
void
Paper_score::typeset_unbroken_spanner (Spanner*span_p)
{
- span_p_list_.bottom ().add (span_p);
+ span_p_arr_.push (span_p);
span_p->pscore_l_=this;
-
- // do not init start/stop fields. These are for broken spans only.
span_p->add_processing ();
}
-
-void
-Paper_score::clean_cols ()
-{
- int rank_i = 0;
- for (iter_top (col_p_list_,c); c.ok ();)
- {
- c->set_rank (rank_i++);
- c++;
- }
-}
-
void
Paper_score::add_column (Paper_column *p)
{
- col_p_list_.bottom ().add (p);
+ p->set_rank (col_l_arr_.size ());
+ col_l_arr_.push (p);
typeset_element(p);
}
return ;
DOUT << "Paper_score { ";
DOUT << "\n elements: ";
- for (iter_top (elem_p_list_,cc); cc.ok (); cc++)
- cc->print ();
- DOUT << "\n unbroken spanners: ";
- for (iter (span_p_list_.top (), i); i.ok (); i++)
- i->print ();
-
+ for (int i=0; i < span_p_arr_.size (); i++)
+ span_p_arr_[i]->print ();
+ for (int i=0; i < elem_p_arr_.size (); i++)
+ elem_p_arr_[i]->print();
+
DOUT << "}\n";
#endif
}
-PCursor<Paper_column *>
-Paper_score::find_col (Paper_column const *c) const
+int
+Paper_score::find_col_idx (Paper_column const *c) const
{
Paper_column const *what = c;
- return col_p_list_.find ((Paper_column*)what);
+ return col_l_arr_.find_i ((Paper_column*)what);
}
-
-
-
Array<Column_x_positions>
Paper_score::calc_breaking ()
{
Break_algorithm *algorithm_p=0;
Array<Column_x_positions> sol;
- bool try_wrap = ! paper_l_->get_var ("castingalgorithm");
+ bool try_wrap = !paper_l_->get_var ("castingalgorithm");
if (!try_wrap)
{
+void delete_array_contents (Link_array<Score_element> const&to_remove, Dictionary<int> &type_stats)
+{
+ for (int i=0; i < to_remove.size (); i++)
+ {
+ Score_element * e = to_remove[i];
+ String nm = e->name();
+ if (type_stats.elem_b (nm))
+ type_stats[nm] ++;
+ else
+ type_stats[nm] = 1;
+
+ if (dynamic_cast<Item*> (e))
+ type_stats["Item"] ++;
+ else if (dynamic_cast<Spanner*>(e))
+ type_stats["Spanner"] ++;
+ type_stats["Total"] ++;
+
+ e->unlink ();
+ assert (!e->linked_b ());
+ delete e;
+ }
+
+}
+Link_array<Score_element>
+Paper_score::remove_break_helpers ()
+{
+ Link_array<Score_element> to_remove;
+ Link_array<Score_element> keep;
+ for (int i=0; i < elem_p_arr_.size (); i++)
+ {
+ Score_element*e = elem_p_arr_[i];
+ if (e->break_helper_only_b_)
+ to_remove.push (e);
+ else
+ keep.push (e);
+ }
+
+ elem_p_arr_ = keep;
+ Link_array<Spanner> keeps;
+ for (int i=0; i<span_p_arr_.size ();i++)
+ {
+ Spanner *s = span_p_arr_[i];
+ Score_element *e = s;
+ if (e->break_helper_only_b_)
+ to_remove.push (e);
+ else
+ keeps.push (s);
+ }
+
+
+ span_p_arr_ =keeps;
+
+ return to_remove;
+}
+
void
Paper_score::process ()
{
- clean_cols ();
+ Dictionary<int> type_stats;
+ type_stats["Item"] =0;
+ type_stats["Spanner"] =0;
+ type_stats["Total"]=0;
+
print ();
*mlog << _ ("Preprocessing elements...") << " " << flush;
- line_l_->breakable_col_processing ();
+ line_l_->breakable_col_processing ();
line_l_->pre_processing ();
*mlog << '\n' << _ ("Calculating column positions...") << " " << flush;
Array<Column_x_positions> breaking = calc_breaking ();
+ delete_array_contents (remove_break_helpers(), type_stats);
+
Paper_stream* paper_stream_p = paper_l_->paper_stream_p ();
outputter_l_ = paper_l_->paper_outputter_p (paper_stream_p, header_l_, origin_str_);
Line_of_score *line_l = line_l_->set_breaking (breaking, i);
lines.push (line_l);
if (line_l != line_l_)
- typeset_broken_spanner (line_l);
-
+ typeset_element (line_l);
}
+ if (experimental_features_global_b)
+ *mlog << elem_p_arr_.size () + span_p_arr_.size () << " elements. ";
*mlog << "\nLine ... ";
for (int i=0; i < lines.size (); i++)
{
line_l->post_processing ();
*mlog << i << flush;
line_l->output_all ();
- *mlog << ']' << flush;
- remove_line (line_l);
+
+ if (experimental_features_global_b)
+ *mlog << '(' << elem_p_arr_.size () + span_p_arr_.size () << ')';
+
+ *mlog << ']' << flush;
+ Link_array<Score_element> to_remove (remove_line (line_l));
+
+ delete_array_contents (to_remove, type_stats);
}
// huh?
delete paper_stream_p;
outputter_l_ = 0;
+
+ /*
+ todo: sort output
+ */
+ if (experimental_features_global_b)
+ {
+ for (Dictionary_iter<int> i(type_stats); i.ok(); i++)
+ {
+ *mlog << i.key () << ": " << i.val () << " objects\n";
+ }
+ }
*mlog << '\n' << flush;
+
}
-void
+
+Link_array<Score_element>
Paper_score::remove_line (Line_of_score *l)
{
Link_array<Score_element> to_remove;
- for (PCursor<Score_element*> i(elem_p_list_.top ()); i.ok (); )
+ Link_array<Score_element> keep;
+ for (int i=0; i < elem_p_arr_.size (); i++)
{
- if (i->line_l () == l)
- to_remove.push (i.remove_p ());
+ Score_element*e = elem_p_arr_[i];
+ if (e->line_l () == l)
+ to_remove.push (e);
else
- i++;
+ keep.push (e);
}
- for (PCursor<Spanner*> i (span_p_list_.top ()); i.ok (); )
+ elem_p_arr_ = keep;
+ Link_array<Spanner> keeps;
+ for (int i=0; i<span_p_arr_.size ();i++)
{
- Score_element *e = i.ptr ();
+ Spanner *s = span_p_arr_[i];
+ Score_element *e = s;
if (e->line_l () == l)
- to_remove.push (i.remove_p ());
+ to_remove.push (e);
else
- i++;
+ keeps.push (s);
}
- // l->unlink_all ();
- for (int i=0; i < to_remove.size (); i++)
- {
- to_remove[i]->unlink ();
- assert (!to_remove[i]->linked_b ());
- delete to_remove [i];
- }
-}
-/** Get all breakable columns between l and r, (not counting l and r). */
-Link_array<Paper_column>
-Paper_score::breakable_col_range (Paper_column*l, Paper_column*r) const
-{
- Link_array<Paper_column> ret;
-
- PCursor<Paper_column*> start (l ? find_col (l)+1 : col_p_list_.top ());
- PCursor<Paper_column*> stop (r ? find_col (r) : col_p_list_.bottom ());
-
- /*
- ugh! windows-suck-suck-suck.
- */
- while (PCursor<Paper_column*>::compare (start,stop) < 0)
- {
- if (start->breakable_b_)
- ret.push (start);
- start++;
- }
-
- return ret;
-}
-
-
-Link_array<Paper_column>
-Paper_score::col_range (Paper_column*l, Paper_column*r) const
-{
- Link_array<Paper_column> ret;
-
- PCursor<Paper_column*> start (l ? find_col (l)+1 : col_p_list_.top ());
- PCursor<Paper_column*> stop (r ? find_col (r) : col_p_list_.bottom ());
- ret.push (l);
-
- /*
- ugh! windows-suck-suck-suck.
- */
- while (PCursor<Paper_column*>::compare (start,stop) < 0)
- ret.push (start++);
- ret.push (r);
- return ret;
+ span_p_arr_ =keeps;
+ return to_remove;
}
Link_array<Item>
-Paper_score::broken_col_range (Item const*l_item_l, Item const*r_item_l) const
+Paper_score::broken_col_range (Item const*l, Item const*r) const
{
Link_array<Item> ret;
- Item const*l=l_item_l;
- Item const*r=r_item_l;
-
- // huh? see Item::left_right_compare ()
- /*
- while (! (dynamic_cast<Paper_column const *> (l)))
- l = dynamic_cast<Item*> (l->axis_group_l_a_[X_AXIS]);
- while (! (dynamic_cast<Paper_column const *> (r)))
- r = dynamic_cast<Item*>(r->axis_group_l_a_[X_AXIS]);
- */
l = l->column_l ();
r = r->column_l ();
- PCursor<Paper_column*> start (l ? find_col ((Paper_column*)l)+1 : col_p_list_.top ());
- PCursor<Paper_column*> stop (r ? find_col ((Paper_column*)r) : col_p_list_.bottom ());
+ int start = l
+ ? find_col_idx (dynamic_cast<Paper_column*> ((Item*)l))+1
+ : 0;
- /*
- ugh! windows-suck-suck-suck.
- */
- while (PCursor<Paper_column*>::compare (start,stop) < 0)
+ int stop = r
+ ? find_col_idx (dynamic_cast<Paper_column*>((Item*)r))
+ : col_l_arr_.size ();
+
+ while (start < stop)
{
- if (start->breakable_b_ && !start->line_l_)
- ret.push (start);
+ Paper_column *c = col_l_arr_[start];
+ if (c->breakable_b_ && !c->line_l_)
+ ret.push (c);
start++;
}
%type <i> int unsigned
%type <i> script_dir
%type <i> optional_modality
-%type <id> identifier_init simple_identifier_init block_identifier
+%type <id> identifier_init
%type <duration> steno_duration notemode_duration
%type <duration> entered_notemode_duration explicit_duration
%type <intvec> intastint_list int_list
%type <music> property_def translator_change
%type <music_list> Music_list
%type <paper> paper_block paper_def_body
-%type <real> real_expression real dimension
+%type <real> real_expression real real_with_dimension
%type <request> abbrev_command_req
%type <request> post_request structured_post_request
%type <request> command_req verbose_command_req
%type <script> script_definition script_body mudela_script gen_script_def
%type <textdef> text_def finger
%type <string> script_abbreviation
-%type <trans> translator_spec translator_spec_body
+%type <trans> translator_spec_block translator_spec_body
%type <tempo> tempo_request
%type <notenametab> notenames_body notenames_block chordmodifiers_block
;
-simple_identifier_init: identifier_init
- ;
identifier_init:
- block_identifier
- ;
-
-block_identifier:
score_block {
$$ = new Score_identifier ($1, SCORE_IDENTIFIER);
$$ = new Midi_def_identifier ($1, MIDI_IDENTIFIER);
}
- | translator_spec {
+ | translator_spec_block {
$$ = new Translator_identifier ($1, TRANS_IDENTIFIER);
}
| Music {
}
;
-translator_spec:
+translator_spec_block:
TRANSLATOR '{' translator_spec_body '}'
{ $$ = $3; }
;
$$ = t;
delete $2;
}
- | translator_spec_body STRING '=' simple_identifier_init ';' {
+ | translator_spec_body STRING '=' identifier_init ';' {
Identifier* id = $4;
String_identifier *s = dynamic_cast<String_identifier*> (id);
Real_identifier *r= dynamic_cast<Real_identifier*>(id);
}
;
-optional_semicolon:
- /* empty */
- | ';'
- ;
-
optional_dot:
/* empty */
| '.'
THIS-> lexer_p_-> scope_l_arr_.push (p->scope_p_);
$$ = p;
}
- | PAPER_IDENTIFIER optional_semicolon {
+ | PAPER_IDENTIFIER {
Paper_def *p = $1->access_content_Paper_def (true);
THIS->lexer_p_->scope_l_arr_.push (p->scope_p_);
$$ = p;
| paper_def_body assignment ';' {
}
- | paper_def_body translator_spec {
+ | paper_def_body translator_spec_block {
$$->assign_translator ($2);
}
| paper_def_body SHAPE '=' shape_array ';' {
;
-dimension:
+real_with_dimension:
REAL CM_T {
$$ = $1 CM;
}
REAL {
$$ = $1;
}
- | dimension
+ | real_with_dimension
| REAL_IDENTIFIER {
$$= *$1->access_content_Real (false);
}
| MIDI_IDENTIFIER {
$$ = $1-> access_content_Midi_def (true);
}
- | midi_body translator_spec {
+ | midi_body translator_spec_block {
$$-> assign_translator ($2);
}
| midi_body tempo_request ';' {
delete $2;
}
| GROUPING intastint_list {
- $$ = get_grouping_req (*$2); delete $2;
+ Measure_grouping_req * mr_p = new Measure_grouping_req;
+ for (int i=0; i < $2->size();)
+ {
+ mr_p->elt_length_arr_.push (Moment (1, $2->elem(i++)));
+ mr_p->beat_i_arr_.push ($2->elem(i++));
+ }
+
+
+ $$ = mr_p;
+ delete $2;
}
;
;
script_abbreviation:
- '^' { $$ = get_scriptdef ('^'); }
- | '+' { $$ = get_scriptdef ('+'); }
- | '-' { $$ = get_scriptdef ('-'); }
- | '|' { $$ = get_scriptdef ('|'); }
- | 'o' { $$ = get_scriptdef ('o'); }
- | '>' { $$ = get_scriptdef ('>'); }
+ '^' {
+ $$ = THIS->lexer_p_
+ ->lookup_identifier ("dash-hat")->access_content_String (true)
+
+ }
+ | '+' {
+ $$ = THIS->lexer_p_
+ ->lookup_identifier ("dash-plus")->access_content_String (true)
+ }
+ | '-' {
+ $$ = THIS->lexer_p_
+ ->lookup_identifier ("dash-dash")->access_content_String (true)
+ }
+ | '|' {
+ $$ = THIS->lexer_p_
+ ->lookup_identifier ("dash-bar")->access_content_String (true)
+ }
+ | '>' {
+ $$ = THIS->lexer_p_
+ ->lookup_identifier ("dash-larger")->access_content_String (true)
+ }
| '.' {
- $$ = get_scriptdef ('.');
+ $$ = THIS->lexer_p_
+ ->lookup_identifier ("dash-dot")->access_content_String (true);
}
;
;
script_dir:
- '_' { $$ = -1; }
- | '^' { $$ = 1; }
- | '-' { $$ = 0; }
+ '_' { $$ = DOWN; }
+ | '^' { $$ = CENTER; }
+ | '-' { $$ = UP; }
;
pre_requests:
else
{
// int dir_i = - ncol_l_arr_[0]->dir_;
- int dir_i = rest_l_arr_[0]->dir_;
+ Direction dir = rest_l_arr_[0]->dir_;
// minimum move
int minpos = 4;
for (int j = 0; j < ncol_l_arr_[i]->head_l_arr_.size(); j++)
{
int stem = (int)((ncol_l_arr_[i]->stem_l_->extent
- (Y_AXIS)[dir_i]) / internote_f);
- minpos = minpos >? (dir_i * stem + sep_i);
+ (Y_AXIS)[dir]) / internote_f);
+ minpos = minpos >? (dir * stem + sep_i);
}
}
- rest_l_arr_[0]->translate_rests (dir_i * minpos);
+ rest_l_arr_[0]->translate_rests (dir * minpos);
}
}
}
void
-Rest_collision::do_substitute_dependency (Score_element*o,Score_element*n)
+Rest_collision::do_substitute_element_pointer (Score_element*o,Score_element*n)
{
if (Note_column *onl = dynamic_cast<Note_column *> (o))
{
{
children[i]->OK();
if (i>0)
- assert (children[i-1]->interval().right ==
- children[i]->interval().left);
+ assert (children[i-1]->interval()[RIGHT] ==
+ children[i]->interval()[LEFT]);
}
#endif
}
return *interval_;
else
return
- MInterval (children[0]->interval().left,
- children.top()->interval ().right);
+ MInterval (children[0]->interval()[LEFT],
+ children.top()->interval ()[RIGHT]);
}
void
{
MInterval i (interval());
MInterval r1(i), r2(i);
- r1.right = r2.left = i.center();
+ r1[RIGHT] = r2[LEFT] = i.center();
r.push (r1); r.push (r2);
}
else
break;
assert (
- children[starti]->interval().left== splitpoints[startj].left);
- if (children[i]->interval().right < splitpoints[j].right)
+ children[starti]->interval()[LEFT]== splitpoints[startj][LEFT]);
+ if (children[i]->interval()[RIGHT] < splitpoints[j][RIGHT])
{
i ++;
}
- else if (children[i]->interval().right > splitpoints[j].right)
+ else if (children[i]->interval()[RIGHT] > splitpoints[j][RIGHT])
{
j ++;
}
return;
}
Moment dt = t.length ()/Moment (n);
- MInterval basic = MInterval (t.left, t.left+dt);
+ MInterval basic = MInterval (t[LEFT], t[LEFT]+dt);
for (int i= 0; i < n; i++)
children.push (new Rhythmic_grouping (dt*Moment (i) + basic));
}
Rhythmic_grouping::child_fit_b (Moment start)
{
if (children.size())
- return (children.top()->interval ().right== start);
+ return (children.top()->interval ()[RIGHT]== start);
return true;
}
void
Rhythmic_grouping::extend (MInterval m) const
{
- assert (m.left >= interval().left);
- while (m.right >interval().right)
+ assert (m[LEFT] >= interval()[LEFT]);
+ while (m[RIGHT] >interval()[RIGHT])
{
Link_array<Rhythmic_grouping> a (children);
for (int i=0; i < a.size(); i++)
{
a[i] =new Rhythmic_grouping (*children[i]);
- a[i]->translate (children.top()->interval ().right);
+ a[i]->translate (children.top()->interval ()[RIGHT]);
}
((Rhythmic_grouping*)this)->children.concat (a);
}
- assert (m.right <= interval().right);
+ assert (m[RIGHT] <= interval()[RIGHT]);
OK();
}
}
void
-Rhythmic_head::do_substitute_dependent (Score_element*o,Score_element*n)
+Rhythmic_head::do_substitute_element_pointer (Score_element*o,Score_element*n)
{
if (o == dots_l_)
dots_l_ = n ? dynamic_cast<Dots *> (n) :0;
Score_element::Score_element()
{
output_p_ =0;
+ break_helper_only_b_ = false;
transparent_b_ = false;
size_i_ = 0;
pscore_l_=0;
*/
copy_edges_out (s);
output_p_ =0;
+ break_helper_only_b_ = s.break_helper_only_b_;
transparent_b_ = s.transparent_b_;
status_i_ = s.status_i_;
pscore_l_ = s.pscore_l_;
{
delete output_p_;
assert (status_i_ >=0);
+ status_i_ = -1;
}
Score_element*
Paper_def*
Score_element::paper() const
{
- assert (pscore_l_);
return pscore_l_->paper_l_;
}
void
Score_element::add_processing()
{
+ assert (status_i_ >=0);
if (status_i_)
return;
status_i_ ++;
Score_element::calculate_dependencies (int final, int busy,
Score_element_method_pointer funcptr)
{
+ assert (status_i_ >=0);
+
if (status_i_ >= final)
return;
}
void
-Score_element::do_substitute_dependency (Score_element*,Score_element*)
-{
-}
-void
-Score_element::do_substitute_dependent (Score_element*,Score_element*)
+Score_element::do_substitute_element_pointer (Score_element*,Score_element*)
{
}
void
Score_element::substitute_dependency (Score_element* old, Score_element* new_l)
{
- do_substitute_dependency (old,new_l);
- old->do_substitute_dependent (this, 0);
+ do_substitute_element_pointer (old,new_l);
+ old->do_substitute_element_pointer (this, 0);
}
void
do_unlink();
while (dependency_size())
{
- do_substitute_dependency (dependency (0),0);
+ do_substitute_element_pointer (dependency (0),0);
remove_edge_out_idx (0);
}
while (dependent_size())
}
void
-Script_column::do_substitute_dependency (Score_element*o,Score_element*n)
+Script_column::do_substitute_element_pointer (Score_element*o,Score_element*n)
{
if (dynamic_cast <Item *> (o))
{
}
void
-Script::do_substitute_dependency (Score_element*o,Score_element*n)
+Script::do_substitute_element_pointer (Score_element*o,Score_element*n)
{
- Staff_side::do_substitute_dependency (o,n);
+ Staff_side::do_substitute_element_pointer (o,n);
if (o == stem_l_)
{
stem_l_ = dynamic_cast<Stem *> (n);
}
void
-Separating_group_spanner::do_substitute_dependency (Score_element*o, Score_element*n)
+Separating_group_spanner::do_substitute_element_pointer (Score_element*o, Score_element*n)
{
if (dynamic_cast<Single_malt_grouping_item *> (o))
{
}
}
+Separating_group_spanner::Separating_group_spanner()
+{
+ break_helper_only_b_ = true;
+}
Separating_line_group_engraver::do_creation_processing ()
{
sep_span_p_ = new Separating_group_spanner;
- announce_element ( Score_element_info (sep_span_p_, 0));
+ announce_element (Score_element_info (sep_span_p_, 0));
sep_span_p_->set_bounds (LEFT, get_staff_info ().command_pcol_l ());
}
#include "translator-group.hh"
#include "debug.hh"
#include "simultaneous-music-iterator.hh"
-
#include "music-list.hh"
+#include "killing-cons.tcc"
Simultaneous_music_iterator::Simultaneous_music_iterator ()
{
Simultaneous_music_iterator::~Simultaneous_music_iterator ()
{
+ children_p_list_.junk ();
}
void
{
if (sim->translator_type_str_.empty_b ())
set_translator (mi->report_to_l()->ancestor_l (0)); // huh?
- children_p_list_.bottom().add (mi);
+ children_p_list_.append (new Killing_cons<Music_iterator> (mi,0));
}
- else
+ else
delete mi;
}
}
Simultaneous_music_iterator::do_print() const
{
#ifndef NPRINT
- for (PCursor<Music_iterator*> i (children_p_list_.top()); i.ok (); i++)
- {
- i->print();
- }
+ for (Cons<Music_iterator> *p = children_p_list_.head_; p; p = p->next_)
+ p->car_->print();
#endif
}
void
Simultaneous_music_iterator::do_process_and_next (Moment until)
{
- for (PCursor<Music_iterator*> i (children_p_list_.top()); i.ok ();)
+ for (Cons<Music_iterator> **pp = &children_p_list_.head_; *pp; )
{
+ Music_iterator * i = (*pp)->car_;
if (i->next_moment() == until)
{
i->process_and_next (until);
}
- if (!i->ok())
- delete i.remove_p();
+ if (!i->ok())
+ delete children_p_list_.remove_cons (pp);
else
- i++;
+ pp = &(*pp)->next_;
}
Music_iterator::do_process_and_next (until);
}
{
Moment next;
next.set_infinite (1);
- for (PCursor<Music_iterator*> i (children_p_list_.top()); i.ok (); i++)
- next = next <? i->next_moment() ;
+
+ for (Cons<Music_iterator> *p = children_p_list_.head_; p; p = p->next_)
+ next = next <? p->car_->next_moment() ;
return next;
}
bool
Simultaneous_music_iterator::ok() const
{
- return children_p_list_.size();
+ return children_p_list_.head_;
}
Single_malt_grouping_item ::Single_malt_grouping_item()
{
+ break_helper_only_b_ = true;
transparent_b_ = true;
set_empty (true);
}
void
-Single_malt_grouping_item::do_substitute_dependency (Score_element*o, Score_element*n)
+Single_malt_grouping_item::do_substitute_element_pointer (Score_element*o, Score_element*n)
{
if (dynamic_cast <Item *> (o))
{
*/
#include "proto.hh"
-#include "plist.hh"
#include "musical-request.hh"
#include "slur-engraver.hh"
#include "slur.hh"
}
void
-Slur::do_substitute_dependency (Score_element*o, Score_element*n)
+Slur::do_substitute_element_pointer (Score_element*o, Score_element*n)
{
int i;
while ((i = encompass_arr_.find_i (dynamic_cast<Note_column *> (o))) >=0)
return Item::left_right_compare (n1, n2);
}
+static bool
+broken_edge_b (Slur*s, Drul_array<Note_column*>& extrema, Direction dir)
+{
+ return extrema[dir] != s->spanned_drul_[dir];
+}
+
+static bool
+normal_edge_b (Slur*s, Drul_array<Note_column*>& extrema, Direction dir)
+{
+ return !broken_edge_b (s, extrema, dir)
+ && extrema[dir]->stem_l_
+ && !extrema[dir]->stem_l_->transparent_b_
+ && extrema[dir]->head_l_arr_.size ();
+}
+
void
Slur::do_post_processing ()
{
Direction d=LEFT;
-#define NORMAL_SLUR_b(dir) \
- (extrema[dir]->stem_l_ \
- && !extrema[dir]->stem_l_->transparent_b_ \
- && extrema[dir]->head_l_arr_.size ())
-
do
{
- /*
- broken slur
- */
- if (extrema[d] != spanned_drul_[d])
+ if (broken_edge_b (this, extrema, d))
{
// ugh -- check if needed
dx_f_drul_[d] = -d
/*
normal slur
*/
- else if (NORMAL_SLUR_b (d))
+ else if (normal_edge_b (this, extrema, d))
{
Real notewidth_f = extrema[d]->extent (X_AXIS).length ();
dy_f_drul_[d] = (int)rint (extrema[d]->stem_l_-> extent (Y_AXIS)[dir_]);
// now that both are set, do dependent
do
{
- /*
- broken slur
- */
- if (extrema[d] != spanned_drul_[d])
+ if (broken_edge_b (this, extrema, d))
{
Direction u = d;
flip(&u);
/*
Slur should follow line of music
*/
- if (NORMAL_SLUR_b (LEFT) && NORMAL_SLUR_b (RIGHT)
+ if (normal_edge_b (this, extrema, LEFT)
+ && normal_edge_b (this, extrema, RIGHT)
&& (extrema[LEFT]->stem_l_ != extrema[RIGHT]->stem_l_))
{
Real note_dy = extrema[RIGHT]->stem_l_->head_positions ()[dir_]
}
void
-Span_bar::do_substitute_dependency (Score_element*o, Score_element*n)
+Span_bar::do_substitute_element_pointer (Score_element*o, Score_element*n)
{
spanning_l_arr_.unordered_substitute (o, n);
}
#ifndef NPRINT
DOUT << "Between " << classname (spanned_drul_[LEFT])
<< " and " << classname (spanned_drul_[RIGHT]) << '\n';
- if (broken_into_l_arr_.size())
+ /* if (broken_into_l_arr_.size())
{
DOUT << "with broken pieces:\n";
for (int i=0; i < broken_into_l_arr_.size (); i++)
broken_into_l_arr_[i]->print ();
- }
+ }*/
#endif
}
void
Spanner::break_into_pieces ()
{
- if (broken_into_l_arr_.size())
+ if (broken_b ())
return;
Item * left = spanned_drul_[LEFT];
return;
}
- Link_array<Item> break_cols = pscore_l_->broken_col_range (left,right);
+ Link_array<Item> break_points = pscore_l_->broken_col_range (left,right);
Link_array<Spanner> broken_into_l_arr;
- break_cols.insert (left,0);
- break_cols.push (right);
+ break_points.insert (left,0);
+ break_points.push (right);
- for (int i=1; i < break_cols.size(); i++)
+
+ for (int i=1; i < break_points.size(); i++)
{
- Spanner* span_p = dynamic_cast<Spanner*> (clone());
- Item *left = break_cols[i-1];
- Item *right = break_cols[i];
- if (!right->line_l())
- right = right->find_prebroken_piece(LEFT);
- if (!left->line_l())
- left = left->find_prebroken_piece(RIGHT);
-
- assert (left&&right && left->line_l() == right->line_l());
-
- span_p->set_bounds(LEFT,left);
- span_p->set_bounds(RIGHT,right);
-
- pscore_l_->typeset_broken_spanner (span_p);
- broken_into_l_arr.push (span_p);
+ Breaking_information info;
+ info.bounds_[LEFT] = break_points[i-1];
+ info.bounds_[RIGHT] = break_points[i];
+ Direction d = LEFT;
+ do
+ {
+ Item *&pc_l = info.bounds_[d] ;
+ if (!pc_l->line_l())
+ pc_l = pc_l->find_prebroken_piece(- d);
+
+ assert (pc_l);
+ if (!info.line_l_)
+ info.line_l_ = pc_l-> line_l ();
+ else
+ assert( info.line_l_ = pc_l->line_l ());
+
+ }
+ while ((flip(&d))!= LEFT);
+ info.broken_spanner_l_ = 0;
+ broken_info_.push (info);
}
-
- broken_into_l_arr_ = broken_into_l_arr;
}
void
Spanner::do_break_processing()
{
if (!line_l())
- {
- break_into_pieces ();
- for (int i=0; i < broken_into_l_arr_.size(); i++)
- {
- broken_into_l_arr_[i]->handle_broken_dependencies();
- }
- }
+ break_into_pieces ();
else
- {
- handle_broken_dependencies();
- }
+ handle_broken_dependencies();
}
Spanner::Spanner ()
:Score_element (s)
{
spanned_drul_[LEFT] = spanned_drul_[RIGHT] =0;
- unbroken_original_l_ = &s;
+ unbroken_original_l_ = 0;
}
void
Interval
Spanner::do_width() const
-{
-
-
+{
Real l = spanned_drul_[LEFT]->absolute_coordinate (X_AXIS);
Real r = spanned_drul_[RIGHT]->absolute_coordinate (X_AXIS);
Spanner*
Spanner::find_broken_piece (Line_of_score*l) const
{
- for (int i=0; i < broken_into_l_arr_.size(); i++)
- if (broken_into_l_arr_[i]->line_l() == l)
- return broken_into_l_arr_[i];
+ for (int i=0; i < broken_info_.size (); i++)
+ {
+ Spanner *me =(Spanner*) this;
+ Breaking_information &info = me->broken_info_[i];
+ if (info.line_l_ == l)
+ {
+ if (!info.broken_spanner_l_)
+ {
+ Spanner *span_p = dynamic_cast<Spanner*>(clone ());
+ span_p -> unbroken_original_l_ =(Spanner*)this;
+ span_p->set_bounds(LEFT,info.bounds_[LEFT]);
+ span_p->set_bounds(RIGHT,info.bounds_[RIGHT]);
+ pscore_l_->typeset_element (span_p);
+
+
+ info.broken_spanner_l_ = span_p;
+ /* if (Axis_group_spanner *ags
+ = dynamic_cast<Axis_group_spanner*> (span_p))
+ {
+ do something
+ }
+ */
+ span_p->handle_broken_dependencies();
+
+ }
+ return info.broken_spanner_l_;
+ }
+ }
+
return 0;
-
}
bool
Spanner::broken_b() const
{
- return broken_into_l_arr_.size();
+ return broken_info_.size();
}
void
if (unbroken_original_l_)
{
- unbroken_original_l_->broken_into_l_arr_.substitute (this, 0);
- unbroken_original_l_ =0;
+ for (int i=0; i < unbroken_original_l_->broken_info_.size (); i++)
+ {
+ if (unbroken_original_l_->broken_info_[i].broken_spanner_l_ == this)
+ unbroken_original_l_->broken_info_[i].broken_spanner_l_ = 0;
+ }
+
}
}
source file of the GNU LilyPond music typesetter
- (c) 1996, 1997--1999, 1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+ (c) 1996--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
#include <math.h>
#include <limits.h>
+#include "killing-cons.tcc"
#include "spring-spacer.hh"
#include "p-col.hh"
#include "debug.hh"
Vector
Spring_spacer::default_solution() const
{
- return try_initial_solution() ;
+ return try_initial_solution();
}
Score_column*
{
Union_find connected (cols_.size());
Array<int> fixed;
- for (PCursor<Idealspacing*> i (ideal_p_list_.top()); i.ok (); i++)
+
+ for (Cons<Idealspacing> *i = ideal_p_list_; i; i = i->next_)
{
- connected.connect (i->cols_drul_[LEFT],i->cols_drul_[RIGHT]);
+ connected.connect (i->car_->cols_drul_[LEFT],i->car_->cols_drul_[RIGHT]);
}
for (int i = 0; i < cols_.size(); i++)
if (cols_[i].fixed_b())
lin.fill (0);
c = 0;
- for (PCursor<Idealspacing*> i (ideal_p_list_.top()); i.ok (); i++)
+ for (Cons<Idealspacing> *p =ideal_p_list_; p; p = p->next_)
{
+ Idealspacing *i = p->car_;
int l = i->cols_drul_[LEFT];
int r = i->cols_drul_[RIGHT];
Spring_spacer::calculate_energy_f (Vector solution) const
{
Real e = 0.0;
- for (PCursor<Idealspacing*> i (ideal_p_list_.top()); i.ok(); i++)
+ for (Cons<Idealspacing>*p =ideal_p_list_; p; p = p->next_)
{
+ Idealspacing * i = p->car_;
e += i->energy_f(solution(i->cols_drul_[RIGHT]) - solution(i->cols_drul_[LEFT]));
}
Spring_spacer::Spring_spacer ()
{
+ ideal_p_list_ =0;
energy_normalisation_f_ = 1.0;
}
}
return retval;
}
-
+/*
+ Ugh. Should junk this.
+ */
void
-Spring_spacer::loosen_column (int i)
+Spring_spacer::loosen_column (int idx)
{
- Column_info c=cols_.get (i);
- for (PCursor<Idealspacing*> j (ideal_p_list_.top()); j.ok (); j++)
+ Column_info c=cols_.get (idx);
+
+ Cons<Idealspacing> **pp = &ideal_p_list_;
+
+ while (*pp)
{
- if (j->cols_drul_[LEFT] == i|| j->cols_drul_[RIGHT] == i)
- j.del();
+ Idealspacing *j = (*pp)->car_;
+ if (j->cols_drul_[LEFT] == idx|| j->cols_drul_[RIGHT] == idx)
+ {
+ delete remove_cons (pp);
+ }
else
- j++;
+ {
+ pp = &(*pp)->next_;
+ }
}
c.ugh_b_ = true;
DOUT << "col " << i << " ";
cols_[i].print();
}
- for (PCursor<Idealspacing*> i (ideal_p_list_.top()); i.ok (); i++)
+
+ for (Cons<Idealspacing> *p =ideal_p_list_; p; p = p->next_)
{
- i->print();
+ p->car_->print();
}
#endif
}
s->space_f_ = d;
s->hooke_f_ = h;
- ideal_p_list_.bottom().add (s);
+ ideal_p_list_ = new Killing_cons<Idealspacing> (s, ideal_p_list_);
}
}
void
-Staff_side::do_substitute_dependency (Score_element*o, Score_element*n)
+Staff_side::do_substitute_element_pointer (Score_element*o, Score_element*n)
{
support_l_arr_.unordered_substitute (o,n);
}
}
/*
- TODO: head_l_arr_/rest_l_arr_ in do_substitute_dependent ()
+ TODO: head_l_arr_/rest_l_arr_ in
*/
void
-Stem::do_substitute_dependency (Score_element*o,Score_element*n)
+Stem::do_substitute_element_pointer (Score_element*o,Score_element*n)
{
if (Note_head*h=dynamic_cast<Note_head*> (o))
head_l_arr_.substitute (h, dynamic_cast<Note_head*>(n));
if (Rest *r=dynamic_cast<Rest*> (o))
rest_l_arr_.substitute (r, dynamic_cast<Rest*>(n));
+ if (Beam* b = dynamic_cast<Beam*> (o))
+ {
+ if (b == beam_l_)
+ {
+ beam_l_ = dynamic_cast<Beam*> (n);
+ if (!beam_l_)
+ {
+ beams_i_drul_[LEFT] = 0;
+ beams_i_drul_[RIGHT] = 0;
+ mult_i_ = 0;
+ }
+ }
+ }
}
#include "plist.tcc"
#include "music-list.hh"
-#include "music-iterator.hh"
POINTERLIST_INSTANTIATE(Music);
-POINTERLIST_INSTANTIATE(Music_iterator);
+
}
void
-Text_spanner::do_substitute_dependency (Score_element* o, Score_element*n)
+Text_spanner::do_substitute_element_pointer (Score_element* o, Score_element*n)
{
if (support_span_l_ == o)
support_span_l_ = (Directional_spanner*) (n?dynamic_cast <Spanner *> (n):0);
}
void
-Tie::do_substitute_dependency (Score_element*o, Score_element*n)
+Tie::do_substitute_element_pointer (Score_element*o, Score_element*n)
{
Note_head *new_l =n?dynamic_cast<Note_head *> (n):0;
if (dynamic_cast <Item *> (o) == head_l_drul_[LEFT])
*/
#include "proto.hh"
-#include "plist.hh"
#include "translator.hh"
#include "dictionary.hh"
#include "debug.hh"
#include "translator-group.hh"
#include "translator.hh"
#include "debug.hh"
-#include "pcursor.hh"
#include "rational.hh"
#include "dictionary-iter.hh"
+#include "killing-cons.tcc"
+
Translator_group::Translator_group (Translator_group const&s)
: Translator(s)
{
accepts_str_arr_ = s.accepts_str_arr_;
iterator_count_ =0;
properties_dict_ = s.properties_dict_;
-
}
Translator_group::~Translator_group ()
{
assert (removable_b());
+ trans_p_list_.junk ();
}
void
Translator_group::add_translator (Translator *trans_p)
{
- trans_p_list_.bottom().add (trans_p);
+ trans_p_list_.append (new Killing_cons<Translator> (trans_p,0));
+
trans_p->daddy_trans_l_ = this;
trans_p->output_def_l_ = output_def_l_;
trans_p->add_processing ();
bool
Translator_group::removable_b() const
{
- for (PCursor<Translator*> i (trans_p_list_.top ()); i.ok (); i++)
+ for (Cons<Translator> *p = trans_p_list_.head_; p; p = p->next_)
{
- if (dynamic_cast <Translator_group *> (i.ptr ()))
+ if (dynamic_cast <Translator_group *> (p->car_))
return false;
}
Translator_group::group_l_arr () const
{
Link_array<Translator_group> groups;
- for (PCursor<Translator*> i (trans_p_list_.top ()); i.ok (); i++)
+ for (Cons<Translator> *p = trans_p_list_.head_; p; p = p->next_)
{
- if (dynamic_cast <Translator_group *> (i.ptr ()))
- groups.push (dynamic_cast <Translator_group *> (i.ptr ()));
+ if (dynamic_cast <Translator_group *> (p->car_))
+ groups.push (dynamic_cast <Translator_group *> (p->car_));
}
return groups;
}
Translator_group::nongroup_l_arr () const
{
Link_array<Translator> groups;
- for (PCursor<Translator*> i (trans_p_list_.top ()); i.ok (); i++)
+ for (Cons<Translator> *p = trans_p_list_.head_; p; p = p->next_)
{
- if (!dynamic_cast <Translator_group *> (i.ptr ()))
- groups.push (i.ptr ());
+ if (!dynamic_cast <Translator_group *> (p->car_))
+ groups.push (p->car_);
}
return groups;
}
+/**
+ End translator: call "destructor", remove from hierarchy, and delete
+ */
void
Translator_group::terminate_translator (Translator*r_l)
delete trans_p;
}
+
+/**
+ Remove a translator from the hierarchy.
+ */
Translator *
Translator_group::remove_translator_p (Translator*trans_l)
{
assert (trans_l);
- PCursor<Translator*> trans_cur (trans_p_list_.find (trans_l));
- Translator * t = trans_cur.remove_p();
- /*
- For elegant design, we would do this too. Alas, it does not work yet..
+ for (Cons<Translator> **pp = &trans_p_list_.head_; *pp; pp = &(*pp)->next_)
+ if ((*pp)->car_ == trans_l)
+ {
+ Cons<Translator> *r = trans_p_list_.remove_cons (pp);
+ r->car_ =0;
+ trans_l->daddy_trans_l_ =0;
+ delete r;
+ return trans_l;
+ }
- t-> removal_processing ();
- */
- t-> daddy_trans_l_ = 0;
- return t;
+ return 0;
}
void
Translator_group::each (Method_pointer method)
{
- for (PCursor<Translator*> i (trans_p_list_.top ()); i.ok (); i++)
- (i.ptr()->*method) ();
+ for (Cons<Translator> *p = trans_p_list_.head_; p; p = p->next_)
+ (p->car_->*method) ();
}
+
void
Translator_group::each (Const_method_pointer method) const
{
- for (PCursor<Translator*> i (trans_p_list_.top ()); i.ok (); i++)
- (i.ptr()->*method) ();
+ for (Cons<Translator> *p = trans_p_list_.head_; p; p = p->next_)
+ (p->car_->*method) ();
}
void
if (properties_dict_.elem_b (id))
{
if (where_l)
- *where_l = this;
+ *where_l = (Translator_group*) this; // ugh
return properties_dict_[id];
}
if (column_arr_.size())
translate_axis (column_arr_[0]->extent (Y_AXIS)[dir_], Y_AXIS);
- if (!broken_into_l_arr_.size () && beam_l_
+ if (!broken_b () && beam_l_
&& spanned_drul_[LEFT]->column_l () == beam_l_->spanned_drul_[LEFT]->column_l ()
&& spanned_drul_[RIGHT]->column_l () == beam_l_->spanned_drul_[RIGHT]->column_l ())
bracket_visibility_b_ = false;
}
void
-Tuplet_spanner::do_substitute_dependency (Score_element* o, Score_element* n)
+Tuplet_spanner::do_substitute_element_pointer (Score_element* o, Score_element* n)
{
if (Note_column *onc = dynamic_cast <Note_column *> (o))
column_arr_.substitute (onc, dynamic_cast<Note_column*> (n));
- else if (Beam *b = dynamic_cast<Beam *> (o))
+ else if (o == beam_l_)
{
- if (b == beam_l_)
- beam_l_ = dynamic_cast<Beam*> (n);
+ beam_l_ = dynamic_cast<Beam*> (n);
}
}
void
Tuplet_spanner::set_beam (Beam *b)
{
+ assert(!beam_l_);
beam_l_ = b;
add_dependency (b);
}
}
void
-Volta_spanner::do_substitute_dependency (Score_element* o, Score_element* n)
+Volta_spanner::do_substitute_element_pointer (Score_element* o, Score_element* n)
{
if (Note_column* c = dynamic_cast <Note_column*> (o))
note_column_arr_.substitute (c, dynamic_cast<Note_column*> (n));
*/
#include "proto.hh"
-#include "plist.hh"
#include "debug.hh"
#include "my-lily-lexer.hh"
#include "moment.hh"
void
error_t (String const & s, Moment const & r)
{
- String t_mom = r.truncated ().str () + (r - r.truncated ()).str ();
+ String t_mom = r.trunc_rat ().str () + (r - r.trunc_rat ()).str ();
String e=s+ " (t = " + t_mom + ")";
error (e);
}
#include "spring-spacer.hh"
-/** el stupido.
+/** El stupido. Add a measure until we're past the optimum.
A Dynamic Programming type of algorithm
{
problem_OK();
- PCursor<Paper_column*> curcol (pscore_l_->col_p_list_.top());
+ Line_of_cols &allcols (pscore_l_->col_l_arr_);
+ int curcol_idx = 0;
+
Array<Column_x_positions> breaking;
Line_of_cols breakpoints (find_breaks());
assert (breakpoints.size()>=2);
- int break_idx_i=0;
- int line_no_i = 0;
- while (break_idx_i < breakpoints.size() -1)
+ int break_idx=0;
+ int line_no = 0;
+ while (break_idx < breakpoints.size() -1)
{
Column_x_positions minimum;
Column_x_positions current;
+
// do another line
- line_no_i ++;
- Paper_column *post = breakpoints[break_idx_i]->postbreak_l();
- int start_break_idx = break_idx_i;
+ line_no ++;
+ Paper_column *post = breakpoints[break_idx]->postbreak_l();
+ int start_break_idx = break_idx;
current.add_paper_column (post);
- curcol++; // skip the breakable.
- break_idx_i++;
+ curcol_idx++; // skip the breakable.
+ break_idx++;
- while (break_idx_i < breakpoints.size())
+ while (break_idx < breakpoints.size())
{
-
// add another measure.
- while (breakpoints[break_idx_i] != curcol.ptr())
+ while (breakpoints[break_idx] != allcols[curcol_idx])
{
- current.add_paper_column (curcol);
- curcol++;
+ current.add_paper_column (allcols[curcol_idx]);
+ curcol_idx++;
}
- current.add_paper_column (breakpoints[break_idx_i]->prebreak_l());
+
+ current.add_paper_column (breakpoints[break_idx]->prebreak_l());
current.spacer_l_ = generate_spacing_problem (current.cols,
- pscore_l_->paper_l_->line_dimensions_int (line_no_i));
+ pscore_l_->paper_l_->line_dimensions_int (line_no));
// try to solve
if (!feasible (current.cols))
if (!minimum.cols.size())
{
warning (_ ("ugh, this measure is too long")
- + ", " + _f ("breakpoint: %d", break_idx_i)
+ + ", " + _f ("breakpoint: %d", break_idx)
+ "(" + _ ("generating stupido solution") + ")");
current.stupid_solution();
current.energy_f_ = - 1; // make sure we break out.
delete current.spacer_l_;
current.spacer_l_ =0;
- if (!current.satisfies_constraints_b_ && start_break_idx == break_idx_i - 1)
+ if (!current.satisfies_constraints_b_ && start_break_idx == break_idx - 1)
{
warning ( _ ("I don't fit; put me on Montignac"));
minimum = current;
minimum = current;
}
else { // we're one col too far.
- break_idx_i--;
- while (curcol.ptr() != breakpoints[break_idx_i])
- curcol --;
+ break_idx--;
+ while (allcols[curcol_idx] != breakpoints[break_idx])
+ curcol_idx --;
break; // do the next line.
}
// add nobreak version of breakable column
- current.cols.top()=breakpoints[break_idx_i];
- curcol ++;
- break_idx_i++;
+ current.cols.top()=breakpoints[break_idx];
+ curcol_idx ++;
+ break_idx++;
}
- *mlog << "[" << break_idx_i << "]" << flush;
+ *mlog << "[" << break_idx << "]" << flush;
breaking.push (minimum);
}
return breaking;
prallmordent =\script { "prallmordent" 0 0 1 0 0 }
upprall =\script { "upprall" 0 0 1 0 0 }
downprall =\script { "downprall" 0 0 1 0 0 }
+
+"dash-hat" = "marcato"
+"dash-plus" = "stopped"
+"dash-dash" = "tenuto"
+"dash-bar" = "staccatissimo"
+"dash-larger" = "accent"
+"dash-dot" = "staccato"
strip lily/out/lilypond mi2mu/out/mi2mu
make prefix="$RPM_BUILD_ROOT/usr" install
+gzip -9fn $RPM_BUILD_ROOT/usr/info/* || true
mkdir -p $RPM_BUILD_ROOT/etc/profile.d
cp buildscripts/out/lilypond-profile $RPM_BUILD_ROOT/etc/profile.d/lilypond.sh
cp buildscripts/out/lilypond-login $RPM_BUILD_ROOT/etc/profile.d/lilypond.csh
-%files
+%post
+
+touch /tmp/.lilypond-install
+rm `find /var/lib/texmf -name 'feta*pk -print' -or -name 'feta*tfm -print'` /tmp/.lilypond-install
+/sbin/install-info /usr/info/lilypond.info.gz /usr/info/dir || true
+
+%preun
+if [ $1 = 0 ]; then
+ /sbin/install-info --delete /usr/info/lilypond.info.gz /usr/info/dir || true
+fi
+
+%files
%doc htmldocs/
# hairy to hook it in (possibly non-existing) emacs
/usr/bin/ly2dvi
/usr/bin/lilypond
/usr/bin/mi2mu
+/usr/info/*
/usr/man/man1/mi2mu.1
/usr/man/man1/lilypond.1
/usr/man/man1/mudela-book.1
/usr/share/locale/*/LC_MESSAGES/lilypond.mo
/etc/profile.d/lilypond.*
-%post
-
-touch /tmp/.lilypond-install
-rm `find /var/lib/texmf -name 'feta*pk -print' -or -name 'feta*tfm -print'` /tmp/.lilypond-install
$(MAKE) CONFIGSUFFIX='www' -C mutopia WWW
tar --exclude='*.dvi' --exclude='*.tex' --exclude='*.ps' --exclude='*.ppm' -czf $(outdir)/examples.tar.gz `find input mutopia -type d -name 'out-www' -print`
-CMR10DIR=$(dir $(shell kpsewhich cmr10.tfm))#ugh! Need kpsewhich
-TEX_TFMDIR=$(CMR10DIR)
localinstall:
mkdir -p $(datadir)
ln -s $(TEX_TFMDIR) $(datadir)/tfm
+pl 71
+ - bf: c-tags
+ - yodl: groff, ditroff
+
+pl 70
+ - GUILE config fixes (AF)
+
pl 69
- package_depth detection fix
PACKAGE_NAME=StepMake
MAJOR_VERSION=0
MINOR_VERSION=1
-PATCH_LEVEL=69
+PATCH_LEVEL=71
MY_PATCH_LEVEL=
# use the above to send patches, always empty for released version:
])
AC_DEFUN(AC_STEPMAKE_MAN, [
+ AC_CHECK_PROGS(GROFF, groff ditroff, -echo no groff)
AC_CHECK_PROGS(TROFF, troff, -echo no troff)
AC_CHECK_PROGS(TBL, tbl, cat)
])
O_FILES+=$(addprefix $(outdir)/, $(Y_FILES:.y=.o) $(C_FILES:.c=.o) $(L_FILES:.l=.o))
-TAGS_FILES += C_FILES H_FILES
+TAGS_FILES += $(C_FILES) $(H_FILES)
# C/C++
#
$(outdir)/%.txt: %.yo
# $(YODL2TXT) -doutdir=$(outdir) --live-data=3 -o $@ $<
- $(YODL2MSLESS) -doutdir=$(outdir) --live-data=3 $< | $(STRIPROFF) > $@
+ $(YODL2MSLESS) -doutdir=$(outdir) --live-data=3 $< > $@
rm -f $(basename $<).ms