whenhtml(sc(ARG1)))
def(mycode)(1)(tt(ARG1))
+
+
COMMENT( This document contains Mudela fragments. You need at least
Yodl-1.30.18 to convert this to tex or html.
\setlength{\textwidth}{5.875in}
\setlength{\oddsidemargin}{0.25in}
\setlength{\evensidemargin}{0.25in}
+\usepackage[T1]{fontenc}
\input mudela-book
)
itself.) This document intends to give an idea of how it works. It is
not a guide on how to use it.
-sect(Files)
-The de-facto extension of Mudela is file(.ly). Files may be included by
-entering code(\include) at the start of a line:
+sect(Running LilyPond)
-verb(\include "a_file.ly")
+When invoked with a filename that has no extension, LilyPond will add
+a file(.ly) extension. When invoked with a filename ending in
+file(.fly), LilyPond processes the file as a music fragment using
+file(init.fly). When file(foo.fly) is read, LilyPond does something
+like this:
+\verb(\score {
+ \notes\relative c {
+ \input "foo.fly"
+ }
+ \paper{}
+ \midi{}
+})
sect(Syntax)
-COMMENT(I don't understand the syntax, so I can't write this
-section very well. --Adrian)
-
-A one line comment is introduced by a
-code(%) character.
-Block comments are started
-by
-code(%{)
-and
-ended by code(%}).
-They cannot be nested.
-
-Mudela supports three types of constants: strings, reals, and integers.
-verb("I am a string"
--1.2e3 % a real
-12 % an integer)
-A string which contains no spaces can be written without the quotes.
-However, in Note mode, unquoted text can be intepreted as note names
-rather than as a string.
-
-Pairs of braces `code({)' and `code(})' or pairs of angle brackets
-`code(<)' and `code(>)' are used to identify the scope
-of contexts and enable the construction of hierarchical structure.
-Items in braces will be treated as serial; items in angle brackets
-will be stacked into chords.
-Braces are also used to group arguments for certain commands.
+A Mudela files consists of statements, generally
+separated by spaces, tabs or newlines. A one line comment is
+introduced by a code(%) character. Block comments are started by
+code(%{) and ended by code(%}). They cannot be nested.
+
+Mudela supports several data types. Four types of simple constants
+are supported: integers, reals, strings, and notes. An integer is a
+sequence of digits such as code(12). A real is fromed from an
+optional minus sign and a sequence of digits followed by a decimal
+point and an optional exponent such as code(-1.2e3). A string is
+started and ended with the code(") character. To include a code(")
+character in a string, you must write code(\"). Various other
+backslash sequences have special interpretations as in the C language.
+A string that contains no spaces can be written without the quotes. A
+note consists of a note name followed by an optional duration. See
+section ref(notedesc) for details on this type. A dimension consists
+of a real followed by one of the dimension keywords: code(\mm),
+code(\pt), code(\in), or code(\cm). Dimensions are converted
+immediately to a real which gives the dimension in points, so they can
+be mixed with reals.
+
+Compound types are built up from the simple types. The compound types
+are: arglist, assignlist and musiclist. An arglist is a
+white space separated list of integers, reals and or strings surrounded
+by braces code({) and code(}). An assignlist is a list of
+identifier assignments, which have the form var(key)code(=)var(value).
+The simplest musiclist is a single note. More complicated music lists
+are formed by surrounding a list of musiclists with braces code({) and
+code(}) or with angle brackets code(<) and code(>). Items appearing
+in braces will be treated as serial. Items in angle brackets will be
+simultaneous.
+
+A statement in Mudela has one of three forms:
+verb(\keyword argument
+\keyword argument1 argument2 ... ;
+string=value)
To assign an identifier you use:
verb(string = ...)
The following words are keywords. You can define an identifer whose
name is a keyword, but you will not be able to reference it.
-verb(absdynamic font time penalty spandynamic
-accepts grouping midi property symboltables
-bar in mm pt table
-cadenza include multi relative tempo
-clear lyric header score translator
-clef key notenames script type
-cm keysignature octave shape transpose
-consists mark output skip version
-contains notes partial staff
-duration musicalpitch paper spandynamic)
-
-COMMENT( I don't know the proper way to make this kind of table in
-yodl.
-
-Also note: Lilypond should really give an error when I write
- lyric = .....
-Instead, I get the error later, after I try to use my redefinition of
-\lyric. The cause is much less clear. )
+verb(absdynamic font mm pt time
+accepts grouping musicalpitch relative translator
+bar header notenames score transpose
+cadenza in notes script type
+clear include octave shape version
+clef key output skip
+cm keysignature paper spandynamic
+consists lyric partial symboltables
+contains mark penalty table
+duration midi property tempo )
+COMMENT( I don't know the proper way to make this kind of table in
+yodl. )
+COMMENT(
subsect(Hierarchical structures)
The general structure consists of declarations:
Some exceptions on this rule have been made to prevent inputting
Mudela becoming tedious
-
-
-COMMENT(As far as I can tell, the last bit is simply a repetition of
-the information on how to use an identifier, so it should be deleted.
-
-But I'm uncertain about the meaning of \TYPE in the above section.
-Different from \type? Does it refer to \notes, \lyric? In general,
-the use of the word "type" seems to be a source of confusion.
)
+
sect(Modes)
To simplify different aspects of music definition (entering the notes
dit(Note mode) Note mode is introduced by the keyword
code(\notes). In Note mode, words can only contain alphabetic
-characters. If code(word) is encountered, Lilypond first checks for a
+characters. If code(word) is encountered, LilyPond first checks for a
notename of code(word). If no notename is found, then code(word) is
treated as a string. If you mistype a notename, the parser will most
likely complain that you should be in code(\lyric) mode to do lyrics.
sect(Note Description)
+label(notedesc)
-subsect(Basic note specification)
+subsect(Basic Note Specification)
A note specification has the form
-var(pitch)[var(octavespec)][var(duration)].
+var(pitch)[var(octavespec)][code(!)][var(duration)].
The pitch of the note is specified by the note's name.
-Lilypond has predefined note names for various languages. The default
+LilyPond has predefined note names for various languages. The default
names are the Dutch note names. The notes are specified by the
letters code(c) through code(b), where code(c) is an octave below
middle C and the letters span the ocatave above that C.
ceses' eses' geses' ases' beses'
)
-Whenever a C-sharp is desired, you must specify a C-sharp. Lilypond
+Whenever a C-sharp is desired, you must specify a C-sharp. LilyPond
will determine what accidentals to typeset depending on the key and
context.
A reminder accidental can be forced by
-using an exclamation mark code(!)
+using the optional exclamation mark `code(!)'
on a pitch.
mudela(fragment,verbatim,center)(
cis' d' e' cis' c'! d' e' c'
In addition, the duration can be followed by a multiplier which is
introduced with the asterisk code(*) and can be an integer or a
-fraction. The multiplier changes the duration that Lilypond uses
+fraction. The multiplier changes the duration that LilyPond uses
internally for the note, but it does not change the symbol that is
printed.
mudela(fragment,verbatim,center)(
In order to create triplets, you must use a length multiplier after
the brackets. An open bracket code([) followed by a fraction
-instructs Lilypond to print a number over the beam, and it also
+instructs LilyPond to print a number over the beam, and it also
starts multiplying all note lengths by the fraction. The closing
bracket code(]) should be followed by the fraction code(1/1) in order
to restore normal note lengths. To create a triplet without a beam,
)
+
subsect(Slurs and Ties)
A tie connects two adjacent note heads
c'( d' e' )f'
)
+subsect(Note Ornaments)
+
+A variety of symbols can appear above and below notes to indicate
+different characteristics of the performance. These symbols can be
+added to a note with `var(note)code(-\)var(name)'. Numerous different
+symbols are defined in file(script.ly). Each symbol is defined using
+the code(\script) keyword which specifies where symbols appear.
+Symbols can be forced to appear above the note by writing
+`var(note)code(^\)var(name)', and they can be forced to appear below
+by writing `var(note)code(_\)var(name)'. Here is a chart showing
+symbols above notes, with the name of the corresponding symbol
+appearing underneath.
+
+mudela()(
+\score{
+ < \notes{ c''-\accent c''-\marcato c''-\staccatissimo f'-\fermata
+ c''-\stopped c''-\staccato c''-\tenuto c''-\upbow c''-\downbow
+ c''-\lheel c''-\rheel c''-\ltoe c''-\rtoe c''-\turn
+ c''-\open c''-\flageolet c''-\reverseturn
+ c''-\trill
+ c''-\prall c''-\mordent c''-\prallprall c''-\prallmordent
+ c''-\upprall c''-\downprall }
+ \type Lyrics \lyric{
+ accent marcato staccatissimo fermata stopped
+ staccato tenuto upbow downbow lheel rheel ltoe rtoe turn
+ open flageolet reverseturn
+ trill prall
+ mordent prallprall prallmordent uprall downprall }>
+ \paper{linewidth = 5.875\in
+ indent = 0.0
+ }
+}
+)
+
+In addition, it is possible to place arbitrary strings of text or
+TeX() above or below notes by using a string instead of an identifier:
+`code(c^"text")'. Fingerings can be placed by simply using digits.
+
+To save typing, a few common symbols can be abbreviated with
+single characters:
+mudela()(
+\score{ \notes {
+ \property Voice.textstyle = typewriter
+ c''4-._"c-." s4
+ c''4--_"c--" s4
+ c''4-+_"c-+" s4
+ c''4-|_"c-|" s4
+ c''4->_"c->" s4
+ c''4-^_"c-\\^{ }" s4 }
+ \paper { linewidth = 12.\cm; }})
+
+Dynamic marks are specified by using an identifier after
+a note without a dash: code(c4 \ff). The available dynamic marks
+are: code(\ppp), code(\pp), code(\p), code(\mp), code(\mf),
+code(\f), code(\ff), code(\fff), code(\fp), code(sf), and code(\sfz).
+
+A crescendo mark is started with code(\cr) and terminated with
+code(\rc). A decrescendo mark is started with code(\decr) and
+terminated with code(\rced).
+
+
sect(Lyrics)
Lyrics are entered like notes, with pitches replaced
by text. For example code(Twin-4 kle4 twin-4 kle4) enters four
-syllables, each with quarter note duration. Two words can be bound
-together by an underscore If a single duration
+syllables, each with quarter note duration.
-In order to instruct Lilypond to write lyrics underneath the
+In order to instruct LilyPond to write lyrics underneath the
staff, you must enter the lyrics context with code(\type Lyrics).
Lyrics should be entered in lyrics mode which is entered with code(\lyric).
sect(Time)
-Lilypond aligns all musical objects according to the amount of time
+LilyPond aligns all musical objects according to the amount of time
they occupy. All of these objects have a duration. When music is
written in series using braces the duration is the sum of the
durations of the elements. When music is stacked using angle
brackets, the duration is the maximum of the durations of the
elements.
-Because Lilypond knows the durations of all musical elements, the time
-signature enables Lilypond to draw bar lines automatically. The time
-signature is specified with the code(\time) command: code(\time 3/4).
-If no time signature is given, Lilypond assumes 4/4. The automatic
-generation of bar lines can toggled with the code(\cadenza) command,
+Because LilyPond knows the durations of all musical elements, the time
+signature enables LilyPond to draw bar lines automatically. The time
+signature is specified with the code(\time) keyword: code(\time 3/4).
+If no time signature is given, LilyPond assumes 4/4. The automatic
+generation of bar lines can toggled with the code(\cadenza) keyword,
and an incomplete measure at the start of the music can be created
-using the code(\partial) command: code(\partial 8*2;) creates a
+using the code(\partial) keyword: code(\partial 8*2;) creates a
starting measure lasting two eighth notes.
In order to help with error checking, you can insert bar markers in
-your music by typing code(|). Whenever Lilypond encounters a code(|)
+your music by typing code(|). Whenever LilyPond encounters a code(|)
that doesn't fall at a measure boundary, she prints a warning message.
Rhythmic grouping is a concept closely associated with this.
The default consists of combinations of 2 and 3 beats with as many
groups of 3 as possible, and the groups of 3 coming first. For
example, 4/4 is divided into 2+2 and 8/8 is divided into 3+3+2. This
-default grouping can be changed using the \grouping command which
+default grouping can be changed using the \grouping keyword which
takes a list of durations to specify the grouping.
-sect(A complete example)
-COMMENT(%label(se:complete))
-
-A Mudela file needs some red tape
-
-mudela(verbatim)(
-\score{
- \notes {
- c' d' e' c' |
- c' d' e' c' |
- e' f' g'2 |
- }
-}
-)
-
-
sect(Composition: forming bigger structures)
label(sec:grammar)
)
-sect(Properties)
-
-By default the same key signature is valid for all octaves, but
- this can be changed with the property code(keyoctaviation).
-
-The identifier code(\specialkey) sets the property for the Staff. A
-key with two flats in one octave and three sharps in the next can be
-declared with verb(\specialkey \keysignature bes es fis' cis' gis';)
-sect(Music fragments)
-label(tutorial:music-fragments)
+sect(Keywords)
-Sometimes you only need to print a small fragment of music, perhaps
-something much like one of the examples in this document. Back in
-section ref(sec:running-lilypond) we told you that the music you
-enter should be encapsulated in something like:
-verb(\score<
- \notes\relative c{
- d
- }
- \paper{ }
- \midi{ }
->)
-where the only interesting information is this particular example is verb(
- d
-)
-The rest of the above example was already nicknamed `red tape'.
-You may easily get bored if you have to provide this same red tape
-for every fragmenty you nop(try)footnote(Of course, in most cases your
-favourite text editor (TM)
-will help you out.).
-
-Luckily there's a trick around this, and it's called file(.fly) files.
-If you use the extension file(.fly) for Mudela file file(foo),
-LilyPond will embed your file(foo.fly) nop(in)footnote(Or something very
-similar. If you want to know exactly, see file(init/init.fly)):
-verb(\score<
- \notes\relative c{
- <<foo.ly>>
- }
- \paper{ }
- \midi{ })
-Here's how it works. If you run LilyPond on your file file(bar.ly), you
-may notice that she starts off by reading quite a number of files before
-she actually reaches your file(bar.ly). There's no magic going on, Lily
-by default reads an initialisation file (file(init/init.ly)). In the
-initialisation process a lot of things are defined that you'll need for
-normal operation, such as notenames and various other mudela shortcuts,
-engraver and perforer definitions, font sizes, musical dimensions and
-paper sizes. When you use the extension file(.fly), Lily just starts
-reading another initialisation file (file(init/init.fly)), that includes the
-red tape for you too.
-
-
-sect(Commands)
-
-Commands take the form of a keyword followed by a list of arguments
-separated by spaces and terminated by a semicolon:
+Keywords sometimes appear alone, but usually they require arguments.
+A keyword may have a single argument, or a sequence of arguments separated
+by spaces and terminated by a semicolon:
`code(\keyword argument argument ... ;)'
-COMMENT(The above is wrong. Many commands have the form
- \keyword { text }
- with no semicolon, at least much of the time, and some commands
-have obligatory braces as far as I can tell, which don't contain music.)
description(
-dit(mycode(\absdynamic))
+dit(code(\absdynamic) code({) var(code) code(})) Internal command for
+printing dynamic marks such as $f$ under music. The parameter
+var(code) is unsigned and specifies the dynamic mark to print.
+Normally you should use the more user friendly abbreviations defined
+in the init file file(dynamic.ly).
-dit(mycode(\accepts))
+dit(code(\accepts) var(string)code(;)) This command can appear only within a
+code(\translator) block. It specifies what contexts are allowed
-dit(mycode(\bar) var(bartype)) Prints a special bar symbol, or at
+dit(code(\bar) var(bartype)code(;)) Prints a special bar symbol, or at
measure boundaries, replaces the regular bar symbol with a special
symbol. The argument var(bartype) is a string which specifies the
kind of bar to print. Options are code(":|"), code("|:"),
-code(":|:"), code("||"), code("|."),
-code(".|"), or code(".|."). These produce respectively a right repeat, a left
-repeat, a double repeat, a double bar, a start bar, an end bar, or a
-thick double bar. If var(bartype) is set to "empty" then nothing is
-printed, but a line break is allowed at that spot.
-
-dit(mycode(\cadenza) var(togglevalue)) Toggles the automatic generation
+code(":|:"), code("||"), code("|."), code(".|"), or code(".|.").
+These produce respectively a right repeat, a left repeat, a double
+repeat, a double bar, a start bar, an end bar, or a thick double bar.
+If var(bartype) is set to code("empty") then nothing is printed, but a
+line break is allowed at that spot. Note that the printing of special bars
+has no effect on the MIDI output.
+
+dit(code(\cadenza) var(togglevalue)code(;)) Toggles the automatic generation
of bar lines. If var(togglevalue) is 0 then bar line generation is
turne off. If var(togglevalue) is 1 then a bar is immediately
printed and bar generation is turned on.
-dit(mycode(\clear))
+dit(code(\clear)) Allowed only within code(\notename). Clears all the
+previously defined note names.
-dit(mycode(\clef) var(clefname)) Sets the current clef. The argument
-is the name of the clef. Possibilities are code(bass), code(alto),
-and code(treble). Treble clef is the default.
+dit(code(\clef) var(clefname)code(;)) Allowed only in music.
+Sets the current clef. The argument is
+a string which specifies the name of the clef. Several clef names are
+supported. If code(_8) or code(^8) is added to the end of a clef
+name then the clef lowered or raised an octave will be generated.
+Here are the supported clef names with middle C shown in each clef:
+mudela()(
+\score{
+ \notes{
+ %\property Voice.textstyle = typewriter
+ \clef subbass; c'4-"\kern-10mm subbass"
+ \clef bass; c'4^"\kern -8mm bass"
+ \clef baritone; c'4_"\kern -10mm baritone"
+ \clef varbaritone; c'4^"\kern -10mm varbaritone"
+ \clef tenor; c'4_"\kern -10mm tenor"
+ \clef "G_8"; c'4^"\kern -6mm G\_8" }
+\paper{ linewidth= 4.5 \in;
+Staff = \translator {
+ \type "Line_group_engraver_group";
+
+ defaultclef = violin;
+
+% \consists "Bar_engraver";
+ \consists "Clef_engraver";
+ \consists "Key_engraver";
+ \consists "Local_key_engraver";
+ \consists "Time_signature_engraver";
+ \consists "Staff_sym_engraver";
+ \consists "Collision_engraver";
+ \consists "Rest_collision_engraver";
+ \consists "Separating_line_group_engraver";
+
+ \accepts "Voice";
+ }
+
+}
+
+}
+)
+mudela()(
+\score{
+ \notes{\clef alto; c'4_"\kern -10mm alto"
+ \clef mezzosoprano; c'4^"\kern -10mm mezzosoprano"
+ \clef soprano; c'4_"\kern -10mm soprano"
+ \clef treble; c'4^"\kern -6mm treble"
+ \clef french; c'4_"\kern -10mm french" }
+\paper{ linewidth= 4.5 \in;
+Staff = \translator {
+ \type "Line_group_engraver_group";
+
+ defaultclef = violin;
+
+% \consists "Bar_engraver";
+ \consists "Clef_engraver";
+ \consists "Key_engraver";
+ \consists "Local_key_engraver";
+ \consists "Time_signature_engraver";
+ \consists "Staff_sym_engraver";
+ \consists "Collision_engraver";
+ \consists "Rest_collision_engraver";
+ \consists "Separating_line_group_engraver";
+
+ \accepts "Voice";
+ }
+}
+}
+)
+The treble clef can also be obtained using the names code(G) or
+code(violin). The bass clef is also available by code(\clef F).
-dit(mycode(\cm)) Specify a width in centimeters.
+dit(code(\cm)) Specify a dimension in centimeters.
-dit(mycode(\consists))
+dit(code(\consists) var(string)code(;)) This command can appear only within a
+code(\translator) block. It specifies that an engraver named
+var(string) should be added to the translator.
-dit(mycode(\contains))
+dit(code(\contains)) Produces a parse error. (There is no rule in the
+grammar that refers to this token.)
-dit(mycode(\duration) { var(length) var(dotcount) }) Specify note
+dit(code(\duration) code({) var(length) var(dotcount) code(})) Specify note
duration. The parameter var(length) is the negative logarithm (base
2) of duration: 1 is a half note, 2 is a quarter note, 3 is an eighth
note, etc. The number of dots after the note is given by
var(dotcount).
-dit(mycode(\font))
+dit(code(\font) var(string)) Internal command. Used within
+code(\symboltables) to specify the font.
-dit(mycode(\grouping) var(durationlist)) Sets the metric structure of
-the measure.
-COMMENT(elaboration is needed here.)
+dit(code(\grouping) var(durationseq); ) Sets the metric structure of
+the measure. Each argument specifies the duration of one metric unit.
+For example, code(\duration 16*5;) specifies a grouping of five beats
+together in 5/16 time. The default grouping is to have as many groups
+of 3 as possible followed by groups of two.
-dit(mycode(\in)) Specify a width in inches.
+dit(code(\in)) Specify a dimension in inches.
-dit(mycode(\include) var(file)) Include the specified file.
+dit(code(\include) var(file)) Include the specified file. The
+argument var(file) is a string. The full filename including the
+file(.ly) extension must be given.
-dit(mycode(\lyric) { var(list) } ) Parse var(list) in lyrics mode.
+dit(code(\lyric) var(lyriclist)) Parse var(lyriclist) in lyrics mode.
-dit(mycode(\key) var(pitch)) Change key signature to that of var(pitch)-major.
+dit(code(\key) var(pitch)) Change key signature to that of
+var(pitch)-major.
-dit(mycode(\keysignature) var(notelist))
-Specify an arbitrary key signature. The notes from var(notelist) will
+dit(code(\keysignature) var(pitchseq);)
+Specify an arbitrary key signature. The pitches from var(pitch) will
be printed in the key signature in the order that they appear on the list.
-dit(mycode(\mark))
+dit(code(\mark) var(unsigned) or code(\mark) var(string)) Allowed in
+music only. What does this do?
-dit(mycode(\notes) var(music)) Enter note mode and process the
-specified music.
+dit(code(\musicalpitch) code({) var(octave) var(note) var(shift) code(}))
+Specify note pitch. The octave is specified by an integer,
+zero for the octave containing middle C. The note is a number from 0
+to 7, with 0 corresponding to C and 7 corresponding to B. The shift
+is zero for a natural, negative to add flats, or positive to add
+sharps.
-dit(mycode(\musicalpitch) { var(octave) var(note) var(shift) }) Specify
-note pitch. The octave is specified by an integer, zero for the
-octave containing middle C. The note is a number from 0 to 7, with 0
-corresponding to C and 7 corresponding to B. The shift is zero for a
-natural, negative to add flats, or positive to add sharps.
+dit(code(\notes) var(music)) Enter note mode and process the
+specified music.
-dit(mycode(\time) var(numerator)mycode(/)var(denominator)) Change the time
+dit(code(\time) var(numerator)code(/)var(denominator)) Change the time
signature. The default time signature is 4/4.
-dit(mycode(\midi)) Produce musical output. See code(\tempo) for setting
-the tempo.
-
-dit(mycode(\mm)) Specify a width in millimeters.
+dit(code(\midi) var(statementlist)) Appears in a score block to
+indicate that musical output should be produced. See code(\tempo).
-dit(mycode(\multi))
+dit(code(\mm)) Specify a dimension in millimeters.
-dit(mycode(\header) { var(key1) = var(val1); var(key2) = var(val2); ... })
+dit(code(\header) code({) var(key1) = var(val1); var(key2) = var(val2); ... code(}))
Specifies information about the music. A header should appear at the
top of the file describing the file's contents. If a file has
multiple code(\score) blocks, then a header should appear in
use this information for generating titles. Some possible key values
are: title, opus, description, composer, enteredby, and copyright.
-dit(mycode(\notenames) { var(list) }) Define new note names.
-The argument var(list) is a list of definitions of the form
+dit(code(\notenames) var(assignmentlist)) Define new note names.
+The argument is a list of definitions of the form
var(name) = var(pitch), where var(pitch) is specified with the
-code(\musicalpitch) command.
+code(\musicalpitch) command. Another possibility is code(\clear)
+which can appear instead of an assignment.
-dit(mycode(\octave))
-dit(mycode(\nop(output)))
+dit(code(\octave)) Generate a parse error. Never referred to in the
+grammar.
-dit(mycode(\partial) var(duration)) Specify that the first measure of
+dit(code(\output) var(string)code(;)) Allowed only in
+code(\paper) block. The parameter var(string) specifies an alternate
+name for the TeX() output. A file(.tex) extension will be added to
+var(string) to produce the output file name.
+
+dit(code(\partial) var(duration)) Specify that the first measure of
the music lasts only for the specified duration.
-dit(mycode(\paper) mycode({) [ mycode(linewidth = )var(width)mycode(;) ] mycode(}))
+dit(code(\paper) var(statmentlist))
Appears in a score block to indicate that the music should be printed.
-The line width can be set to -1. in order to prevent justification of
-small fragments of music, or the width can be specified explicitly
-using code(\cm), code(\in), code(\mm), or code(\pt) to specify the
-units.
-dit(mycode(\penalty))
+dit(code(\penalty) code(=) var(int)) Allowed only in musiclists.
+Discourages line breaks.
-dit(mycode(\property))
+dit(code(\property) var(contextname)code(.)var(propname) code(=) var(value))
+Sets the var(propname) property of the context var(contextname) to the
+specified var(value). All three arguments are strings.
-dit(mycode(\pt)) Specify a width in points.
+dit(code(\pt)) Specify a dimension in points.
-dit(mycode(\relative) var(pitch) var(music)) Processes the specified
+dit(code(\relative) var(pitch) var(music)) Processes the specified
var(music) in relative pitch
mode. In this mode, the octave of a pitch note is chosen so that the
note is closest to the preceeding note.
first note of a chord is used as the base for the pitches in the next
chord.
-dit(mycode(\score)) Start a music definition.
+dit(code(\score) var(statementlist)) Define music.
+
+dit(code(\script) code({) var(name) var(instaff) var(withstem)
+var(location) var(invertible) var(priority) code(})) This command is
+used the initialization file(script.ly) to define the various symbols
+that can appear above and below notes. The first argument is the name
+of the symbol. The second argument var(instaff) is 1 if the symbol
+follows the notehead into the staff and 0 if the symbol stays above or
+below the staff lines. The third parameter var(withstem) is 0 if the
+symbol's placement does not depend on the stem direction; it is 1 if
+the symbol should be at the stem end of the note and it is -1 if the
+symbol should be at the note head end of the note. The argument
+var(location) is set to 1 for symbols that always appear above the
+staff; it is -1 for symbols that appear below the staff. If
+var(invertible) is set to 1 then the symbol can be inverted; otherwise
+it cannot. The last argument var(priority) sets a priority for the
+order of placement of several symbols on a single note.
+
+dit(code(\shape) code(=) var(indent1) var(width1) var(indent2)
+var(width2) ... code(;)) Allowed only within code(\paper). Each pair
+of var(indent) and var(width) values is a dimension specifying how far
+to indent and how wide to make the line. The indentation and width of
+successive lines are specified by the successive pairs of dimensions.
+The last pair of dimensions will define the characeristics of all
+lines beyond those explicitly specified.
+
+COMMENT(First pair of dimensions seems to be skipped. At least it is
+in the example file denneboom.ly.)
+
+dit(code(\skip) var(duration)) Skips the amount of time specified by
+var(duration). A gap will be left for the skipped time with no notes
+printed. It works in Note Mode or Lyrics Mode (but generates a
+mysterious error in lyrics).
+
+dit(code(\spandynamic) code({) var(kind) var(toggle) code(})) Internal
+command for crescendo and decrescendo symbols. The first parameter
+var(kind) is set to 1 for a crescendo and -1 for a decrescendo. The
+second parameter is set to 1 to start the mark and 2 to stop it.
+Users should use the abbreviations which are defined in the
+initialization file file(dynamic.ly).
+
+dit(code(\symboltables)) Internal command. Used to create symbol
+tables. See initialization files file(paper*.ly), file(feta*.ly), and
+file(table*.ly).
+
+dit(code(\table)) Internal command. Used within code(\symboltables)
+to specify the tables. See initialization files.
+
+dit(code(\tempo) var(duration) = var(perminute)) Used within
+code(\midi) to specify the tempo. For example,
+`code(\midi { \tempo 4 = 76})' requests output with 76 quarter notes
+per minute.
+
+dit(code(\translator) var(statements) or code(\translator)
+var(context) = var(name)) The first variant appears only within
+code(\paper) and specifies a translator for
+converting music to notation. The translator is specified with a
+single code(\type) statement and a series of code(\accepts), and
+code(\consists) statements. The second variant appears in a
+musiclist. It specifies that the current the contexts
+contained within the specified context should be shifted to the
+context with the specified name.
+
+COMMENT( \translator seems like a strange name for the second
+operation, and is the overloading desireable? )
+
+dit(code(\type) var(contexttype) [code(=) var(contextname)]
+var(musiclist) or code(\type) var(translatortype)code(;)) The first
+variant is used only within musiclists to
+create a instance of a context. The new context
+can optionally be given a name. The second variant appears within a
+code(\translator) block and specifies the type of translator being
+created.
+
+dit(code(\transpose) var(pitch) var(music)) Transposes the specified
+music. Middle C is tranposed to var(pitch).
+
+dit(code(\version) var(string)) Specify the version of Mudela that a
+file was written for. The argument is the version number, for example
+code("1.0.1"). Note that the Mudela version is different from the
+LilyPond version.
-dit(mycode(\script))
+)
-dit(mycode(\shape))
-dit(mycode(\skip))
+sect(Notation Contexts)
-dit(mycode(\staff))
+Notation contexts provide information that appears in printed music
+but not in the music itself. A new musical context is created using
+the code(\type) keyword: `code(\type) var(contexttype) [code(=)
+var(contextname)] var(musiclist)'. The following context types are
+allowed.
-dit(mycode(\spandynamic))
-dit(mycode(\symboltables))
-dit(mycode(\table))
+description(
-dit(mycode(\tempo) var(duration) = var(perminute)) Used when creating
-MIDI output to specify the tempo. For example,
-`code(\midi { \temp0 4 = 76})' requests output with 76 quarter notes
-per minute.
+dit(code(Lyrics)) Typesets lyrics.
-dit(mycode(\translator))
-dit(mycode(\type))
+dit(code(Voice)) Corresponds to a voice on a staff.
+ This context handles the conversion of noteheads,
+ dynamic signs, stems, beams, super- and subscripts, slurs, ties and rests.
-dit(mycode(\transpose) var(pitch) var(music)) Transposes the specified
-music. Middle C is tranposed to var(pitch).
+dit(code(Staff)) Handles clefs, bar lines, keys,
+ accidentals. It can contain code(Voice) or code(Lyrics) contexts.
+
+dit(code(RhythmicStaff)) A context like code(Staff) but for printing
+rhythms. Pitches are ignored; the notes are printed on one line.
+It can contain code(Voice) or code(Lyrics) contexts.
+
+dit(code(GrandStaff)) Contains code(Staff) or code(RhythmicStaff)
+contexts. It adds a brace on the left side grouping the staffs
+together. The bar lines of the contained staffs are connected vertically.
+It can contain code(Staff), code(RhythmicStaff) or code(Lyrics) contexts.
+
+dit(code(StaffGroup)) Contains code(Staff) or code(RhythmicStaff)
+contexsts. Adds a bracket on the left side, grouping the staffs
+together. The bar lines of the contained staffs are connected vertically.
+It can contain code(Staff), code(RhythmicStaff) or code(Lyrics) contexts.
-dit(mycode(\version) var(string)) Specify the version of Lilypond that
-a file was written for. The argument is the version number,
-for example code("1.0.4").
+dit(code(ChoireStaff)) Identical to code(StaffGroup) except that the
+contained staffs are not connected vertically.
+COMMENT(Odd spelling of "choir".)
+
+dit(code(Score)) This is the top level notation context. It is entered with
+the code(\score) command rather than the code(\type) command. No
+other context can contain a code(Score) context. This context handles
+the administration of time signatures. It also makes sure that items
+such as clefs, time signatures, and key-signatures are aligned across
+staffs. It can contain code(Lyrics), code(Staff),
+code(RhythmicStaff), code(GrandStaff), code(StaffGroup), and
+code(ChoireStaff) contexts.
+
+)
+
+The various contexts have properties associated with them. These
+properties can be changed using the code(\property) command:
+`code(\property) var(context)code(.)var(propname) code(=) var(value)'.
+Properties can also be set within the code(\translator) block
+corresponding to the appropriate context. In this case, they are
+assigned by `var(propname) code(=) var(value)'.
+
+
+description(
+ dit(Lyrics properties)
+
+ description(
+ dit(code(textstyle)) Set the font for lyrics. The available
+font choices are code(normaltext), code(roman), code(italic), code(bold)
+code(normaltext), code(large), code(Large), code(huge), and
+code(finger). The code(finger) font can only display numbers.
+Note also that you must be careful when using code(\property) in
+Lyrics mode. Because of the way strings are parsed, either put quotes
+around the arguments to code(\property) or be sure to leave a space on
+both sides of the dot.
+ dit(code(textalignment))
+Controls alignment of lyrics.
+Set to -1 to align the left end of the lyric with
+the note; set to 1 to align the right end of the lyric with the note.
+Set to 0 to align the center of the lyric with the note.
+ )
+ dit(Voice properties)
+
+ description(
+ dit(code(ydirection)) Determines the direction of
+stems, subscripts, beams, slurs, and ties. Set to -1 to force them
+down, 1 to force them up, or 0 to let LilyPond decide. This can be
+used to distinguish between voices on the same staff. The
+code(\stemdown), code(\stemup), and code(\stemboth) identifiers set
+this property.
+ dit(code(slurydirection)) Set to 0 for free choice of slur
+direction, set to 1 to force slurs up, set to 0 to force slurs down.
+The shorthands code(\slurup), code(\slurdown), and code(\slurboth) are
+available.
+
+ dit(code(slurdash)) Set to 0 for normal slurs, 1 for dotted slurs,
+and a larger value for dashed slurs. Identifiers code(\slurnormal)
+ and code(\slurdotted) are predefined to set the first two settings.
+
+ dit(code(hshift)) Set to 1 to enable LilyPond to shift notes
+horizontally if they collide with other notes. This is useful when
+typesetting many voices on one staff. The identifier code(\shift) is
+defined to enable this.
+
+ dit(code(textalignment)) Controls alignment of superscripted and
+subscripted text. Set to -1 to align the left end of the text with
+the note; set to 1 to align the right end of the text with the note.
+Set to 0 to align the center of the text with the note.
+ dit(code(textstyle)) Set the text style for superscripts and
+subscripts. See above for list of text styles.
+
+ dit(code(fontsize)) Can be used to select smaller font sizes for music. The
+ normal font size is 0, and the two smaller sizes are -1 and -2.
+
+ dit(code(pletvisibility)) Determines whether tuplets of notes are
+ labelled. Setting to 0 shows nothing; setting to 1 shows a
+ number; setting to 2 shows a number and a bracket if there is no
+ beam; setting to 3 shows a number, and if there is no beam it
+ adds a bracket; setting to 4 shows both a number and a bracket
+ unconditionally.
)
+dit(Staff properties)
+
+ description(
+
+ dit(code(defaultclef)) Determines the default clef. See code(\clef)
+ keyword.
+
+ dit(code(nolines)) If set to 1, then the staff has only one line instead
+ of the usual five lines.
+
+ dit(code(barAlways)) If set to 1 a bar line is drawn after each note.
+
+ dit(code(defaultBarType)) Sets the default type of bar line. See
+ code(\bar) keyword.
+
+ dit(code(keyoctaviation)) If set to 1, then keys are the same in all
+ octaves. If set to 0 then the key signature for different octaves
+ can be different and is specified independently:
+ code(\keysignature bes fis'). The default value
+ is 1. Can be set to zero with code(\specialkey) or reset to 1 with
+ code(\normalkey).
+
+ dit(code(instrument) and code(instr)) If code(Staff_margin_engraver) is
+ added to the Staff translator, then the code(instrument) property is used to
+ label the first line of the staff and the code(instr) property is used to
+ label subsequent lines.
+COMMENT(Check that this works)
+
+ dit(code(midi_instrument)) Sets the instrument for MIDI output.
+
+ dit(code(transposing)) Tranpose the MIDI output.
+COMMENT(What syntax? "0 c" "2 c" ???)
+
+ dit(code(ydirection)) What does this do in staff ???
+)
+
+ dit(GrandStaff properties)
+
+ description(
+ dit(code(maxVerticalAlign))
+ dit(code(minVerticalAlign))
+ )
+
+ dit(Score properties)
+
+ description(
+ dit(code(part)) Set to a part number for music with several parts.
+ Each part has its own code(\score) block with a different part setting.
+ dit(code(SkipBars)) ???
+
+ dit(code(beamquantisation)) Set to 0 for no quantization. Set to 1 to
+ quantize position and slope. Set to 2 to avoid wedges. These three
+ settings are available via code(\beamposfree), code(\beamposnormal), and
+ code(\beampostraditional).
+
+ dit(code(beamslopedamping)) Set to 0 for undamped beams. Set to 1 for
+ damped beams. Set to 100000 for beams with zero slope. The identifiers
+ code(\beamslopeproportional), code(\beamslopedamped), and
+ code(\beamslopezero) each set the corresponding value.
+ )
+
+)
+
+
+COMMENT(
+
+Mystery properties:
+
+bar-column-engraver.cc: "barColumnPriority"
+bar-number-engraver.cc: "barNumberBreakPriority"
+bar-number-engraver.cc: "barScriptPadding"
+dynamic-engraver.cc: "dynamicdir"
+mark-engraver.cc: "markScriptPadding"
+mark-engraver.cc: "markBreakPriority"
+span-bar-engraver.cc: "singleStaffBracket"
+staff-margin-engraver.cc:"marginBreakPriority"
+stem-engraver.cc: "abbrev"
+)
+
+sec(Pre-defined Identifiers)
+
+Various identifiers are defined in the initialization files to
+provide shorthands for some settings.
+
+description(
+dit(code(\cr)) Start a crescendo.
+dit(code(\decr)) Start a decrescendo.
+dit(code(\f)) Print forte symbol on the preceeding note.
+dit(code(\ff)) Print fortissimo symbol on the preceeding note.
+dit(code(\fff)) Print fortississimo symbol on preceeding note.
+dit(code(\fp)) Print fortepiano symbol on preceeding note.
+dit(code(\mf)) Print mezzoforte symbol on preceeding note.
+dit(code(\mp)) Print mezzopiano symbol on preceeding note.
+dit(code(\normalkey)) Select normal key signatures where each octave
+has the same key signature. This sets the Staff.keyoctaviation property.
+dit(code(\p)) Print a piano symbol on preceeding note.
+dit(code(\pp)) Print pianissimo symbol on preceeding note.
+dit(code(\ppp)) Print pianississimo symbol on preceeding note.
+dit(code(\rc)) Terminate a crescendo.
+dit(code(\rced)) Terminate a decrescendo
+dit(code(\sf)) Print a ?? symbol on preceeding note.
+dit(code(\sfz)) Print a ?? symbol on preceeding note.
+dit(code(\shift)) Enable note heads that collide with other note heads
+to be shifted horiztonally. This sets the Voice.hshift property.
+dit(code(\slurboth)) Allow slurs to be above or below notes. This
+sets the Voice.slurydirection property.
+dit(code(\slurdown)) Force slurs to be below notes. This sets the
+Voice.slurydirection property.
+dit(code(\slurup)) Force slurs to be above notes. This sets the
+Voice.slurydirection property.
+dit(code(\specialkey)) Allow keys signatures do differ in different
+octaves. This sets the Staff.keyoctaviation property.
+dit(code(\stemboth)) Allow stems, beams, and slurs to point either
+direction. This sets the Voice.ydirection property.
+dit(code(\stemdown)) Force stems, beams, and slurs to point down.
+This sets the Voice.ydirection property.
+dit(code(\stemup)) Force stems, beams and slurs to point up. This
+sets the Voice.ydirectoin property.
+)
+
+
+sect(The code(\paper) Block)
+
+The code(\paper) block may begin with an optional identifier reference. No
+identifier references are allowed anywhere else in the block.
+The keywords code(\shape), code(\output) and code(\translator) may
+appear in this block. In addition, variable assignments may appear.
+The variables control layout details and are set to reasonable
+defaults that depend on the font size in use.
+
+subsect(Paper variables)
+
+description(
+ dit(var(integer)) If an integer appears on the left side of an
+assignment then a code(\symboltables) keyword must appear on the right
+side. This defines a font.
+
+dit(code(arithmetic_basicspace))
+dit(code(arithmetic_multiplier))
+dit(code(basicspace))
+dit(code(beam_thickness)) Specify the thickness of beams
+dit(code(geometric))
+dit(code(indent)) Sets the indentation of the first line of music.
+dit(code(interbeam))
+dit(code(interbeam4))
+dit(code(interline))
+dit(code(internote))
+dit(code(linewidth)) Sets the width of the lines. If it is set to
+-1, then a single unjustified line is produced.
+dit(code(notewidth))
+dit(code(rulethickness)) Determines thickness of staff lines and bars.
+dit(code(staffheight))
+dit(code(unitspace))
+)
AC_DEFUN(AC_STEPMAKE_YODL, [
if test "x$YODL" = "x"; then
+ AC_CHECK_PROGS(STRIPROFF, striproff, -echo no striproff)
AC_CHECK_PROGS(YODL, yodl, -echo no yodl)
AC_CHECK_PROGS(YODL2HTML, yodl2html, -echo no yodl)
AC_CHECK_PROGS(YODL2LATEX, yodl2latex, )
AC_CHECK_PROGS(YODL2TEXINFO, yodl2texinfo, -echo no yodl)
AC_CHECK_PROGS(YODL2TXT, yodl2txt, -echo no yodl)
else
+ AC_SUBST(STRIPROFF)
AC_SUBST(YODL)
AC_SUBST(YODL2HTML)
AC_SUBST(YODL2LATEX)
AC_SUBST(YODL2MSLESS)
AC_SUBST(YODL2TEXINFO)
AC_SUBST(YODL2TXT)
- export YODL YODL2HTML YODL2LATEX YODL2MAN YODL2MSLESS YODL2TEXINFO YODL2TXT
+ export STRIPROFF YODL YODL2HTML YODL2LATEX YODL2MAN YODL2MSLESS YODL2TEXINFO YODL2TXT
fi
if test "x$YODL" = "-echo no yodl"; then
AC_STEPMAKE_WARN(Did not find YODL (Yodl is Yet Oneother Document Language, see http://www.cs.uu.nl/~hanwen/yodl))
fi
])
+
# Configure paths for GTK+
# Owen Taylor 97-11-3
dnl Get the cflags and libraries from the gtk-config script
dnl
AC_PATH_PROG(GTK_CONFIG, gtk-config, no)
- min_gtk_version=ifelse([$1], ,0.99.7,$1)
+ min_gtk_version=ifelse([$1], ,1.1.1,$1)
AC_MSG_CHECKING(for GTK - version >= $min_gtk_version)
no_gtk=""
if test "$GTK_CONFIG" != "no" ; then
# Configure paths for GTK--
-# Jan Nieuwenhuizen 98-06-3
+# Erik Andersen 30 May 1998
+# Modified by Tero Pulkkinen (added the compiler checks... I hope they work..)
+
+dnl Test for GTK__, and define GTK___CFLAGS and GTK___LIBS
+dnl to be used as follows:
+dnl AM_PATH_GTKMM([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
+dnl
-dnl AM_PATH_GTK__([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
-dnl Test for GTK--, and define GTK___CFLAGS and GTK___LIBS
+dnl Get the cflags and libraries from the gtkmm-config script
dnl
-AC_DEFUN(AM_PATH_GTK__,
+AC_ARG_WITH(gtkmm-prefix,[ --with-gtkmm-prefix=PREFIX
+ Prefix where GTK-- is installed (optional)],
+ gtkmm_config_prefix="$withval", gtkmm_config_prefix="")
+AC_ARG_WITH(gtkmm-exec-prefix,[ --with-gtkmm-exec-prefix=PREFIX
+ Exec prefix where GTK-- is installed (optional)],
+ gtkmm_config_exec_prefix="$withval", gtkmm_config_exec_prefix="")
+AC_ARG_ENABLE(gtkmmtest, [ --disable-gtkmmtest Do not try to compile and run a test GTK-- program],
+ , enable_gtkmmtest=yes)
+
+ if test x$gtkmm_config_exec_prefix != x ; then
+ gtkmm_config_args="$gtkmm_config_args --exec-prefix=$gtkmm_config_exec_prefix"
+ if test x${GTKMM_CONFIG+set} != xset ; then
+ GTKMM_CONFIG=$gtkmm_config_exec_prefix/bin/gtkmm-config
+ fi
+ fi
+ if test x$gtkmm_config_prefix != x ; then
+ gtkmm_config_args="$gtkmm_config_args --prefix=$gtkmm_config_prefix"
+ if test x${GTKMM_CONFIG+set} != xset ; then
+ GTKMM_CONFIG=$gtkmm_config_prefix/bin/gtkmm-config
+ fi
+ fi
+
+
+AC_DEFUN(AM_PATH_GTKMM,
+[dnl
+
+dnl
+dnl Check check if the installed GTK-- is sufficiently new.
+dnl
+ AC_PATH_PROG(GTKMM_CONFIG, gtkmm-config, no)
+ min_gtkmm_version=ifelse([$1], ,0.9.14,$1)
+
+ AC_MSG_CHECKING(for GTK-- - version >= $min_gtkmm_version)
+ no_gtkmm=""
+ if test "$GTKMM_CONFIG" = "no" ; then
+ no_gtkmm=yes
+ else
+ AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
+
+ GTK___CFLAGS=`$GTKMM_CONFIG $gtkmm_config_args --cflags`
+ GTK___LIBS=`$GTKMM_CONFIG $gtkmm_config_args --libs`
+ gtkmm_config_major_version=`$GTKMM_CONFIG $gtkmm_config_args --version | \
+ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
+ gtkmm_config_minor_version=`$GTKMM_CONFIG $gtkmm_config_args --version | \
+ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
+ gtkmm_config_micro_version=`$GTKMM_CONFIG $gtkmm_config_args --version | \
+ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
+ if test "x$enable_gtkmmtest" = "xyes" ; then
+ ac_save_CXXFLAGS="$CXXFLAGS"
+ ac_save_LIBS="$LIBS"
+ CXXFLAGS="$CXXFLAGS $GTK___CFLAGS"
+ LIBS="$LIBS $GTK___LIBS"
+dnl
+dnl Now check if the installed GTK-- is sufficiently new. (Also sanity
+dnl checks the results of gtkmm-config to some extent
+dnl
+ rm -f conf.gtkmmtest
+ AC_TRY_RUN([
+#include <gtk--.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int
+main ()
+{
+ int major, minor, micro;
+ char *tmp_version;
+
+ system ("touch conf.gtkmmtest");
+
+ /* HP/UX 0 (%@#!) writes to sscanf strings */
+ tmp_version = g_strdup("$min_gtkmm_version");
+ if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, µ) != 3) {
+ printf("%s, bad version string\n", "$min_gtkmm_version");
+ exit(1);
+ }
+
+ if ((gtkmm_major_version != $gtkmm_config_major_version) ||
+ (gtkmm_minor_version != $gtkmm_config_minor_version) ||
+ (gtkmm_micro_version != $gtkmm_config_micro_version))
+ {
+ printf("\n*** 'gtkmm-config --version' returned %d.%d.%d, but GTK-- (%d.%d.%d)\n",
+ $gtkmm_config_major_version, $gtkmm_config_minor_version, $gtkmm_config_micro_version,
+ gtkmm_major_version, gtkmm_minor_version, gtkmm_micro_version);
+ printf ("*** was found! If gtkmm-config was correct, then it is best\n");
+ printf ("*** to remove the old version of GTK--. You may also be able to fix the error\n");
+ printf("*** by modifying your LD_LIBRARY_PATH enviroment variable, or by editing\n");
+ printf("*** /etc/ld.so.conf. Make sure you have run ldconfig if that is\n");
+ printf("*** required on your system.\n");
+ printf("*** If gtkmm-config was wrong, set the environment variable GTKMM_CONFIG\n");
+ printf("*** to point to the correct copy of gtkmm-config, and remove the file config.cache\n");
+ printf("*** before re-running configure\n");
+ }
+/* GTK-- does not have the GTKMM_*_VERSION constants */
+/*
+ else if ((gtkmm_major_version != GTKMM_MAJOR_VERSION) ||
+ (gtkmm_minor_version != GTKMM_MINOR_VERSION) ||
+ (gtkmm_micro_version != GTKMM_MICRO_VERSION))
+ {
+ printf("*** GTK-- header files (version %d.%d.%d) do not match\n",
+ GTKMM_MAJOR_VERSION, GTKMM_MINOR_VERSION, GTKMM_MICRO_VERSION);
+ printf("*** library (version %d.%d.%d)\n",
+ gtkmm_major_version, gtkmm_minor_version, gtkmm_micro_version);
+ }
+*/
+ else
+ {
+ if ((gtkmm_major_version > major) ||
+ ((gtkmm_major_version == major) && (gtkmm_minor_version > minor)) ||
+ ((gtkmm_major_version == major) && (gtkmm_minor_version == minor) && (gtkmm_micro_version >= micro)))
+ {
+ return 0;
+ }
+ else
+ {
+ printf("\n*** An old version of GTK-- (%d.%d.%d) was found.\n",
+ gtkmm_major_version, gtkmm_minor_version, gtkmm_micro_version);
+ printf("*** You need a version of GTK-- newer than %d.%d.%d. The latest version of\n",
+ major, minor, micro);
+ printf("*** GTK-- is always available from ftp://ftp.gtk.org.\n");
+ printf("***\n");
+ printf("*** If you have already installed a sufficiently new version, this error\n");
+ printf("*** probably means that the wrong copy of the gtkmm-config shell script is\n");
+ printf("*** being found. The easiest way to fix this is to remove the old version\n");
+ printf("*** of GTK--, but you can also set the GTKMM_CONFIG environment to point to the\n");
+ printf("*** correct copy of gtkmm-config. (In this case, you will have to\n");
+ printf("*** modify your LD_LIBRARY_PATH enviroment variable, or edit /etc/ld.so.conf\n");
+ printf("*** so that the correct libraries are found at run-time))\n");
+ }
+ }
+ return 1;
+}
+],, no_gtkmm=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ LIBS="$ac_save_LIBS"
+ fi
+ fi
+ if test "x$no_gtkmm" = x ; then
+ AC_MSG_RESULT(yes)
+ ifelse([$2], , :, [$2])
+ else
+ AC_MSG_RESULT(no)
+ if test "$GTKMM_CONFIG" = "no" ; then
+ echo "*** The gtkmm-config script installed by GTK-- could not be found"
+ echo "*** If GTK-- was installed in PREFIX, make sure PREFIX/bin is in"
+ echo "*** your path, or set the GTK_CONFIG environment variable to the"
+ echo "*** full path to gtk-config."
+ echo "*** The gtkmm-config script was not available in GTK-- versions"
+ echo "*** prior to 0.9.12. Perhaps you need to update your installed"
+ echo "*** version to 0.9.12 or later"
+ else
+ if test -f conf.gtkmmtest ; then
+ :
+ else
+ echo "*** Could not run GTK-- test program, checking why..."
+ CXXFLAGS="$CFLAGS $GTKMM_CXXFLAGS"
+ LIBS="$LIBS $GTK___LIBS"
+ AC_TRY_LINK([
+#include <gtk--.h>
+#include <stdio.h>
+], [ return ((gtkmm_major_version) || (gtkmm_minor_version) || (gtkmm_micro_version)); ],
+ [ echo "*** The test program compiled, but did not run. This usually means"
+ echo "*** that the run-time linker is not finding GTK-- or finding the wrong"
+ echo "*** version of GTK--. If it is not finding GTK--, you'll need to set your"
+ echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point"
+ echo "*** to the installed location Also, make sure you have run ldconfig if that"
+ echo "*** is required on your system"
+ echo "***"
+ echo "*** If you have an old version installed, it is best to remove it, although"
+ echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH" ],
+ [ echo "*** The test program failed to compile or link. See the file config.log for the"
+ echo "*** exact error that occured. This usually means GTK-- was incorrectly installed"
+ echo "*** or that you have moved GTK-- since it was installed. In the latter case, you"
+ echo "*** may want to edit the gtkmm-config script: $GTKMM_CONFIG" ])
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ LIBS="$ac_save_LIBS"
+ fi
+ fi
+ GTK___CFLAGS=""
+ GTK__LIBS=""
+ ifelse([$3], , :, [$3])
+ AC_LANG_RESTORE
+ fi
+ AC_SUBST(GTK___CFLAGS)
+ AC_SUBST(GTK___LIBS)
+ rm -f conf.gtkmmtest
+])
+
+# Configure paths for GTK--DRAW
+# Derek Quinn Wyatt 98-08-21 (adapted from Jan Nieuwenhuizen's code)
+
+dnl AM_PATH_GTK__DRAW([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
+dnl Test for GTK--DRAW, and define GTK___CFLAGS and GTK___LIBS
+dnl
+AC_DEFUN(AM_PATH_GTK__DRAW,
[dnl
dnl Get the cflags and libraries from the gtk__-config script
dnl
- min_gtk___version=ifelse([$1], ,0.9.4,$1)
- AC_MSG_CHECKING(for GTK-- - version >= $min_gtk___version)
+ AC_PATH_PROG(GTKMM_CONFIG, gtkmm-config, no)
+ min_gtk___version=ifelse([$1], ,0.0.5,$1)
+ AC_MSG_CHECKING(for GTK--DRAW - version >= $min_gtk___version)
no_gtk__=""
- if test "$GTK_CONFIG" != "no" ; then
- GTK___CFLAGS=`$GTK_CONFIG --cflags`
- GTK_LIBS=`$GTK_CONFIG --libs`
- GTK___LIBS="$GTK_LIBS -lgtkmm"
+ if test "$GTKMM_CONFIG" != "no" ; then
+ GTK___CFLAGS=`$GTKMM_CONFIG --cflags`
+ GTK___LIBS=`$GTKMM_CONFIG --libs`
+ GTK___DLIBS="$GTK___LIBS -lgtkmmdraw"
+ GTK___LIBS="$GTK___DLIBS"
ac_save_CFLAGS="$CFLAGS"
ac_save_LIBS="$LIBS"
ac_save_CXXFLAGS="$CXXFLAGS"
#! /bin/sh
+ac_help="$ac_help
+ --with-gtkmm-prefix=PREFIX
+ Prefix where GTK-- is installed (optional)"
+# Check whether --with-gtkmm-prefix or --without-gtkmm-prefix was given.
+if test "${with_gtkmm_prefix+set}" = set; then
+ withval="$with_gtkmm_prefix"
+ gtkmm_config_prefix="$withval"
+else
+ gtkmm_config_prefix=""
+fi
+
+ac_help="$ac_help
+ --with-gtkmm-exec-prefix=PREFIX
+ Exec prefix where GTK-- is installed (optional)"
+# Check whether --with-gtkmm-exec-prefix or --without-gtkmm-exec-prefix was given.
+if test "${with_gtkmm_exec_prefix+set}" = set; then
+ withval="$with_gtkmm_exec_prefix"
+ gtkmm_config_exec_prefix="$withval"
+else
+ gtkmm_config_exec_prefix=""
+fi
+
+ac_help="$ac_help
+ --disable-gtkmmtest Do not try to compile and run a test GTK-- program"
+# Check whether --enable-gtkmmtest or --disable-gtkmmtest was given.
+if test "${enable_gtkmmtest+set}" = set; then
+ enableval="$enable_gtkmmtest"
+ :
+else
+ enable_gtkmmtest=yes
+fi
+
+
+ if test x$gtkmm_config_exec_prefix != x ; then
+ gtkmm_config_args="$gtkmm_config_args --exec-prefix=$gtkmm_config_exec_prefix"
+ if test x${GTKMM_CONFIG+set} != xset ; then
+ GTKMM_CONFIG=$gtkmm_config_exec_prefix/bin/gtkmm-config
+ fi
+ fi
+ if test x$gtkmm_config_prefix != x ; then
+ gtkmm_config_args="$gtkmm_config_args --prefix=$gtkmm_config_prefix"
+ if test x${GTKMM_CONFIG+set} != xset ; then
+ GTKMM_CONFIG=$gtkmm_config_prefix/bin/gtkmm-config
+ fi
+ fi
+
+
+
+
+# Configure paths for GTK--DRAW
+# Derek Quinn Wyatt 98-08-21 (adapted from Jan Nieuwenhuizen's code)
+
+
+
# Guess values for system-dependent variables and create Makefiles.
# Generated automatically using autoconf version 2.12
# Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
fi
echo $ac_n "checking host system type""... $ac_c" 1>&6
-echo "configure:659: checking host system type" >&5
+echo "configure:713: checking host system type" >&5
host_alias=$host
case "$host_alias" in
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:684: checking for $ac_word" >&5
+echo "configure:738: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_MAKE'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:718: checking for $ac_word" >&5
+echo "configure:772: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_FIND'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:755: checking for $ac_word" >&5
+echo "configure:809: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_TAR'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:789: checking for $ac_word" >&5
+echo "configure:843: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_BASH'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "python", so it can be a program name with args.
set dummy python; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:822: checking for $ac_word" >&5
+echo "configure:876: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_PYTHON'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1038: checking for $ac_word" >&5
+echo "configure:1092: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1067: checking for $ac_word" >&5
+echo "configure:1121: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
fi
echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
-echo "configure:1115: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
+echo "configure:1169: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
ac_ext=c
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
cross_compiling=$ac_cv_prog_cc_cross
cat > conftest.$ac_ext <<EOF
-#line 1125 "configure"
+#line 1179 "configure"
#include "confdefs.h"
main(){return(0);}
EOF
-if { (eval echo configure:1129: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
+if { (eval echo configure:1183: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
ac_cv_prog_cc_works=yes
# If we can't run a trivial program, we are probably using a cross compiler.
if (./conftest; exit) 2>/dev/null; then
{ echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
fi
echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
-echo "configure:1149: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
+echo "configure:1203: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
cross_compiling=$ac_cv_prog_cc_cross
echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
-echo "configure:1154: checking whether we are using GNU C" >&5
+echo "configure:1208: checking whether we are using GNU C" >&5
if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
yes;
#endif
EOF
-if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1163: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1217: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
ac_cv_prog_gcc=yes
else
ac_cv_prog_gcc=no
ac_save_CFLAGS="$CFLAGS"
CFLAGS=
echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
-echo "configure:1178: checking whether ${CC-cc} accepts -g" >&5
+echo "configure:1232: checking whether ${CC-cc} accepts -g" >&5
if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
fi
echo $ac_n "checking how to run the C++ preprocessor""... $ac_c" 1>&6
-echo "configure:1235: checking how to run the C++ preprocessor" >&5
+echo "configure:1289: checking how to run the C++ preprocessor" >&5
if test -z "$CXXCPP"; then
if eval "test \"`echo '$''{'ac_cv_prog_CXXCPP'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
cross_compiling=$ac_cv_prog_cxx_cross
CXXCPP="${CXX-g++} -E"
cat > conftest.$ac_ext <<EOF
-#line 1248 "configure"
+#line 1302 "configure"
#include "confdefs.h"
#include <stdlib.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:1253: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:1307: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
:
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1284: checking for $ac_word" >&5
+echo "configure:1338: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CXX'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
echo $ac_n "checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works""... $ac_c" 1>&6
-echo "configure:1315: checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works" >&5
+echo "configure:1369: checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works" >&5
ac_ext=C
# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
cross_compiling=$ac_cv_prog_cxx_cross
cat > conftest.$ac_ext <<EOF
-#line 1325 "configure"
+#line 1379 "configure"
#include "confdefs.h"
main(){return(0);}
EOF
-if { (eval echo configure:1329: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
+if { (eval echo configure:1383: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
ac_cv_prog_cxx_works=yes
# If we can't run a trivial program, we are probably using a cross compiler.
if (./conftest; exit) 2>/dev/null; then
{ echo "configure: error: installation or configuration problem: C++ compiler cannot create executables." 1>&2; exit 1; }
fi
echo $ac_n "checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
-echo "configure:1349: checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) is a cross-compiler" >&5
+echo "configure:1403: checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) is a cross-compiler" >&5
echo "$ac_t""$ac_cv_prog_cxx_cross" 1>&6
cross_compiling=$ac_cv_prog_cxx_cross
echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6
-echo "configure:1354: checking whether we are using GNU C++" >&5
+echo "configure:1408: checking whether we are using GNU C++" >&5
if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
yes;
#endif
EOF
-if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1363: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1417: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
ac_cv_prog_gxx=yes
else
ac_cv_prog_gxx=no
ac_save_CXXFLAGS="$CXXFLAGS"
CXXFLAGS=
echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6
-echo "configure:1378: checking whether ${CXX-g++} accepts -g" >&5
+echo "configure:1432: checking whether ${CXX-g++} accepts -g" >&5
if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
ac_safe=`echo "FlexLexer.h" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for FlexLexer.h""... $ac_c" 1>&6
-echo "configure:1408: checking for FlexLexer.h" >&5
+echo "configure:1462: checking for FlexLexer.h" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 1413 "configure"
+#line 1467 "configure"
#include "confdefs.h"
#include <FlexLexer.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:1418: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:1472: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
rm -rf conftest*
echo $ac_n "checking whether explicit instantiation is needed""... $ac_c" 1>&6
-echo "configure:1468: checking whether explicit instantiation is needed" >&5
+echo "configure:1522: checking whether explicit instantiation is needed" >&5
if eval "test \"`echo '$''{'lily_cv_need_explicit_instantiation'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 1473 "configure"
+#line 1527 "configure"
#include "confdefs.h"
template <class T> struct foo { static int baz; };
return foo<int>::baz;
; return 0; }
EOF
-if { (eval echo configure:1483: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
+if { (eval echo configure:1537: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
rm -rf conftest*
lily_cv_need_explicit_instantiation=no
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1510: checking for $ac_word" >&5
+echo "configure:1564: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_YACC'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1552: checking for $ac_word" >&5
+echo "configure:1606: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_BISON'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1586: checking for $ac_word" >&5
+echo "configure:1640: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_FLEX'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1653: checking for $ac_word" >&5
+echo "configure:1707: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "ranlib", so it can be a program name with args.
set dummy ranlib; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1685: checking for $ac_word" >&5
+echo "configure:1739: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
echo $ac_n "checking language""... $ac_c" 1>&6
-echo "configure:1740: checking language" >&5
+echo "configure:1794: checking language" >&5
case "$language" in
En* | en* | Am* | am* | US* | us*)
lang=English;;
echo $ac_n "checking for gettext in -lintl""... $ac_c" 1>&6
-echo "configure:1776: checking for gettext in -lintl" >&5
+echo "configure:1830: checking for gettext in -lintl" >&5
ac_lib_var=`echo intl'_'gettext | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
ac_save_LIBS="$LIBS"
LIBS="-lintl $LIBS"
cat > conftest.$ac_ext <<EOF
-#line 1784 "configure"
+#line 1838 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error. */
#ifdef __cplusplus
gettext()
; return 0; }
EOF
-if { (eval echo configure:1798: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
+if { (eval echo configure:1852: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
rm -rf conftest*
eval "ac_cv_lib_$ac_lib_var=yes"
else
for ac_func in gettext
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:1828: checking for $ac_func" >&5
+echo "configure:1882: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 1833 "configure"
+#line 1887 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:1859: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
+if { (eval echo configure:1913: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1891: checking for $ac_word" >&5
+echo "configure:1945: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_MSGFMT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
test -n "$MSGFMT" || MSGFMT="\$(SHELL) \$(step-bindir)/fake-msgfmt.sh "
echo $ac_n "checking whether msgfmt accepts -o""... $ac_c" 1>&6
-echo "configure:1921: checking whether msgfmt accepts -o" >&5
+echo "configure:1975: checking whether msgfmt accepts -o" >&5
msgfmt_output="`msgfmt -o bla 2>&1 | grep usage`"
if test "$msgfmt_output" = ""; then
echo "$ac_t""yes" 1>&6
echo $ac_n "checking TeX/MF root dir directory""... $ac_c" 1>&6
-echo "configure:1974: checking TeX/MF root dir directory" >&5
+echo "configure:2028: checking TeX/MF root dir directory" >&5
find_root_prefix="$prefix"
echo $ac_n "checking MF input directory""... $ac_c" 1>&6
-echo "configure:2015: checking MF input directory" >&5
+echo "configure:2069: checking MF input directory" >&5
find_dirdir=`(cd $find_texprefix;
$FIND ./ -type d -a -name source -print |sort|head -1|sed 's#^\./##')`
echo $ac_n "checking TeX input directory""... $ac_c" 1>&6
-echo "configure:2040: checking TeX input directory" >&5
+echo "configure:2094: checking TeX input directory" >&5
find_dirdir=`(cd $find_texprefix;
$FIND ./ -type d -a -name tex -print |sort|head -1|sed 's#^\./##')`
if test "x$YODL" = "x"; then
+ for ac_prog in striproff
+do
+# Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:2125: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_STRIPROFF'+set}'`\" = set"; then
+ echo $ac_n "(cached) $ac_c" 1>&6
+else
+ if test -n "$STRIPROFF"; then
+ ac_cv_prog_STRIPROFF="$STRIPROFF" # Let the user override the test.
+else
+ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
+ for ac_dir in $PATH; do
+ test -z "$ac_dir" && ac_dir=.
+ if test -f $ac_dir/$ac_word; then
+ ac_cv_prog_STRIPROFF="$ac_prog"
+ break
+ fi
+ done
+ IFS="$ac_save_ifs"
+fi
+fi
+STRIPROFF="$ac_cv_prog_STRIPROFF"
+if test -n "$STRIPROFF"; then
+ echo "$ac_t""$STRIPROFF" 1>&6
+else
+ echo "$ac_t""no" 1>&6
+fi
+
+test -n "$STRIPROFF" && break
+done
+test -n "$STRIPROFF" || STRIPROFF="-echo no striproff"
+
for ac_prog in yodl
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2071: checking for $ac_word" >&5
+echo "configure:2159: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_YODL'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2105: checking for $ac_word" >&5
+echo "configure:2193: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_YODL2HTML'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2139: checking for $ac_word" >&5
+echo "configure:2227: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_YODL2LATEX'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2172: checking for $ac_word" >&5
+echo "configure:2260: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_YODL2MAN'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2206: checking for $ac_word" >&5
+echo "configure:2294: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_YODL2MSLESS'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2240: checking for $ac_word" >&5
+echo "configure:2328: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_YODL2TEXINFO'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2274: checking for $ac_word" >&5
+echo "configure:2362: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_YODL2TXT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
- export YODL YODL2HTML YODL2LATEX YODL2MAN YODL2MSLESS YODL2TEXINFO YODL2TXT
+
+ export STRIPROFF YODL YODL2HTML YODL2LATEX YODL2MAN YODL2MSLESS YODL2TEXINFO YODL2TXT
fi
if test "x$YODL" = "-echo no yodl"; then
echo $ac_n "checking for 8-bit clean memcmp""... $ac_c" 1>&6
-echo "configure:2333: checking for 8-bit clean memcmp" >&5
+echo "configure:2422: checking for 8-bit clean memcmp" >&5
if eval "test \"`echo '$''{'ac_cv_func_memcmp_clean'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
ac_cv_func_memcmp_clean=no
else
cat > conftest.$ac_ext <<EOF
-#line 2341 "configure"
+#line 2430 "configure"
#include "confdefs.h"
#ifdef __cplusplus
extern "C" void exit(int);
}
EOF
-if { (eval echo configure:2354: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:2443: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit) 2>/dev/null
then
ac_cv_func_memcmp_clean=yes
else
test $ac_cv_func_memcmp_clean = no && LIBOBJS="$LIBOBJS memcmp.o"
echo $ac_n "checking for vprintf""... $ac_c" 1>&6
-echo "configure:2372: checking for vprintf" >&5
+echo "configure:2461: checking for vprintf" >&5
if eval "test \"`echo '$''{'ac_cv_func_vprintf'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 2377 "configure"
+#line 2466 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char vprintf(); below. */
; return 0; }
EOF
-if { (eval echo configure:2403: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
+if { (eval echo configure:2492: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
rm -rf conftest*
eval "ac_cv_func_vprintf=yes"
else
if test "$ac_cv_func_vprintf" != yes; then
echo $ac_n "checking for _doprnt""... $ac_c" 1>&6
-echo "configure:2427: checking for _doprnt" >&5
+echo "configure:2516: checking for _doprnt" >&5
if eval "test \"`echo '$''{'ac_cv_func__doprnt'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 2432 "configure"
+#line 2521 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char _doprnt(); below. */
; return 0; }
EOF
-if { (eval echo configure:2458: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
+if { (eval echo configure:2547: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
rm -rf conftest*
eval "ac_cv_func__doprnt=yes"
else
for ac_func in memmem snprintf vsnprintf gettext
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:2485: checking for $ac_func" >&5
+echo "configure:2574: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 2490 "configure"
+#line 2579 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:2516: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
+if { (eval echo configure:2605: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2555: checking for $ac_word" >&5
+echo "configure:2644: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_MAKEINFO'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
s%@TEXPREFIX@%$TEXPREFIX%g
s%@TEXDIR@%$TEXDIR%g
s%@MFDIR@%$MFDIR%g
+s%@STRIPROFF@%$STRIPROFF%g
s%@YODL@%$YODL%g
s%@YODL2HTML@%$YODL2HTML%g
s%@YODL2LATEX@%$YODL2LATEX%g
projects / lilypond.git / commitdiff