* scm/markup.scm (define-markup-command): change

def-markup-command to define-markup-command

* scm/music-functions.scm (define-music-function): change
def-music-function to define-music-function.

* python/convertrules.py (conv): rules for def-music-function
and def-markup-commands

* Documentation/user/programming-interface.itely,
input/no-notation/display-lily-tests.ly,
input/regression/lily-in-scheme.ly,
input/regression/markup-user.ly,
input/regression/music-function.ly, input/regression/tie-chord.ly,
scm/fret-diagrams.scm, ly/music-functions-init.ly,
ly/gregorian-init.ly: use new macro names (define-music-function,
define-markup-command).

diff --git a/ChangeLog b/ChangeLog
index 447ed2037e393a366e5690505c203d26277c9fe5..4cc2cbaad77f76f9a807031fed136fe155e5e6e1 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,23 @@
+2006-02-25  Nicolas Sceaux  <nicolas.sceaux@free.fr>
+
+       * scm/markup.scm (define-markup-command): change
+       def-markup-command to define-markup-command
+
+       * scm/music-functions.scm (define-music-function): change
+       def-music-function to define-music-function.
+
+       * python/convertrules.py (conv): rules for def-music-function
+       and def-markup-commands
+
+       * Documentation/user/programming-interface.itely,
+       input/no-notation/display-lily-tests.ly,
+       input/regression/lily-in-scheme.ly,
+       input/regression/markup-user.ly,
+       input/regression/music-function.ly, input/regression/tie-chord.ly,
+       scm/fret-diagrams.scm, ly/music-functions-init.ly,
+       ly/gregorian-init.ly: use new macro names (define-music-function,
+       define-markup-command).
+
 2006-02-25  Han-Wen Nienhuys  <hanwen@xs4all.nl>
 
        * scripts/lilypond-book.py (main): write Makefile dependencies file. 

diff --git a/Documentation/user/programming-interface.itely b/Documentation/user/programming-interface.itely
index d51464bb9bcb6c6ac74655f09bf4ecc8da8a81ca..8c45e57d26c38827d5e2e9d487252b0eabb3558f 100644 (file)
--- a/Documentation/user/programming-interface.itely
+++ b/Documentation/user/programming-interface.itely
@@ -215,12 +215,12 @@ applyMusic = #(ly:make-music-function
                   (func music)))
 @end example
 
-A @code{def-music-function} macro is introduced on top of
+A @code{define-music-function} macro is introduced on top of
 @code{ly:make-music-function} to ease the definition of music
 functions:
 
 @example
-applyMusic = #(def-music-function (parser location func music)
+applyMusic = #(define-music-function (parser location func music)
                 (procedure? ly:music?)
                 (func music))
 @end example
@@ -440,7 +440,7 @@ This function may also be defined as a music function:
 
 @lilypond[quote,verbatim,ragged-right]
 withPadding =
-  #(def-music-function (parser location padding music) (number? ly:music?)
+  #(define-music-function (parser location padding music) (number? ly:music?)
     #{ \override TextScript #'padding = #$padding
        $music 
        \revert TextScript #'padding #})
@@ -568,9 +568,9 @@ of this section, and in @file{scm/@/define@/-markup@/-commands@/.scm}.
 @subsection Markup command definition
 
 New markup commands can be defined
-with the @code{def-markup-command} scheme macro.
+with the @code{define-markup-command} scheme macro.
 @lisp
