This msg. is crossposted to bug and devel.
Please follow-up to only one of the lists.
In latest git, the score-function of Accidental_result looks like the
following:
int score () const {
return need_acc ? 1 : 0
+ need_restore ? 1 : 0;
}
The intention is clearly to sum the number of true booleans: 0 if none
of them are true, 1 if one of them is true, and 2 if both are true.
Iow, the intended behaviour is
return (need_acc ? 1 : 0)
+ (need_restore ? 1 : 0);
Unfortunately this is not what happens. "+" binds tighter than ":". So
what we get is
return need_acc ? 1 : (0 + need_restore ? 1 : 0);
The function cannot return 2.
This is related to a very old discussion of what to typeset if the
cautionary-rule wants to typeset an accidental-restore and a accidental
whereas the accidental-ryle wants to typeset only one accidental.
E.g.
{
#(set-accidental-style 'modern-cautionary)
\set Staff.extraNatural = ##t
cisis'1 | cis'1
}
What accidental to typeset in front of the cis?
The cautionary rule remembers the cisis from previous measure and
therefore wants to typeset an extra reminder:
(x)O | (n#)O |
(x is a double sharp, n is a natural, O is a whole note)
The accidental rule does not remember the previous measure and therefore
only wants to typeset the sharp:
xO | #O |
In 2.10 the logic said that the rule who wanted to typeset the larger
number of accidentals won. Therefore, because the cautionary rule wanted
to typeset the most, it won, and the resulting output was:
xO | (n#)O |
In 2.11 the logic still says that the rule who wants to typeset the
larger number of accidentals wins. Unfortunately it is the buggy
function above that is used to decide this, and therefore it is not
realized that the cautionary rule wants to typeset more accidentals than
the accidental rule. In case of a tie, the accidental rule wins, so in
current git, the output is
xO | #O |
Both results (2.10 result and 2.11 result) are IMO very unfortunate. In
1.10 the accidental is typeset as a cautionary even though it is a real
accidental, whereas in the 2.11 version we do not get the cautionary
cancelling of the double sharp.
When I wrote the accidental code back in 2001 my intention was, that the
only sensible thing to do in this case would be to output
xO | (n)#O |
and I implemented it that way.
But, alas, this small part of my patch was rejected, and the problem was
never really solved in another way.
The current behaviour is the result of a bug in a function, not of a
decision of what to do.
I still think that we should do the (n)#O. I think this clearly
represents that the x cautionally needs to be cancelled whereas the # is
real.
Comments?
-Rune
_______________________________________________
bug-lilypond mailing list
bug-lilypond@gnu.org
http://lists.gnu.org/mailman/listinfo/bug-lilypond
