X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fparser.yy;h=b9439c3e211cdcf5591135075fddbb199029ef0c;hb=d519250e6ba979578b1bc9406dcd70576f5652d5;hp=190b42ce83770d0511eda246be92e06a43a41977;hpb=2d51c5db4b6405476a7c6ce560b5fff6e3eb2961;p=lilypond.git

diff --git a/lily/parser.yy b/lily/parser.yy
index 190b42ce83..b9439c3e21 100644
--- a/lily/parser.yy
+++ b/lily/parser.yy
@@ -1,46 +1,14 @@
 %{ // -*-Fundamental-*-
 
 /*
-  parser.yy -- Bison/C++ parser for lilypond
+  parser.yy -- Bison/C++ parser for LilyPond
 
   source file of the GNU LilyPond music typesetter
 
   (c) 1997--2004 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-           Jan Nieuwenhuizen <janneke@gnu.org>
+                 Jan Nieuwenhuizen <janneke@gnu.org>
 */
 
-/*
-  Four shift/reduce problems:
-
-1.	foo = bar.
-
-	"bar" -> String -> Lyric -> Music -> music-assignment
-
-	"bar" -> String -> string-assignment
-
-
-Similar problem for
-
- * \markup identifier.
- * \markup { }
-
-
-2.  \repeat
-	\repeat .. \alternative
-
-
-    \repeat { \repeat .. \alternative }
-
-or
-
-    \repeat { \repeat } \alternative 
-
-)
-
---hwn
-
- */
-
 /*
 
 TODO:
@@ -57,40 +25,39 @@ TODO:
 #include <stdio.h>
 
 
-#include "scm-option.hh"
+#include "book.hh"
+
 #include "context-def.hh"
-#include "lily-guile.hh"
-#include "misc.hh"
-#include "my-lily-lexer.hh"
-#include "paper-def.hh"
-#include "midi-def.hh"
-#include "main.hh"
-#include "file-path.hh"
-#include "warn.hh"
 #include "dimensions.hh"
-#include "my-lily-parser.hh"
-#include "score.hh"
-#include "input-file-results.hh"
+#include "event.hh"
+#include "file-path.hh"
+#include "input-smob.hh"
 #include "input.hh"
+#include "lily-guile.hh"
 #include "lilypond-input-version.hh"
-#include "scm-hash.hh"
 #include "ly-module.hh"
-#include "music-sequence.hh"
-#include "input-smob.hh"
-#include "event.hh"
-#include "text-item.hh"
+#include "main.hh"
+#include "misc.hh"
 #include "music-list.hh"
+#include "music-sequence.hh"
+#include "my-lily-lexer.hh"
+#include "my-lily-parser.hh"
 #include "paper-book.hh"
+#include "output-def.hh"
+#include "scm-hash.hh"
+#include "scm-option.hh"
+#include "score.hh"
+#include "text-item.hh"
+#include "warn.hh"
 
 #define MY_MAKE_MUSIC(x)  make_music_by_name (ly_symbol2scm (x))
 
 Music *property_op_to_music (SCM op);
-Music *context_spec_music (SCM type, SCM id, Music * m, SCM ops_);
+Music *context_spec_music (SCM type, SCM id, Music *m, SCM ops_);
 SCM get_next_unique_context ();
 
 #define YYERROR_VERBOSE 1
 
-My_lily_parser* my_lily_parser;
 #define YYPARSE_PARAM my_lily_parser
 #define YYLEX_PARAM my_lily_parser
 #define THIS\
@@ -98,54 +65,53 @@ My_lily_parser* my_lily_parser;
 
 #define yyerror THIS->parser_error
 
-/*
-  Add symbols to the  TAGS field of a music object. 
-*/
+/* Add symbols to the TAGS field of a music object.  */
 
 void
-tag_music (Music*m,  SCM tag, Input ip)
+tag_music (Music *m, SCM tag, Input ip)
 {
 	SCM tags = m->get_property ("tags");
-	if (gh_symbol_p (tag))
+	if (ly_c_symbol_p (tag))
 		tags = scm_cons (tag, tags);
-	else if (gh_list_p (tag))
-		tags = gh_append2 (tag, tags);
+	else if (ly_c_list_p (tag))
+		tags = ly_append2 (tag, tags);
 	else
-		ip.warning (_("Tag must be symbol or list of symbols."));
+		ip.warning (_ ("Tag must be symbol or list of symbols."));
 
 	m->set_property ("tags", tags);
 }
 
-
-
 bool
 is_regular_identifier (SCM id)
 {
   String str = ly_scm2string (id);
-  char const *s = str.to_str0 () ;
+  char const *s = str.to_str0 ();
 
   bool v = true;
+#if 0
+  isalpha (*s);
+  s++;
+#endif
   while (*s && v)
    {
-        v = v && isalpha (*s);
+        v = v && isalnum (*s);
         s++;
    }
   return v;
 }
 
 SCM
-make_simple_markup (SCM a)
+make_simple_markup (SCM encoding, SCM a)
 {
-	static SCM simple;
-	if (!simple)
-	simple = scm_c_eval_string ("simple-markup");
-
+	SCM simple = ly_scheme_function ("simple-markup");
+	if (ly_c_symbol_p (encoding))
+		return scm_list_3 (ly_scheme_function ("encoded-simple-markup"),
+			   encoding, a);
 	return scm_list_2 (simple, a);
 }
 
-
 bool
-is_is_duration (int t)
+is_duration (int t)
 {
   return t && t == 1 << intlog2 (t);
 }
@@ -153,10 +119,8 @@ is_is_duration (int t)
 void
 set_music_properties (Music *p, SCM a)
 {
-  for (SCM k = a; gh_pair_p (k); k = ly_cdr (k))
-	{
-	p->internal_set_property (ly_caar (k), ly_cdar (k));
-	}
+  for (SCM k = a; ly_c_pair_p (k); k = ly_cdr (k))
+ 	p->internal_set_property (ly_caar (k), ly_cdar (k));
 }
 
 SCM
@@ -165,9 +129,9 @@ make_chord_step (int step, int alter)
 	if (step == 7)
 		alter += FLAT;
 
-	while(step < 0)
+	while (step < 0)
 		step += 7;
-	Pitch m((step -1) / 7 , (step - 1) % 7, alter);
+	Pitch m ((step -1) / 7, (step - 1) % 7, alter);
 	return m.smobbed_copy ();
 }
 
@@ -175,55 +139,74 @@ make_chord_step (int step, int alter)
 SCM
 make_chord (SCM pitch, SCM dur, SCM modification_list)
 {
-	static SCM chord_ctor;
-	if (!chord_ctor)
-		chord_ctor= scm_c_eval_string ("construct-chord");
-	SCM ch=  scm_call_3 (chord_ctor, pitch, dur, modification_list);
+	SCM chord_ctor = ly_scheme_function ("construct-chord");
+	SCM ch = scm_call_3 (chord_ctor, pitch, dur, modification_list);
 	scm_gc_protect_object (ch);
 	return ch;
 }
 
-/*
-  Todo: actually also use apply iso. call too ... 
-*/
+/* Todo: actually also use apply iso. call too ...  */
 bool
 ly_input_procedure_p (SCM x)
 {
-	return gh_procedure_p (x)
-		|| (gh_pair_p (x) && gh_procedure_p (gh_car (x)));
+	return ly_c_procedure_p (x)
+		|| (ly_c_pair_p (x) && ly_c_procedure_p (ly_car (x)));
 }
 
-Music* 
+Music*
 set_property_music (SCM sym, SCM value)
 {
-	Music * p = MY_MAKE_MUSIC ("PropertySet");
+	Music *p = MY_MAKE_MUSIC ("PropertySet");
 	p->set_property ("symbol", sym);
 	p->set_property ("value", value);
 	return p;
 }
 
+Music*
+make_music_relative (Pitch start, Music *music)
+{
+	Music *relative = MY_MAKE_MUSIC ("RelativeOctaveMusic");
+ 	relative->set_property ("element", music->self_scm ());
+	
+ 	Pitch last = music->to_relative_octave (start);
+ 	if (lily_1_8_relative)
+ 		music->set_property ("last-pitch", last.smobbed_copy ());
+	return relative;
+}
+
+Music*
+make_lyric_combine_music (SCM name, Music *music)
+{
+	Music *combine = MY_MAKE_MUSIC ("NewLyricCombineMusic");
+	combine->set_property ("element", music->self_scm ());
+ 	combine->set_property ("associated-context", name);
+	return combine;
+}
+
 %}
 
 /* We use SCMs to do strings, because it saves us the trouble of
 deleting them.  Let's hope that a stack overflow doesnt trigger a move
 of the parse stack onto the heap. */
 