-(def-markup-command (@var{command-name} @var{layout} @var{props} @var{arg1} @var{arg2} ...)
+(define-markup-command (@var{command-name} @var{layout} @var{props} @var{arg1} @var{arg2} ...)
             (@var{arg1-type?} @var{arg2-type?} ...)
   ..command body..)
 @end lisp
@@ -600,11 +600,11 @@ This selects the caps font by setting the @code{font-shape} property to
 @code{#'caps} for interpreting @code{Text-in-caps}.
 
 To make the above available as @code{\smallcaps} command, we have to
-define a function using @code{def-markup-command}.  The command should
+define a function using @code{define-markup-command}.  The command should
 take a single argument, of type markup.  Therefore, the start of the
 definition should read
 @example
-(def-markup-command (smallcaps layout props argument) (markup?)
+(define-markup-command (smallcaps layout props argument) (markup?)
 @end example
 
 @noindent
@@ -638,7 +638,7 @@ that takes into account the necessary translation, and uses the newly
 defined @code{\smallcaps} command:
 
 @example
-#(def-markup-command (character layout props name) (string?)
+#(define-markup-command (character layout props name) (string?)
   "Print the character name in small caps, translated to the left and
   top.  Syntax: \\character #\"name\""
   (interpret-markup layout props 
@@ -663,7 +663,7 @@ The final result is as follows:
 @end example
 
 @lilypond[quote,ragged-right]
-#(def-markup-command (smallcaps layout props str) (string?)
+#(define-markup-command (smallcaps layout props str) (string?)
   "Print the string argument in small caps.  Syntax: \\smallcaps #\"string\""
   (interpret-markup layout props
    (make-line-markup
@@ -675,7 +675,7 @@ The final result is as follows:
                       #:tiny (string-upcase (substring s 1)))))
          (string-split str #\Space)))))
 
-#(def-markup-command (character layout props name) (string?)
+#(define-markup-command (character layout props name) (string?)
   "Print the character name in small caps, translated to the left and
   top.  Syntax: \\character #\"name\""
   (interpret-markup layout props 
@@ -693,7 +693,7 @@ the small caps font by setting a string in upcase with the first
 letter a little larger:
 
 @example
-#(def-markup-command (smallcaps layout props str) (string?)
+#(define-markup-command (smallcaps layout props str) (string?)
   "Print the string argument in small caps."
   (interpret-markup layout props
    (make-line-markup

diff --git a/input/no-notation/display-lily-tests.ly b/input/no-notation/display-lily-tests.ly
index 136a87aa88701c7264ed9bc2c525cc86568b8b67..41943b9ea1255dcdf0453c66bb34f568b9cd3e12 100644 (file)
--- a/input/no-notation/display-lily-tests.ly
+++ b/input/no-notation/display-lily-tests.ly
@@ -1,4 +1,4 @@
-\version "2.7.6"
+\version "2.7.36"
 
 #(use-modules (srfi srfi-13)
               (ice-9 format))
@@ -34,7 +34,7 @@
 #(define (lily-string->markup str)
    (make-column-markup (string-split str #\NewLine)))
 
-test = #(def-music-function (parser location result-info strings) (string? pair?)
+test = #(define-music-function (parser location result-info strings) (string? pair?)
          (display-lily-init parser)
           (let ((input (car strings))
                 (output (cdr strings)))

diff --git a/input/regression/lily-in-scheme.ly b/input/regression/lily-in-scheme.ly
index b011204d128b3421e1b202b633c70954e95fcac7..f9a4fe3c7cb96ab0585c9363486fd0d92c2c7975 100644 (file)
--- a/input/regression/lily-in-scheme.ly
+++ b/input/regression/lily-in-scheme.ly
@@ -12,20 +12,20 @@ the @code{TextScript} grob.
           
       }
 
-\version "2.7.32"
+\version "2.7.36"
 \layout { ragged-right = ##t }
 
-withPaddingA = #(def-music-function (parser location padding music) (number? ly:music?)
+withPaddingA = #(define-music-function (parser location padding music) (number? ly:music?)
                 #{ \override TextScript #'padding = #$padding
                 $music 
                 \revert TextScript #'padding #})
 
-withPaddingB = #(def-music-function (parser location padding music) (number? ly:music?)
+withPaddingB = #(define-music-function (parser location padding music) (number? ly:music?)
                 #{ \override TextScript #'padding = #$(* padding 2)
                 $music 
                 \revert TextScript #'padding #})
 
-withPaddingC = #(def-music-function (parser location padding music) (number? ly:music?)
+withPaddingC = #(define-music-function (parser location padding music) (number? ly:music?)
                 #{ \override TextScript #'padding = #(+ 1 $(* padding 2))
                    $music 
                    \revert TextScript #'padding #})

diff --git a/input/regression/markup-user.ly b/input/regression/markup-user.ly
index 586e7cb0c1123b8ea4bbebcb55da3b12f254079a..6b5c2b41d5199924a1ac53cbe53219dd894350cf 100644 (file)
--- a/input/regression/markup-user.ly
+++ b/input/regression/markup-user.ly
@@ -2,7 +2,7 @@
 \header {
 
   texidoc = "Own markup commands may be defined by using the
-    @code{def-markup-command} scheme macro."
+    @code{define-markup-command} scheme macro."
 
 
 }
@@ -12,9 +12,9 @@
   
 
 
-\version "2.7.32" % to be updated
+\version "2.7.36"
 
-#(def-markup-command (upcase paper props str) (string?)
+#(define-markup-command (upcase paper props str) (string?)
   "Upcase the string characters. Syntax: \\upcase #\"string\""
   (interpret-markup paper props (make-simple-markup (string-upcase str))))
 

diff --git a/input/regression/music-function.ly b/input/regression/music-function.ly
index 680a9162eabe9913f151c2f35fff9f0e82828c0b..99464d5bb2650c8bd7a7216ac98a0fb18e4d015e 100644 (file)
--- a/input/regression/music-function.ly
+++ b/input/regression/music-function.ly
@@ -7,9 +7,9 @@ demonstrate a @code{\myBar} function, which works similar to
 @code{\bar}, but is implemented completely in Scheme."
 
 }
-\version "2.7.32"
+\version "2.7.36"
 
-myBar = #(def-music-function (parser location bar-type) (string?)
+myBar = #(define-music-function (parser location bar-type) (string?)
           (context-spec-music
            (context-spec-music (make-property-set 'whichBar bar-type) 'Timing)
            'Score))
@@ -17,6 +17,6 @@ myBar = #(def-music-function (parser location bar-type) (string?)
 \layout { ragged-right = ##t }
 
 {
-    d4 \myBar #"|:" d4
+    d4 \myBar "|:" d4
 }
 

diff --git a/input/regression/tie-chord.ly b/input/regression/tie-chord.ly
index 6ca08201cc3e96d0690ac5854b82ea7c6b4fba4e..1b48651a9ffa4f368b22e25213436bc727f49854 100644 (file)
--- a/input/regression/tie-chord.ly
+++ b/input/regression/tie-chord.ly
@@ -13,7 +13,7 @@ each system.  "
 
 }
 
-\version "2.7.32"
+\version "2.7.36"
 
 \paper {
   indent = #0.0
@@ -23,7 +23,7 @@ each system.  "
 
 
 generateTiePattern
-= #(def-music-function (parser location is-long chords) (boolean? ly:music?)
+= #(define-music-function (parser location is-long chords) (boolean? ly:music?)
 
     "
 

diff --git a/ly/gregorian-init.ly b/ly/gregorian-init.ly
index 5b580ae510e1a842e8eed4fff3cc6adda9b3cede..d8e7dcfc23ab1a8a189b65208baddfee205c10b9 100644 (file)
--- a/ly/gregorian-init.ly
+++ b/ly/gregorian-init.ly
@@ -119,7 +119,7 @@ episemFinis = #(make-span-event 'TextSpanEvent STOP)
                                       'elements (list
                                                  (make-span-event 'LigatureEvent STOP)))))))
 
-ligature = #(def-music-function
+ligature = #(define-music-function
              (location music) (ly:music?)
              (make-ligature music))
 
@@ -144,7 +144,7 @@ ligature = #(def-music-function
 % % \[ \virga x \inclinatum y \inclinatum z ... \]
 %
 %#(defmacro def-climacus-function (start stop)
-%  `(def-music-function (location music) (ly:music?)
+%  `(define-music-function (location music) (ly:music?)
 %     (make-music 'SequentialMusic
 %        'elements (list 'LigatureStartEvent
 %                      (ly:music-deep-copy ,start)

diff --git a/ly/music-functions-init.ly b/ly/music-functions-init.ly
index 50b87caf21854b3ccc33444bba105121b995e31c..8079d42e80e805013543da0037d390b724800494 100644 (file)
--- a/ly/music-functions-init.ly
+++ b/ly/music-functions-init.ly
@@ -7,7 +7,7 @@
 #(use-modules (srfi srfi-1))  
 
 
-tweak = #(def-music-function (parser location sym val arg)
+tweak = #(define-music-function (parser location sym val arg)
           (symbol? scheme? ly:music?)
 
           "Add @code{sym . val} to the @code{tweaks} property of @var{arg}."
@@ -19,7 +19,7 @@ tweak = #(def-music-function (parser location sym val arg)
                   (ly:music-property arg 'tweaks)))
           arg)
 
-tag = #(def-music-function (parser location tag arg)
+tag = #(define-music-function (parser location tag arg)
    (symbol? ly:music?)
 
    "Add @var{tag} to the @code{tags} property of @var{arg}."
@@ -31,7 +31,7 @@ tag = #(def-music-function (parser location tag arg)
    arg)
 
 clef =
-#(def-music-function (parser location type)
+#(define-music-function (parser location type)
    (string?)
    
    "Set the current clef."
@@ -39,18 +39,18 @@ clef =
    (make-clef-set type))
 
 bar =
-#(def-music-function (parser location type)
+#(define-music-function (parser location type)
    (string?)
    (context-spec-music
     (make-property-set 'whichBar type)
     'Timing))
 
 applyMusic =
-#(def-music-function (parser location func music) (procedure? ly:music?)
+#(define-music-function (parser location func music) (procedure? ly:music?)
                (func music))
 
 oldaddlyrics =
-#(def-music-function (parser location music lyrics) (ly:music? ly:music?)
+#(define-music-function (parser location music lyrics) (ly:music? ly:music?)
 
               (make-music 'OldLyricCombineMusic 
                           'origin location
@@ -65,25 +65,25 @@ appoggiatura =
 #(def-grace-function startAppoggiaturaMusic stopAppoggiaturaMusic)
 
 partcombine =
-#(def-music-function (parser location part1 part2) (ly:music? ly:music?)
+#(define-music-function (parser location part1 part2) (ly:music? ly:music?)
                 (make-part-combine-music (list part1 part2)))
 
 autochange =
-#(def-music-function (parser location music) (ly:music?)
+#(define-music-function (parser location music) (ly:music?)
                (make-autochange-music music))
 
 applyContext =
-#(def-music-function (parser location proc) (procedure?)
+#(define-music-function (parser location proc) (procedure?)
                  (make-music 'ApplyContext 
                    'origin location
                    'procedure proc))
 
 musicMap =
-#(def-music-function (parser location proc mus) (procedure? ly:music?)
+#(define-music-function (parser location proc mus) (procedure? ly:music?)
             (music-map proc mus))
 
 displayMusic =
-#(def-music-function (parser location music) (ly:music?)
+#(define-music-function (parser location music) (ly:music?)
                 (display-scheme-music music)
                 music)
 
@@ -93,18 +93,18 @@ displayMusic =
 #(use-modules (scm display-lily))
 #(display-lily-init parser)
 displayLilyMusic =
-#(def-music-function (parser location music) (ly:music?)
+#(define-music-function (parser location music) (ly:music?)
    (display-lily-music music)
    music)
 
 applyOutput =
-#(def-music-function (parser location proc) (procedure?)
+#(define-music-function (parser location proc) (procedure?)
                 (make-music 'ApplyOutputEvent 
                   'origin location
                   'procedure proc))
 
 overrideProperty =
-#(def-music-function (parser location name property value)
+#(define-music-function (parser location name property value)
    (string? symbol? scheme?)
 
 
@@ -137,29 +137,29 @@ or @code{\"GrobName\"}"
       context-name)))
 
 breathe =
-#(def-music-function (parser location) ()
+#(define-music-function (parser location) ()
             (make-music 'EventChord 
               'origin location
               'elements (list (make-music 'BreathingSignEvent))))
 
 
 unfoldRepeats =
-#(def-music-function (parser location music) (ly:music?)
+#(define-music-function (parser location music) (ly:music?)
                  (unfold-repeats music))
 
 compressMusic =
-#(def-music-function
+#(define-music-function
                  (parser location fraction music) (number-pair? ly:music?)
                  (ly:music-compress music (ly:make-moment (car fraction) (cdr fraction))))
 
 makeClusters =
-#(def-music-function
+#(define-music-function
                (parser location arg) (ly:music?)
                (music-map note-to-cluster arg))
 
 
 removeWithTag = 
-#(def-music-function
+#(define-music-function
   (parser location tag music) (symbol? ly:music?)
   (music-filter
    (lambda (m)
@@ -169,7 +169,7 @@ removeWithTag =
  music))
              
 keepWithTag =
-#(def-music-function
+#(define-music-function
   (parser location tag music) (symbol? ly:music?)
   (music-filter
    (lambda (m)
@@ -183,10 +183,10 @@ keepWithTag =
 
 %% Todo:
 %% doing
-%% def-music-function in a .scm causes crash.
+%% define-music-function in a .scm causes crash.
 
 cueDuring = 
-#(def-music-function
+#(define-music-function
   (parser location what dir main-music)
   (string? ly:dir? ly:music?)
   (make-music 'QuoteMusic
@@ -199,7 +199,7 @@ cueDuring =
 
 
 quoteDuring = #
-(def-music-function
+(define-music-function
   (parser location what main-music)
   (string? ly:music?)
   (make-music 'QuoteMusic
@@ -210,7 +210,7 @@ quoteDuring = #
 
 
 pitchedTrill =
-#(def-music-function
+#(define-music-function
    (parser location main-note secondary-note)
    (ly:music? ly:music?)
    (let*
@@ -237,7 +237,7 @@ pitchedTrill =
      main-note))
 
 killCues =
-#(def-music-function
+#(define-music-function
    (parser location music)
    (ly:music?)
    (music-map
@@ -251,7 +251,7 @@ afterGraceFraction =
 #(cons 6 8)
 
 afterGrace =
-#(def-music-function
+#(define-music-function
   (parser location main grace)
   (ly:music? ly:music?)
 
@@ -277,7 +277,7 @@ afterGrace =
 
 
 barNumberCheck =
-#(def-music-function (parser location n) (integer?)
+#(define-music-function (parser location n) (integer?)
    (make-music 'ApplyContext 
               'origin location
               'procedure 
@@ -292,7 +292,7 @@ barNumberCheck =
 
 % for regression testing purposes.
 assertBeamQuant =
-#(def-music-function (parser location l r) (pair? pair?)
+#(define-music-function (parser location l r) (pair? pair?)
   (make-grob-property-override 'Beam 'positions
    (ly:make-simple-closure
     (ly:make-simple-closure
@@ -302,7 +302,7 @@ assertBeamQuant =
     
 % for regression testing purposes.
 assertBeamSlope =
-#(def-music-function (parser location comp) (procedure?)
+#(define-music-function (parser location comp) (procedure?)
   (make-grob-property-override 'Beam 'positions
    (ly:make-simple-closure
     (ly:make-simple-closure
@@ -312,7 +312,7 @@ assertBeamSlope =
 
 
 parallelMusic =
-#(def-music-function (parser location voice-ids music) (list? ly:music?)
+#(define-music-function (parser location voice-ids music) (list? ly:music?)
   "Define parallel music sequences, separated by '|' (bar check signs),
 and assign them to the identifiers provided in @var{voice-ids}.
 
@@ -404,11 +404,11 @@ Example:
 
 %% this is a stub. Write your own to suit the spacing tweak output.
 spacingTweaks =
-#(def-music-function (parser location parameters) (list?)
+#(define-music-function (parser location parameters) (list?)
    (make-music 'SequentialMusic 'void #t))
 
 octave =
-#(def-music-function (parser location pitch-note) (ly:music?)
+#(define-music-function (parser location pitch-note) (ly:music?)
    "octave check"
 
    (make-music 'RelativeOctaveCheck
@@ -417,14 +417,14 @@ octave =
               ))
 
 addquote =
-#(def-music-function (parser location name music) (string? ly:music?)
+#(define-music-function (parser location name music) (string? ly:music?)
    "Add a piece of music to be quoted "
    (add-quotable name music)
    (make-music 'SequentialMusic 'void #t))
 
    
 parenthesize =
-#(def-music-function (parser loc arg) (ly:music?)
+#(define-music-function (parser loc arg) (ly:music?)
    "Tag @var{arg} to be parenthesized."
 
    (set! (ly:music-property arg 'parenthesize) #t)

diff --git a/python/convertrules.py b/python/convertrules.py
index 3d89f22f609f0bf22040814ba1026087957a7406..0e43d001fb37afb39f54fc0d8945a76109d25e13 100644 (file)
--- a/python/convertrules.py
+++ b/python/convertrules.py
@@ -2747,3 +2747,12 @@ def conv (str):
 
 conversions.append (((2, 7, 32), conv,
                     """debug-beam-quanting -> debug-beam-scoring"""))
+
+
+def conv (str):
+       str = re.sub ('def-music-function', 'define-music-function', str)
+       str = re.sub ('def-markup-command', 'define-markup-command', str)
+       return str
+
+conversions.append (((2, 7, 36), conv,
+                   """def-(music-function|markup-command) -> define-(music-function|markup-command)"""))

diff --git a/scm/define-markup-commands.scm b/scm/define-markup-commands.scm
index 7712177700731ab7a8a319452602c7881f3dac3f..3b84ff6b1749a50d707c85be29f791bfce3ed3af 100644 (file)
--- a/scm/define-markup-commands.scm
+++ b/scm/define-markup-commands.scm
@@ -24,13 +24,13 @@
 ;; geometric shapes
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(def-markup-command (draw-circle layout props radius thickness fill)
+(define-markup-command (draw-circle layout props radius thickness fill)
   (number? number? boolean?)
   "A circle of radius @var{radius}, thickness @var{thickness} and
 optionally filled."
   (make-circle-stencil radius thickness fill))
 
-(def-markup-command (triangle layout props filled) (boolean?)
+(define-markup-command (triangle layout props filled) (boolean?)
   "A triangle, filled or not"
   (let*
       ((th (chain-assoc-get 'thickness props  0.1))
@@ -51,7 +51,7 @@ optionally filled."
      (cons 0 (* .86 ex))
      )))
 
-(def-markup-command (circle layout props arg) (markup?)
+(define-markup-command (circle layout props arg) (markup?)
   "Draw a circle around @var{arg}.  Use @code{thickness},
 @code{circle-padding} and @code{font-size} properties to determine line
 thickness and padding around the markup."
@@ -63,7 +63,7 @@ thickness and padding around the markup."
         (m (interpret-markup layout props arg)))
     (circle-stencil m th pad)))
 
-(def-markup-command (with-url layout props url arg) (string? markup?)
+(define-markup-command (with-url layout props url arg) (string? markup?)
   "Add a link to URL @var{url} around @var{arg}. This only works in
 the PDF backend."
   (let* ((stil (interpret-markup layout props arg))
@@ -74,7 +74,7 @@ the PDF backend."
     (ly:stencil-add (ly:make-stencil url-expr xextent yextent) stil)))
 
 
-(def-markup-command (beam layout props width slope thickness)
+(define-markup-command (beam layout props width slope thickness)
   (number? number? number?)
   "Create a beam with the specified parameters."
   (let* ((y (* slope width))
@@ -93,7 +93,7 @@ the PDF backend."
      (cons (+ (- half) (car yext))
           (+ half (cdr yext))))))
 
-(def-markup-command (box layout props arg) (markup?)
+(define-markup-command (box layout props arg) (markup?)
   "Draw a box round @var{arg}.  Looks at @code{thickness},
 @code{box-padding} and @code{font-size} properties to determine line
 thickness and padding around the markup."
@@ -105,7 +105,7 @@ thickness and padding around the markup."
         (m (interpret-markup layout props arg)))
     (box-stencil m th pad)))
 
-(def-markup-command (filled-box layout props xext yext blot)
+(define-markup-command (filled-box layout props xext yext blot)
   (number-pair? number-pair? number?)
   "Draw a box with rounded corners of dimensions @var{xext} and
 @var{yext}.  For example,
@@ -118,7 +118,7 @@ circle of diameter 0 (ie sharp corners)."
   (ly:round-filled-box
    xext yext blot))
 
-(def-markup-command (whiteout layout props arg) (markup?)
+(define-markup-command (whiteout layout props arg) (markup?)
   "Provide a white underground for @var{arg}"
   (let* ((stil (interpret-markup layout props
                                 (make-with-color-markup black arg)))
@@ -133,7 +133,7 @@ circle of diameter 0 (ie sharp corners)."
 
     (ly:stencil-add white stil)))
 
-(def-markup-command (pad-markup layout props padding arg) (number? markup?)
+(define-markup-command (pad-markup layout props padding arg) (number? markup?)
   "Add space around a markup object."
 
   (let*
@@ -151,7 +151,7 @@ circle of diameter 0 (ie sharp corners)."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;;FIXME: is this working? 
-(def-markup-command (strut layout props) ()
+(define-markup-command (strut layout props) ()
   "Create a box of the same height as the space in the current font."
   (let ((m (ly:text-interface::interpret-markup layout props " ")))
     (ly:make-stencil (ly:stencil-expr m)
@@ -161,7 +161,7 @@ circle of diameter 0 (ie sharp corners)."
 
 
 ;; todo: fix negative space
-(def-markup-command (hspace layout props amount) (number?)
+(define-markup-command (hspace layout props amount) (number?)
   "This produces a invisible object taking horizontal space.
 @example 
 \\markup @{ A \\hspace #2.0 B @} 
@@ -178,7 +178,7 @@ normally inserted before elements on a line.
 ;; importing graphics.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(def-markup-command (stencil layout props stil) (ly:stencil?)
+(define-markup-command (stencil layout props stil) (ly:stencil?)
   "Stencil as markup"
   stil)
 
@@ -197,7 +197,7 @@ normally inserted before elements on a line.
             
        #f)))
 
-(def-markup-command (epsfile layout props axis size file-name) (number? number? string?)
+(define-markup-command (epsfile layout props axis size file-name) (number? number? string?)
   "Inline an EPS image. The image is scaled along @var{axis} to
 @var{size}."
 
@@ -206,7 +206,7 @@ normally inserted before elements on a line.
       (eps-file->stencil axis size file-name)
       ))
 
-(def-markup-command (postscript layout props str) (string?)
+(define-markup-command (postscript layout props str) (string?)
   "This inserts @var{str} directly into the output as a PostScript
 command string.  Due to technicalities of the output backends,
 different scales should be used for the @TeX{} and PostScript backend,
@@ -240,7 +240,7 @@ gsave /ecrm10 findfont
    '(0 . 0) '(0 . 0)))
 
 
-(def-markup-command (score layout props score) (ly:score?)
+(define-markup-command (score layout props score) (ly:score?)
   "Inline an image of music."
   (let* ((output (ly:score-embedded-format score layout)))
 
@@ -251,7 +251,7 @@ gsave /ecrm10 findfont
          (ly:warning (_"no systems found in \\score markup, does it have a \\layout block?"))
          empty-stencil))))
 
-(def-markup-command (null layout props) ()
+(define-markup-command (null layout props) ()
   "An empty markup with extents of a single point"
 
   point-stencil)
@@ -260,7 +260,7 @@ gsave /ecrm10 findfont
 ;; basic formatting.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(def-markup-command (simple layout props str) (string?)
+(define-markup-command (simple layout props str) (string?)
   "A simple text string; @code{\\markup @{ foo @}} is equivalent with
 @code{\\markup @{ \\simple #\"foo\" @}}."
   (interpret-markup layout props str))
@@ -302,7 +302,7 @@ gsave /ecrm10 findfont
        (/ (+ (car text-widths) (car (cdr text-widths))) 2))
      (get-fill-space word-count line-width (cdr text-widths))))))
 
-(def-markup-command (fill-line layout props markups)
+(define-markup-command (fill-line layout props markups)
   (markup-list?)
   "Put @var{markups} in a horizontal line of width @var{line-width}.
    The markups are spaced/flushed to fill the entire line.
@@ -360,7 +360,7 @@ gsave /ecrm10 findfont
        (stack-stencils-padding-list X
                                     RIGHT fill-space-normal line-stencils))))
        
-(def-markup-command (line layout props args) (markup-list?)
+(define-markup-command (line layout props args) (markup-list?)
   "Put @var{args} in a horizontal line.  The property @code{word-space}
 determines the space between each markup in @var{args}."
   (let*
@@ -471,14 +471,14 @@ determines the space between each markup in @var{args}."
 
     (stack-lines DOWN 0.0 baseline-skip lines)))
 
-(def-markup-command (justify layout props args) (markup-list?)
+(define-markup-command (justify layout props args) (markup-list?)
   "Like wordwrap, but with lines stretched to justify the margins.
 Use @code{\\override #'(line-width . X)} to set line-width, where X
 is the number of staff spaces."
 
   (wordwrap-markups layout props args #t))
 
-(def-markup-command (wordwrap layout props args) (markup-list?)
+(define-markup-command (wordwrap layout props args) (markup-list?)
   "Simple wordwrap.  Use @code{\\override #'(line-width . X)} to set
 line-width, where X is the number of staff spaces."
 
@@ -519,23 +519,23 @@ line-width, where X is the number of staff spaces."
     (stack-lines DOWN 0.0 baseline-skip (apply append para-lines))))
 
 
-(def-markup-command (wordwrap-string layout props arg) (string?)
+(define-markup-command (wordwrap-string layout props arg) (string?)
   "Wordwrap a string. Paragraphs may be separated with double newlines"
   (wordwrap-string layout props  #f arg))
   
-(def-markup-command (justify-string layout props arg) (string?)
+(define-markup-command (justify-string layout props arg) (string?)
   "Justify a string. Paragraphs may be separated with double newlines"
   (wordwrap-string layout props #t arg))
 
 
-(def-markup-command (wordwrap-field layout props symbol) (symbol?)
+(define-markup-command (wordwrap-field layout props symbol) (symbol?)
    (let* ((m (chain-assoc-get symbol props)))
      (if (string? m)
       (interpret-markup layout props
        (list wordwrap-string-markup m))
       (ly:make-stencil '()  '(1 . -1) '(1 . -1)))))
 
-(def-markup-command (justify-field layout props symbol) (symbol?)
+(define-markup-command (justify-field layout props symbol) (symbol?)
 -   (let* ((m (chain-assoc-get symbol props)))
      (if (string? m)
       (interpret-markup layout props
@@ -544,7 +544,7 @@ line-width, where X is the number of staff spaces."
 
 
 
-(def-markup-command (combine layout props m1 m2) (markup? markup?)
+(define-markup-command (combine layout props m1 m2) (markup? markup?)
   "Print two markups on top of each other."
   (let* ((s1 (interpret-markup layout props m1))
         (s2 (interpret-markup layout props m2)))
@@ -553,7 +553,7 @@ line-width, where X is the number of staff spaces."
 ;;
 ;; TODO: should extract baseline-skip from each argument somehow..
 ;; 
-(def-markup-command (column layout props args) (markup-list?)
+(define-markup-command (column layout props args) (markup-list?)
   "Stack the markups in @var{args} vertically.  The property
 @code{baseline-skip} determines the space between each markup in @var{args}."
 
@@ -567,7 +567,7 @@ line-width, where X is the number of staff spaces."
      (remove ly:stencil-empty? arg-stencils))))
 
 
-(def-markup-command (dir-column layout props args) (markup-list?)
+(define-markup-command (dir-column layout props args) (markup-list?)
   "Make a column of args, going up or down, depending on the setting
 of the @code{#'direction} layout property."
   (let* ((dir (chain-assoc-get 'direction props)))
@@ -577,39 +577,39 @@ of the @code{#'direction} layout property."
      (chain-assoc-get 'baseline-skip props)
      (map (lambda (x) (interpret-markup layout props x)) args))))
 
-(def-markup-command (center-align layout props args) (markup-list?)
+(define-markup-command (center-align layout props args) (markup-list?)
   "Put @code{args} in a centered column. "
   (let* ((mols (map (lambda (x) (interpret-markup layout props x)) args))
          (cmols (map (lambda (x) (ly:stencil-aligned-to x X CENTER)) mols)))
     
     (stack-lines -1 0.0 (chain-assoc-get 'baseline-skip props) cmols)))
 
-(def-markup-command (vcenter layout props arg) (markup?)
+(define-markup-command (vcenter layout props arg) (markup?)
   "Align @code{arg} to its Y center. "
   (let* ((mol (interpret-markup layout props arg)))
     (ly:stencil-aligned-to mol Y CENTER)))
 
-(def-markup-command (hcenter layout props arg) (markup?)
+(define-markup-command (hcenter layout props arg) (markup?)
   "Align @code{arg} to its X center. "
   (let* ((mol (interpret-markup layout props arg)))
     (ly:stencil-aligned-to mol X CENTER)))
 
-(def-markup-command (right-align layout props arg) (markup?)
+(define-markup-command (right-align layout props arg) (markup?)
   "Align @var{arg} on its right edge. "
   (let* ((m (interpret-markup layout props arg)))
     (ly:stencil-aligned-to m X RIGHT)))
 
-(def-markup-command (left-align layout props arg) (markup?)
+(define-markup-command (left-align layout props arg) (markup?)
   "Align @var{arg} on its left edge. "
   (let* ((m (interpret-markup layout props arg)))
     (ly:stencil-aligned-to m X LEFT)))
 
-(def-markup-command (general-align layout props axis dir arg)  (integer? number? markup?)
+(define-markup-command (general-align layout props axis dir arg)  (integer? number? markup?)
   "Align @var{arg} in @var{axis} direction to the @var{dir} side."
   (let* ((m (interpret-markup layout props arg)))
     (ly:stencil-aligned-to m axis dir)))
 
-(def-markup-command (halign layout props dir arg) (number? markup?)
+(define-markup-command (halign layout props dir arg) (number? markup?)
   "Set horizontal alignment. If @var{dir} is @code{-1}, then it is
 left-aligned, while @code{+1} is right. Values in between interpolate
 alignment accordingly."
@@ -618,14 +618,14 @@ alignment accordingly."
 
 
 
-(def-markup-command (with-dimensions layout props x y arg) (number-pair? number-pair? markup?)
+(define-markup-command (with-dimensions layout props x y arg) (number-pair? number-pair? markup?)
   "Set the dimensions of @var{arg} to @var{x} and @var{y}."
   
   (let* ((m (interpret-markup layout props arg)))
     (ly:make-stencil (ly:stencil-expr m) x y)))
 
 
-(def-markup-command (pad-around layout props amount arg) (number? markup?)
+(define-markup-command (pad-around layout props amount arg) (number? markup?)
 
   "Add padding @var{amount} all around @var{arg}. "
   
@@ -641,7 +641,7 @@ alignment accordingly."
    ))
 
 
-(def-markup-command (pad-x layout props amount arg) (number? markup?)
+(define-markup-command (pad-x layout props amount arg) (number? markup?)
 
   "Add padding @var{amount} around @var{arg} in the X-direction. "
   (let*
@@ -656,7 +656,7 @@ alignment accordingly."
    ))
 
 
-(def-markup-command (put-adjacent layout props arg1 axis dir arg2) (markup? integer? ly:dir?  markup?)
+(define-markup-command (put-adjacent layout props arg1 axis dir arg2) (markup? integer? ly:dir?  markup?)
 
   "Put @var{arg2} next to @var{arg1}, without moving @var{arg1}.  "
   
@@ -666,7 +666,7 @@ alignment accordingly."
     (ly:stencil-combine-at-edge m1 axis dir m2 0.0 0.0)
   ))
 
-(def-markup-command (transparent layout props arg) (markup?)
+(define-markup-command (transparent layout props arg) (markup?)
   "Make the argument transparent"
   (let*
       ((m (interpret-markup layout props arg))
@@ -679,7 +679,7 @@ alignment accordingly."
                     x y)))
 
 
-(def-markup-command (pad-to-box layout props x-ext y-ext arg) (number-pair? number-pair? markup?)
+(define-markup-command (pad-to-box layout props x-ext y-ext arg) (number-pair? number-pair? markup?)
   "Make @var{arg} take at least @var{x-ext}, @var{y-ext} space"
 
   (let*
@@ -697,7 +697,7 @@ alignment accordingly."
 ;; property
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(def-markup-command (fromproperty layout props symbol) (symbol?)
+(define-markup-command (fromproperty layout props symbol) (symbol?)
   "Read the @var{symbol} from property settings, and produce a stencil
   from the markup contained within. If @var{symbol} is not defined, it
   returns an empty markup"
@@ -707,7 +707,7 @@ alignment accordingly."
        (ly:make-stencil '()  '(1 . -1) '(1 . -1)))))
 
 
-(def-markup-command (on-the-fly layout props procedure arg) (symbol? markup?)
+(define-markup-command (on-the-fly layout props procedure arg) (symbol? markup?)
   "Apply the @var{procedure} markup command to
 @var{arg}. @var{procedure} should take a single argument."
   (let* ((anonymous-with-signature (lambda (layout props arg) (procedure layout props arg))))
@@ -718,7 +718,7 @@ alignment accordingly."
 
 
 
-(def-markup-command (override layout props new-prop arg) (pair? markup?)
+(define-markup-command (override layout props new-prop arg) (pair? markup?)
   "Add the first argument in to the property list.  Properties may be
 any sort of property supported by @internalsref{font-interface} and
 @internalsref{text-interface}, for example
@@ -734,7 +734,7 @@ any sort of property supported by @internalsref{font-interface} and
 ;; files
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(def-markup-command (verbatim-file layout props name) (string?)
+(define-markup-command (verbatim-file layout props name) (string?)
   "Read the contents of a file, and include verbatimly"
 
   (interpret-markup
@@ -754,26 +754,26 @@ any sort of property supported by @internalsref{font-interface} and
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
-(def-markup-command (bigger layout props arg) (markup?)
+(define-markup-command (bigger layout props arg) (markup?)
   "Increase the font size relative to current setting"
   (interpret-markup layout props
    `(,fontsize-markup 1 ,arg)))
 
-(def-markup-command (smaller layout props arg) (markup?)
+(define-markup-command (smaller layout props arg) (markup?)
   "Decrease the font size relative to current setting"
   (interpret-markup layout props
    `(,fontsize-markup -1 ,arg)))
 
-(def-markup-command larger (markup?) bigger-markup)
+(define-markup-command larger (markup?) bigger-markup)
 
-(def-markup-command (finger layout props arg) (markup?)
+(define-markup-command (finger layout props arg) (markup?)
   "Set the argument as small numbers."
   (interpret-markup layout
                     (cons '((font-size . -5) (font-encoding . fetaNumber)) props)
                     arg))
 
 
-(def-markup-command (fontsize layout props increment arg) (number? markup?)
+(define-markup-command (fontsize layout props increment arg) (number? markup?)
   "Add @var{increment} to the font-size. Adjust baseline skip accordingly."
 
   (let* ((fs (chain-assoc-get 'font-size props 0))
@@ -787,7 +787,7 @@ any sort of property supported by @internalsref{font-interface} and
 
 
 ;; FIXME -> should convert to font-size.
-(def-markup-command (magnify layout props sz arg) (number? markup?)
+(define-markup-command (magnify layout props sz arg) (number? markup?)
   "Set the font magnification for the its argument. In the following
 example, the middle A will be 10% larger:
 @example
@@ -801,53 +801,53 @@ Use @code{\\fontsize} otherwise."
    (prepend-alist-chain 'font-magnification sz props)
    arg))
 
-(def-markup-command (bold layout props arg) (markup?)
+(define-markup-command (bold layout props arg) (markup?)
   "Switch to bold font-series"
   (interpret-markup layout (prepend-alist-chain 'font-series 'bold props) arg))
 
-(def-markup-command (sans layout props arg) (markup?)
+(define-markup-command (sans layout props arg) (markup?)
   "Switch to the sans serif family"
   (interpret-markup layout (prepend-alist-chain 'font-family 'sans props) arg))
 
-(def-markup-command (number layout props arg) (markup?)
+(define-markup-command (number layout props arg) (markup?)
   "Set font family to @code{number}, which yields the font used for
 time signatures and fingerings.  This font only contains numbers and
 some punctuation. It doesn't have any letters.  "
   (interpret-markup layout (prepend-alist-chain 'font-encoding 'fetaNumber props) arg))
 
-(def-markup-command (roman layout props arg) (markup?)
+(define-markup-command (roman layout props arg) (markup?)
   "Set font family to @code{roman}."
   (interpret-markup layout (prepend-alist-chain 'font-family 'roman props) arg))
 
-(def-markup-command (huge layout props arg) (markup?)
+(define-markup-command (huge layout props arg) (markup?)
   "Set font size to +2."
   (interpret-markup layout (prepend-alist-chain 'font-size 2 props) arg))
 
-(def-markup-command (large layout props arg) (markup?)
+(define-markup-command (large layout props arg) (markup?)
   "Set font size to +1."
   (interpret-markup layout (prepend-alist-chain 'font-size 1 props) arg))
 
-(def-markup-command (normalsize layout props arg) (markup?)
+(define-markup-command (normalsize layout props arg) (markup?)
   "Set font size to default."
   (interpret-markup layout (prepend-alist-chain 'font-size 0 props) arg))
 
-(def-markup-command (small layout props arg) (markup?)
+(define-markup-command (small layout props arg) (markup?)
   "Set font size to -1."
   (interpret-markup layout (prepend-alist-chain 'font-size -1 props) arg))
 
-(def-markup-command (tiny layout props arg) (markup?)
+(define-markup-command (tiny layout props arg) (markup?)
   "Set font size to -2."
   (interpret-markup layout (prepend-alist-chain 'font-size -2 props) arg))
 
-(def-markup-command (teeny layout props arg) (markup?)
+(define-markup-command (teeny layout props arg) (markup?)
   "Set font size to -3."
   (interpret-markup layout (prepend-alist-chain 'font-size -3 props) arg))
 
-(def-markup-command (caps layout props arg) (markup?)
+(define-markup-command (caps layout props arg) (markup?)
   "Set @code{font-shape} to @code{caps}."
   (interpret-markup layout (prepend-alist-chain 'font-shape 'caps props) arg))
 
-(def-markup-command (dynamic layout props arg) (markup?)
+(define-markup-command (dynamic layout props arg) (markup?)
   "Use the dynamic font.  This font only contains @b{s}, @b{f}, @b{m},
 @b{z}, @b{p}, and @b{r}.  When producing phrases, like ``pi@`{u} @b{f}'', the
 normal words (like ``pi@`{u}'') should be done in a different font.  The
@@ -855,7 +855,7 @@ recommend font for this is bold and italic"
   (interpret-markup
    layout (prepend-alist-chain 'font-encoding 'fetaDynamic props) arg))
 
-(def-markup-command (text layout props arg) (markup?)
+(define-markup-command (text layout props arg) (markup?)
   "Use a text font instead of music symbol or music alphabet font."  
 
   ;; ugh - latin1
@@ -863,26 +863,26 @@ recommend font for this is bold and italic"
                    arg))
 
 
-(def-markup-command (italic layout props arg) (markup?)
+(define-markup-command (italic layout props arg) (markup?)
   "Use italic @code{font-shape} for @var{arg}. "
   (interpret-markup layout (prepend-alist-chain 'font-shape 'italic props) arg))
 
-(def-markup-command (typewriter layout props arg) (markup?)
+(define-markup-command (typewriter layout props arg) (markup?)
   "Use @code{font-family} typewriter for @var{arg}."
   (interpret-markup
    layout (prepend-alist-chain 'font-family 'typewriter props) arg))
 
-(def-markup-command (upright layout props arg) (markup?)
+(define-markup-command (upright layout props arg) (markup?)
   "Set font shape to @code{upright}.  This is the opposite of @code{italic}."
   (interpret-markup
    layout (prepend-alist-chain 'font-shape 'upright props) arg))
 
-(def-markup-command (medium layout props arg) (markup?)
+(define-markup-command (medium layout props arg) (markup?)
   "Switch to medium font-series (in contrast to bold)."
   (interpret-markup layout (prepend-alist-chain 'font-series 'medium props)
                    arg))
 
-(def-markup-command (normal-text layout props arg) (markup?)
+(define-markup-command (normal-text layout props arg) (markup?)
   "Set all font related properties (except the size) to get the default normal text font, no matter what font was used earlier."
   ;; ugh - latin1
   (interpret-markup layout
@@ -895,44 +895,44 @@ recommend font for this is bold and italic"
 ;; symbols.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(def-markup-command (doublesharp layout props) ()
+(define-markup-command (doublesharp layout props) ()
   "Draw a double sharp symbol."
 
   (interpret-markup layout props (markup #:musicglyph "accidentals.4")))
 
-(def-markup-command (sesquisharp layout props) ()
+(define-markup-command (sesquisharp layout props) ()
   "Draw a 3/2 sharp symbol."
   (interpret-markup layout props (markup #:musicglyph "accidentals.3")))
 
-(def-markup-command (sharp layout props) ()
+(define-markup-command (sharp layout props) ()
   "Draw a sharp symbol."
   (interpret-markup layout props (markup #:musicglyph "accidentals.2")))
 
-(def-markup-command (semisharp layout props) ()
+(define-markup-command (semisharp layout props) ()
   "Draw a semi sharp symbol."
   (interpret-markup layout props (markup #:musicglyph "accidentals.1")))
 
-(def-markup-command (natural layout props) ()
+(define-markup-command (natural layout props) ()
   "Draw a natural symbol."
   (interpret-markup layout props (markup #:musicglyph "accidentals.0")))
 
-(def-markup-command (semiflat layout props) ()
+(define-markup-command (semiflat layout props) ()
   "Draw a semiflat."
   (interpret-markup layout props (markup #:musicglyph "accidentals.M1")))
 
-(def-markup-command (flat layout props) ()
+(define-markup-command (flat layout props) ()
   "Draw a flat symbol."
   (interpret-markup layout props (markup #:musicglyph "accidentals.M2")))
 
-(def-markup-command (sesquiflat layout props) ()
+(define-markup-command (sesquiflat layout props) ()
   "Draw a 3/2 flat symbol."
   (interpret-markup layout props (markup #:musicglyph "accidentals.M3")))
 
-(def-markup-command (doubleflat layout props) ()
+(define-markup-command (doubleflat layout props) ()
   "Draw a double flat symbol."
   (interpret-markup layout props (markup #:musicglyph "accidentals.M4")))
 
-(def-markup-command (with-color layout props color arg) (color? markup?)
+(define-markup-command (with-color layout props color arg) (color? markup?)
   "Draw @var{arg} in color specified by @var{color}"
 
   (let* ((stil (interpret-markup layout props arg)))
@@ -947,7 +947,7 @@ recommend font for this is bold and italic"
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
-(def-markup-command (arrow-head layout props axis direction filled)
+(define-markup-command (arrow-head layout props axis direction filled)
   (integer? ly:dir? boolean?)
   "produce an arrow head in specified direction and axis. Use the filled head if @var{filled} is  specified."
   (let*
@@ -962,7 +962,7 @@ recommend font for this is bold and italic"
                                     props))
      name)))
 
-(def-markup-command (musicglyph layout props glyph-name) (string?)
+(define-markup-command (musicglyph layout props glyph-name) (string?)
   "This is converted to a musical symbol, e.g. @code{\\musicglyph
 #\"accidentals.0\"} will select the natural sign from the music font.
 See @usermanref{The Feta font} for  a complete listing of the possible glyphs."
@@ -971,12 +971,12 @@ See @usermanref{The Feta font} for  a complete listing of the possible glyphs."
                                   props))
    glyph-name))
 
-(def-markup-command (lookup layout props glyph-name) (string?)
+(define-markup-command (lookup layout props glyph-name) (string?)
   "Lookup a glyph by name."
   (ly:font-get-glyph (ly:paper-get-font layout props)
                     glyph-name))
 
-(def-markup-command (char layout props num) (integer?)
+(define-markup-command (char layout props num) (integer?)
   "Produce a single character, e.g. @code{\\char #65} produces the 
 letter 'A'."
   (ly:get-glyph (ly:paper-get-font layout props) num))
@@ -1004,13 +1004,13 @@ letter 'A'."
                       (number->markletter-string vec (remainder n lst)))
        (make-string 1 (vector-ref vec n)))))
 
-(def-markup-command (markletter layout props num) (integer?)
+(define-markup-command (markletter layout props num) (integer?)
   "Make a markup letter for @var{num}.  The letters start with A to Z
  (skipping I), and continues with double letters."
   (ly:text-interface::interpret-markup layout props
     (number->markletter-string number->mark-letter-vector num)))
 
-(def-markup-command (markalphabet layout props num) (integer?)
+(define-markup-command (markalphabet layout props num) (integer?)
    "Make a markup letter for @var{num}.  The letters start with A to Z
  and continues with double letters."
    (ly:text-interface::interpret-markup layout props
@@ -1018,7 +1018,7 @@ letter 'A'."
 
 
 
-(def-markup-command (slashed-digit layout props num) (integer?)
+(define-markup-command (slashed-digit layout props num) (integer?)
   "A feta number, with slash. This is for use in the context of
 figured bass notation"
   (let*
@@ -1065,7 +1065,7 @@ figured bass notation"
 
 ;; TODO: better syntax.
 
-(def-markup-command (note-by-number layout props log dot-count dir) (number? number? number?)
+(define-markup-command (note-by-number layout props log dot-count dir) (number? number? number?)
   "Construct a note symbol, with stem.  By using fractional values for
 @var{dir}, you can obtain longer or shorter stems."
   (let* ((font (ly:paper-get-font layout (cons '((font-encoding . fetaMusic)) props)))
@@ -1138,7 +1138,7 @@ figured bass notation"
                 (if dots (string-length dots) 0)))
         (ly:error (_ "not a valid duration string: ~a") duration-string))))
 
-(def-markup-command (note layout props duration dir) (string? number?)
+(define-markup-command (note layout props duration dir) (string? number?)
   "This produces a note with a stem pointing in @var{dir} direction, with
 the @var{duration} for the note head type and augmentation dots. For
 example, @code{\\note #\"4.\" #-0.75} creates a dotted quarter note, with
@@ -1151,7 +1151,7 @@ a shortened down stem."
 ;; translating.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(def-markup-command (lower layout props amount arg) (number? markup?)
+(define-markup-command (lower layout props amount arg) (number? markup?)
   "
 Lower @var{arg}, by the distance @var{amount}.
 A negative @var{amount} indicates raising, see also @code{\\raise}.
@@ -1160,7 +1160,7 @@ A negative @var{amount} indicates raising, see also @code{\\raise}.
                             (- amount) Y))
 
 
-(def-markup-command (raise layout props amount arg) (number? markup?)
+(define-markup-command (raise layout props amount arg) (number? markup?)
   "
 Raise @var{arg}, by the distance @var{amount}.
 A negative @var{amount} indicates lowering, see also @code{\\lower}.
@@ -1179,7 +1179,7 @@ positions it next to the staff cancels any shift made with
 and/or @code{extra-offset} properties. "
   (ly:stencil-translate-axis (interpret-markup layout props arg) amount Y))
 
-(def-markup-command (fraction layout props arg1 arg2) (markup? markup?)
+(define-markup-command (fraction layout props arg1 arg2) (markup? markup?)
   "Make a fraction of two markups."
   (let* ((m1 (interpret-markup layout props arg1))
          (m2 (interpret-markup layout props arg2)))
@@ -1202,13 +1202,13 @@ and/or @code{extra-offset} properties. "
 
 
 
-(def-markup-command (normal-size-super layout props arg) (markup?)
+(define-markup-command (normal-size-super layout props arg) (markup?)
   "Set @var{arg} in superscript with a normal font size."
   (ly:stencil-translate-axis
    (interpret-markup layout props arg)
    (* 0.5 (chain-assoc-get 'baseline-skip props)) Y))
 
-(def-markup-command (super layout props arg) (markup?)
+(define-markup-command (super layout props arg) (markup?)
   "
 @cindex raising text
 @cindex lowering text
@@ -1234,7 +1234,7 @@ Raising and lowering texts can be done with @code{\\super} and
    (* 0.5 (chain-assoc-get 'baseline-skip props))
    Y))
 
-(def-markup-command (translate layout props offset arg) (number-pair? markup?)
+(define-markup-command (translate layout props offset arg) (number-pair? markup?)
   "This translates an object. Its first argument is a cons of numbers
 @example
 A \\translate #(cons 2 -3) @{ B C @} D
@@ -1248,7 +1248,7 @@ that.
   (ly:stencil-translate (interpret-markup  layout props arg)
                        offset))
 
-(def-markup-command (sub layout props arg) (markup?)
+(define-markup-command (sub layout props arg) (markup?)
   "Set @var{arg} in subscript."
   (ly:stencil-translate-axis
    (interpret-markup
@@ -1258,7 +1258,7 @@ that.
    (* -0.5 (chain-assoc-get 'baseline-skip props))
    Y))
 
-(def-markup-command (normal-size-sub layout props arg) (markup?)
+(define-markup-command (normal-size-sub layout props arg) (markup?)
   "Set @var{arg} in subscript, in a normal font size."
   (ly:stencil-translate-axis
    (interpret-markup layout props arg)
@@ -1269,19 +1269,19 @@ that.
 ;; brackets.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(def-markup-command (hbracket layout props arg) (markup?)
+(define-markup-command (hbracket layout props arg) (markup?)
   "Draw horizontal brackets around @var{arg}."  
   (let ((th 0.1) ;; todo: take from GROB.
         (m (interpret-markup layout props arg)))
     (bracketify-stencil m X th (* 2.5 th) th)))
 
-(def-markup-command (bracket layout props arg) (markup?)
+(define-markup-command (bracket layout props arg) (markup?)
   "Draw vertical brackets around @var{arg}."  
   (let ((th 0.1) ;; todo: take from GROB.
         (m (interpret-markup layout props arg)))
     (bracketify-stencil m Y th (* 2.5 th) th)))
 
-(def-markup-command (bracketed-y-column layout props indices args)
+(define-markup-command (bracketed-y-column layout props indices args)
   (list? markup-list?)
   "Make a column of the markups in @var{args}, putting brackets around
 the elements marked in @var{indices}, which is a list of numbers.

diff --git a/scm/fret-diagrams.scm b/scm/fret-diagrams.scm
index d7431d61704901f163e5f75555b0f825fce0b133..fe5b6128d76b479ad399ae8bf6d55dcf793bff61 100644 (file)
--- a/scm/fret-diagrams.scm
+++ b/scm/fret-diagrams.scm
@@ -291,7 +291,7 @@ Line thickness is given by @var{th}, fret & string spacing by
            (sans-serif-stencil layout props (* size label-font-mag) label-text) 
                        (* size (+ fret-count label-vertical-offset)) Y)))
  
-(def-markup-command (fret-diagram-verbose layout props marking-list)
+(define-markup-command (fret-diagram-verbose layout props marking-list)
   (list?)
   "Make a fret diagram containing the symbols indicated in @var{marking-list}
   
@@ -384,7 +384,7 @@ indications per string.
          (ly:stencil-aligned-to fret-diagram-stencil X alignment)
         ))
          
-(def-markup-command (fret-diagram layout props definition-string)
+(define-markup-command (fret-diagram layout props definition-string)
   (string?)
   "  
 Example
@@ -515,7 +515,7 @@ Note:  There is no limit to the number of fret indications per string.
                 (cons* numeric-value (numerify (cdr mylist)))
                 (cons* (car (string->list (car mylist))) (numerify (cdr mylist)))))))
            
-(def-markup-command (fret-diagram-terse layout props definition-string)
+(define-markup-command (fret-diagram-terse layout props definition-string)
   (string?)
   "Make a fret diagram markup using terse string-based syntax.
 

diff --git a/scm/markup.scm b/scm/markup.scm
index fc9fa946a3cf130ad90593032ffe1659c8951ee8..a98ba122db072d329bcc29e65eff99ecbeb9f0f0 100644 (file)
--- a/scm/markup.scm
+++ b/scm/markup.scm
@@ -20,9 +20,9 @@ The function should return a stencil (i.e. a formatted, ready to
 print object).
 
 
-To add a function, use the def-markup-command utility.
+To add a function, use the define-markup-command utility.
 
-  (def-markup-command (mycommand layout prop arg1 ...) (arg1-type? ...)
+  (define-markup-command (mycommand layout prop arg1 ...) (arg1-type? ...)
     \"my command usage and description\"
     ...function body...)
 
@@ -35,10 +35,10 @@ The command is now available in markup mode, e.g.
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; markup definer utilities
-;;; `def-markup-command' can be used both for built-in markup
+;;; `define-markup-command' can be used both for built-in markup
 ;;; definitions and user defined markups.
 
-(defmacro-public def-markup-command (command-and-args signature . body)
+(defmacro-public define-markup-command (command-and-args signature . body)
   "
 
 * Define a COMMAND-markup function after command-and-args and body,
@@ -51,11 +51,11 @@ register COMMAND-markup and its signature,
 * define a make-COMMAND-markup function.
 
 Syntax:
-  (def-markup-command (COMMAND layout props arg1 arg2 ...) (arg1-type? arg2-type? ...)
+  (define-markup-command (COMMAND layout props arg1 arg2 ...) (arg1-type? arg2-type? ...)
     \"documentation string\"
     ...command body...)
  or:
-  (def-markup-command COMMAND (arg1-type? arg2-type? ...)
+  (define-markup-command COMMAND (arg1-type? arg2-type? ...)
     function)
 "
   (let* ((command (if (pair? command-and-args) (car command-and-args) command-and-args))

diff --git a/scm/music-functions.scm b/scm/music-functions.scm
index 724165a88f399d9e02d4877f256990bd1763860b..2c815e021fcca91e834bc188679b91f7defade5c 100644 (file)
--- a/scm/music-functions.scm
+++ b/scm/music-functions.scm
@@ -668,7 +668,7 @@ without context specification. Called  from parser."
 
 
 (defmacro-public def-grace-function (start stop)
-  `(def-music-function (parser location music) (ly:music?)
+  `(define-music-function (parser location music) (ly:music?)
      (make-music 'GraceMusic
                 'origin location
                 'element (make-music 'SequentialMusic
@@ -676,10 +676,10 @@ without context specification. Called  from parser."
                                                      music
                                                      (ly:music-deep-copy ,stop))))))
 
-(defmacro-public def-music-function (args signature . body)
+(defmacro-public define-music-function (args signature . body)
   "Helper macro for `ly:make-music-function'.
 Syntax:
-  (def-music-function (parser location arg1 arg2 ...) (arg1-type? arg2-type? ...)
+  (define-music-function (parser location arg1 arg2 ...) (arg1-type? arg2-type? ...)
     ...function body...)
 "
   `(ly:make-music-function (list ,@signature)