X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fparser.yy;h=50e13b4fa35367c7ecc22b265c57d5a2c2a5d234;hb=a478e5ad057eaf795f915e2b31293e947364d41d;hp=10e1b8df1a817e513033edea21cd0d230985f041;hpb=106e5978fe2fa568bbc6649bc8fcf1134307373a;p=lilypond.git

diff --git a/lily/parser.yy b/lily/parser.yy
index 10e1b8df1a..bbfaf2438a 100644
--- a/lily/parser.yy
+++ b/lily/parser.yy
@@ -1,67 +1,80 @@
 %{ // -*-Fundamental-*-
 
 /*
-  parser.yy -- Bison/C++ parser for mudela
+  parser.yy -- Bison/C++ parser for lilypond
 
   source file of the GNU LilyPond music typesetter
 
-  (c) 1997 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+  (c)  1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
            Jan Nieuwenhuizen <janneke@gnu.org>
 */
 
 #include <iostream.h>
-#include "notename-table.hh"
-#include "scalar.hh"
-#include "translation-property.hh"
-#include "script-def.hh"
-#include "symtable.hh"
-#include "lookup.hh"
+#include "translator-def.hh"
+#include "lily-guile.hh"
+#include "change-iterator.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 "keyword.hh"
 #include "debug.hh"
-#include "parseconstruct.hh"
-#include "dimension.hh"
-#include "identifier.hh"
+#include "dimensions.hh"
 #include "command-request.hh"
 #include "musical-request.hh"
 #include "my-lily-parser.hh"
-#include "text-def.hh"
-#include "translator-group.hh"
+#include "context-specced-music.hh"
 #include "score.hh"
 #include "music-list.hh"
-#include "header.hh"
-#include "duration-convert.hh"
-#include "change-translator.hh"
+#include "output-property-music-iterator.hh"
+#include "property-iterator.hh"
 #include "file-results.hh"
-#include "mudela-version.hh"
+#include "input.hh"
 #include "scope.hh"
 #include "relative-music.hh"
+#include "lyric-combine-music.hh"
 #include "transposed-music.hh"
+#include "time-scaled-music.hh"
+#include "repeated-music.hh"
+#include "lilypond-input-version.hh"
+#include "grace-music.hh"
+#include "auto-change-music.hh"
+#include "part-combine-music.hh"
+#include "scm-hash.hh"
+
+#include "chord.hh"
+
+bool
+is_duration_b (int t)
+{
+  return t && t == 1 << intlog2(t);
+}
 
-// mmm
-Mudela_version oldest_version ("1.0.6");
-Mudela_version version ("1.0.6");
 
+void
+set_music_properties (Music *p, SCM a)
+{
+  for (SCM k = a; gh_pair_p (k); k = gh_cdr (k))
+	{
+	p->set_mus_property (gh_caar (k), gh_cdar (k));
+	}
+}
 
-// needed for bison.simple's malloc() and free()
-#include <malloc.h>
 
-int const GUESS_PLET = 5;
-int guess_plet_a[GUESS_PLET] =
-{ 
-  1,
-  3,
-  2,
-  3,
-  4
-};
+// mmm JUNKME ?
+Lilypond_version oldest_version ("1.3.59");
+
+void
+print_lilypond_versions (ostream &os)
+{
+  os << _f ("Oldest supported input version: %s", oldest_version.str ()) 
+    << endl;
+}
+
 
-Paper_def* current_paper = 0;
+// needed for bison.simple's malloc() and free()
+#include <malloc.h>
 
 #ifndef NDEBUG
 #define YYDEBUG 1
@@ -74,52 +87,34 @@ Paper_def* current_paper = 0;
 #define THIS ((My_lily_parser *) my_lily_parser_l)
 
 #define yyerror THIS->parser_error
-#define ARRAY_SIZE(a,s)   if (a.size () != s) THIS->parser_error (_f("expecting %d arguments", s))
-
+#define ARRAY_SIZE(a,s)   if (a.size () != s) THIS->parser_error (_f ("Expecting %d arguments", s))
 
 %}
 
 
 %union {
-    Array<Interval>* intarr;
-    Array<Musical_pitch> *pitch_arr;
-    Array<String> * strvec;
-    Array<int> *intvec;
-    Box *box;
-    Simultaneous_music *chord;
-    Duration *duration;
-    Identifier *id;
-    Translator* trans;
+
+    Link_array<Request> *reqvec;
+    String * string;
     Music *music;
-    Music_list *music_list;
     Score *score;
-    Header *header;
-    Interval *interval;
-    Lookup*lookup;
-
+    Scope *scope;
+    Scheme_hash_table *scmhash;
     Musical_req* musreq;
     Music_output_def * outputdef;
-    Musical_pitch * pitch;
+
     Midi_def* midi;
-    Moment *moment;
-    Note_req *notereq;
-    Notename_table *notenametab;
-    Paper_def *paper;
     Real real;
     Request * request;
-    General_script_def * script;
-    Scalar *scalar;
-    String *string;
-    Atom * symbol;
-    Symtable * symtable;
-    Symtables * symtables;
-    Text_def * textdef;
+
+    /* 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. */
+
+    SCM scm;
+
     Tempo_req *tempo;
-    char c;
-    const char *consstr;
     int i;
-    int pair[2];
-    int ii[10];
 }
 %{
 
@@ -139,219 +134,242 @@ yylex (YYSTYPE *s,  void * v_l)
 %pure_parser
 
 /* tokens which are not keywords */
-
-%token ABSDYNAMIC
+%token AUTOCHANGE
+%token APPLY
+%token ARPEGGIO
+%token DYNAMICSCRIPT
+%token TEXTSCRIPT
 %token ACCEPTS
+%token ALTERNATIVE
 %token BAR
-%token BEAMPLET
-%token CADENZA
+%token BREATHE
+%token CHORDMODIFIERS
+%token CHORDS
+%token CHAR_T
 %token CLEF
 %token CM_T
 %token CONSISTS
 %token DURATION
-%token END
+%token SEQUENTIAL
+%token ELEMENTDESCRIPTIONS
+%token SIMULTANEOUS
+%token CONSISTSEND
+%token DENIES
+%token DURATION
+%token EXTENDER
 %token FONT
-%token GROUPING
+%token GLISSANDO
+%token GRACE
 %token HEADER
+%token HYPHEN
 %token IN_T
+%token INVALID
 %token KEY
-%token KEYSIGNATURE
-%token LYRIC
-%token MAEBTELP
+%token LYRICS
 %token MARK
 %token MEASURES
 %token MIDI
 %token MM_T
-%token MUSIC
-%token MUSICAL_PITCH
-%token NOTENAMES
+%token PITCH
+%token NAME
+%token PITCHNAMES
 %token NOTES
-%token OCTAVE
-%token OUTPUT
 %token PAPER
 %token PARTIAL
 %token PENALTY
-%token PLET
 %token PROPERTY
+%token OVERRIDE SET REVERT 
 %token PT_T
 %token RELATIVE
 %token REMOVE
+%token REPEAT
+%token ADDLYRICS
+%token PARTCOMBINE
+%token SCM_T
 %token SCORE
 %token SCRIPT
-%token SHAPE
 %token SKIP
-%token SPANDYNAMIC
-%token SYMBOLTABLES
-%token TABLE
-%token TELP
+%token SPANREQUEST
+%token STYLESHEET
+%token COMMANDSPANREQUEST
 %token TEMPO
+%token OUTPUTPROPERTY
 %token TIME_T
+%token TIMES
 %token TRANSLATOR
 %token TRANSPOSE
 %token TYPE
-%token VERSION
+%token CONTEXT
 
 /* escaped */
-%token E_EXCLAMATION E_SMALLER E_BIGGER E_CHAR
+%token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER 
+%token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET 
 
-%type <i>	dots
+%type <i>	exclamations questions dots
 %token <i>	DIGIT
-%token <pitch>	NOTENAME_PITCH
-%token <id>	DURATION_IDENTIFIER
+%token <scm>	NOTENAME_PITCH
+%token <scm>	TONICNAME_PITCH
+%token <scm>	CHORDMODIFIER_PITCH
+%token <scm>	DURATION_IDENTIFIER
 %token <id>	IDENTIFIER
-%token <id>	NOTENAME_TABLE_IDENTIFIER
-%token <id>	MUSIC_IDENTIFIER
-%token <id>	POST_REQUEST_IDENTIFIER
-%token <id>	SCRIPT_IDENTIFIER
-%token <id>	COMMAND_IDENTIFIER
-%token <id>	REAL_IDENTIFIER
-%token <id>	STRING_IDENTIFIER
-%token <id>	TRANS_IDENTIFIER
-%token <id>	INT_IDENTIFIER
-%token <id>	SCORE_IDENTIFIER
-%token <id>	MIDI_IDENTIFIER
-%token <id>	PAPER_IDENTIFIER
-%token <id>	REQUEST_IDENTIFIER
-%token <real>	REAL
-%token <string>	DURATION RESTNAME
-%token <string>	STRING
-%token <i>	UNSIGNED
 
 
+%token <scm>	SCORE_IDENTIFIER
+%token <scm>	MUSIC_OUTPUT_DEF_IDENTIFIER
+
+%token <scm>	NUMBER_IDENTIFIER
+%token <scm>	REQUEST_IDENTIFIER
+%token <scm>	MUSIC_IDENTIFIER TRANSLATOR_IDENTIFIER
+%token <scm>	STRING_IDENTIFIER SCM_IDENTIFIER 
+%token <scm>	RESTNAME
+%token <scm>	STRING 
+%token <scm>	SCM_T
+%token <i>	UNSIGNED
+%token <real>   REAL
+
 %type <outputdef> output_def
-%type <header> 	mudela_header mudela_header_body
-%type <box>	box
-%type <i>	open_request_parens close_request_parens
-%type <i>	open_abbrev_parens
-%type <i>	open_plet_parens close_plet_parens
+%type <scmhash> 	lilypond_header lilypond_header_body
+%type <request>	open_request_parens close_request_parens open_request close_request
+%type <request> request_with_dir request_that_take_dir verbose_request
 %type <i>	sub_quotes sup_quotes
-%type <music>	simple_element  request_chord command_element
-%type <i>	abbrev_type
-%type <i>	int unsigned
+%type <music>	simple_element  request_chord command_element Simple_music  Composite_music 
+%type <music>	Alternative_music Repeated_music
+%type <i>	tremolo_type
+%type <i>	bare_int  bare_unsigned
 %type <i>	script_dir
-%type <id>	identifier_init simple_identifier_init
-%type <duration> steno_duration notemode_duration
-%type <duration> entered_notemode_duration explicit_duration
-%type <interval>	dinterval
-%type <intvec>	intastint_list int_list
-%type <lookup>	symtables symtables_body
-
-%type <pitch>   explicit_musical_pitch steno_musical_pitch musical_pitch absolute_musical_pitch
-%type <notereq>	steno_notepitch
-%type <pitch_arr>	pitch_list
-%type <midi>	midi_block midi_body
-%type <duration>	duration_length
-
-%type <scalar>  scalar
-%type <music>	Music  relative_music Sequential_music Simultaneous_music
+
+%type <scm>	identifier_init 
+
+%type <scm> steno_duration optional_notemode_duration
+%type <scm> entered_notemode_duration explicit_duration
+	
+%type <reqvec>  pre_requests post_requests
+%type <request> gen_text_def
+%type <scm>   steno_pitch pitch absolute_pitch
+%type <scm>   explicit_pitch steno_tonic_pitch
+
+%type <scm>	chord_additions chord_subtractions chord_notes chord_step
+%type <music>	chord
+%type <scm>	chord_note chord_inversion chord_bass
+%type <scm>	duration_length
+
+%type <scm>  embedded_scm scalar
+%type <music>	Music Sequential_music Simultaneous_music Music_sequence
+%type <music>	relative_music re_rhythmed_music part_combined_music
 %type <music>	property_def translator_change
-%type <music_list> Music_list
-%type <paper>	paper_block paper_def_body
-%type <real>	dim real
-%type <real>	real_mult_expression real_primary
-%type <real>	unit
-%type <request> abbrev_command_req
-%type <request>	post_request structured_post_request
-%type <pair>	plet_fraction
-%type <request> command_req verbose_command_req
-%type <request>	script_req  dynamic_req
-%type <string>	string
-%type <string>	string_primary
+%type <scm> Music_list
+%type <outputdef>  music_output_def_body
+%type <request> shorthand_command_req
+%type <request>	post_request 
+%type <music> command_req verbose_command_req
+%type <request>	extender_req
+%type <request> hyphen_req
+%type <scm>	string bare_number number_expression
 %type <score>	score_block score_body
-%type <intarr>	shape_array
-%type <script>	script_definition script_body mudela_script gen_script_def
-%type <textdef> text_def finger
-%type <string>	script_abbreviation
-%type <symbol>	symboldef
-%type <symtable>	symtable symtable_body
-%type <trans>	translator_spec translator_spec_body
+
+%type <scm>	translator_spec_block translator_spec_body
 %type <tempo> 	tempo_request
-%type <notenametab> notenames_body notenames_block
-%expect 1
+%type <scm> notenames_body notenames_block chordmodifiers_block
+%type <scm>	script_abbreviation
+
 
 
+%left '-' '+'
+%left '*' '/'
+%left UNARY_MINUS
+
 %%
 
-mudela:	/* empty */
-	| mudela toplevel_expression {}
-	| mudela add_declaration { }
-	| mudela error
-	| mudela check_version { }
+lilypond:	/* empty */
+	| lilypond toplevel_expression {}
+	| lilypond assignment  { }
+	| lilypond error {
+		THIS->error_level_i_  = 1;
+		//THIS->parser_error (_ ("ly invalid"));
+	}
+	| lilypond INVALID	{
+		THIS->error_level_i_  = 1;
+		//THIS->parser_error (_ ("ly invalid"));
+	}
 	;
 
 toplevel_expression:
 	notenames_block			{
-		THIS->lexer_p_->set_notename_table ($1);
+		THIS->lexer_p_->pitchname_tab_ =  $1;
+	}
+	| chordmodifiers_block			{
+		THIS->lexer_p_->chordmodifier_tab_  = $1;
 	}
-	| mudela_header {
-		delete header_global_p;
-		header_global_p = $1;
+	| lilypond_header {
+		if (global_header_p)
+			scm_unprotect_object (global_header_p->self_scm ());
+		global_header_p = $1;
 	}
 	| score_block {
 		score_global_array.push ($1);
+		
 	}
-	| paper_block {
-		Identifier * id = new
-			Paper_def_identifier ($1, PAPER_IDENTIFIER);
-		THIS->lexer_p_->set_identifier ("$defaultpaper", id)
-	}
-	| midi_block {
-		Identifier * id = new
-			Midi_def_identifier ($1, MIDI_IDENTIFIER);
-		THIS->lexer_p_->set_identifier ("$defaultmidi", id)
+	| output_def {
+		if (dynamic_cast<Paper_def*> ($1))
+			THIS->lexer_p_->set_identifier ("$defaultpaper", $1->self_scm ());
+		else if (dynamic_cast<Midi_def*> ($1))
+			THIS->lexer_p_->set_identifier ("$defaultmidi", $1->self_scm ());
 	}
+	| embedded_scm {
+		// junk value
+	}	
 	;
 
-check_version:
-	VERSION STRING ';'		{
-	 	Mudela_version ver (*$2);
-		if (!((ver >= oldest_version) && (ver <= version))) {
-			if (THIS->ignore_version_b_) {
-				THIS->here_input ().error (_f ("incorrect mudela version: %s (%s, %s)", ver.str (), oldest_version.str (), version.str ()));
-			} else {
-				THIS->fatal_error_i_ = 1;
-				THIS->parser_error (_f ("incorrect mudela version: %s (%s, %s)", ver.str (), oldest_version.str (), version.str ()));
-			}
-		}
-	}
+embedded_scm:
+	SCM_T
+	| SCM_IDENTIFIER 
+	;
+
+
+chordmodifiers_block:
+	CHORDMODIFIERS notenames_body   {  $$ = $2; }
 	;
 
 
 notenames_block:
-	NOTENAMES '{' notenames_body '}'  {  $$ = $3; }
+	PITCHNAMES notenames_body   {  $$ = $2; }
 	;
 
 
 
 notenames_body:
-	/**/	{
-		$$ = new Notename_table;
-	}
-	| NOTENAME_TABLE_IDENTIFIER	{
-		$$ = $1-> access_Notename_table();
-	}
-	| notenames_body STRING '=' explicit_musical_pitch {
-		(*$$)[*$2] = *$4;
+	embedded_scm	{
+	  int i = scm_ilength ($1);
+
+	  SCM tab = scm_make_vector (gh_int2scm (i), SCM_EOL);
+	  for (SCM s = $1; gh_pair_p (s); s = gh_cdr (s)) {
+		SCM pt = gh_cdar (s);
+		if (!unsmob_pitch (pt))
+			THIS->parser_error ("Need pitch object.");
+		else
+			scm_hashq_set_x (tab, gh_caar(s), pt);
+	  }
 
-		delete $4;
-		delete $2;
+	  $$ = tab;
 	}
 	;
 
-mudela_header_body:
-		{
-		$$ = new Header;
+lilypond_header_body:
+	{
+		$$ = new Scheme_hash_table;
+		
+		Scope *sc = new Scope ($$);
+		THIS->lexer_p_-> scope_l_arr_.push (sc);
 	}
-	| mudela_header_body STRING '=' string ';' {
-		(*$$)[*$2] = *$4;
-		delete $2;
-		delete $4;
+	| lilypond_header_body assignment semicolon { 
+
 	}
 	;
 
-mudela_header:
-	HEADER '{' mudela_header_body '}'	{
+lilypond_header:
+	HEADER '{' lilypond_header_body '}'	{
 		$$ = $3;
+		delete THIS->lexer_p_-> scope_l_arr_.pop ();
 	}
 	;
 
@@ -359,118 +377,125 @@ mudela_header:
 /*
 	DECLARATIONS
 */
-add_declaration:
+assignment:
 	STRING {
 		THIS->remember_spot ();
 	}
-	/* cont */ '=' identifier_init optional_semicolon {
-	    THIS->lexer_p_->set_identifier (*$1, $4);
-	    $4->init_b_ = THIS->init_parse_b_;
-	    $4->set_spot (THIS->pop_spot ());
+	/* cont */ '=' identifier_init  {
+	        THIS->lexer_p_->set_identifier (ly_scm2string ($1), $4);
+
+/*
+ TODO: devise standard for protection in parser.
+
+  The parser stack lives on the C-stack, which means that
+all objects can be unprotected as soon as they're here.
+
+*/
+	/*
+		Should find generic way of associating input with objects.
+	*/
+		THIS->pop_spot ();
 	}
 	;
-simple_identifier_init: identifier_init
-	;
+
+
+
 identifier_init:
 	score_block {
-		$$ = new Score_identifier ($1, SCORE_IDENTIFIER);
-
-	}
-	| notenames_block {
-		$$ = new Notename_table_identifier ($1, NOTENAME_TABLE_IDENTIFIER);
+		$$ = $1->self_scm ();
+		scm_unprotect_object ($$);
 	}
-	| paper_block {
-		$$ = new Paper_def_identifier ($1, PAPER_IDENTIFIER);
+	| output_def {
+		$$ = $1->self_scm ();
+		scm_unprotect_object ($$);
 	}
-	| midi_block {
-		$$ = new Midi_def_identifier ($1, MIDI_IDENTIFIER);
-
-	}
-	| script_definition {
-		$$ = new General_script_def_identifier ($1, SCRIPT_IDENTIFIER);
-
+	| translator_spec_block {
+		$$ = $1;
 	}
 	| Music  {
-		$$ = new Music_identifier ($1, MUSIC_IDENTIFIER);
-
-	}
-	| symtables {
-		$$ = new Lookup_identifier ($1, IDENTIFIER);
-
+		$$ = $1->self_scm ();
+		scm_unprotect_object ($$);
 	}
 	| post_request {
-		$$ = new Request_identifier ($1, POST_REQUEST_IDENTIFIER);
+		$$ = $1->self_scm ();
+		scm_unprotect_object ($$);
 	}
 	| explicit_duration {
-		$$ = new Duration_identifier ($1, DURATION_IDENTIFIER);
+		$$ = $1;
 	}
-	| real {
-		$$ = new Real_identifier (new Real ($1), REAL_IDENTIFIER);
+	| number_expression {
+		$$ = $1;
 	}
 	| string {
-		$$ = new String_identifier ($1, STRING_IDENTIFIER);
-	}
-	| int	{
-		$$ = new int_identifier (new int ($1), INT_IDENTIFIER);
+		$$ = $1;
 	}
-	| translator_spec {
-		$$ = new Translator_identifier ($1, TRANS_IDENTIFIER);
+	| embedded_scm	{
+		$$ = $1;
 	}
 	;
 
-translator_spec:
+translator_spec_block:
 	TRANSLATOR '{' translator_spec_body '}'
-		{ $$ = $3; }
+		{
+		$$ = $3;
+	}
 	;
 
 translator_spec_body:
-	TRANS_IDENTIFIER	{
-		$$ = $1->access_Translator ();
-		$$-> set_spot (THIS->here_input ());
-	}
-	| TYPE STRING ';'	{
-		Translator* t = get_translator_l (*$2);
-		Translator_group * tg = t->access_Translator_group ();
+	TRANSLATOR_IDENTIFIER	{
+		$$ = unsmob_translator_def ($1)->clone_scm ();
+		unsmob_translator_def ($$)-> set_spot (THIS->here_input ());
+	}
+	| TYPE STRING semicolon	{
+		$$ = Translator_def::make_scm ();
+		Translator_def*td =  unsmob_translator_def ($$);
+		td->translator_group_type_ = $2;
+		td->set_spot (THIS->here_input ());
+	}
+	| translator_spec_body STRING '=' embedded_scm			{
+		unsmob_translator_def ($$)->add_property_assign ($2, $4);
+	}
+	| translator_spec_body STRING OVERRIDE embedded_scm '=' embedded_scm {
+		unsmob_translator_def ($$)
+			->add_push_property (scm_string_to_symbol ($2), $4, $6);
+	}
+	| translator_spec_body STRING REVERT embedded_scm  {
+	  unsmob_translator_def($$)->add_pop_property (
+		scm_string_to_symbol ($2), $4);
+	}
+	| translator_spec_body STRING '=' identifier_init semicolon	{ 
+		SCM v = gh_int2scm (0);
+		if (gh_string_p ($4) || gh_number_p ($4) || gh_boolean_p ($4))
+			v = $4;
+		else 
+			THIS->parser_error (_("Wrong type for property value"));
 
-		if (!tg)
-			THIS->parser_error (_("Need a translator group for a context"));
-		
-		t = t->clone ();
-		t->set_spot (THIS->here_input ());
-		$$ = t;
-		delete $2;
+		/* ugh*/
+		unsmob_translator_def($$)->add_property_assign ($2, v);
 	}
-	| translator_spec_body STRING '=' simple_identifier_init ';'	{ 
-		Identifier* id = $4;
-		String_identifier *s = id->access_String_identifier ();
-		Real_identifier *r= id->access_Real_identifier ();
-		int_identifier *i = id->access_int_identifier ();
-	
-		String str;
-		if (s) str = *s->access_String (false); 
-		if (i) str = to_str (*i->access_int (false));
-		if (r) str = to_str (*r->access_Real (false));
-		if (!s && !i && !r)
-			THIS->parser_error (_("Wrong type for property value"));
+	| translator_spec_body NAME STRING semicolon {
+		unsmob_translator_def ($$)->type_name_ = $3;
+	}
+	| translator_spec_body CONSISTS STRING semicolon {
+		unsmob_translator_def ($$)->add_element ($3);
+	}
+	| translator_spec_body ELEMENTDESCRIPTIONS embedded_scm {
+		for (SCM p = $3; gh_pair_p (p); p = gh_cdr (p))
+			unsmob_translator_def ($$)
+			->add_property_assign (scm_symbol_to_string (gh_caar (p)), gh_cdar (p));
 
-		delete $4;
-		$$->set_property (*$2, str);
 	}
-	| translator_spec_body STRING ';' {
-		$$->type_str_ = *$2;
-		delete $2;
+	| translator_spec_body CONSISTSEND STRING semicolon {
+		unsmob_translator_def ($$)->add_last_element ( $3);
 	}
-	| translator_spec_body CONSISTS STRING ';' {
-		$$->access_Translator_group ()-> set_element (*$3, true);
-		delete $3;
+	| translator_spec_body ACCEPTS STRING semicolon {
+		unsmob_translator_def ($$)->set_acceptor ($3,true);
 	}
-	| translator_spec_body ACCEPTS STRING ';' {
-		$$->access_Translator_group ()-> set_acceptor (*$3, true);
-		delete $3;
+	| translator_spec_body DENIES STRING semicolon {
+		unsmob_translator_def ($$)->set_acceptor ($3,false);
 	}
-	| translator_spec_body REMOVE STRING ';' {
-		$$->access_Translator_group ()-> set_element (*$3, false);
-		delete $3;
+	| translator_spec_body REMOVE STRING semicolon {
+		unsmob_translator_def ($$)->remove_element ($3);
 	}
 	;
 
@@ -478,35 +503,38 @@ translator_spec_body:
 	SCORE
 */
 score_block:
-	SCORE { THIS->remember_spot ();
-		THIS->error_level_i_ =0;
+	SCORE { 
+		THIS->remember_spot ();
 	}
 	/*cont*/ '{' score_body '}' 	{
+		THIS->pop_spot ();
 		$$ = $4;
-		$$->set_spot (THIS->pop_spot ());
 		if (!$$->def_p_arr_.size ())
-			$$->add_output (THIS->default_paper_p ());
-
-		/* handle error levels. */
-		$$->errorlevel_i_ = THIS->error_level_i_;
-		THIS->error_level_i_ = 0;
+		{
+		  Music_output_def *id =
+			unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultpaper"));
+		  $$->add_output (id ? id->clone () :  new Paper_def );
+		}
 	}
 	;
 
-score_body:		{
+score_body:
+	Music	{
 		$$ = new Score;
+	
+		$$->set_spot (THIS->here_input ());
+		SCM m = $1->self_scm ();
+		scm_unprotect_object (m);
+		$$->music_ = m;
 	}
 	| SCORE_IDENTIFIER {
-		$$ = $1->access_Score ();
+		$$ = new Score (*unsmob_score ($1));
+		$$->set_spot (THIS->here_input ());
 	}
-	| score_body mudela_header 	{
+	| score_body lilypond_header 	{
+		scm_unprotect_object ($2->self_scm ()); 
 		$$->header_p_ = $2;
 	}
-	| score_body Music	{
-		if ($$->music_p_)
-			$2->warning (_ ("More than one music block"));	
-		$$->music_p_ = $2;
-	}
 	| score_body output_def {
 		$$->add_output ($2);
 	}
@@ -515,389 +543,740 @@ score_body:		{
 	}
 	;
 
-output_def:
-	paper_block {
-		$$ = $1;
-	}
-	|  midi_block		{
-		$$= $1;
-	}
-	;
-
-intastint_list:
-	/* */	{ $$ =new Array<int>; }
-	| intastint_list int '*' int	{
-		$$->push ($2); $$->push ($4);
-	}
-	| intastint_list int	{
-		$$->push ($2); $$->push (1);
-	}
-	;	
-
 
 /*
-	PAPER
+	MIDI
 */
-paper_block:
-	PAPER '{' paper_def_body '}' 	{ 
-		$$ = $3;
-		THIS-> lexer_p_->scope_l_arr_.pop ();
+output_def:
+	music_output_def_body '}' {
+		$$ = $1;
+		THIS-> lexer_p_-> scope_l_arr_.pop();
 	}
 	;
 
-optional_semicolon:
-	/* empty */
-	| ';'
-	;
+music_output_def_body:
+	MIDI '{'    {
+	   Music_output_def *id = unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultmidi"));
 
-paper_def_body:
-	/* empty */		 	{
-		Paper_def *p = THIS->default_paper_p ();
+		
+	 Midi_def* p =0;
+	if (id)
+		p = dynamic_cast<Midi_def*> (id->clone ());
+	else
+		p = new Midi_def;
+
+	 $$ = p;
+	 THIS->lexer_p_->scope_l_arr_.push (p->scope_p_);
+	}
+	| PAPER '{' 	{
+		Music_output_def *id = unsmob_music_output_def (THIS->lexer_p_->lookup_identifier ("$defaultpaper"));
+		  Paper_def *p = 0;
+		if (id)
+			p = dynamic_cast<Paper_def*> (id->clone ());
+		else
+			p = new Paper_def;
 		THIS-> lexer_p_-> scope_l_arr_.push (p->scope_p_);
 		$$ = p;
 	}
-	| PAPER_IDENTIFIER optional_semicolon	{
-		Paper_def *p = $1->access_Paper_def ();
+	| PAPER '{' MUSIC_OUTPUT_DEF_IDENTIFIER 	{
+		Music_output_def *p = unsmob_music_output_def ($3);
+		p = p->clone();
+		THIS->lexer_p_->scope_l_arr_.push (p->scope_p_);
+		$$ = p;
+	}
+	| MIDI '{' MUSIC_OUTPUT_DEF_IDENTIFIER 	{
+		Music_output_def *p = unsmob_music_output_def ($3);
+		p = p->clone();
+
 		THIS->lexer_p_->scope_l_arr_.push (p->scope_p_);
 		$$ = p;
 	}
-	| paper_def_body int '=' symtables		{ // ugh, what a syntax
-		$$->set_lookup ($2, $4);
+	| music_output_def_body assignment semicolon {
+
 	}
-	| paper_def_body STRING '=' simple_identifier_init ';' {
-	      THIS->lexer_p_->set_identifier (*$2, $4);
-	      delete $2;
+	| music_output_def_body translator_spec_block	{
+		$$->assign_translator ($2);
 	}
-	| paper_def_body translator_spec {
-		$$-> assign_translator ($2);
+	| music_output_def_body STYLESHEET embedded_scm {
+		dynamic_cast<Paper_def*> ($$)-> style_sheet_ = $3;
 	}
-	| paper_def_body SHAPE '=' shape_array ';' {
-		$$->shape_int_a_ = *$4;
-		delete $4;
+	| music_output_def_body tempo_request semicolon {
+		/*
+			junk this ? there already is tempo stuff in
+			music.
+		*/
+		int m = gh_scm2int ( $2->get_mus_property ("metronome-count"));
+		Duration *d = unsmob_duration ($2->get_mus_property ("duration"));
+		dynamic_cast<Midi_def*> ($$)->set_tempo (d->length_mom (), m);
 	}
-	| paper_def_body error {
+	| music_output_def_body error {
 
 	}
 	;
 
-real_primary:
-	REAL		{
-		$$ = $1;
-	}
-	| REAL_IDENTIFIER		{
-		Real *r_p = $1->access_Real ();
-		$$ = * r_p;
-		DOUT << "Lookup real: " << *r_p << "\n";
-		delete r_p;
-	}
-	| dim
-	| '(' real ')' {
-		$$ = $2;
+tempo_request:
+	TEMPO steno_duration '=' bare_unsigned	{
+		$$ = new Tempo_req;
+		$$->set_mus_property ("duration", $2);
+		$$->set_mus_property ("metronome-count", gh_int2scm ( $4));
 	}
 	;
 
-real:
-	real_mult_expression
-	| real '+' real_mult_expression {
-		$$ = $1 + $3;
+Music_list: /* empty */ {
+		$$ = gh_cons (SCM_EOL, SCM_EOL);
 	}
-	| real '-' real_mult_expression {
-		$$ = $1 - $3;
+	| Music_list Music {
+		SCM s = $$;
+		SCM c = gh_cons ($2->self_scm (), SCM_EOL);
+		scm_unprotect_object ($2->self_scm ()); /* UGH */
+		if (gh_pair_p (gh_cdr (s)))
+			gh_set_cdr_x (gh_cdr (s), c); /* append */
+		else
+			gh_set_car_x (s, c); /* set first cons */
+		gh_set_cdr_x (s, c) ;  /* remember last cell */ 
+	}
+	| Music_list error {
 	}
 	;
 
-real_mult_expression:
-	real_primary
-	| real_mult_expression '*' real_primary {
-		$$ = $1 * $3;
-	}
-	| real_mult_expression '/' real_primary {
-		$$ = $1 / $3;
-	}
+
+Music:
+	Simple_music
+	| Composite_music
 	;
 
-shape_array:
+Alternative_music:
 	/* empty */ {
-		$$ = new Array<Interval>;
+		$$ = 0;
+	}
+	| ALTERNATIVE Music_sequence {
+		$$ = $2;
+		$2->set_spot (THIS->here_input ());
 	}
-	| shape_array dim dim {
-		$$->push(Interval($2, $2 + $3));
-	};
+	;
 
-/*
-	MIDI
-*/
-midi_block:
-	MIDI
 
-	'{' midi_body '}' 	{ $$ = $3; }
-	;
 
-midi_body: /* empty */ 		{
-		$$ = THIS->default_midi_p ();
-	}
-	| MIDI_IDENTIFIER	{
-		$$ = $1-> access_Midi_def ();		
-	}
-	| midi_body translator_spec	{
-		$$-> assign_translator ($2);
+
+Repeated_music:
+	REPEAT STRING bare_unsigned Music Alternative_music
+	{
+		Music_sequence* alts = dynamic_cast <Music_sequence*> ($5);
+		if (alts && $3 < alts->length_i ())
+			$5->origin ()->warning (_ ("More alternatives than repeats.  Junking excess alternatives."));
+		Music *beg = $4;
+		int times = $3;
+
+		Repeated_music * r = new Repeated_music (SCM_EOL);
+
+		if (beg)
+			{
+			r-> set_mus_property ("body", beg->self_scm ());
+			scm_unprotect_object (beg->self_scm ());
+			}
+		r->set_mus_property ("repeat-count", gh_int2scm (times >? 1));
+
+		if (alts)
+			{
+			alts->truncate (times);
+			r-> set_mus_property ("alternatives", alts->self_scm ());
+			scm_unprotect_object (alts->self_scm ());  
+			}
+		SCM func = scm_eval2 (ly_symbol2scm ("repeat-name-to-ctor"), SCM_EOL);
+		SCM result = gh_call1 (func, $2);
+
+		set_music_properties (r, result);
+
+		r->set_spot (*$4->origin ());
+		$$ = r;
 	}
-	| midi_body tempo_request ';' {
-		$$->set_tempo ($2->dur_.length (), $2->metronome_i_);
-		delete $2;
+	;
+
+Music_sequence: '{' Music_list '}'	{
+		$$ = new Music_sequence (SCM_EOL);
+		$$->set_mus_property ("elements", gh_car ($2));
 	}
-	| midi_body error {
+	;
 
+Sequential_music:
+	SEQUENTIAL '{' Music_list '}'		{
+		$$ = new Sequential_music (SCM_EOL);
+		$$->set_mus_property ("elements", gh_car ($3));
+	}
+	| '{' Music_list '}'		{
+		$$ = new Sequential_music (SCM_EOL);
+		$$->set_mus_property ("elements", gh_car ($2));
 	}
 	;
 
-tempo_request:
-	TEMPO entered_notemode_duration '=' unsigned	{
-		$$ = new Tempo_req;
-		$$->dur_ = *$2;
-		delete $2;
-		$$-> metronome_i_ = $4;
+Simultaneous_music:
+	SIMULTANEOUS '{' Music_list '}'{
+		$$ = new Simultaneous_music (SCM_EOL);
+		$$->set_mus_property ("elements", gh_car ($3));
+
+	}
+	| '<' Music_list '>'	{
+		$$ = new Simultaneous_music (SCM_EOL);
+		$$->set_mus_property ("elements", gh_car ($2));
 	}
 	;
 
-Music_list: /* empty */ {
-		$$ = new Music_list;
+Simple_music:
+	request_chord		{ $$ = $1; }
+	| OUTPUTPROPERTY embedded_scm embedded_scm '=' embedded_scm	{
+		SCM pred = $2;
+		if (!gh_symbol_p ($3))
+		{
+			THIS->parser_error (_("Second argument must be a symbol")); 
+		}
+		/*hould check # args */
+		if (!gh_procedure_p (pred))
+		{
+			THIS->parser_error (_("First argument must be a procedure taking 1 argument"));
+		}
+
+	  Music *m = new Music (SCM_EOL);
+	  m->set_mus_property ("predicate", pred);
+	  m->set_mus_property ("symbol", $3);
+	  m->set_mus_property ("value",  $5);
+	  m->set_mus_property ("iterator-ctor",
+			Output_property_music_iterator::constructor_cxx_function);
+
+		$$ = m;
 	}
-	| Music_list Music {
-		$$->add_music ($2);
+	| MUSIC_IDENTIFIER {
+		$$ = unsmob_music ($1)->clone ();
 	}
-	| Music_list error {
+	| property_def
+	| translator_change
+	| Simple_music '*' bare_unsigned '/' bare_unsigned 	{
+		$$ = $1;
+		$$->compress (Moment($3, $5 ));
+	}
+	| Simple_music '*' bare_unsigned		 {
+		$$ = $1;
+		$$->compress (Moment ($3, 1));
 	}
 	;
 
 
-Sequential_music: '{' Music_list '}'		{
-		$$ = new Sequential_music ($2);
+Composite_music:
+	CONTEXT STRING Music	{
+		Context_specced_music *csm =  new Context_specced_music (SCM_EOL);
+		csm->set_mus_property ("element", $3->self_scm ());
+		scm_unprotect_object ($3->self_scm ());
+
+		csm->set_mus_property ("context-type",$2);
+		csm->set_mus_property ("context-id", ly_str02scm (""));
+
+		$$ = csm;
 	}
-	;
+	| AUTOCHANGE STRING Music	{
+		Auto_change_music * chm = new Auto_change_music (SCM_EOL);
+		chm->set_mus_property ("element", $3->self_scm ());
 
-Simultaneous_music: '<' Music_list '>'	{
-		$$ = new Simultaneous_music ($2);
+		scm_unprotect_object ($3->self_scm ());
+		chm->set_mus_property ("what", $2); 
+
+		$$ = chm;
+		chm->set_spot (*$3->origin ());
 	}
-	;
-Music:
-	request_chord		{ $$ = $1; }
-	| TYPE STRING Music	{
-		$$ = $3;
-		$$->translator_type_str_ = *$2;
-		delete $2;
+	| GRACE Music {
+		$$ = new Grace_music (SCM_EOL);
+		$$->set_mus_property ("element", $2->self_scm ());
+		scm_unprotect_object ($2->self_scm ());
+
+	}
+	| CONTEXT STRING '=' STRING Music {
+		Context_specced_music *csm =  new Context_specced_music (SCM_EOL);
+		csm->set_mus_property ("element", $5->self_scm ());
+		scm_unprotect_object ($5->self_scm ());
+
+		csm->set_mus_property ("context-type", $2);
+		csm->set_mus_property ("context-id", $4);
+
+		$$ = csm;
+	}
+	| TIMES {
+		THIS->remember_spot ();
 	}
-	| TYPE STRING '=' STRING Music {
-		$$ = $5;
-		$$->translator_type_str_ = *$2;
-		$$->translator_id_str_ = *$4;
-		delete $2;
-		delete $4;
+	/* CONTINUED */ 
+		bare_unsigned '/' bare_unsigned Music 	
+
+	{
+		int n = $3; int d = $5;
+		Music *mp = $6;
+		$$ = new Time_scaled_music (SCM_EOL);
+		$$->set_spot (THIS->pop_spot ());
+
+
+		$$->set_mus_property ("element", mp->self_scm ());
+		scm_unprotect_object (mp->self_scm ());
+		$$->set_mus_property ("numerator", gh_int2scm (n));
+		$$->set_mus_property ("denominator", gh_int2scm (d));
+		$$->compress (Moment (n,d));
+
 	}
+	| Repeated_music		{ $$ = $1; }
 	| Simultaneous_music		{ $$ = $1; }
 	| Sequential_music		{ $$ = $1; }
-	| TRANSPOSE musical_pitch Music {
-		$$ = new Transposed_music ($3, *$2);
-		delete $2;
+	| TRANSPOSE pitch Music {
+		$$ = new Transposed_music (SCM_EOL);
+		Music *p = $3;
+		Pitch pit = *unsmob_pitch ($2);
+
+		p->transpose (pit);
+		$$->set_mus_property ("element", p->self_scm ());
+		scm_unprotect_object (p->self_scm ());
+	}
+	| TRANSPOSE steno_tonic_pitch Music {
+		$$ = new Transposed_music (SCM_EOL);
+		Music *p = $3;
+		Pitch pit = *unsmob_pitch ($2);
+
+		p->transpose (pit);
+		$$->set_mus_property ("element", p->self_scm ());
+		scm_unprotect_object (p->self_scm ());
+	
+	}
+	| APPLY embedded_scm Music  {
+		SCM ret = gh_call1 ($2, $3->self_scm ());
+		Music *m = unsmob_music (ret);
+		if (!m) {
+			THIS->parser_error ("\\apply must return a Music");
+			m = new Music (SCM_EOL);
+			}
+		$$ = m;
 	}
-	| MUSIC_IDENTIFIER { $$ = $1->access_Music (); }
 	| NOTES
 		{ THIS->lexer_p_->push_note_state (); }
 	Music
 		{ $$ = $3;
 		  THIS->lexer_p_->pop_state ();
 		}
-
-	| LYRIC
+	| CHORDS
+		{ THIS->lexer_p_->push_chord_state (); }
+	Music
+		{
+		  $$ = $3;
+		  THIS->lexer_p_->pop_state ();
+	}
+	| LYRICS
 		{ THIS->lexer_p_->push_lyric_state (); }
 	Music
 		{
 		  $$ = $3;
 		  THIS->lexer_p_->pop_state ();
-		}
-	| property_def
-	| translator_change
+	}
 	| relative_music	{ $$ = $1; }
+	| re_rhythmed_music	{ $$ = $1; } 
+	| part_combined_music	{ $$ = $1; } 
 	;
 
 relative_music:
-	RELATIVE absolute_musical_pitch Music {
-		$$ = new Relative_octave_music ($3, *$2);
-		delete $2;
+	RELATIVE absolute_pitch Music {
+		Music * p = $3;
+		Pitch pit = *unsmob_pitch ($2);
+		$$ = new Relative_octave_music (SCM_EOL);
+
+		$$->set_mus_property ("element", p->self_scm ());
+		scm_unprotect_object (p->self_scm ());
+
+		$$->set_mus_property ("last-pitch", p->to_relative_octave (pit).smobbed_copy ());
+
+	}
+	;
+
+re_rhythmed_music:
+	ADDLYRICS Music Music {
+	  Lyric_combine_music * l = new Lyric_combine_music (SCM_EOL);
+	  l->set_mus_property ("music", $2->self_scm ());
+	  l->set_mus_property ("lyrics", $3->self_scm ());
+	  scm_unprotect_object ($3->self_scm ());
+	  scm_unprotect_object ($2->self_scm ());
+	  $$ = l;
+	}
+	;
+
+part_combined_music:
+	PARTCOMBINE STRING Music Music {
+		Part_combine_music * p = new Part_combine_music (SCM_EOL);
+
+		p->set_mus_property ("what", $2);
+		p->set_mus_property ("one", $3->self_scm ());
+		p->set_mus_property ("two", $4->self_scm ());  
+
+		scm_unprotect_object ($3->self_scm());
+		scm_unprotect_object ($4->self_scm());  
+
+
+		$$ = p;
 	}
 	;
 
 translator_change:
 	TRANSLATOR STRING '=' STRING  {
-		Change_translator * t = new Change_translator;
-		t-> change_to_type_str_ = *$2;
-		t-> change_to_id_str_ = *$4;
+		Music * t = new Music (SCM_EOL);
+		t->set_mus_property ("iterator-ctor",
+			Change_iterator::constructor_cxx_function);
+		t-> set_mus_property ("change-to-type", $2);
+		t-> set_mus_property ("change-to-id", $4);
 
 		$$ = t;
 		$$->set_spot (THIS->here_input ());
-		delete $2;
-		delete $4;
 	}
 	;
 
 property_def:
-	PROPERTY STRING '.' STRING '=' scalar	{
-		Translation_property *t = new Translation_property;
-		t-> translator_type_str_ = *$2;
-		t-> var_str_ = *$4;
-		t-> value_ = *$6;
-		$$ = t;
+	PROPERTY STRING '.' STRING '='  scalar {
+		Music *t = new Music (SCM_EOL);
+
+		t->set_mus_property ("iterator-ctor",
+			Property_iterator::constructor_cxx_function);
+		t->set_mus_property ("symbol", scm_string_to_symbol ($4));
+		t->set_mus_property ("value", $6);
+
+		Context_specced_music *csm = new Context_specced_music (SCM_EOL);
+
+		csm->set_mus_property ("element", t->self_scm ());
+		scm_unprotect_object (t->self_scm ());
+
+		$$ = csm;
+		$$->set_spot (THIS->here_input ());
+
+		csm-> set_mus_property ("context-type", $2);
+	}
+	| PROPERTY STRING '.' STRING SET embedded_scm '=' embedded_scm {
+		Music *t = new Music (SCM_EOL);
+		t->set_mus_property ("iterator-ctor",
+			Push_property_iterator::constructor_cxx_function);
+		t->set_mus_property ("symbols", scm_string_to_symbol ($4));
+		t->set_mus_property ("pop-first", SCM_BOOL_T);
+		t->set_mus_property ("grob-property", $6);
+		t->set_mus_property ("grob-value", $8);
+		Context_specced_music *csm = new Context_specced_music (SCM_EOL);
+		csm->set_mus_property ("element", t->self_scm ());
+		scm_unprotect_object (t->self_scm ());
+		$$ = csm;
+		$$->set_spot (THIS->here_input ());
+
+		csm-> set_mus_property ("context-type", $2);
+	}
+	| PROPERTY STRING '.' STRING OVERRIDE embedded_scm '=' embedded_scm {
+		Music *t = new Music (SCM_EOL);
+		t->set_mus_property ("iterator-ctor",
+			Push_property_iterator::constructor_cxx_function);
+		t->set_mus_property ("symbols", scm_string_to_symbol ($4));
+		t->set_mus_property ("grob-property", $6);
+		t->set_mus_property ("grob-value", $8);
+		Context_specced_music *csm = new Context_specced_music (SCM_EOL);
+		csm->set_mus_property ("element", t->self_scm ());
+		scm_unprotect_object (t->self_scm ());
+
+		$$ = csm;
 		$$->set_spot (THIS->here_input ());
-		delete $2;
-		delete $4;
-		delete $6;
+
+		csm-> set_mus_property ("context-type", $2);
+	}
+	| PROPERTY STRING '.' STRING REVERT embedded_scm {
+		Music *t = new Music (SCM_EOL);
+		t->set_mus_property ("iterator-ctor",
+			Pop_property_iterator::constructor_cxx_function);
+		t->set_mus_property ("symbols", scm_string_to_symbol ($4));
+		t->set_mus_property ("grob-property", $6);
+
+		Context_specced_music *csm = new Context_specced_music (SCM_EOL);
+		csm->set_mus_property ("element", t->self_scm ());
+		scm_unprotect_object (t->self_scm ());
+
+		$$ = csm;
+		$$->set_spot (THIS->here_input ());
+
+		csm-> set_mus_property ("context-type", $2);
 	}
 	;
 
 scalar:
-	STRING		{ $$ = new Scalar (*$1); delete $1; }
-	| int		{ $$ = new Scalar ($1); }
+	string		{ $$ = $1; }
+	| bare_int	{ $$ = gh_int2scm ($1); }
+	| embedded_scm 	{ $$ = $1; }
 	;
 
 
-
 request_chord:
 	pre_requests simple_element post_requests	{
-	 	THIS->add_requests ((Simultaneous_music*)$2);//ugh
+		Music_sequence *l = dynamic_cast<Music_sequence*>($2);
+		if (l) {
+			for (int i=0; i < $1->size(); i++)
+				l->append_music ($1->elem(i));
+			for (int i=0; i < $3->size(); i++)
+				l->append_music ($3->elem(i));
+			}
+		else
+			programming_error ("Need Sequence to add music to");
  		$$ = $2;
+		
 	}
 	| command_element
 	;
 
-
-
-
 command_element:
 	command_req {
-		$$ = new Request_chord;
+		$$ = new Request_chord (SCM_EOL);
+		$$->set_mus_property ("elements", gh_cons ($1->self_scm (), SCM_EOL));
 		$$-> set_spot (THIS->here_input ());
 		$1-> set_spot (THIS->here_input ());
-		((Simultaneous_music*)$$) ->add_music ($1);//ugh
+	}
+	| BAR STRING ';' 			{
+		Music *t = new Music (SCM_EOL);
+
+		t->set_mus_property ("iterator-ctor",
+			Property_iterator::constructor_cxx_function);
+		t->set_mus_property ("symbol", ly_symbol2scm ("whichBar"));
+		t->set_mus_property ("value", $2);
+
+		Context_specced_music *csm = new Context_specced_music (SCM_EOL);
+		csm->set_mus_property ("element", t->self_scm ());
+		scm_unprotect_object (t->self_scm ());
+
+		$$ = csm;
+		$$->set_spot (THIS->here_input ());
 
+		csm->set_mus_property ("context-type", ly_str02scm ("Score"));
+	}
+	| PARTIAL duration_length ';' 	{
+		Music * p = new Music (SCM_EOL);
+		p->set_mus_property ("symbol", ly_symbol2scm ( "measurePosition"));
+		p->set_mus_property ("iterator-ctor",
+			Property_iterator::constructor_cxx_function);
+
+		Moment m = - unsmob_duration($2)->length_mom ();
+		p->set_mus_property ("value", m.smobbed_copy ());
+
+		Context_specced_music * sp = new Context_specced_music (SCM_EOL);
+		sp->set_mus_property ("element", p->self_scm ());
+		scm_unprotect_object (p->self_scm ());
+
+		$$ =sp ;
+		sp-> set_mus_property ("context-type", ly_str02scm ( "Score"));
+	}
+	| CLEF STRING ';' {
+		SCM func = scm_eval2 (ly_symbol2scm ("clef-name-to-properties"), SCM_EOL);
+		SCM result = gh_call1 (func, $2);
+
+		SCM l = SCM_EOL;
+		for (SCM s = result ; gh_pair_p (s); s = gh_cdr (s)) {
+			Music * p = new Music (SCM_EOL);
+			set_music_properties(p, gh_car (s));
+			l = gh_cons (p->self_scm (), l);
+			scm_unprotect_object (p->self_scm ());
+		}
+		Sequential_music * seq = new Sequential_music (SCM_EOL);
+		seq->set_mus_property ("elements", l);
+
+		Context_specced_music * sp = new Context_specced_music (SCM_EOL);
+		sp->set_mus_property ("element", seq->self_scm ());
+		scm_unprotect_object (seq->self_scm ());
+
+		$$ =sp ;
+		sp-> set_mus_property("context-type", ly_str02scm("Staff"));
+	}
+	| TIME_T bare_unsigned '/' bare_unsigned ';' {
+		Music * p = new Music (SCM_EOL);
+		p->set_mus_property ("symbol",
+			ly_symbol2scm ( "timeSignatureFraction"));
+		p->set_mus_property ("iterator-ctor",
+			Property_iterator::constructor_cxx_function);
+
+		p->set_mus_property ("value", gh_cons (gh_int2scm ($2),
+							gh_int2scm ($4)));
+
+		Context_specced_music * sp = new Context_specced_music (SCM_EOL);
+		sp->set_mus_property ("element", p->self_scm ());
+		scm_unprotect_object (p->self_scm ());
+
+		$$ = sp;
+		sp-> set_mus_property ("context-type", ly_str02scm ( "Score"));
 	}
 	;
 
 command_req:
-	abbrev_command_req
-	| verbose_command_req ';'	{ $$ = $1; }
+	shorthand_command_req  	{ $$ = $1; }
+	| verbose_command_req semicolon	{ $$ = $1; }
 	;
 
-abbrev_command_req:
-	'|'				{
+shorthand_command_req:
+	extender_req {
+		$$ = $1;
+	}
+	| hyphen_req {
+		$$ = $1;
+	}
+	| '|'				{
 		$$ = new Barcheck_req;
 	}
-	| COMMAND_IDENTIFIER	{
-		$$ = $1->access_Request ();
+	| '~'	{
+		$$ = new Tie_req;
+	}
+	| '['		{
+		Span_req*b= new Span_req;
+		b->set_span_dir(START);
+		b->set_mus_property ("span-type", ly_str02scm ("beam"));
+		$$ =b;
+	}
+	| ']'		{
+		Span_req*b= new Span_req;
+		b->set_span_dir( STOP);
+		b->set_mus_property ("span-type", ly_str02scm ("beam"));
+		$$ = b;
+	}
+	| BREATHE {
+		$$ = new Breathing_sign_req;
 	}
 	;
 
+
 verbose_command_req:
-	BAR STRING 			{
-		$$ = new Bar_req (*$2);
-		delete $2;
+	COMMANDSPANREQUEST bare_int STRING {
+		Span_req * sp_p = new Span_req;
+		sp_p-> set_span_dir ( Direction($2));
+		sp_p->set_mus_property ("span-type",$3);
+		sp_p->set_spot (THIS->here_input ());
+		$$ = sp_p;
 	}
-	| MARK STRING {
-		$$ = new Mark_req (*$2);
-		delete $2;
+	| MARK  {
+		Mark_req * m = new Mark_req;
+		$$ = m;
 	}
-	| MARK unsigned {
-		$$ = new Mark_req (to_str ($2));
+	| MARK STRING {
+		Mark_req *m = new Mark_req;
+		m->set_mus_property ("label", $2);
+		$$ = m;
+
 	}
-	| TIME_T unsigned '/' unsigned 	{
-		Time_signature_change_req *m = new Time_signature_change_req;
-		m->beats_i_ = $2;
-		m->one_beat_i_=$4;
+	| MARK bare_unsigned {
+		Mark_req *m = new Mark_req;
+		m->set_mus_property ("label",  gh_int2scm ($2));
 		$$ = m;
 	}
-	| PENALTY '=' int	{
+	| PENALTY bare_int 	{
 		Break_req * b = new Break_req;
-		b->penalty_i_ = $3;
-		b-> set_spot (THIS->here_input ());
+		b->set_mus_property ("penalty", gh_double2scm ( $2 / 100.0));
+		b->set_spot (THIS->here_input ());
 		$$ = b;
 	}
 	| SKIP duration_length {
 		Skip_req * skip_p = new Skip_req;
-		skip_p->duration_ = *$2;
-		delete $2;
+		skip_p->set_mus_property ("duration", $2);
+
 		$$ = skip_p;
 	}
 	| tempo_request {
 		$$ = $1;
 	}
-	| CADENZA unsigned	{
-		$$ = new Cadenza_req ($2);
-	}
-	| PARTIAL duration_length 	{
-		$$ = new Partial_measure_req ($2->length ());
-		delete $2;
-	}
-	| CLEF STRING {
-		$$ = new Clef_change_req (*$2);
-		delete $2;
-	}
-	| KEY NOTENAME_PITCH 	{
+	| KEY {
 		Key_change_req *key_p= new Key_change_req;
-		key_p->pitch_arr_.push(*$2);
-		key_p->ordinary_key_b_ = true;
 		$$ = key_p;
-		delete $2;
 	}
-	| KEYSIGNATURE pitch_list 	{
+	| KEY NOTENAME_PITCH SCM_IDENTIFIER 	{
 		Key_change_req *key_p= new Key_change_req;
-		key_p->pitch_arr_ = *$2;
-		key_p->ordinary_key_b_ = false;
-		$$ = key_p;
-		delete $2;
-	}
-	| GROUPING intastint_list {
-		$$ = get_grouping_req (*$2); delete $2;
+		
+		key_p->set_mus_property ("pitch-alist", $3);
+		((Music* )key_p)->transpose (* unsmob_pitch ($2));
+		$$ = key_p; 
 	}
 	;
 
 post_requests:
 	{
-		/* something silly happened.  Junk this stuff*/
-		if (!THIS->post_reqs.empty ())
-		{
-			warning ("Junking post-requests");
-			THIS->post_reqs.clear ();
-		}
+		$$ = new Link_array<Request>;
 	}
-	| post_requests structured_post_request {
+	| post_requests post_request {
 		$2->set_spot (THIS->here_input ());
-		THIS->post_reqs.push ($2);
-	}
-	| post_requests close_request_parens	{
-		Array<Request*>& r = *THIS->get_parens_request ($2);
-		for (int i = 0; i < r.size (); i++ )
-			r[i]->set_spot (THIS->here_input ());
-		THIS->post_reqs.concat (r);
-		delete &r;
+		$$->push ($2);
 	}
 	;
 
-structured_post_request:
-	script_req
-	| post_request
+post_request:
+	verbose_request
+	| request_with_dir
+	| close_request
 	;
 
-post_request:
-	POST_REQUEST_IDENTIFIER	{
-		$$ = (Request*)$1->access_Request ();
+
+request_that_take_dir:
+	gen_text_def
+	| verbose_request
+	| script_abbreviation {
+		SCM s = THIS->lexer_p_->lookup_identifier ("dash-" + ly_scm2string ($1));
+		Articulation_req *a = new Articulation_req;
+		if (gh_string_p (s))
+			a->set_mus_property ("articulation-type", s);
+		else THIS->parser_error (_ ("Expecting string as script definition"));
+		$$ = a;
 	}
-	| dynamic_req {
-		$$ = $1;
+	;
+
+request_with_dir:
+	script_dir request_that_take_dir	{
+		if (Script_req * gs = dynamic_cast<Script_req*> ($2))
+			gs->set_direction (Direction ($1));
+		else if ($1)
+			$2->origin ()->warning (_ ("Can't specify direction for this request"));
+		$$ = $2;
+	}
+	;
+	
+verbose_request:
+	REQUEST_IDENTIFIER	{
+		$$ = dynamic_cast<Request*> (unsmob_music ($1)->clone ());
+		$$->set_spot (THIS->here_input ());
+	}
+	| DYNAMICSCRIPT embedded_scm {
+		/*
+			TODO: junkme, use text-type == dynamic
+		*/
+		Text_script_req *d = new Text_script_req;
+		d->set_mus_property ("text-type" , ly_symbol2scm ("dynamic"));
+		d->set_mus_property ("text", $2);
+		d->set_spot (THIS->here_input ());
+		$$ = d;
+	}
+	| TEXTSCRIPT embedded_scm {
+		Text_script_req *t = new Text_script_req;
+		t->set_mus_property ("text", $2);
+		t->set_spot (THIS->here_input ());
+		$$ = t;
+	}
+	| SPANREQUEST bare_int STRING {
+		Span_req * sp_p = new Span_req;
+		sp_p->set_span_dir( Direction($2));
+		sp_p->set_mus_property ("span-type", $3);
+		sp_p->set_spot (THIS->here_input ());
+		$$ = sp_p;
+	}
+	| tremolo_type	{
+		Tremolo_req* a = new Tremolo_req;
+		a->set_spot (THIS->here_input ());
+		a->set_mus_property ("tremolo-type", gh_int2scm ($1));
+		$$ = a;
+	}
+	| SCRIPT STRING 	{ 
+		Articulation_req * a = new Articulation_req;
+		a->set_mus_property ("articulation-type", $2);
+		a->set_spot (THIS->here_input ());
+		$$ = a;
 	}
-	| abbrev_type	{
-		Abbreviation_req* a = new Abbreviation_req;
-		a->type_i_ = $1;
+	| ARPEGGIO {
+		Arpeggio_req *a = new Arpeggio_req;
+		a->set_spot (THIS->here_input ());
 		$$ = a;
 	}
+	| GLISSANDO {
+		Glissando_req *g = new Glissando_req;
+		g->set_spot /* No pun intended */ (THIS->here_input ());
+		$$ = g;
+	}	
 	;
 
 sup_quotes:
@@ -908,6 +1287,7 @@ sup_quotes:
 		$$ ++;
 	}
 	;
+
 sub_quotes:
 	',' {
 		$$ = 1;
@@ -917,273 +1297,201 @@ sub_quotes:
 	}
 	;
 
-steno_musical_pitch:
+steno_pitch:
 	NOTENAME_PITCH	{
 		$$ = $1;
 	}
 	| NOTENAME_PITCH sup_quotes 	{
-		$$ = $1;
-		$$->octave_i_ +=  $2;
+		Pitch p = *unsmob_pitch ($1);
+		p.octave_i_ +=  $2;
+		$$ = p.smobbed_copy ();
 	}
 	| NOTENAME_PITCH sub_quotes	 {
-		$$ = $1;
-		$$->octave_i_ += - $2;
-	}
-	;
+		Pitch p =* unsmob_pitch ($1);
+
+		p.octave_i_ +=  -$2;
+		$$ = p.smobbed_copy ();
 
-explicit_musical_pitch:
-	MUSICAL_PITCH '{' int_list '}'	{/* ugh */
-		Array<int> &a = *$3;
-		ARRAY_SIZE(a,3);
-		$$ = new Musical_pitch;
-		$$->octave_i_ = a[0];
-		$$->notename_i_ = a[1];
-		$$->accidental_i_ = a[2];
-		delete &a;
 	}
 	;
 
-musical_pitch:
-	steno_musical_pitch
-	| explicit_musical_pitch
-	;
+/*
+ugh. duplication
+*/
 
-steno_notepitch:
-	musical_pitch	{
-		$$ = new Note_req;
-		
-		$$->pitch_ = *$1;
-		delete $1;
+steno_tonic_pitch:
+	TONICNAME_PITCH	{
+		$$ = $1;
 	}
-	| steno_notepitch  '!' 		{
-		$$->forceacc_b_ = ! $$->forceacc_b_;
+	| TONICNAME_PITCH sup_quotes 	{
+		Pitch p = *unsmob_pitch ($1);
+		p.octave_i_ +=  $2;
+		$$ = p.smobbed_copy ();
 	}
-	;
-
+	| TONICNAME_PITCH sub_quotes	 {
+		Pitch p =* unsmob_pitch ($1);
 
-explicit_duration:
-	DURATION '{' int_list '}'	{
-		$$ = new Duration;
-		Array<int> &a = *$3;
-		ARRAY_SIZE(a,2);
-			
-		$$-> durlog_i_ = a[0];
-		$$-> dots_i_ = a[1];
+		p.octave_i_ +=  -$2;
+		$$ = p.smobbed_copy ();
 
-		delete &a;		
 	}
 	;
 
-dynamic_req:
-	ABSDYNAMIC '{' unsigned '}'	{
-		Absolute_dynamic_req *ad_p = new Absolute_dynamic_req;
-		ad_p ->loudness_ = (Dynamic_req::Loudness)$3;
-		$$ =ad_p;
+pitch:
+	steno_pitch {
+		$$ = $1;
 	}
-	| SPANDYNAMIC '{' int int '}' {
-		Span_dynamic_req * sp_p = new Span_dynamic_req;
-		sp_p->spantype = (Span_req::Spantype)$4;
-		sp_p-> dynamic_dir_  = (Direction)$3;
-		$$ = sp_p;
+	| explicit_pitch {
+		$$ = $1;
 	}
 	;
 
-plet_fraction:
-	unsigned '/' unsigned {
-		$$[0] = $1;
-		$$[1] = $3;
-	}
-	|
-	'/' unsigned {
-		int num = $2 >? 1;
-		$$[0] = guess_plet_a[(num <? GUESS_PLET) - 1];
-		$$[1] = num;
+explicit_pitch:
+	PITCH embedded_scm {
+		$$ = $2;
+		if (!unsmob_pitch ($2)) {
+			THIS->parser_error (_f ("Expecting musical-pitch value", 3));
+			 $$ = Pitch ().smobbed_copy ();
+		}
 	}
 	;
 
-close_plet_parens:
-	']' plet_fraction {
-		$$ = MAEBTELP;
-		THIS->plet_.type_i_ = $2[1];
-		THIS->plet_.iso_i_ = $2[0];
-		THIS->default_duration_.plet_ = THIS->plet_;
-	}
-	| TELP {
-		$$ = TELP;
-		THIS->plet_.type_i_ = 1;
-		THIS->plet_.iso_i_ = 1;
-		THIS->default_duration_.plet_ = THIS->plet_;
+explicit_duration:
+	DURATION embedded_scm 	{
+		$$ = $2;
+		if (!unsmob_duration ($2))
+		{
+			THIS->parser_error (_("Must have duration object"));
+			$$ = Duration ().smobbed_copy ();
+		}
 	}
-	| TELP plet_fraction {
-		$$ = TELP;
-		THIS->plet_.type_i_ = $2[1];
-		THIS->plet_.iso_i_ = $2[0];
-		THIS->default_duration_.plet_ = THIS->plet_;
+	;
+
+extender_req:
+	EXTENDER {
+		if (!THIS->lexer_p_->lyric_state_b ())
+			THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
+		$$ = new Extender_req;
 	}
 	;
 
-close_request_parens:
-	'~'	{
-		$$ = '~';
+hyphen_req:
+	HYPHEN {
+		if (!THIS->lexer_p_->lyric_state_b ())
+			THIS->parser_error (_ ("Have to be in Lyric mode for lyrics"));
+		$$ = new Hyphen_req;
 	}
-	| '('	{
-		$$='(';
+	;
+
+close_request:
+	close_request_parens {
+		$$ = $1;
+		dynamic_cast<Span_req*> ($$)->set_span_dir ( START);
 	}
-	| ']'	{
-		$$ = ']';
+	
+close_request_parens:
+	'('	{
+		Span_req* s= new Span_req;
+		$$ = s;
+		s->set_mus_property ("span-type", ly_str02scm( "slur"));
 	}
 	| E_SMALLER {
-		$$ = '<';
+		Span_req*s =new Span_req;
+		$$ = s;
+		s->set_mus_property ("span-type", ly_str02scm ( "crescendo"));
 	}
 	| E_BIGGER {
-		$$ = '>';
+		Span_req*s =new Span_req;
+		$$ = s;
+		s->set_mus_property ("span-type", ly_str02scm ("decrescendo"));
 	}
-	| close_plet_parens
 	;
 
-open_abbrev_parens:
-	'[' ':' unsigned {
-		$$ = '[';
-		if (!Duration::duration_type_b ($3))
-			THIS->parser_error (_f ("not a duration: %d", $3));
-		else if ($3 < 8)
-			THIS->parser_error (_ ("can't abbreviate"));
-		else
-			THIS->set_abbrev_beam ($3);
-	}
-	;
 
-open_plet_parens:
-	'[' plet_fraction {
-		$$ = BEAMPLET;
-		THIS->plet_.type_i_ = $2[1];
-		THIS->plet_.iso_i_ = $2[0];
-		THIS->default_duration_.plet_ = THIS->plet_;
-	}
-	| PLET plet_fraction {
-		$$ = PLET;
-		THIS->plet_.type_i_ = $2[1];
-		THIS->plet_.iso_i_ = $2[0];
-		THIS->default_duration_.plet_ = THIS->plet_;
+open_request:
+	open_request_parens {
+		$$ = $1;
+		dynamic_cast<Span_req*> ($$)->set_span_dir (STOP);
 	}
 	;
 
 open_request_parens:
 	E_EXCLAMATION 	{
-		$$ = '!';
+		Span_req *s =  new Span_req;
+		s->set_mus_property ("span-type", ly_str02scm ( "crescendo"));
+
+		$$ = s;
 	}
 	| ')'	{
-		$$=')';
+		Span_req* s= new Span_req;
+		$$ = s;
+		s->set_mus_property ("span-type", ly_str02scm( "slur"));
 	}
-	| '['	{
-		$$='[';
-	}
-	| open_abbrev_parens
-	| open_plet_parens
-	;
-
-
-
-script_definition:
-	SCRIPT '{' script_body '}' 	{ $$ = $3; }
 	;
 
-script_body:
-	STRING int int int int int		{
-		Script_def *s = new Script_def;
-		s->set_from_input (*$1,$2, $3,$4,$5, $6);
-		$$  = s;
-		delete $1;
+gen_text_def:
+	embedded_scm {
+		Text_script_req *t = new Text_script_req;
+		t->set_mus_property ("text", $1);
+		t->set_spot (THIS->here_input ());
+		$$ = t;
 	}
-	;
+	| string {
+		Text_script_req *t = new Text_script_req;
+		t->set_mus_property ("text", $1);
+		t->set_spot (THIS->here_input ());
+		$$ = t;
+	}
+	| DIGIT {
+		String ds = to_str ($1);
+		Text_script_req* t = new Text_script_req;
 
-script_req:
-	script_dir gen_script_def	{
-		Musical_script_req *m = new Musical_script_req;
-		$$ = m;
-		m->scriptdef_p_ = $2;
-		m->set_spot (THIS->here_input ());
-		if (!m->dir_)
-		  m->dir_  = (Direction)$1;
+		t->set_mus_property ("text",  ly_str02scm (ds.ch_C()));
+		t->set_mus_property ("text-type" , ly_symbol2scm ("finger"));
+		t->set_spot (THIS->here_input ());
+		$$ = t;
 	}
 	;
 
-gen_script_def:
-	text_def	{ 
-		$$ = $1;
-		((Text_def*) $$)->align_dir_ = LEFT; /* UGH */
+script_abbreviation:
+	'^'		{
+		$$ = gh_str02scm  ("hat");
 	}
-	| mudela_script	{ 
-		$$ = $1;
-		$$-> set_spot (THIS->here_input ());
+	| '+'		{
+		$$ = gh_str02scm("plus");
 	}
-	| finger {
-		$$ = $1;
-		((Text_def*)$$)->align_dir_ = RIGHT; /* UGH */
+	| '-' 		{
+		$$ = gh_str02scm ("dash");
 	}
-	;
-
-text_def:
-	string {
-		Text_def *t  = new Text_def;
-		$$ = t;
-		t->text_str_ = *$1;
-		delete $1;
-		$$->set_spot (THIS->here_input ());
+ 	| '|'		{
+		$$ = gh_str02scm ("bar");
 	}
-	;
-
-finger:
-	 DIGIT {
-		Text_def* t  = new Text_def;
-		$$ = t;
-		t->text_str_ = to_str ($1);
-		t->style_str_ = "finger";
-		$$->set_spot (THIS->here_input ());
+	| '>'		{
+		$$ = gh_str02scm ("larger");
 	}
-	;
-
-script_abbreviation:
-	'^'		{ $$ = get_scriptdef ('^'); }
-	| '+'		{ $$ = get_scriptdef ('+'); }
-	| '-'		{ $$ = get_scriptdef ('-'); }
- 	| '|'		{ $$ = get_scriptdef ('|'); }
-	| 'o'		{ $$ = get_scriptdef ('o'); }
-	| '>'		{ $$ = get_scriptdef ('>'); }
 	| '.' 		{
-		$$ = get_scriptdef ('.');
+		$$ = gh_str02scm ("dot");
 	}
 	;
 
-mudela_script:
-	SCRIPT_IDENTIFIER		{ $$ = $1->access_General_script_def (true); }
-	| script_definition		{ $$ = $1; }
-	| script_abbreviation		{
-		$$ = THIS->lexer_p_->lookup_identifier (*$1)->access_General_script_def (true);
-		delete $1;
-	}
-	;
 
 script_dir:
-	'_'	{ $$ = -1; }
-	| '^'	{ $$ = 1; }
-	| '-'	{ $$ = 0; }
+	'_'	{ $$ = DOWN; }
+	| '^'	{ $$ = UP; }
+	| '-'	{ $$ = CENTER; }
 	;
 
 pre_requests:
 	{
+		$$ = new Link_array<Request>;
 	}
-	| pre_requests open_request_parens {
-		Array<Request*>& r = *THIS->get_parens_request ($2);
-		for (int i = 0; i < r.size (); i++ )
-			r[i]->set_spot (THIS->here_input ());
-		THIS->pre_reqs.concat (r);
-		delete &r;
+	| pre_requests open_request {
+		$$->push ($2);
 	}
 	;
 
-absolute_musical_pitch:
-	steno_musical_pitch	{
+absolute_pitch:
+	steno_pitch	{
 		$$ = $1;
 	}
 	;
@@ -1192,245 +1500,389 @@ duration_length:
 	steno_duration {
 		$$ = $1;
 	}
-	;
-
-dots:
-	'.'		{ $$ = 1; }
-	| dots '.'	{ $$ ++; }
+	| explicit_duration {
+		$$ = $1;
+	}	
+	| duration_length '*' bare_unsigned {
+		$$ = unsmob_duration ($$)->compressed ( $3) .smobbed_copy ();
+	}
+	| duration_length '/' bare_unsigned {
+		$$ = unsmob_duration ($$)->compressed (Moment (1,$3)).smobbed_copy ();
+	}
 	;
 
 entered_notemode_duration:
-	/* */		{
-		$$ = new Duration (THIS->default_duration_);
-	}
-	| dots		{
-		$$ = new Duration (THIS->default_duration_);
-		$$->dots_i_  = $1;
-	}
-	| steno_duration	{
-		THIS->set_last_duration ($1);
+	steno_duration	{
+		THIS->set_last_duration (unsmob_duration ($1));
 	}
 	;
 
-notemode_duration:
-	entered_notemode_duration {
+optional_notemode_duration:
+	{
+		$$ = THIS->default_duration_.smobbed_copy ();
+	}
+	| entered_notemode_duration {
 		$$ = $1;
 	}
+	| explicit_duration {
+		$$ = $1;
+	}	
 	;
 
 steno_duration:
-	unsigned		{
-		$$ = new Duration;
-		if (!Duration::duration_type_b ($1))
+	bare_unsigned dots		{
+		int l = 0;
+		if (!is_duration_b ($1))
 			THIS->parser_error (_f ("not a duration: %d", $1));
-		else {
-			$$->durlog_i_ = Duration_convert::i2_type ($1);
-			$$->set_plet (THIS->plet_.iso_i_, THIS->plet_.type_i_);
-		     }
-	}
-	| DURATION_IDENTIFIER	{
-		$$ = $1->access_Duration ();
+		else
+			l =  intlog2 ($1);
+
+		$$ = Duration (l, $2).smobbed_copy ();
 	}
-	| steno_duration '.' 	{
-		$$->dots_i_ ++;
+	| DURATION_IDENTIFIER dots	{
+		Duration *d =unsmob_duration ($1);
+		Duration k (d->duration_log (),d->dot_count () + $2);
+		$$ = k.smobbed_copy ();		
 	}
-	| steno_duration '*' unsigned  {
-		$$->plet_.iso_i_ *= $3;
+	;
+
+dots:
+	/* empty */ 	{
+		$$ = 0;
 	}
-	| steno_duration '/' unsigned {
-		$$->plet_.type_i_ *= $3;
+	| dots '.' {
+		$$ ++;
 	}
 	;
 
 
-abbrev_type: 
+tremolo_type: 
 	':'	{
 		$$ =0;
 	}
-	| ':' unsigned {
-		if (!Duration::duration_type_b ($2))
+	| ':' bare_unsigned {
+		if (!is_duration_b ($2))
 			THIS->parser_error (_f ("not a duration: %d", $2));
-		else if ($2 < 8)
-			THIS->parser_error (_ ("can't abbreviate"));
 		$$ = $2;
 	}
 	;
 
 
-
 simple_element:
-	steno_notepitch notemode_duration  {
+	pitch exclamations questions optional_notemode_duration {
 		if (!THIS->lexer_p_->note_state_b ())
-			THIS->parser_error (_ ("have to be in Note mode for notes"));
-		$1->set_duration (*$2);
-		int durlog_i = $2->durlog_i_;
-		$$ = THIS->get_note_element ($1, $2);
-	}
-	| RESTNAME notemode_duration		{
-		$$ = THIS->get_rest_element (*$1, $2);
-		delete $1;  // delete notename
-	}
-	| MEASURES notemode_duration  	{
-		Multi_measure_rest_req* m = new Multi_measure_rest_req;
-		m->duration_ = *$2;
-		delete $2;
-
-		Simultaneous_music*velt_p = new Request_chord;
-		velt_p->set_spot (THIS->here_input ());
-		velt_p->add_music (m);
-		$$ = velt_p;
-	}
-	| STRING notemode_duration 			{
-		if (!THIS->lexer_p_->lyric_state_b ())
-			THIS->parser_error (_ ("have to be in Lyric mode for lyrics"));
-		$$ = THIS->get_word_element (*$1, $2);
-		delete $1;
-	}
-	;
+			THIS->parser_error (_ ("Have to be in Note mode for notes"));
 
+		Note_req *n = new Note_req;
+		
+		n->set_mus_property ("pitch", $1);
+		n->set_mus_property ("duration", $4);
 
+		if ($3 % 2)
+			n->set_mus_property ("cautionary", SCM_BOOL_T);
+		if ($2 % 2 || $3 % 2)
+			n->set_mus_property ("force-accidental", SCM_BOOL_T);
+
+		Simultaneous_music*v = new Request_chord (SCM_EOL);
+		v->set_mus_property ("elements", gh_list (n->self_scm (), SCM_UNDEFINED));
+		
 /*
-	UTILITIES
- */
-pitch_list:			{
-		$$ = new Array<Musical_pitch>;
+FIXME: location is one off, since ptich & duration don't contain origin refs. 
+*/
+		v->set_spot (THIS->here_input ());
+		n->set_spot (THIS->here_input ());
+
+		$$ = v;
+	}
+	| RESTNAME optional_notemode_duration		{
+
+		SCM e = SCM_UNDEFINED;
+		  if (ly_scm2string ($1) =="s")
+		    { /* Space */
+		      Skip_req * skip_p = new Skip_req;
+		      skip_p->set_mus_property ("duration" ,$2);
+
+		      skip_p->set_spot (THIS->here_input());
+			e = skip_p->self_scm ();
+		    }
+		  else
+		    {
+		      Rest_req * rest_req_p = new Rest_req;
+		      rest_req_p->set_mus_property ("duration", $2);
+		      rest_req_p->set_spot (THIS->here_input());
+			e = rest_req_p->self_scm ();
+		    }
+		  Simultaneous_music* velt_p = new Request_chord (SCM_EOL);
+		velt_p-> set_mus_property ("elements", gh_list (e,SCM_UNDEFINED));
+		  velt_p->set_spot (THIS->here_input());
+
+
+		  $$ = velt_p;
+	}
+	| MEASURES optional_notemode_duration  	{
+		Skip_req * sk = new Skip_req;
+		sk->set_mus_property ("duration", $2);
+		Span_req *sp1 = new Span_req;
+		Span_req *sp2 = new Span_req;
+		sp1-> set_span_dir ( START);
+		sp2-> set_span_dir ( STOP);
+		SCM r = ly_str02scm ("rest");
+		sp1->set_mus_property ("span-type", r);
+		sp2->set_mus_property ("span-type", r);
+
+		Request_chord * rqc1 = new Request_chord (SCM_EOL);
+		rqc1->set_mus_property ("elements", gh_list (sp1->self_scm (), SCM_UNDEFINED));
+		Request_chord * rqc2 = new Request_chord (SCM_EOL);
+		rqc2->set_mus_property ("elements", gh_list (sk->self_scm (), SCM_UNDEFINED));;
+		Request_chord * rqc3 = new Request_chord(SCM_EOL);
+		rqc3->set_mus_property ("elements", gh_list (sp2->self_scm (), SCM_UNDEFINED));;
+
+		SCM ms = gh_list (rqc1->self_scm (), rqc2->self_scm (), rqc3->self_scm (), SCM_UNDEFINED);
+
+		$$ = new Sequential_music (SCM_EOL);
+		$$->set_mus_property ("elements", ms);
+	}
+	| STRING { 
+	 	THIS->remember_spot ();
+	} 
+	/* cont */
+	optional_notemode_duration 	{
+		if (!THIS->lexer_p_->lyric_state_b ()) {
+			THIS->pop_spot ().error (_ ("Have to be in Lyric mode for lyrics"));
+			THIS->error_level_i_  = 1;
+			THIS->parser_error (_ ("Giving up"));
+		} 
+		else
+			THIS->pop_spot ();
+		Lyric_req* lreq_p = new Lyric_req;
+                lreq_p->set_mus_property ("text", $1);
+		lreq_p->set_mus_property ("duration",$3);
+		lreq_p->set_spot (THIS->here_input());
+		Simultaneous_music* velt_p = new Request_chord (SCM_EOL);
+		velt_p->set_mus_property ("elements", gh_list (lreq_p->self_scm (), SCM_UNDEFINED));
+
+
+		$$= velt_p;
+
 	}
-	| pitch_list musical_pitch	{
-		$$->push (*$2);
-		delete $2;
+	| chord {
+		if (!THIS->lexer_p_->chord_state_b ())
+			THIS->parser_error (_ ("Have to be in Chord mode for chords"));
+		$$ = $1;
 	}
 	;
 
 
-int_list:
-	/**/			{
-		$$ = new Array<int>
-	}
-	| int_list int 		{
-		$$->push ($2);		
+chord:
+	steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
+                $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
+		$$->set_spot (THIS->here_input ());
+        };
+
+chord_additions: 
+	{
+		$$ = SCM_EOL;
+	} 
+	| CHORD_COLON chord_notes {
+		$$ = $2;
 	}
 	;
 
-unsigned:
-	UNSIGNED	{
-		$$ = $1;
+chord_notes:
+	chord_step {
+		$$ = $1
 	}
-	| DIGIT {
-		$$ = $1;
-	};
+	| chord_notes '.' chord_step {
+		$$ = gh_append2 ($$, $3);
+	}
+	;
 
-int:
-	unsigned {
-		$$ = $1;
+chord_subtractions: 
+	{
+		$$ = SCM_EOL;
+	} 
+	| CHORD_CARET chord_notes {
+		$$ = $2;
 	}
-	| '-' unsigned {
-		$$ = -$2;
+	;
+
+
+chord_inversion:
+	{
+		$$ = SCM_EOL;
 	}
-	| INT_IDENTIFIER	{
-		int *i_p = $1->access_int ();
-		$$ = *i_p;
-		delete i_p;
+	| '/' steno_tonic_pitch {
+		$$ = $2;
 	}
 	;
 
-string_primary:
-	STRING		{
-		$$ = $1;
+chord_bass:
+	{
+		$$ = SCM_EOL;
 	}
-	| STRING_IDENTIFIER	{
-		String *s_p = $1->access_String ();
-
-		$$ = s_p;
-		DOUT << "Lookup string: " << *s_p << "\n";
+	| CHORD_BASS steno_tonic_pitch {
+		$$ = $2;
 	}
 	;
 
-string:
-	string_primary {
-		$$ = $1;
+chord_step:
+	chord_note {
+		$$ = gh_cons ($1, SCM_EOL);
+	}
+	| CHORDMODIFIER_PITCH {
+		$$ = gh_cons ($1, SCM_EOL);
 	}
-	| string '+' string_primary {
-		*$$ += *$3;
-		delete $3;
+	| CHORDMODIFIER_PITCH chord_note { /* Ugh. */
+		$$ = gh_list ($1, $2, SCM_UNDEFINED);
 	}
 	;
 
-dim:
-	real_primary unit	{ $$ = $1*$2; }
-	;
+chord_note:
+	bare_unsigned {
+		 Pitch m;
+		m.notename_i_ = ($1 - 1) % 7;
+		m.octave_i_ = $1 > 7 ? 1 : 0;
+		m.alteration_i_ = 0;
 
+		$$ = m.smobbed_copy ();
+        } 
+	| bare_unsigned '+' {
+		Pitch m;
+		m.notename_i_ = ($1 - 1) % 7;
+		m.octave_i_ = $1 > 7 ? 1 : 0;
+		m.alteration_i_ = 1;
 
-unit:	CM_T		{ $$ = 1 CM; }
-	|IN_T		{ $$ = 1 INCH; }
-	|MM_T		{ $$ = 1 MM; }
-	|PT_T		{ $$ = 1 PT; }
-	;
+
+		$$ = m.smobbed_copy ();
+	}
+	| bare_unsigned CHORD_MINUS {
+		Pitch m;
+		m.notename_i_ = ($1 - 1) % 7;
+		m.octave_i_ = $1 > 7 ? 1 : 0;
+		m.alteration_i_ = -1;
+
+		$$ = m.smobbed_copy ();
+	}
+        ;
 
 /*
-	symbol tables
-*/
-symtables:
-	SYMBOLTABLES '{' symtables_body '}'	{ $$ = $3; }
+	UTILITIES
+ */
+number_expression:
+	bare_number {
+		$$ = $1;
+	}
+	| '-'  number_expression %prec UNARY_MINUS {
+		$$ = scm_difference ($2, SCM_UNDEFINED);
+	}
+	| number_expression '*' number_expression {
+		$$ = scm_product ($1, $3);
+	}
+	| number_expression '/' number_expression {
+		$$ = scm_divide ($1, $3);
+	}
+	| number_expression '+' number_expression {
+		$$ = scm_sum ($1, $3);
+	}
+	| number_expression '-' number_expression {
+		$$ = scm_difference ($1, $3);
+	}
+	| '(' number_expression ')'	{
+		$$ = $2;
+	}
 	;
 
-symtables_body:
-	 		{
-		$$ = new Lookup;
+bare_number:
+	UNSIGNED	{
+		$$ = gh_int2scm ($1);
 	}
-	| IDENTIFIER		{
-		$$ = $1->access_Lookup ();
+	| DIGIT		{
+		$$ = gh_int2scm ($1);
 	}
-	| symtables_body FONT STRING 		{
-		$$->font_ = *$3;
-		$$->font_path_ = global_path.find (*$3);
-		if  (!$$->font_path_.length_i ())
-			THIS->here_input ().error (_f("can't open file: `%s'", $3->ch_C()));
-
-		delete $3;
+	| REAL		{
+		$$ = gh_double2scm ($1);
+	}
+	| NUMBER_IDENTIFIER		{
+		$$ = $1;
+	}
+	| REAL CM_T	{
+		$$ = gh_double2scm ($1 CM);
+	}
+	| REAL PT_T	{
+		$$ = gh_double2scm ($1 PT);
 	}
-	| symtables_body STRING '=' symtable		{
-		$$->add (*$2, $4);
-		delete $2;
+	| REAL IN_T	{
+		$$ = gh_double2scm ($1 INCH);
+	}
+	| REAL MM_T	{
+		$$ = gh_double2scm ($1 MM);
+	}
+	| REAL CHAR_T	{
+		$$ = gh_double2scm ($1 CHAR);
 	}
 	;
 
-symtable:
-	TABLE '{' symtable_body '}' { $$ = $3; }
-	;
 
-symtable_body:
-				{ $$ = new Symtable; }
-	| symtable_body	STRING	symboldef {
-		$$->add (*$2, *$3);
-		delete $2;
-		delete $3;
+bare_unsigned:
+	bare_number {
+		if (scm_integer_p ($1) == SCM_BOOL_T) {
+			$$ = gh_scm2int ($1);
+
+		} else {
+			THIS->parser_error (_("need integer number arg"));
+			$$ = 0;
+		}
+		if ($$ < 0) {
+			THIS->parser_error (_("Must be positive integer"));
+			$$ = -$$;
+			}
+
 	}
 	;
-
-symboldef:
-	STRING 	box		{
-		$$ = new Atom (*$1, *$2);
-		delete $1;
-		delete $2;
+bare_int:
+	bare_number {
+		if (scm_integer_p ($1) == SCM_BOOL_T)
+		{
+			int k = gh_scm2int ($1);
+			$$ = k;
+		} else
+		{
+			THIS->parser_error (_("need integer number arg"));
+			$$ = 0;
+		}
 	}
-	| STRING {
-		Box b (Interval (0,0), Interval (0,0));
-		$$ = new Atom (*$1, b);
-		delete $1;
+	| '-' bare_int {
+		$$ = -$2;
 	}
 	;
 
-box:
-	dinterval dinterval 	{
-		$$ = new Box (*$1, *$2);
-		delete $1;
-		delete $2;
+
+string:
+	STRING		{
+		$$ = $1;
+	}
+	| STRING_IDENTIFIER	{
+		$$ = $1;
+	}
+	| string '+' string {
+		$$ = scm_string_append (scm_listify ($1, $3, SCM_UNDEFINED));
 	}
 	;
 
-dinterval: dim	dim		{
-		$$ = new Interval ($1, $2);
-	}
+
+exclamations:
+		{ $$ = 0; }
+	| exclamations '!'	{ $$ ++; }
+	;
+
+questions:
+		{ $$ = 0; }
+	| questions '?'	{ $$ ++; }
+	;
+
+
+semicolon:
+	';'
 	;
 
 %%
@@ -1442,9 +1894,15 @@ My_lily_parser::set_yydebug (bool b)
 	yydebug = b;
 #endif
 }
+
+extern My_lily_parser * current_parser;
+
 void
 My_lily_parser::do_yyparse ()
 {
+
+	current_parser = this;;
 	yyparse ((void*)this);
 }
 
+