+%left NEWLYRICS
 
 %union {
-	String * string;
-    Music *music;
-    Score *score;
-    Music_output_def * outputdef;
-    SCM scm;
-    int i;
+	Book *book;
+	Output_def *outputdef;
+	SCM scm;
+	String *string;
+ 	Music *music;
+ 	Score *score;
+ 	int i;
 }
 %{
 
 int
-yylex (YYSTYPE *s,  void * v)
+yylex (YYSTYPE *s, void *v)
 {
-	My_lily_parser	 *pars = (My_lily_parser*) v;
-	My_lily_lexer * lex = pars->lexer_;
+	My_lily_parser *pars = (My_lily_parser*) v;
+	My_lily_lexer *lex = pars->lexer_;
 
 	lex->lexval = (void*) s;
 	lex->prepare_for_next_token ();
@@ -233,26 +216,44 @@ yylex (YYSTYPE *s,  void * v)
 
 %}
 
-%pure_parser
+%expect 3
+
+/*
+  Three shift/reduce problems:
+
+2. \markup identifier.
+
+3. \markup { }
+
+4.  \repeat
+	\repeat .. \alternative
+
+
+    \repeat { \repeat .. \alternative }
+
+or
+
+    \repeat { \repeat } \alternative 
+
+)
+ */
 
 
+%pure_parser
+
 %token ACCEPTS
-%token ADDLYRICS
 %token ADDQUOTE
-%token NEWADDLYRICS
+%token LYRICSTO
 %token ALIAS
 %token ALTERNATIVE
-%token APPLY
-%token APPLYCONTEXT
-%token APPLYOUTPUT
-%token AUTOCHANGE
 %token BAR
-%token BREATHE
+%token BOOK
+%token BOOKPAPER
 %token CHANGE
-%token CHORDMODIFIERS  
+%token CHORDMODIFIERS
 %token CHORDS
-%token LESSLESS
-%token MOREMORE
+%token DOUBLE_ANGLE_OPEN
+%token DOUBLE_ANGLE_CLOSE
 %token CLEF
 %token COMMANDSPANREQUEST
 %token CONSISTS
@@ -264,15 +265,13 @@ yylex (YYSTYPE *s,  void * v)
 %token EXTENDER
 %token FIGURES FIGURE_OPEN FIGURE_CLOSE
 %token FIGURE_BRACKET_CLOSE FIGURE_BRACKET_OPEN
-%token GRACE 
-%token ACCIACCATURA
-%token APPOGGIATURA 
 %token GROBDESCRIPTIONS
 %token HEADER
 %token HYPHEN
 %token INVALID
 %token KEY
 %token LYRICS
+%token LYRICS_STRING
 %token MARK
 %token MIDI
 %token MULTI_MEASURE_REST
@@ -281,9 +280,8 @@ yylex (YYSTYPE *s,  void * v)
 %token NOTES
 %token OCTAVE
 %token ONCE
-%token OVERRIDE SET REVERT 
+%token OVERRIDE SET REVERT
 %token PAPER
-%token PARTCOMBINE
 %token PARTIAL
 %token QUOTE
 %token RELATIVE
@@ -293,6 +291,7 @@ yylex (YYSTYPE *s,  void * v)
 %token SCM_T
 %token SCORE
 %token SEQUENTIAL
+%token NEWLYRICS
 %token SIMULTANEOUS
 %token SKIP
 %token SPANREQUEST
@@ -307,6 +306,11 @@ yylex (YYSTYPE *s,  void * v)
 %token WITH
 
 /* escaped */
+/* FIXME: this sucks.  The user will get to see these names:
+    syntax error, unexpected E_CHAR:
+		\
+                 %%
+  */
 %token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER E_OPEN E_CLOSE
 %token E_LEFTSQUARE E_RIGHTSQUARE E_TILDE
 %token E_BACKSLASH
@@ -314,13 +318,6 @@ yylex (YYSTYPE *s,  void * v)
 %token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET  CHORD_SLASH
 %token FIGURE_SPACE
 
-%type <i>	exclamations questions dots optional_rest
-%type <i>  	 bass_mod
-%type <scm> 	grace_head
-%type <scm> 	oct_check
-%type <scm> 	context_mod_list
-%type <scm>  	lyric_element
-%type <scm> 	bass_number br_bass_figure bass_figure figure_list figure_spec
 %token <i>	DIGIT
 %token <scm>	NOTENAME_PITCH
 %token <scm>	TONICNAME_PITCH
@@ -336,9 +333,9 @@ yylex (YYSTYPE *s,  void * v)
 %token <scm>	NUMBER_IDENTIFIER
 %token <scm>	EVENT_IDENTIFIER
 %token <scm>	MUSIC_IDENTIFIER CONTEXT_DEF_IDENTIFIER
-%token <scm>	STRING_IDENTIFIER SCM_IDENTIFIER 
+%token <scm>	STRING_IDENTIFIER SCM_IDENTIFIER
 %token <scm>	RESTNAME
-%token <scm>	STRING   
+%token <scm>	STRING
 %token <scm>	SCM_T
 %token <i>	UNSIGNED
 %token <scm>   REAL
@@ -349,49 +346,74 @@ yylex (YYSTYPE *s,  void * v)
 %token <scm> MARKUP_HEAD_MARKUP0_MARKUP1
 %token <scm> MARKUP_HEAD_SCM0
 %token <scm> MARKUP_HEAD_SCM0_MARKUP1
-%token <scm> MARKUP_HEAD_SCM0_SCM1 
-%token <scm> MARKUP_HEAD_SCM0_SCM1_SCM2 
+%token <scm> MARKUP_HEAD_SCM0_SCM1
+%token <scm> MARKUP_HEAD_SCM0_SCM1_SCM2
 %token <scm> MARKUP_HEAD_SCM0_SCM1_MARKUP2
 
+%token <scm> MUSIC_FUNCTION
+%token <scm> MUSIC_FUNCTION_SCM 
+%token <scm> MUSIC_FUNCTION_MUSIC 
+%token <scm> MUSIC_FUNCTION_SCM_MUSIC 
+%token <scm> MUSIC_FUNCTION_MUSIC_MUSIC 
+%token <scm> MUSIC_FUNCTION_SCM_SCM_MUSIC 
+%token <scm> MUSIC_FUNCTION_SCM_MUSIC_MUSIC 
+
 %token <scm> MARKUP_IDENTIFIER MARKUP_HEAD_LIST0
-%type <scm> markup markup_line markup_list  markup_list_body full_markup 
+%type <scm> markup markup_line markup_list  markup_list_body full_markup
 
+%type <book>	book_block book_body
+%type <outputdef> book_paper_head book_paper_block book_paper_body
+
+%type <i>	exclamations questions dots optional_rest
+%type <i>  	bass_mod
+%type <scm> 	oct_check
+%type <scm> 	context_mod_list
+%type <scm>  	lyric_element
+%type <scm> 	bass_number br_bass_figure bass_figure figure_list figure_spec
+%type <scm>	new_lyrics
 %type <outputdef> output_def
-%type <scm> 	lilypond_header lilypond_header_body
+%type <scm>	lilypond_header lilypond_header_body
 %type <music>	open_event close_event
 %type <i>	sub_quotes sup_quotes
-%type <music>	simple_element  event_chord command_element Simple_music  Composite_music 
+%type <music>	toplevel_music
+%type <music>	simple_element event_chord command_element
+%type <music>	Composite_music Simple_music Prefix_composite_music Generic_prefix_music
+%type <scm>  	Generic_prefix_music_scm 
+%type <music>	Grouped_music_list
 %type <music>	Repeated_music
 %type <scm>     Alternative_music
 %type <i>	tremolo_type
 %type <i>	bare_int  bare_unsigned
 %type <i>	script_dir
-%type <scm>	identifier_init 
+%type <scm>	identifier_init
+%type <scm>	simple_string
 
-%type <music> note_chord_element chord_body chord_body_element
-%type <scm>  chord_body_elements 
-%type <scm> steno_duration optional_notemode_duration multiplied_duration
+%type <music>	note_chord_element chord_body chord_body_element
+%type <scm>	chord_body_elements
+%type <scm> 	steno_duration optional_notemode_duration multiplied_duration
 	
-%type <scm>   post_events 
-%type <music> gen_text_def direction_less_event direction_reqd_event
-%type <scm>   steno_pitch pitch absolute_pitch pitch_also_in_chords
-%type <scm>    steno_tonic_pitch
+%type <scm>	post_events
+%type <music>	gen_text_def direction_less_event direction_reqd_event
+%type <scm>	steno_pitch pitch absolute_pitch pitch_also_in_chords
+%type <scm>	steno_tonic_pitch
 %type <scm>	duration_length fraction
 
-%type <scm> new_chord step_number chord_items chord_item chord_separator step_numbers
+%type <scm>	chord_item chord_items chord_separator new_chord
+%type <scm>	step_number step_numbers 
 
-%type <scm>  embedded_scm scalar
-%type <music>	Music Sequential_music Simultaneous_music 
-%type <music>	relative_music re_rhythmed_music 
+%type <scm>	embedded_scm scalar
+%type <music>	Music Sequential_music Simultaneous_music
+%type <music>	relative_music re_rhythmed_music
 %type <music>	music_property_def context_change
-%type <scm> context_prop_spec 
-%type <scm> Music_list 
-%type <scm> property_operation context_mod context_def_mod optional_context_mod
-%type <outputdef>  music_output_def_body music_output_def_head
+%type <scm>	context_prop_spec
+%type <scm>	Music_list
+%type <scm>	property_operation
+%type <scm>	context_mod context_def_mod optional_context_mod
+%type <outputdef>	music_output_def_body music_output_def_head
 %type <music>	post_event tagged_post_event
-%type <music> command_req 
-%type <music> string_number_event
-%type <scm>	string bare_number number_expression number_term number_factor 
+%type <music>	command_req
+%type <music>	string_number_event
+%type <scm>	string bare_number number_expression number_term number_factor
 %type <score>	score_block score_body
 
 %type <scm>	context_def_spec_block context_def_spec_body
@@ -410,80 +432,81 @@ prec levels in different prods */
 %%
 
 lilypond:	/* empty */
-	| lilypond toplevel_expression {}
-	| lilypond assignment  { }
+	| lilypond toplevel_expression {
+	}
+	| lilypond assignment {
+	}
 	| lilypond error {
-		THIS->error_level_  = 1;
+		THIS->error_level_ = 1;
 	}
 	| lilypond INVALID	{
-		THIS->error_level_  = 1;
+		THIS->error_level_ = 1;
 	}
 	;
 
 toplevel_expression:
 	lilypond_header {
-		THIS->input_file_->header_ = $1;
+		THIS->header_ = $1;
 	}
 	| add_quote {
+	
+	}
+	| book_block {
+		Book *book = $1;
+		SCM proc = THIS->lexer_->lookup_identifier ("toplevel-book-handler");
+		scm_call_2 (proc, THIS->self_scm (), book->self_scm ());
+ 		scm_gc_unprotect_object (book->self_scm ());
 	}
 	| score_block {
-		Score * sc = $1;
-
-		SCM head = ly_module_p (sc->header_) ? sc->header_ : THIS->input_file_->header_.to_SCM ();
-
-		Path p = split_path (THIS->output_basename_);
-		int *c =  &THIS->input_file_->score_count_;
-		if (*c)
-			{
-			p.base += "-" + to_string (*c);
-			}
-
-		(*c)++;
-		SCM outname = scm_makfrom0str (p.to_string ().to_str0());
-
-		for (int i=0; i < sc->defs_.size (); i++)
-			default_rendering (sc->music_, sc->defs_[i]->self_scm (), head, outname);
-
-		if (sc->defs_.is_empty ())
-		{
-		   Music_output_def *id =
-			unsmob_music_output_def (THIS->lexer_->lookup_identifier
-				("$defaultpaper"));
-
-		   id = id ? id->clone () : new Paper_def;
-	
-		   default_rendering (sc->music_, id->self_scm (), head, outname);
-
- 		   scm_gc_unprotect_object (id->self_scm ());
-		}
- 		scm_gc_unprotect_object (sc->self_scm ());
+		Score *score = $1;
+		
+		SCM proc = THIS->lexer_->lookup_identifier ("toplevel-score-handler");
+		scm_call_2 (proc, THIS->self_scm (), score->self_scm ());
+ 		scm_gc_unprotect_object (score->self_scm ());
+	}
+	| toplevel_music {
+		Music *music = $1;
+		SCM proc = THIS->lexer_->lookup_identifier ("toplevel-music-handler");
+		scm_call_2 (proc, THIS->self_scm (), music->self_scm ());
+ 		scm_gc_unprotect_object (music->self_scm ());
 	}
 	| output_def {
 		SCM id = SCM_EOL;
-		if (dynamic_cast<Paper_def*> ($1))
-			id = scm_makfrom0str ("$defaultpaper");
-		else if (dynamic_cast<Midi_def*> ($1))
-			id = scm_makfrom0str ("$defaultmidi");
-		THIS->lexer_->set_identifier (id,   $1->self_scm ());
+		Output_def * od = $1;
+
+		if ($1->c_variable ("is-paper") == SCM_BOOL_T)
+			id = ly_symbol2scm ("$defaultpaper");
+		else if ($1->c_variable ("is-midi") == SCM_BOOL_T)
+			id = ly_symbol2scm ("$defaultmidi");
+		else if ($1->c_variable ("is-bookpaper") == SCM_BOOL_T)
+			id = ly_symbol2scm ("$defaultbookpaper");
+
+		THIS->lexer_->set_identifier (id, od->self_scm ());
+		scm_gc_unprotect_object (od->self_scm ());
+	}
+	| book_paper_block {
+		THIS->lexer_->set_identifier (ly_symbol2scm ("$defaultbookpaper"), $1->self_scm ());
 		scm_gc_unprotect_object ($1->self_scm ());
 	}
 	;
 
+toplevel_music:
+	Composite_music {
+	}
+	;
 
 embedded_scm:
 	SCM_T
-	| SCM_IDENTIFIER 
+	| SCM_IDENTIFIER
 	;
 
 
-
-
 lilypond_header_body:
 	{
-		$$ = ly_make_anonymous_module (); 
+		$$ = ly_make_anonymous_module (safe_global_b);
 		THIS->lexer_->add_scope ($$);
 	}
-	| lilypond_header_body assignment  { 
+	| lilypond_header_body assignment  {
 		
 	}
 	;
@@ -574,19 +597,19 @@ context_def_spec_body:
 		$$ = Context_def::make_scm ();
 		unsmob_context_def ($$)->set_spot (THIS->here_input ());
 	}
-	| CONTEXT_DEF_IDENTIFIER	{
+	| CONTEXT_DEF_IDENTIFIER {
 		$$ = $1;
 		unsmob_context_def ($$)->set_spot (THIS->here_input ());
 	}
 	| context_def_spec_body GROBDESCRIPTIONS embedded_scm {
 		Context_def*td = unsmob_context_def ($$);
 
-		for (SCM p = $3; gh_pair_p (p); p = ly_cdr (p)) {
-			SCM tag = gh_caar (p);
+		for (SCM p = $3; ly_c_pair_p (p); p = ly_cdr (p)) {
+			SCM tag = ly_caar (p);
 
 			/* TODO: should make new tag "grob-definition" ? */
 			td->add_context_mod (scm_list_3 (ly_symbol2scm ("assign"),
-							tag, gh_cons (ly_cdar (p), SCM_EOL)));
+							tag, scm_cons (ly_cdar (p), SCM_EOL)));
 		}
 	}
 	| context_def_spec_body context_mod {
@@ -594,17 +617,79 @@ context_def_spec_body:
 	}
 	;
 
-/*
-	SCORE
-*/
+
+book_paper_block:
+	book_paper_body '}' {
+		$$ = $1;
+		THIS->lexer_->remove_scope ();
+	}
+	;
+book_paper_head:
+	BOOKPAPER '{' {
+		$$ = get_bookpaper (THIS);
+		$$->input_origin_ = THIS->here_input ();
+		THIS->lexer_->add_scope ($$->scope_);
+	}
+	;
+
+book_paper_body:
+	book_paper_head
+	| book_paper_body assignment { }
+	;
+	
+
+
+book_block:
+	BOOK {
+		THIS->push_spot ();
+	}
+	/*cont*/ '{' book_body '}' 	{
+		THIS->pop_spot ();
+		$$ = $4;
+	}
+	;
+
+/* FIXME:
+   * Use 'handlers' like for toplevel-* stuff?
+   * grok \paper and \midi?  */
+book_body:
+	{
+		$$ = new Book;
+		$$->set_spot (THIS->here_input ());
+		$$->bookpaper_ = dynamic_cast<Output_def*> (unsmob_output_def (THIS->lexer_->lookup_identifier ("$defaultbookpaper"))->clone ());
+		scm_gc_unprotect_object ($$->bookpaper_->self_scm ());
+	}
+	| book_body book_paper_block {
+		$$->bookpaper_ = $2;
+		scm_gc_unprotect_object ($2->self_scm ());
+	}
+	| book_body score_block {
+		Score *score = $2;
+		$$->scores_.push (score);
+		scm_gc_unprotect_object (score->self_scm ());
+	}
+	| book_body Composite_music {
+		Music *music = $2;
+		Score *score
+			= unsmob_score (ly_music_scorify (music->self_scm ()));
+		$$->scores_.push (score);
+		scm_gc_unprotect_object (music->self_scm ());
+	}
+	| lilypond_header {
+		THIS->header_ = $1;
+	}
+	| book_body error {
+
+	}
+	;
+
 score_block:
-	SCORE { 
+	SCORE {
 		THIS->push_spot ();
 	}
 	/*cont*/ '{' score_body '}' 	{
 		THIS->pop_spot ();
 		$$ = $4;
-
 	}
 	;
 
@@ -619,9 +704,9 @@ score_body:
 		/*
 			guh.
 		*/
-		SCM check_funcs = scm_c_eval_string ("toplevel-music-functions");
-		for (; gh_pair_p (check_funcs); check_funcs = gh_cdr (check_funcs))
-			m = gh_call1 (gh_car (check_funcs), m);
+		SCM check_funcs = ly_scheme_function ("toplevel-music-functions");
+		for (; ly_c_pair_p (check_funcs); check_funcs = ly_cdr (check_funcs))
+			m = scm_call_1 (ly_car (check_funcs), m);
 		$$->music_ = m;
 
 	}
@@ -648,31 +733,25 @@ score_body:
 output_def:
 	music_output_def_body '}' {
 		$$ = $1;
-		THIS-> lexer_-> remove_scope ();
+		if ($1->parent_)
+			THIS->lexer_->remove_scope ();
+
+		THIS->lexer_->remove_scope ();
+		THIS->lexer_->pop_state ();
 	}
 	;
 
 music_output_def_head:
 	MIDI    {
-		Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultmidi"));
-
-
-		Midi_def* p =0;
-		if (id)
-			p = dynamic_cast<Midi_def*> (id->clone ());
-		else
-			p = new Midi_def;
-
+		Output_def *p = get_midi (THIS);
 		$$ = p;
 		THIS->lexer_->add_scope (p->scope_);
 	}
 	| PAPER 	{
-		Music_output_def *id = unsmob_music_output_def (THIS->lexer_->lookup_identifier ("$defaultpaper"));
-		  Paper_def *p = 0;
-		if (id)
-			p = dynamic_cast<Paper_def*> (id->clone ());
-		else
-			p = new Paper_def;
+		Output_def* p = get_paper (THIS);
+
+		if (p->parent_)
+			THIS->lexer_->add_scope (p->parent_->scope_);
 
 		THIS->lexer_->add_scope (p->scope_);
 		$$ = p;
@@ -681,32 +760,34 @@ music_output_def_head:
 
 
 music_output_def_body:
-	music_output_def_head '{' { 
-		
+	music_output_def_head '{' {
+		$$ = $1;
+		$$->input_origin_.set_spot (THIS->here_input ());
+		THIS->lexer_->push_initial_state ();
 	}
 	| music_output_def_head '{' MUSIC_OUTPUT_DEF_IDENTIFIER 	{
 		scm_gc_unprotect_object ($1->self_scm ());
-		Music_output_def * o =  unsmob_music_output_def ($3);
+		Output_def *o = unsmob_output_def ($3);
+		o->input_origin_.set_spot (THIS->here_input ());
 		$$ = o;
 		THIS->lexer_->remove_scope ();
 		THIS->lexer_->add_scope (o->scope_);
+		THIS->lexer_->push_initial_state ();
 	}
 	| music_output_def_body assignment  {
 
 	}
 	| music_output_def_body context_def_spec_block	{
-		$$->assign_context_def ($2);
+		assign_context_def ($$, $2);
 	}
 	| music_output_def_body tempo_event  {
 		/*
 			junk this ? there already is tempo stuff in
 			music.
 		*/
-		int m = gh_scm2int ( $2->get_property ("metronome-count"));
+		int m = ly_scm2int ($2->get_property ("metronome-count"));
 		Duration *d = unsmob_duration ($2->get_property ("tempo-unit"));
-		Midi_def * md = dynamic_cast<Midi_def*> ($$);
-		if (md)
-			md->set_tempo (d->get_length (), m);
+		set_tempo ($$, d->get_length (), m);
 		scm_gc_unprotect_object ($2->self_scm ());
 	}
 	| music_output_def_body error {
@@ -718,7 +799,7 @@ tempo_event:
 	TEMPO steno_duration '=' bare_unsigned	{
 		$$ = MY_MAKE_MUSIC ("MetronomeChangeEvent");
 		$$->set_property ("tempo-unit", $2);
-		$$->set_property ("metronome-count", gh_int2scm ( $4));
+		$$->set_property ("metronome-count", scm_int2num ( $4));
 	}
 	;
 
@@ -737,11 +818,13 @@ Music_list:
 		SCM s = $$;
  		SCM c = scm_cons ($2->self_scm (), SCM_EOL);
 		scm_gc_unprotect_object ($2->self_scm ()); /* UGH */
-		if (gh_pair_p (ly_cdr (s)))
-			gh_set_cdr_x (ly_cdr (s), c); /* append */
+		if (ly_c_pair_p (ly_cdr (s)))
+			scm_set_cdr_x (ly_cdr (s), c); /* append */
 		else
-			gh_set_car_x (s, c); /* set first cons */
-		gh_set_cdr_x (s, c) ;  /* remember last cell */ 
+			scm_set_car_x (s, c); /* set first cons */
+		scm_set_cdr_x (s, c);  /* remember last cell */
+	}
+	| Music_list embedded_scm {
 	}
 	| Music_list error {
 	}
@@ -762,58 +845,58 @@ Alternative_music:
 	}
 	;
 
+
 Repeated_music:
-	REPEAT string bare_unsigned Music Alternative_music
+	REPEAT simple_string bare_unsigned Music Alternative_music
 	{
 		Music *beg = $4;
 		int times = $3;
-		SCM alts = gh_pair_p ($5) ? gh_car ($5) : SCM_EOL;
+		SCM alts = ly_c_pair_p ($5) ? ly_car ($5) : SCM_EOL;
 		if (times < scm_ilength (alts)) {
-		  unsmob_music (gh_car (alts))
+		  unsmob_music (ly_car (alts))
 		    ->origin ()->warning (
-		    _("More alternatives than repeats.  Junking excess alternatives."));
+		    _ ("More alternatives than repeats.  Junking excess alternatives."));
 		  alts = ly_truncate_list (times, alts);
 		}
 
 
-		static SCM proc;
-		if (!proc)
-			proc = scm_c_eval_string ("make-repeated-music");
+		SCM proc = ly_scheme_function ("make-repeated-music");
 
 		SCM mus = scm_call_1 (proc, $2);
-		scm_gc_protect_object (mus); // UGH. 
-		Music *r =unsmob_music (mus);
+		scm_gc_protect_object (mus); // UGH.
+		Music *r = unsmob_music (mus);
 		if (beg)
 			{
 			r-> set_property ("element", beg->self_scm ());
 			scm_gc_unprotect_object (beg->self_scm ());
 			}
-		r->set_property ("repeat-count", gh_int2scm (times >? 1));
+		r->set_property ("repeat-count", scm_int2num (times >? 1));
 
 		r-> set_property ("elements",alts);
-		if (gh_equal_p ($2, scm_makfrom0str ("tremolo"))) {
+		if (ly_c_equal_p ($2, scm_makfrom0str ("tremolo"))) {
+			/*
+			TODO: move this code to Scheme.
+			*/
+
 			/*
 			we can not get durations and other stuff correct down the line, so we have to
 			add to the duration log here.
 			*/
-			static SCM func;
-
-			if (!func)
-				func = scm_primitive_eval (ly_symbol2scm ("shift-duration-log"));
+			SCM func = ly_scheme_function ("shift-duration-log");
 
 			int dots = ($3 % 3) ? 0 : 1;
 			int shift = -intlog2 ((dots) ? ($3*2/3) : $3);
 
-			Sequential_music * seq = dynamic_cast<Sequential_music*> ($4);
+			Sequential_music *seq = dynamic_cast<Sequential_music*> ($4);
 			
 			if (seq) {
-				int list_len =scm_ilength (seq->music_list ());
+				int list_len = scm_ilength (seq->music_list ());
 				if (list_len != 2)
 					seq->origin ()->warning ("Chord tremolo must have 2 elements.");
 				shift -= 1;
-				r->compress (Moment (Rational (1,list_len)));
+				r->compress (Moment (Rational (1, list_len)));
 				}
-			gh_call3 (func, r->self_scm (), gh_int2scm (shift),gh_int2scm (dots));
+			scm_call_3 (func, r->self_scm (), scm_int2num (shift),scm_int2num (dots));
 
 		}
 		r->set_spot (*$4->origin ());
@@ -851,20 +934,6 @@ Simultaneous_music:
 
 Simple_music:
 	event_chord		{ $$ = $1; }
-	| APPLYOUTPUT embedded_scm {
-		if (!ly_input_procedure_p ($2))
-			THIS->parser_error (_ ("\\applycontext takes function argument"));
-		$$ = MY_MAKE_MUSIC ("ApplyOutputEvent");
-		$$->set_property ("procedure", $2);
-		$$->set_spot (THIS->here_input ());
-	}
-	| APPLYCONTEXT embedded_scm {
-		if (!ly_input_procedure_p ($2))
-			THIS->parser_error (_ ("\\applycontext takes function argument"));
-		$$ = MY_MAKE_MUSIC ("ApplyContext");
-		$$->set_property ("procedure", $2);
-		$$->set_spot (THIS->here_input ());
-	}
 	| MUSIC_IDENTIFIER {
 		$$ = unsmob_music ($1);
 	}
@@ -875,117 +944,132 @@ Simple_music:
 
 optional_context_mod:
 	/**/ { $$ = SCM_EOL; }
-	| WITH '{' context_mod_list '}'  { $$ = $3; }
-	;
-
-grace_head:
-	GRACE  { $$ = scm_makfrom0str ("Grace"); } 
-	| ACCIACCATURA { $$ = scm_makfrom0str ("Acciaccatura"); }
-	| APPOGGIATURA { $$ = scm_makfrom0str ("Appoggiatura"); }
+	| WITH { THIS->lexer_->push_initial_state (); }
+	'{' context_mod_list '}'
+	{
+		THIS->lexer_->pop_state ();
+		$$ = $4;
+	}
 	;
 
 context_mod_list:
 	/* */  { $$ = SCM_EOL; }
 	| context_mod_list context_mod  {
-		 $$ = gh_cons ($2, $1);
+		 $$ = scm_cons ($2, $1);
 	}
 	;
 
+
 Composite_music:
-	AUTOCHANGE Music	{
-		static SCM proc ;
-		if (!proc)
-			proc = scm_c_eval_string ("make-autochange-music");
-	
-		SCM res = scm_call_1 (proc,  $2->self_scm ());
-		scm_gc_unprotect_object ($2->self_scm ());
-		$$ = unsmob_music (res);
-		scm_gc_protect_object (res);
-		$$->set_spot (THIS->here_input ());
-	}
-	| PARTCOMBINE Music Music {
-		static SCM proc;
-		if (!proc)
-			proc = scm_c_eval_string ("make-part-combine-music");
+	Prefix_composite_music { $$ = $1; }
+	| Grouped_music_list { $$ = $1; }
+	;
+
+Grouped_music_list:
+	Simultaneous_music		{ $$ = $1; }
+	| Sequential_music		{ $$ = $1; }
+	;
 
-		SCM res = scm_call_1 (proc, gh_list ($2->self_scm (),
-			$3->self_scm (), SCM_UNDEFINED));  
+Generic_prefix_music_scm:
+	MUSIC_FUNCTION {
+		$$ = scm_list_2 ($1, make_input (THIS->here_input ()));
+	}
+	| MUSIC_FUNCTION_SCM {
+		THIS->push_spot ();
+	} embedded_scm {
+		$$ = scm_list_3 ($1, make_input (THIS->pop_spot ()), $3);
+	}
+	| MUSIC_FUNCTION_MUSIC {
+		THIS->push_spot (); 
+	} Music {
+		$$ = scm_list_3 ($1, make_input (THIS->pop_spot ()), $3->self_scm ());
 		scm_gc_unprotect_object ($3->self_scm ());
-		scm_gc_unprotect_object ($2->self_scm ());
-		$$ = unsmob_music (res);
-		scm_gc_protect_object (res);
-		$$->set_spot (THIS->here_input ());
 	}
-	| grace_head Music {
-#if 1
-	/*
-		The other version is for easier debugging  of
-		Sequential_music_iterator in combination with grace notes.
-	*/
-
-/*
-
-TODO: should distinguish between both grace types in the
-basic music objects too, since the meaning is different.
-
-*/
-
-		String start_str = "start" + ly_scm2string ($1) + "Music"; 
-		String stop_str = "stop" + ly_scm2string ($1) + "Music"; 
-		
-		SCM start = THIS->lexer_->lookup_identifier (start_str);
-		SCM stop = THIS->lexer_->lookup_identifier (stop_str);
-
-		Music *startm = unsmob_music (start);
-		Music *stopm = unsmob_music (stop);
-
-		SCM ms = SCM_EOL;
-		if (stopm) {
-			stopm = stopm->clone ();
-			ms = scm_cons (stopm->self_scm (), ms);
-			scm_gc_unprotect_object (stopm->self_scm ());
-		}
-		ms = scm_cons ($2->self_scm (), ms);
-		scm_gc_unprotect_object ($2->self_scm ());
-		if (startm) {
-			startm = startm->clone ();
-			ms = scm_cons (startm->self_scm () , ms);
-			scm_gc_unprotect_object (startm->self_scm ());
+	| MUSIC_FUNCTION_SCM_MUSIC {
+		THIS->push_spot (); 
+	}  embedded_scm Music {
+		$$ = scm_list_4 ($1, make_input (THIS->pop_spot ()), $3, $4->self_scm ());
+		scm_gc_unprotect_object ($4->self_scm ());
+	}
+	| MUSIC_FUNCTION_MUSIC_MUSIC {
+		THIS->push_spot (); 
+	}  Music  Music {
+		$$ = scm_list_4 ($1, make_input (THIS->pop_spot ()), $3->self_scm (), $4->self_scm ());
+		scm_gc_unprotect_object ($3->self_scm ());
+		scm_gc_unprotect_object ($4->self_scm ());
+	}
+	| MUSIC_FUNCTION_SCM_MUSIC_MUSIC {
+		THIS->push_spot (); 
+	} embedded_scm Music Music {
+		$$ = scm_list_5 ($1, make_input (THIS->pop_spot ()),
+			$3, $4->self_scm (), $5->self_scm ());
+		scm_gc_unprotect_object ($5->self_scm ());
+		scm_gc_unprotect_object ($4->self_scm ());
+	}
+	;
+
+Generic_prefix_music:
+	Generic_prefix_music_scm {
+		SCM func = ly_car ($1);
+		Input *loc = unsmob_input (ly_cadr ($1));
+		SCM args = ly_cddr ($1);
+		SCM sig = scm_object_property (func, ly_symbol2scm ("music-function-signature"));
+		int k = 0;
+		bool ok  = true; 
+		for (SCM s = sig, t = args;
+			ok && ly_c_pair_p (s) && ly_c_pair_p (t);
+			s = ly_cdr (s), t = ly_cdr (t)) {
+			k++;
+			if (scm_call_1 (ly_car (s), ly_car (t)) != SCM_BOOL_T)
+			{
+				loc->error (_f ("Argument %d failed typecheck", k));
+				THIS->error_level_ = 1;
+				ok = false;
+			}
 		}
+		SCM m = SCM_EOL;
+		if (ok)
+			m = scm_apply_0 (func, ly_cdr ($1));
+		if (unsmob_music (m))
+			{
+			$$ = unsmob_music (m);
+			scm_gc_protect_object (m);
+			}
+		else 
+			{
+			if (ok)
+ 				loc->error (_ ("Music head function should return Music object.")); 
+			$$ = MY_MAKE_MUSIC ("Music");
+			}
+		$$->set_spot (*loc);
+	}
+	;
 
-		Music* seq = MY_MAKE_MUSIC ("SequentialMusic");
-		seq->set_property ("elements", ms);
 
-		
-		$$ = MY_MAKE_MUSIC ("GraceMusic");
-		$$->set_property ("element", seq->self_scm ());
-		scm_gc_unprotect_object (seq->self_scm ());
-#else
-		$$ = MY_MAKE_MUSIC ("GraceMusic");
-		$$->set_property ("element", $2->self_scm ());
-		scm_gc_unprotect_object ($2->self_scm ());
-#endif
+Prefix_composite_music:
+	Generic_prefix_music {
+		$$ = $1;
 	}
-	| CONTEXT string '=' string optional_context_mod Music {
+	| CONTEXT simple_string '=' simple_string optional_context_mod Music {
 		$$ = context_spec_music ($2, $4, $6, $5);
 
 	}
-	| CONTEXT STRING optional_context_mod Music {
+	| CONTEXT simple_string optional_context_mod Music {
 		$$ = context_spec_music ($2, SCM_UNDEFINED, $4, $3);
 	}
-	| NEWCONTEXT string optional_context_mod Music {
-		$$ = context_spec_music ($2, get_next_unique_context (),
-					 $4, $3);
+	| NEWCONTEXT simple_string optional_context_mod Music {
+		$$ = context_spec_music ($2, get_next_unique_context (), $4,
+			$3);
 	}
 
 	| TIMES {
 		THIS->push_spot ();
 	}
-	/* CONTINUED */ 
+	/* CONTINUED */
 		fraction Music 	
 
 	{
-		int n = gh_scm2int (ly_car ($3)); int d = gh_scm2int (ly_cdr ($3));
+		int n = ly_scm2int (ly_car ($3)); int d = ly_scm2int (ly_cdr ($3));
 		Music *mp = $4;
 
 		$$= MY_MAKE_MUSIC ("TimeScaledMusic");
@@ -993,14 +1077,12 @@ basic music objects too, since the meaning is different.
 
 		$$->set_property ("element", mp->self_scm ());
 		scm_gc_unprotect_object (mp->self_scm ());
-		$$->set_property ("numerator", gh_int2scm (n));
-		$$->set_property ("denominator", gh_int2scm (d));
+		$$->set_property ("numerator", scm_int2num (n));
+		$$->set_property ("denominator", scm_int2num (d));
 		$$->compress (Moment (Rational (n,d)));
 
 	}
 	| Repeated_music		{ $$ = $1; }
-	| Simultaneous_music		{ $$ = $1; }
-	| Sequential_music		{ $$ = $1; }
 	| TRANSPOSE pitch_also_in_chords pitch_also_in_chords Music {
 		$$ = MY_MAKE_MUSIC ("TransposedMusic");
 		Music *p = $4;
@@ -1011,23 +1093,6 @@ basic music objects too, since the meaning is different.
 		$$->set_property ("element", p->self_scm ());
 		scm_gc_unprotect_object (p->self_scm ());
 	}
-	| APPLY embedded_scm Music  {
-		if (!ly_input_procedure_p ($2))
-			{
-			THIS->parser_error (_ ("\\apply takes function argument"));
-			$$ = $3;
-			}
-		else
-			{
-			SCM ret = gh_call1 ($2, $3->self_scm ());
-			Music *m = unsmob_music (ret);
-			if (!m) {
-				THIS->parser_error ("\\apply must return a Music");
-				m = MY_MAKE_MUSIC ("Music");
-				}
-			$$ = m;
-			}
-	}
 	| NOTES
 		{
 		SCM nn = THIS->lexer_->lookup_identifier ("pitchnames");
@@ -1042,15 +1107,21 @@ basic music objects too, since the meaning is different.
 		SCM nn = THIS->lexer_->lookup_identifier ("drumPitchNames");
 		THIS->lexer_->push_note_state (alist_to_hashq (nn));
 	}
+	/* FIXME: This used to be: */
 	Music
+/*	Grouped_music_list */
 		{ $$ = $3;
 		  THIS->lexer_->pop_state ();
 		}
 	| FIGURES
 		{ THIS->lexer_->push_figuredbass_state (); }
+	/* FIXME: This used to be:
 	Music
+ 	but that breaks web build
+	*/
+	Grouped_music_list
 		{
-		  Music * chm = MY_MAKE_MUSIC ("UntransposableMusic");
+		  Music *chm = MY_MAKE_MUSIC ("UntransposableMusic");
 		  chm->set_property ("element", $3->self_scm ());
 		  $$ = chm;
 		  scm_gc_unprotect_object ($3->self_scm ());
@@ -1063,8 +1134,13 @@ basic music objects too, since the meaning is different.
 		nn = THIS->lexer_->lookup_identifier ("pitchnames");
 		THIS->lexer_->push_chord_state (alist_to_hashq (nn));
 
-	} Music {
-		  Music * chm = MY_MAKE_MUSIC ("UnrelativableMusic");
+	}
+	/* FIXME:
+	Music
+*/
+	Grouped_music_list
+	{
+		  Music *chm = MY_MAKE_MUSIC ("UnrelativableMusic");
 		  chm->set_property ("element", $3->self_scm ());
 		  scm_gc_unprotect_object ($3->self_scm ());
 		  $$ = chm;
@@ -1073,13 +1149,16 @@ basic music objects too, since the meaning is different.
 	}
 	| LYRICS
 		{ THIS->lexer_->push_lyric_state (); }
+	/* FIXME:
 	Music
+*/
+	Grouped_music_list
 		{
 		  $$ = $3;
 		  THIS->lexer_->pop_state ();
 	}
 	| relative_music	{ $$ = $1; }
-	| re_rhythmed_music	{ $$ = $1; } 
+	| re_rhythmed_music	{ $$ = $1; }
 	| TAG embedded_scm Music {
 		tag_music ($3, $2, THIS->here_input ());
 		$$ = $3;
@@ -1088,34 +1167,75 @@ basic music objects too, since the meaning is different.
 
 relative_music:
 	RELATIVE absolute_pitch Music {
-		Music * p = $3;
-		Pitch pit = *unsmob_pitch ($2);
-		$$ = MY_MAKE_MUSIC ("RelativeOctaveMusic");
-
-		$$->set_property ("element", p->self_scm ());
-		scm_gc_unprotect_object (p->self_scm ());
-
-
-		Pitch retpitch = p->to_relative_octave (pit);
-		if (lily_1_8_relative)
-			$$->set_property ("last-pitch", retpitch.smobbed_copy ());
+		Music *m = $3;
+		Pitch start = *unsmob_pitch ($2);
+		$$ = make_music_relative (start, m);
+		scm_gc_unprotect_object (m->self_scm ());
+	}
+	| RELATIVE Composite_music {
+		Music *m = $2;
+		/* FIXME: why is octave==0 and default not middleC? */
+		Pitch middle_c (-1, 0, 0);
+		$$ = make_music_relative (middle_c, m);
+		scm_gc_unprotect_object (m->self_scm ());
+	}
+	;
+
+new_lyrics:
+	NEWLYRICS { THIS->lexer_->push_lyric_state (); }
+	/*cont */
+	Grouped_music_list {
+	/* Can also use Music at the expensive of two S/Rs similar to
+           \repeat \alternative */
+		THIS->lexer_->pop_state ();
+#if 0
+		Music *music = MY_MAKE_MUSIC ("SimultaneousMusic");
+		music->set_property ("elements", scm_list_1 ($3->self_scm ()));
+		$$ = music;
+#else
+		$$ = scm_cons ($3->self_scm (), SCM_EOL);
+#endif
+	}
+	| new_lyrics NEWLYRICS { THIS->lexer_->push_lyric_state (); }
+	Grouped_music_list {
+		THIS->lexer_->pop_state ();
+		$$ = scm_cons ($4->self_scm (), $1);
 	}
 	;
 
 re_rhythmed_music:
-	ADDLYRICS Music Music {
-	Music*l =MY_MAKE_MUSIC ("LyricCombineMusic");
-	  l->set_property ("elements", gh_list ($2->self_scm (), $3->self_scm (), SCM_UNDEFINED));
-	  scm_gc_unprotect_object ($3->self_scm ());
-	  scm_gc_unprotect_object ($2->self_scm ());
-	  $$ = l;
+	Grouped_music_list new_lyrics {
+
+		/* FIXME: should find out uniqueXXX name from music */
+		SCM name = $1->get_property ("context-id");
+		//if (name == SCM_EOL)
+		if (!ly_c_string_p (name))
+			name = scm_makfrom0str ("");
+
+		SCM context = scm_makfrom0str ("Lyrics");
+		Music *all = MY_MAKE_MUSIC ("SimultaneousMusic");
+
+		SCM lst = SCM_EOL;
+		for (SCM s = $2; ly_c_pair_p (s); s = ly_cdr (s))
+		{
+			Music *music = unsmob_music (ly_car (s));
+			Music *com = make_lyric_combine_music (name, music);
+			Music *csm = context_spec_music (context,
+				get_next_unique_context (), com, SCM_EOL);
+			lst = scm_cons (csm->self_scm (), lst);
+		}
+		/* FIXME: only first lyric music is accepted,
+			  the rest is junked */
+		all->set_property ("elements", scm_cons ($1->self_scm (),
+			lst));
+		$$ = all;
+		scm_gc_unprotect_object ($1->self_scm ());
 	}
-	| NEWADDLYRICS string Music {
-	  Music*l =MY_MAKE_MUSIC ("NewLyricCombineMusic");
-	  l->set_property ("element", $3->self_scm ());
-	  scm_gc_unprotect_object ($3->self_scm ());
-	  $$ = l;
-	  l->set_property ("associated-context", $2);
+	| LYRICSTO string Music {
+		Music *music = $3;
+		SCM name = $2;
+		$$ = make_lyric_combine_music (name, music);
+		scm_gc_unprotect_object (music->self_scm ());
 	}
 	;
 
@@ -1131,19 +1251,19 @@ context_change:
 	;
 
 property_operation:
-	STRING '='  scalar {
+	STRING '=' scalar {
 		$$ = scm_list_3 (ly_symbol2scm ("assign"),
 			scm_string_to_symbol ($1), $3);
 	}
-	| UNSET STRING {
+	| UNSET simple_string {
 		$$ = scm_list_2 (ly_symbol2scm ("unset"),
 			scm_string_to_symbol ($2));
 	}
-	| OVERRIDE STRING embedded_scm '=' embedded_scm {
+	| OVERRIDE simple_string embedded_scm '=' embedded_scm {
 		$$ = scm_list_4 (ly_symbol2scm ("push"),
 			scm_string_to_symbol ($2), $3, $5);
 	}
-	| REVERT STRING embedded_scm {
+	| REVERT simple_string embedded_scm {
 		$$ = scm_list_3 (ly_symbol2scm ("pop"),
 			scm_string_to_symbol ($2), $3);
 	}
@@ -1171,11 +1291,13 @@ context_mod:
 	;
 
 context_prop_spec:
-	STRING  {
-		$$ = scm_list_2 (ly_symbol2scm ("Bottom"), scm_string_to_symbol ($1));
+	simple_string {
+		$$ = scm_list_2 (ly_symbol2scm ("Bottom"),
+			scm_string_to_symbol ($1));
 	}
-	| STRING '.' STRING {
-		$$ = scm_list_2 (scm_string_to_symbol ($1), scm_string_to_symbol ($3));
+	| simple_string '.' simple_string {
+		$$ = scm_list_2 (scm_string_to_symbol ($1),
+			scm_string_to_symbol ($3));
 	}
 	;
 
@@ -1183,50 +1305,77 @@ music_property_def:
 	OVERRIDE context_prop_spec embedded_scm '=' scalar {
 		$$ = property_op_to_music (scm_list_4 (
 			ly_symbol2scm ("poppush"),
-			gh_cadr ($2),
+			ly_cadr ($2),
 			$3, $5));
-		$$= context_spec_music (gh_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
+		$$= context_spec_music (ly_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
 	}
 	| REVERT context_prop_spec embedded_scm {
 		$$ = property_op_to_music (scm_list_3 (
 			ly_symbol2scm ("pop"),
-			gh_cadr ($2),
+			ly_cadr ($2),
 			$3));
 
-		$$= context_spec_music (gh_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
+		$$= context_spec_music (ly_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
 	}
 	| SET context_prop_spec '=' scalar {
 		$$ = property_op_to_music (scm_list_3 (
 			ly_symbol2scm ("assign"),
-			gh_cadr ($2),
+			ly_cadr ($2),
 			$4));
-		$$= context_spec_music (gh_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
+		$$= context_spec_music (ly_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
 	}
 	| UNSET context_prop_spec {
 		$$ = property_op_to_music (scm_list_2 (
 			ly_symbol2scm ("unset"),
-			gh_cadr ($2)));
-		$$= context_spec_music (gh_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
+			ly_cadr ($2)));
+		$$= context_spec_music (ly_car ($2), SCM_UNDEFINED, $$, SCM_EOL);
 	}
 	| ONCE music_property_def {
 		SCM e = $2->get_property ("element");
                 unsmob_music (e)->set_property ("once", SCM_BOOL_T);
 		$$ = $2;
-        
+
 	}
 	;
 
 
+string:
+	STRING {
+		$$ = $1;
+	}
+	| STRING_IDENTIFIER {
+		$$ = $1;
+	}
+	| string '+' string {
+		$$ = scm_string_append (scm_list_2 ($1, $3));
+	}
+	;
+
+simple_string: STRING {
+	}
+	| LYRICS_STRING {
+	}
+	;
 
-scalar:
-        string          { $$ = $1; }
-        | bare_int      { $$ = gh_int2scm ($1); }
-        | embedded_scm  { $$ = $1; }
-	| full_markup {  $$ = $1; }
-	| DIGIT { $$ = gh_int2scm ($1); }
-        ;
+scalar: string {
+	}
+	| LYRICS_STRING {
+	}
+        | bare_int {
+		$$ = scm_int2num ($1);
+	}
+        | embedded_scm {
+	}
+	| full_markup {
+	}
+	| DIGIT {
+		$$ = scm_int2num ($1);
+	}
+	;
 
 /*
+FIXME: remove or fix this comment.  What is `This'?
+
 This is a trick:
 
 Adding pre_events to the simple_element
@@ -1241,7 +1390,7 @@ and
 a single shift/reduction conflict.
 
 nevertheless, this is not very clean, and we should find a different
-solution.  
+solution.
 
 */
 pre_events: {
@@ -1253,7 +1402,7 @@ event_chord:
 	pre_events simple_element post_events	{
 		SCM elts = $2-> get_property ("elements");
 
-		elts = gh_append2 (elts, scm_reverse_x ($3, SCM_EOL));
+		elts = ly_append2 (elts, scm_reverse_x ($3, SCM_EOL));
 
 		$2->set_property ("elements", elts);
 		$$ = $2;
@@ -1270,9 +1419,9 @@ note_chord_element:
 		SCM es = $1->get_property ("elements");
 		SCM postevs = scm_reverse_x ($3, SCM_EOL);
 
-		for (SCM s = es; gh_pair_p (s); s = gh_cdr (s))
-		  unsmob_music (gh_car (s))->set_property ("duration", dur);
-		es = gh_append2 (es, postevs);
+		for (SCM s = es; ly_c_pair_p (s); s = ly_cdr (s))
+		  unsmob_music (ly_car (s))->set_property ("duration", dur);
+		es = ly_append2 (es, postevs);
 
 		$1-> set_property ("elements", es);
 		$$ = $1;
@@ -1285,10 +1434,10 @@ chord_open: '<'
 chord_close: '>'
 	;
 
-simul_open: LESSLESS
+simul_open: DOUBLE_ANGLE_OPEN
 	;
 
-simul_close: MOREMORE
+simul_close: DOUBLE_ANGLE_CLOSE
 	;
 
 chord_body:
@@ -1303,7 +1452,7 @@ chord_body:
 chord_body_elements:
 	/* empty */ 		{ $$ = SCM_EOL; }
 	| chord_body_elements chord_body_element {
-		$$ = gh_cons ($2->self_scm (), $1);
+		$$ = scm_cons ($2->self_scm (), $1);
 		scm_gc_unprotect_object ($2->self_scm ());
 	}
 	;
@@ -1311,26 +1460,26 @@ chord_body_elements:
 chord_body_element:
 	pitch exclamations questions post_events
 	{
-		Music * n = MY_MAKE_MUSIC ("NoteEvent");
+		Music *n = MY_MAKE_MUSIC ("NoteEvent");
 		n->set_property ("pitch", $1);
 		if ($3 % 2)
 			n->set_property ("cautionary", SCM_BOOL_T);
 		if ($2 % 2 || $3 % 2)
 			n->set_property ("force-accidental", SCM_BOOL_T);
 
-		if (gh_pair_p ($4)) {
+		if (ly_c_pair_p ($4)) {
 			SCM arts = scm_reverse_x ($4, SCM_EOL);
 			n->set_property ("articulations", arts);
 		}
 		$$ = n;
 	}
 	| DRUM_PITCH post_events {
-		Music *n =  MY_MAKE_MUSIC ("NoteEvent");
-		n->set_property ("duration" ,$2);
-		n->set_property ("drum-type" , $1);
+		Music *n = MY_MAKE_MUSIC ("NoteEvent");
+		n->set_property ("duration", $2);
+		n->set_property ("drum-type", $1);
 		n->set_spot (THIS->here_input ());
 
-		if (gh_pair_p ($2)) {
+		if (ly_c_pair_p ($2)) {
 			SCM arts = scm_reverse_x ($2, SCM_EOL);
 			n->set_property ("articulations", arts);
 		}
@@ -1340,9 +1489,7 @@ chord_body_element:
 
 add_quote:
 	ADDQUOTE string Music {
-		static SCM adder;
-		if (!adder)
-			adder = scm_c_eval_string ("add-quotable");
+		SCM adder = ly_scheme_function ("add-quotable");
 		
 		scm_call_2 (adder, $2, $3->self_scm ());
 		scm_gc_unprotect_object ($3->self_scm ());
@@ -1359,66 +1506,71 @@ command_element:
 		$1-> set_spot (THIS->here_input ());
 	}
 	| SKIP duration_length {
-		Music * skip = MY_MAKE_MUSIC ("SkipMusic");
+		Music *skip = MY_MAKE_MUSIC ("SkipMusic");
 		skip->set_property ("duration", $2);
 
 		$$ = skip;
 	}
 	| QUOTE STRING duration_length {
 		SCM tab = THIS->lexer_->lookup_identifier ("musicQuotes");
-		SCM evs =  SCM_EOL;
+		SCM evs = SCM_EOL;
 		if (scm_hash_table_p (tab) == SCM_BOOL_T)
-		{ 
-			SCM key = $2; // use symbol? 
+		{
+			SCM key = $2; // use symbol?
 			evs = scm_hash_ref (tab, key, SCM_BOOL_F);
 		}
-		Music * quote = 0;
-		if (gh_vector_p (evs))
+		Music *quote = 0;
+		if (ly_c_vector_p (evs))
 		{
 			quote = MY_MAKE_MUSIC ("QuoteMusic");
 			quote->set_property ("duration", $3);
 			quote->set_property ("quoted-events", evs);
 		} else {
-			THIS->here_input ().warning (_f ("Can\'t find music")); 
+			THIS->here_input ().warning (_f ("Can\'t find music"));
 			quote = MY_MAKE_MUSIC ("Event");
 		}
 		quote->set_spot (THIS->here_input ());
-		$$ = quote; 
+		$$ = quote;
 	}
 	| OCTAVE { THIS->push_spot (); }
  	  pitch {
-		Music *l = MY_MAKE_MUSIC ("RelativeOctaveCheck");
-		$$ = l;
+		Music *m = MY_MAKE_MUSIC ("RelativeOctaveCheck");
+		$$ = m;
 		$$->set_spot (THIS->pop_spot ());
 		$$->set_property ("pitch", $3);
 	}
 	| E_LEFTSQUARE {
-		Music *l = MY_MAKE_MUSIC ("LigatureEvent");
-		l->set_property ("span-direction", gh_int2scm (START));
-		l->set_spot (THIS->here_input ());
+		Music *m = MY_MAKE_MUSIC ("LigatureEvent");
+		m->set_property ("span-direction", scm_int2num (START));
+		m->set_spot (THIS->here_input ());
 
 		$$ = MY_MAKE_MUSIC ("EventChord");
-		$$->set_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
-		scm_gc_unprotect_object (l->self_scm ());
+		$$->set_property ("elements", scm_cons (m->self_scm (), SCM_EOL));
+		scm_gc_unprotect_object (m->self_scm ());
 		$$->set_spot (THIS->here_input ());
 	}
 	| E_RIGHTSQUARE {
-		Music *l = MY_MAKE_MUSIC ("LigatureEvent");
-		l->set_property ("span-direction", gh_int2scm (STOP));
-		l->set_spot (THIS->here_input ());
+		Music *m = MY_MAKE_MUSIC ("LigatureEvent");
+		m->set_property ("span-direction", scm_int2num (STOP));
+		m->set_spot (THIS->here_input ());
 
 		$$ = MY_MAKE_MUSIC ("EventChord");
-		$$->set_property ("elements", scm_cons (l->self_scm (), SCM_EOL));
+		$$->set_property ("elements", scm_cons (m->self_scm (), SCM_EOL));
 		$$->set_spot (THIS->here_input ());
-		scm_gc_unprotect_object (l->self_scm ());
+		scm_gc_unprotect_object (m->self_scm ());
 	}
 	| E_BACKSLASH {
 		$$ = MY_MAKE_MUSIC ("VoiceSeparator");
 		$$->set_spot (THIS->here_input ());
 	}
 	| '|'      {
+		SCM pipe =THIS->lexer_->lookup_identifier ("pipeSymbol");
+
+		if (Music * m = unsmob_music (pipe))
+			$$ = m->clone ();
+		else
+			$$ = MY_MAKE_MUSIC ("BarCheck");
 
-		$$ = MY_MAKE_MUSIC ("BarCheck");
 		$$->set_spot (THIS->here_input ());
 	}
 	| TRANSPOSITION pitch {
@@ -1426,7 +1578,7 @@ command_element:
 					$2);
 		$$->set_spot (THIS-> here_input ());
 		$$ = context_spec_music (ly_symbol2scm ("Staff"), SCM_UNDEFINED,
-			$$ , SCM_EOL);
+			$$, SCM_EOL);
 	}
 	| BAR STRING  			{
 		Music *t = set_property_music (ly_symbol2scm ("whichBar"), $2);
@@ -1439,36 +1591,30 @@ command_element:
 	}
 	| PARTIAL duration_length  	{
 		Moment m = - unsmob_duration ($2)->get_length ();
-		Music * p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
+		Music *p = set_property_music (ly_symbol2scm ( "measurePosition"),m.smobbed_copy ());
 		p->set_spot (THIS->here_input ());
 		p = context_spec_music (ly_symbol2scm ("Timing"), SCM_UNDEFINED,
 					p, SCM_EOL);
 		p = context_spec_music (ly_symbol2scm ("Score"), SCM_UNDEFINED,
 					p, SCM_EOL);
-		$$ =p ;
+		$$ = p;
 	}
 	| CLEF STRING  {
-		static SCM proc ;
-		if (!proc)
-			proc = scm_c_eval_string ("make-clef-set");
+		SCM proc = ly_scheme_function ("make-clef-set");
 
 		SCM result = scm_call_1 (proc, $2);
 		scm_gc_protect_object (result);
 		$$ = unsmob_music (result);
 	}
 	| TIME_T fraction  {
-		static SCM proc;
-		if (!proc)
-			proc = scm_c_eval_string ("make-time-signature-set");
+		SCM proc= ly_scheme_function ("make-time-signature-set");
 
-		SCM result = scm_apply_2   (proc, gh_car ($2), gh_cdr ($2), SCM_EOL);
+		SCM result = scm_apply_2   (proc, ly_car ($2), ly_cdr ($2), SCM_EOL);
 		scm_gc_protect_object (result);
 		$$ = unsmob_music (result);
 	}
 	| MARK scalar {
-		static SCM proc;
-		if (!proc)
-			proc = scm_c_eval_string ("make-mark-set");
+		SCM proc = ly_scheme_function ("make-mark-set");
 
 		SCM result = scm_call_1 (proc, $2);
 		scm_gc_protect_object (result);
@@ -1477,14 +1623,11 @@ command_element:
 	;
 
 command_req:
-	BREATHE {
-		$$ = MY_MAKE_MUSIC ("BreathingSignEvent");
-	}
-	| E_TILDE {
+	E_TILDE {
 		$$ = MY_MAKE_MUSIC ("PesOrFlexaEvent");
 	}
 	| MARK DEFAULT  {
-		Music * m = MY_MAKE_MUSIC ("MarkEvent");
+		Music *m = MY_MAKE_MUSIC ("MarkEvent");
 		$$ = m;
 	}
 	| tempo_event {
@@ -1503,7 +1646,7 @@ command_req:
 			key->set_property ("tonic", Pitch (0,0,0).smobbed_copy ());
 			((Music*)key)->transpose (* unsmob_pitch ($2));
 		} else {
-			THIS->parser_error (_("Second argument must be pitch list."));
+			THIS->parser_error (_ ("Second argument must be pitch list."));
 		}
 
 		$$ = key;
@@ -1516,7 +1659,7 @@ post_events:
 	}
 	| post_events post_event {
 		$2->set_spot (THIS->here_input ());
-		$$ = gh_cons ($2->self_scm (), $$);
+		$$ = scm_cons ($2->self_scm (), $$);
 		scm_gc_unprotect_object ($2->self_scm ());
 	}
 	| post_events tagged_post_event {
@@ -1550,12 +1693,12 @@ post_event:
 	}
 	| script_dir direction_reqd_event {
 		if ($1)
-			$2->set_property ("direction", gh_int2scm ($1));
+			$2->set_property ("direction", scm_int2num ($1));
 		$$ = $2;
 	}
 	| script_dir direction_less_event {
 		if ($1)
-			$2->set_property ("direction", gh_int2scm ($1));
+			$2->set_property ("direction", scm_int2num ($1));
 		$$ = $2;
 	}
 	| string_number_event
@@ -1563,8 +1706,8 @@ post_event:
 
 string_number_event:
 	E_UNSIGNED {
-		Music * s = MY_MAKE_MUSIC ("StringNumberEvent");
-		s->set_property ("string-number",  gh_int2scm ($1));
+		Music *s = MY_MAKE_MUSIC ("StringNumberEvent");
+		s->set_property ("string-number", scm_int2num ($1));
 		s->set_spot (THIS->here_input ());
 		$$ = s;
 	}
@@ -1584,51 +1727,51 @@ configurable, i.e.
 (set-articulation '~ "trill")
 
 */
-		Music * m = MY_MAKE_MUSIC ("BeamEvent");
+		Music *m = MY_MAKE_MUSIC ("BeamEvent");
 		m->set_spot (THIS->here_input ());
-		m->set_property ("span-direction" , gh_int2scm (START));
+		m->set_property ("span-direction", scm_int2num (START));
 		$$ = m;
 	}
 	| ']'  {
-		Music * m = MY_MAKE_MUSIC ("BeamEvent");
+		Music *m = MY_MAKE_MUSIC ("BeamEvent");
 		m->set_spot (THIS->here_input ());
-		m->set_property ("span-direction" , gh_int2scm (STOP));
+		m->set_property ("span-direction", scm_int2num (STOP));
 		$$ = m;
 	}
 	| '~' {
-		Music * m = MY_MAKE_MUSIC ("TieEvent");
+		Music *m = MY_MAKE_MUSIC ("TieEvent");
 		m->set_spot (THIS->here_input ());
 		$$ = m;
 	}
 	| close_event {
 		$$ = $1;
 		dynamic_cast<Music *> ($$)->set_property ("span-direction",
-			gh_int2scm (START));
+			scm_int2num (START));
 	}
 	| open_event {
 		$$ = $1;
 		dynamic_cast<Music *> ($$)->set_property ("span-direction",
-			gh_int2scm (STOP));
+			scm_int2num (STOP));
 	}
 	| EVENT_IDENTIFIER	{
 		$$ = unsmob_music ($1);
 	}
 	| tremolo_type  {
-               Music * a = MY_MAKE_MUSIC ("TremoloEvent");
+               Music *a = MY_MAKE_MUSIC ("TremoloEvent");
                a->set_spot (THIS->here_input ());
-               a->set_property ("tremolo-type", gh_int2scm ($1));
+               a->set_property ("tremolo-type", scm_int2num ($1));
                $$ = a;
         }
 	;	
 	
 direction_reqd_event:
 	gen_text_def {
-		$$ = $1; 
+		$$ = $1;
 	}
 	| script_abbreviation {
 		SCM s = THIS->lexer_->lookup_identifier ("dash" + ly_scm2string ($1));
 		Music *a = MY_MAKE_MUSIC ("ArticulationEvent");
-		if (gh_string_p (s))
+		if (ly_c_string_p (s))
 			a->set_property ("articulation-type", s);
 		else THIS->parser_error (_ ("Expecting string as script definition"));
 		$$ = a;
@@ -1637,9 +1780,9 @@ direction_reqd_event:
 
 oct_check:
 	/**/ { $$ = SCM_EOL; }
-	| '='  { $$ = gh_int2scm (0); }
-	| '=' sub_quotes { $$ = gh_int2scm ($2); }
-	| '=' sup_quotes { $$ = gh_int2scm ($2); }
+	| '='  { $$ = scm_int2num (0); }
+	| '=' sub_quotes { $$ = scm_int2num ($2); }
+	| '=' sup_quotes { $$ = scm_int2num ($2); }
 	;
 
 sup_quotes:
@@ -1656,7 +1799,7 @@ sub_quotes:
 		$$ = 1;
 	}
 	| sub_quotes ',' {
-		$$ ++ ;
+		$$++;
 	}
 	;
 
@@ -1710,22 +1853,22 @@ pitch_also_in_chords:
 
 close_event:
 	'('	{
-		Music * s= MY_MAKE_MUSIC ("SlurEvent");
+		Music *s = MY_MAKE_MUSIC ("SlurEvent");
 		$$ = s;
 		s->set_spot (THIS->here_input ());
 	}
 	| E_OPEN	{
-		Music * s= MY_MAKE_MUSIC ("PhrasingSlurEvent");
+		Music *s = MY_MAKE_MUSIC ("PhrasingSlurEvent");
 		$$ = s;
 		s->set_spot (THIS->here_input ());
 	}
 	| E_SMALLER {
-		Music *s =MY_MAKE_MUSIC ("CrescendoEvent");
+		Music *s = MY_MAKE_MUSIC ("CrescendoEvent");
 		$$ = s;
 		s->set_spot (THIS->here_input ());
 	}
 	| E_BIGGER {
-		Music *s =MY_MAKE_MUSIC ("DecrescendoEvent");
+		Music *s = MY_MAKE_MUSIC ("DecrescendoEvent");
 		$$ = s;
 		s->set_spot (THIS->here_input ());
 	}
@@ -1734,21 +1877,22 @@ close_event:
 
 open_event:
 	E_EXCLAMATION 	{
-		Music *s =  MY_MAKE_MUSIC ("CrescendoEvent");
+		Music *s = MY_MAKE_MUSIC ("CrescendoEvent");
 		s->set_spot (THIS->here_input ());
 
 		$$ = s;
 	}
 	| ')'	{
-		Music * s= MY_MAKE_MUSIC ("SlurEvent");
+		Music *s= MY_MAKE_MUSIC ("SlurEvent");
 		$$ = s;
 		s->set_spot (THIS->here_input ());
 
 	}
 	| E_CLOSE	{
-		Music * s= MY_MAKE_MUSIC ("PhrasingSlurEvent");
+		Music *s= MY_MAKE_MUSIC ("PhrasingSlurEvent");
 		$$ = s;
-		s->set_property ("span-type", scm_makfrom0str ( "phrasing-slur"));
+		s->set_property ("span-type",
+			scm_makfrom0str ("phrasing-slur"));
 		s->set_spot (THIS->here_input ());
 	}
 	;
@@ -1762,14 +1906,15 @@ gen_text_def:
 	}
 	| string {
 		Music *t = MY_MAKE_MUSIC ("TextScriptEvent");
-		t->set_property ("text", make_simple_markup ($1));
+		t->set_property ("text",
+			make_simple_markup (THIS->lexer_->encoding (), $1));
 		t->set_spot (THIS->here_input ());
 		$$ = t;
 	
 	}
 	| DIGIT {
-		Music * t = MY_MAKE_MUSIC ("FingerEvent");
-		t->set_property ("digit",  gh_int2scm ($1));
+		Music *t = MY_MAKE_MUSIC ("FingerEvent");
+		t->set_property ("digit", scm_int2num ($1));
 		t->set_spot (THIS->here_input ());
 		$$ = t;
 	}
@@ -1835,26 +1980,22 @@ optional_notemode_duration:
 
 steno_duration:
 	bare_unsigned dots		{
-		int l = 0;
-		if (!is_is_duration ($1))
+		int len = 0;
+		if (!is_duration ($1))
 			THIS->parser_error (_f ("not a duration: %d", $1));
 		else
-			l =  intlog2 ($1);
+			len = intlog2 ($1);
 
-		$$ = Duration (l, $2).smobbed_copy ();
+		$$ = Duration (len, $2).smobbed_copy ();
 	}
 	| DURATION_IDENTIFIER dots	{
-		Duration *d =unsmob_duration ($1);
-		Duration k (d->duration_log (),d->dot_count () + $2);
-
+		Duration *d = unsmob_duration ($1);
+		Duration k (d->duration_log (), d->dot_count () + $2);
 		*d = k;
 		$$ = $1;
 	}
 	;
 
-
-
-
 multiplied_duration:
 	steno_duration {
 		$$ = $1;
@@ -1863,7 +2004,7 @@ multiplied_duration:
 		$$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
 	}
 	| multiplied_duration '*' FRACTION {
-		Rational  m (gh_scm2int (ly_car ($3)), gh_scm2int (ly_cdr ($3)));
+		Rational  m (ly_scm2int (ly_car ($3)), ly_scm2int (ly_cdr ($3)));
 
 		$$ = unsmob_duration ($$)->compressed (m).smobbed_copy ();
 	}
@@ -1872,7 +2013,7 @@ multiplied_duration:
 fraction:
 	FRACTION { $$ = $1; }
 	| UNSIGNED '/' UNSIGNED {
-		$$ = scm_cons (gh_int2scm ($1), gh_int2scm ($3));
+		$$ = scm_cons (scm_int2num ($1), scm_int2num ($3));
 	}
 	;
 
@@ -1885,36 +2026,34 @@ dots:
 	}
 	;
 
-
-tremolo_type: 
+tremolo_type:
 	':'	{
-		$$ =0;
+		$$ = 0;
 	}
 	| ':' bare_unsigned {
-		if (!is_is_duration ($2))
+		if (!is_duration ($2))
 			THIS->parser_error (_f ("not a duration: %d", $2));
 		$$ = $2;
 	}
 	;
 
-
-
-/*****************************************************************
-		BASS FIGURES
-*****************************************************************/
 bass_number:
 	DIGIT   {
-		$$ = scm_number_to_string (gh_int2scm ($1), gh_int2scm (10));
+		$$ = scm_number_to_string (scm_int2num ($1), scm_int2num (10));
+		$$ = scm_list_2 (ly_scheme_function ("number-markup"),
+				$$);
 	}
 	| UNSIGNED {
-		$$ = scm_number_to_string (gh_int2scm ($1), gh_int2scm (10));
+		$$ = scm_number_to_string (scm_int2num ($1), scm_int2num (10));
+		$$ = scm_list_2 (ly_scheme_function ("number-markup"),
+				$$);
 	}
-	| STRING { $$ =  $1; }
+	| STRING { $$ = $1; }
 	;
 
 bass_mod:
 	'-' 	{ $$ = -2; }
-	| '+'	{ $$ = 2; } 
+	| '+'	{ $$ = 2; }
 	| '!'	{ $$ = 0; }
 	;
 
@@ -1935,12 +2074,12 @@ bass_figure:
 	| bass_figure bass_mod {
 		Music *m = unsmob_music ($1);
 		if ($2) {
-			SCM salter =m->get_property ("alteration");
-			int alter = gh_number_p ( salter) ? gh_scm2int (salter) : 0;
+			SCM salter = m->get_property ("alteration");
+			int alter = ly_c_number_p (salter) ? ly_scm2int (salter) : 0;
 			m->set_property ("alteration",
-				gh_int2scm (alter + $2));
+				scm_int2num (alter + $2));
 		} else {
-			m->set_property ("alteration", gh_int2scm (0));
+			m->set_property ("alteration", scm_int2num (0));
 		}
 	}
 	;
@@ -1964,15 +2103,15 @@ figure_list:
 		$$ = SCM_EOL;
 	}
 	| figure_list br_bass_figure {
-		$$ = scm_cons ($2, $1); 
+		$$ = scm_cons ($2, $1);
 	}
 	;
 
 figure_spec:
 	FIGURE_OPEN figure_list FIGURE_CLOSE {
-		Music * m = MY_MAKE_MUSIC ("EventChord");
+		Music *m = MY_MAKE_MUSIC ("EventChord");
 		$2 = scm_reverse_x ($2, SCM_EOL);
-		m->set_property ("elements",  $2);
+		m->set_property ("elements", $2);
 		$$ = m->self_scm ();
 	}
 	;
@@ -1992,17 +2131,17 @@ simple_element:
 
 		Music *n = 0;
 		if ($6)
-			n =  MY_MAKE_MUSIC ("RestEvent");
+			n = MY_MAKE_MUSIC ("RestEvent");
 		else
-			n =  MY_MAKE_MUSIC ("NoteEvent");
+			n = MY_MAKE_MUSIC ("NoteEvent");
 		
 		n->set_property ("pitch", $1);
 		n->set_property ("duration", $5);
 
-		if (gh_number_p ($4))
+		if (ly_c_number_p ($4))
 		{
-			int q = gh_scm2int ($4); 
-			n->set_property ("absolute-octave", gh_int2scm (q-1));
+			int q = ly_scm2int ($4);
+			n->set_property ("absolute-octave", scm_int2num (q-1));
 		}
 
 		if ($3 % 2)
@@ -2021,9 +2160,9 @@ simple_element:
 	| DRUM_PITCH optional_notemode_duration {
 		Input i = THIS->pop_spot ();
 
-		Music *n =  MY_MAKE_MUSIC ("NoteEvent");
-		n->set_property ("duration" ,$2);
-		n->set_property ("drum-type" , $1);
+		Music *n = MY_MAKE_MUSIC ("NoteEvent");
+		n->set_property ("duration", $2);
+		n->set_property ("drum-type", $1);
 
 		Music *v = MY_MAKE_MUSIC ("EventChord");
 		v->set_property ("elements", scm_list_1 (n->self_scm ()));
@@ -2034,10 +2173,10 @@ simple_element:
 		
 	}
 	| figure_spec optional_notemode_duration {
-		Music * m = unsmob_music ($1);
-		Input i = THIS->pop_spot (); 
+		Music *m = unsmob_music ($1);
+		Input i = THIS->pop_spot ();
 		m->set_spot (i);
-		for (SCM s = m->get_property ("elements"); gh_pair_p (s); s = ly_cdr (s))
+		for (SCM s = m->get_property ("elements"); ly_c_pair_p (s); s = ly_cdr (s))
 		{
 			unsmob_music (ly_car (s))->set_property ("duration", $2);
 		}
@@ -2046,8 +2185,8 @@ simple_element:
  	| RESTNAME optional_notemode_duration		{
 
 		Input i = THIS->pop_spot ();
-		Music * ev = 0;
- 		if (ly_scm2string ($1) =="s") {
+		Music *ev = 0;
+ 		if (ly_scm2string ($1) == "s") {
 			/* Space */
 			ev = MY_MAKE_MUSIC ("SkipEvent");
 		  }
@@ -2055,9 +2194,9 @@ simple_element:
 			ev = MY_MAKE_MUSIC ("RestEvent");
 		
 		    }
-		ev->set_property ("duration" ,$2);
+		ev->set_property ("duration", $2);
 		ev->set_spot (i);
- 		Music * velt = MY_MAKE_MUSIC ("EventChord");
+ 		Music *velt = MY_MAKE_MUSIC ("EventChord");
 		velt->set_property ("elements", scm_list_1 (ev->self_scm ()));
 		velt->set_spot (i);
 
@@ -2068,10 +2207,7 @@ simple_element:
 	| MULTI_MEASURE_REST optional_notemode_duration  	{
 		THIS->pop_spot ();
 
-		static SCM proc ;
-		if (!proc)
-			proc = scm_c_eval_string ("make-multi-measure-rest");
-
+		SCM proc = ly_scheme_function ("make-multi-measure-rest");
 		SCM mus = scm_call_2 (proc, $2,
 			make_input (THIS->here_input ()));	
 		scm_gc_protect_object (mus);
@@ -2083,11 +2219,11 @@ simple_element:
 		if (!THIS->lexer_->is_lyric_state ())
 			THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
 
-		Music * lreq = MY_MAKE_MUSIC ("LyricEvent");
+		Music *lreq = MY_MAKE_MUSIC ("LyricEvent");
                 lreq->set_property ("text", $1);
 		lreq->set_property ("duration",$2);
 		lreq->set_spot (i);
-		Music * velt = MY_MAKE_MUSIC ("EventChord");
+		Music *velt = MY_MAKE_MUSIC ("EventChord");
 		velt->set_property ("elements", scm_list_1 (lreq->self_scm ()));
 
 		$$= velt;
@@ -2102,8 +2238,11 @@ simple_element:
 	;
 
 lyric_element:
-	full_markup { $$ = $1; }
-	| STRING {  $$ = $1 ; }
+	/* FIXME: lyric flavoured markup would be better */
+	full_markup {
+	}
+	| LYRICS_STRING {
+	}
 	;
 
 new_chord:
@@ -2112,7 +2251,7 @@ new_chord:
 	}
 	| steno_tonic_pitch optional_notemode_duration chord_separator chord_items {
 		SCM its = scm_reverse_x ($4, SCM_EOL);
-		$$ = make_chord ($1, $2, gh_cons ($3, its));
+		$$ = make_chord ($1, $2, scm_cons ($3, its));
 	}
 	;
 
@@ -2121,7 +2260,7 @@ chord_items:
 		$$ = SCM_EOL;		
 	}
 	| chord_items chord_item {
-		$$ = gh_cons ($2, $$);
+		$$ = scm_cons ($2, $$);
 	}
 	;
 
@@ -2130,13 +2269,13 @@ chord_separator:
 		$$ = ly_symbol2scm ("chord-colon");
 	}
 	| CHORD_CARET {
-		$$ = ly_symbol2scm ("chord-caret"); 
+		$$ = ly_symbol2scm ("chord-caret");
 	}
 	| CHORD_SLASH steno_tonic_pitch {
- 		$$ = scm_list_2 (ly_symbol2scm ("chord-slash"), $2); 
+ 		$$ = scm_list_2 (ly_symbol2scm ("chord-slash"), $2);
 	}
 	| CHORD_BASS steno_tonic_pitch {
-		$$ = scm_list_2 (ly_symbol2scm ("chord-bass"), $2); 
+		$$ = scm_list_2 (ly_symbol2scm ("chord-bass"), $2);
 	}
 	;
 
@@ -2153,23 +2292,23 @@ chord_item:
 	;
 
 step_numbers:
-	step_number { $$ = gh_cons ($1, SCM_EOL); } 
+	step_number { $$ = scm_cons ($1, SCM_EOL); }
 	| step_numbers '.' step_number {
-		$$ = gh_cons ($3, $$);
+		$$ = scm_cons ($3, $$);
 	}
 	;
 
 step_number:
 	bare_unsigned {
 		$$ = make_chord_step ($1, 0);
-        } 
+        }
 	| bare_unsigned '+' {
 		$$ = make_chord_step ($1, SHARP);
 	}
 	| bare_unsigned CHORD_MINUS {
 		$$ = make_chord_step ($1, FLAT);
 	}
-        ;	
+	;	
 
 /*
 	UTILITIES
@@ -2184,7 +2323,7 @@ number_expression:
 	| number_expression '-' number_term {
 		$$ = scm_difference ($1, $3);
 	}
-	| number_term 
+	| number_term
 	;
 
 number_term:
@@ -2209,7 +2348,7 @@ number_factor:
 
 bare_number:
 	UNSIGNED	{
-		$$ = gh_int2scm ($1);
+		$$ = scm_int2num ($1);
 	}
 	| REAL		{
 		$$ = $1;
@@ -2218,10 +2357,10 @@ bare_number:
 		$$ = $1;
 	}
 	| REAL NUMBER_IDENTIFIER	{
-		$$ = gh_double2scm (gh_scm2double ($1) * gh_scm2double ($2));
+		$$ = scm_make_real (ly_scm2double ($1) *ly_scm2double ($2));
 	}
 	| UNSIGNED NUMBER_IDENTIFIER	{
-		$$ = gh_double2scm ($1 * gh_scm2double ($2));
+		$$ = scm_make_real ($1 *ly_scm2double ($2));
 	}
 	;
 
@@ -2239,7 +2378,7 @@ bare_int:
 	bare_number {
 		if (scm_integer_p ($1) == SCM_BOOL_T)
 		{
-			int k = gh_scm2int ($1);
+			int k = ly_scm2int ($1);
 			$$ = k;
 		} else
 		{
@@ -2252,20 +2391,6 @@ bare_int:
 	}
 	;
 
-
-string:
-	STRING		{
-		$$ = $1;
-	}
-	| STRING_IDENTIFIER	{
-		$$ = $1;
-	}
-	| string '+' string {
-		$$ = scm_string_append (scm_list_2 ($1, $3));
-	}
-	;
-
-
 exclamations:
 		{ $$ = 0; }
 	| exclamations '!'	{ $$ ++; }
@@ -2282,7 +2407,7 @@ full_markup:
 	MARKUP_IDENTIFIER {
 		$$ = $1;
  	}
-	| MARKUP 
+	| MARKUP
 		{ THIS->lexer_->push_markup_state (); }
 	markup
 		{ $$ = $3;
@@ -2293,10 +2418,10 @@ full_markup:
 
 /*
 This should be done more dynamically if possible.
-*/ 
+*/
 markup:
 	STRING {
-		$$ = make_simple_markup ($1);
+		$$ = make_simple_markup (THIS->lexer_->encoding (), $1);
 	}
 	| MARKUP_HEAD_EMPTY {
 		$$ = scm_list_1 ($1);
@@ -2308,7 +2433,7 @@ markup:
 		$$ = scm_list_3 ($1, $2, $3);
 	}
 	| MARKUP_HEAD_SCM0_MARKUP1 SCM_T markup {
-		$$  = scm_list_3 ($1, $2, $3); 
+		$$ = scm_list_3 ($1, $2, $3);
 	}
 	| markup_line {
 		$$ = $1;
@@ -2334,6 +2459,29 @@ markup:
 	| STRING_IDENTIFIER {
 		$$ = $1;
 	}
+	| {
+		SCM nn = THIS->lexer_->lookup_identifier ("pitchnames");
+		THIS->lexer_->push_note_state (alist_to_hashq (nn));
+	}
+	/* cont */ score_block {
+		/* WIP this is a bit arbitrary,
+		   we should also allow \book or Composite_music.
+		   However, you'd typically want to change paper
+		   settings, and need a \score block anyway.  */
+
+		THIS->lexer_->pop_state ();
+ 		Score *score = $2;
+ 		Book *book = new Book;
+		book->scores_.push (score);
+			
+		Output_def *paper = get_paper (THIS);
+		book->bookpaper_ = get_bookpaper (THIS);
+
+		SCM s = book->to_stencil (paper, THIS->header_);
+ 		scm_gc_unprotect_object (score->self_scm ());
+ 		scm_gc_unprotect_object (book->self_scm ());
+		$$ = scm_list_2 (ly_scheme_function ("stencil-markup"), s);
+	}
 	;
 
 markup_list:
@@ -2342,9 +2490,7 @@ markup_list:
 
 markup_line:
 	'{' markup_list_body '}' {
-		static SCM line ;
-		if (!line)
-			line = scm_c_eval_string ("line-markup");
+		SCM line = ly_scheme_function ("line-markup");
 	
 		$$ = scm_list_2 (line, scm_reverse_x ($2, SCM_EOL));
 	}
@@ -2353,7 +2499,7 @@ markup_line:
 markup_list_body:
 	/**/ {  $$ = SCM_EOL; }
 	| markup_list_body markup {
-		$$ = gh_cons ($2, $1) ;
+		$$ = scm_cons ($2, $1);
 	}
 	;
 
@@ -2368,12 +2514,9 @@ My_lily_parser::set_yydebug (bool )
 #endif
 }
 
-extern My_lily_parser * current_parser;
-
 void
 My_lily_parser::do_yyparse ()
 {
-	current_parser = this;;
 	yyparse ((void*)this);
 }
 
@@ -2395,8 +2538,8 @@ My_lily_parser::beam_check (SCM dur)
   Duration *d = unsmob_duration (dur);
   if (unsmob_music (last_beam_start_) && d->duration_log () <= 2)
     {
-      Music * m = unsmob_music (last_beam_start_);
-      m->origin ()->warning (_("Suspect duration found following this beam"));
+      Music *m = unsmob_music (last_beam_start_);
+      m->origin ()->warning (_ ("Suspect duration found following this beam"));
     }
   last_beam_start_ = SCM_EOL;
 }
@@ -2411,22 +2554,22 @@ otherwise, we have to import music classes into the lexer.
 
 */
 int
-My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
+My_lily_lexer::try_special_identifiers (SCM *destination, SCM sid)
 {
-	if (gh_string_p (sid)) {
+	if (ly_c_string_p (sid)) {
 		*destination = sid;
 		return STRING_IDENTIFIER;
-	} else if (gh_number_p (sid)) {
+	} else if (ly_c_number_p (sid)) {
 		*destination = sid;
 		return NUMBER_IDENTIFIER;
 	} else if (unsmob_context_def (sid)) {
 		*destination = unsmob_context_def (sid)->clone_scm ();
 		return CONTEXT_DEF_IDENTIFIER;
 	} else if (unsmob_score (sid)) {
-		Score *sc =  new Score (*unsmob_score (sid));
-		*destination =sc->self_scm ();
+		Score *score = new Score (*unsmob_score (sid));
+		*destination = score->self_scm ();
 		return SCORE_IDENTIFIER;
-	} else if (Music * mus =unsmob_music (sid)) {
+	} else if (Music *mus = unsmob_music (sid)) {
 		mus = mus->clone ();
 		*destination = mus->self_scm ();
 		unsmob_music (*destination)->
@@ -2436,8 +2579,8 @@ My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
 	} else if (unsmob_duration (sid)) {
 		*destination = unsmob_duration (sid)->smobbed_copy ();
 		return DURATION_IDENTIFIER;
-	} else if (unsmob_music_output_def (sid)) {
-		Music_output_def *p = unsmob_music_output_def (sid);
+	} else if (unsmob_output_def (sid)) {
+		Output_def *p = unsmob_output_def (sid);
 		p = p->clone ();
 
 		*destination = p->self_scm ();
@@ -2453,31 +2596,31 @@ My_lily_lexer::try_special_identifiers (SCM * destination, SCM sid)
 Music *
 property_op_to_music (SCM op)
 {
-	Music * m = 0;
-	SCM tag = gh_car (op);
-	SCM symbol  = gh_cadr (op);
-	SCM args = gh_cddr (op);
+	Music *m = 0;
+	SCM tag = ly_car (op);
+	SCM symbol = ly_cadr (op);
+	SCM args = ly_cddr (op);
 	SCM grob_val = SCM_UNDEFINED;
 	SCM grob_sym = SCM_UNDEFINED;
 	SCM val = SCM_UNDEFINED;
 	
 	if (tag == ly_symbol2scm ("assign"))
 		{
-		m =  MY_MAKE_MUSIC ("PropertySet");
-		val = gh_car (args);
+		m = MY_MAKE_MUSIC ("PropertySet");
+		val = ly_car (args);
 		}
 	else if (tag == ly_symbol2scm ("unset"))
-		m =  MY_MAKE_MUSIC ("PropertyUnset");
+		m = MY_MAKE_MUSIC ("PropertyUnset");
 	else if (tag == ly_symbol2scm ("poppush")
 		 || tag == ly_symbol2scm ("push"))
 		{
-		m  = MY_MAKE_MUSIC ("OverrideProperty");
-		grob_sym = gh_car (args);
-		grob_val = gh_cadr (args);
+		m = MY_MAKE_MUSIC ("OverrideProperty");
+		grob_sym = ly_car (args);
+		grob_val = ly_cadr (args);
 		}
 	else if (tag == ly_symbol2scm ("pop")) {
 		m = MY_MAKE_MUSIC ("RevertProperty");
-		grob_sym = gh_car (args);
+		grob_sym = ly_car (args);
 		}
 
 	m->set_property ("symbol", symbol);
@@ -2492,7 +2635,7 @@ property_op_to_music (SCM op)
 		bool itc = internal_type_checking_global_b;
 		/* UGH.
 		*/
-		bool autobeam = gh_equal_p (symbol, ly_symbol2scm ("autoBeamSettings"));
+		bool autobeam = ly_c_equal_p (symbol, ly_symbol2scm ("autoBeamSettings"));
 		if (autobeam)
 			internal_type_checking_global_b = false;
 		m->set_property ("grob-property", grob_sym);
@@ -2500,39 +2643,36 @@ property_op_to_music (SCM op)
 			internal_type_checking_global_b = itc;
 		}
 
-	if (op == ly_symbol2scm ("poppush"))
-		m->set_property ("pop-first", SCM_BOOL_T); 
+	if (tag == ly_symbol2scm ("poppush"))
+		m->set_property ("pop-first", SCM_BOOL_T);
 
 
 	return m;
 }
 
 Music*
-context_spec_music (SCM type, SCM id, Music * m, SCM ops)
+context_spec_music (SCM type, SCM id, Music *m, SCM ops)
 {
-	Music * csm = MY_MAKE_MUSIC ("ContextSpeccedMusic");
+	Music *csm = MY_MAKE_MUSIC ("ContextSpeccedMusic");
 
 	csm->set_property ("element", m->self_scm ());
 	scm_gc_unprotect_object (m->self_scm ());
 
 	csm->set_property ("context-type",
-		gh_symbol_p (type) ? type : scm_string_to_symbol (type));
+		ly_c_symbol_p (type) ? type : scm_string_to_symbol (type));
 	csm->set_property ("property-operations", ops);
 
-	if (gh_string_p (id))
+	if (ly_c_string_p (id))
 		csm->set_property ("context-id", id);
 	return csm;
 }
 
-
 SCM
 get_next_unique_context ()
 {
 	static int new_context_count;
-
 	char s[1024];
-	snprintf (s, 1024, "uniqueContext%d", new_context_count ++);
-		
+	snprintf (s, 1024, "uniqueContext%d", new_context_count++);
 	return scm_makfrom0str (s);
 }