X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fmy-lily-parser.cc;h=c271d4ed297e566ff55dbb7167aca5b374f86cda;hb=832c21ee509c9ad488e1490ad59a650e89c8f53a;hp=4f56f1d0fd52bad179d6568281dad21ffd45fc8a;hpb=e87d9c881c1ac0dc5d243c7a0f62cb41a02bb3b8;p=lilypond.git

diff --git a/lily/my-lily-parser.cc b/lily/my-lily-parser.cc
index 4f56f1d0fd..c271d4ed29 100644
--- a/lily/my-lily-parser.cc
+++ b/lily/my-lily-parser.cc
@@ -1,5 +1,5 @@
 /*
-  my-lily-parser.cc -- implement My_lily_parser
+  my-lily-parser.cc -- implement Lily_parser
 
   source file of the GNU LilyPond music typesetter
 
@@ -12,20 +12,18 @@
 #include "file-path.hh"
 #include "lily-version.hh"
 #include "ly-module.hh"
-#include "ly-smobs.icc"
 #include "main.hh"
 #include "my-lily-lexer.hh"
 #include "my-lily-parser.hh"
-#include "paper-def.hh"
-#include "parray.hh"
+#include "output-def.hh"
+#include "paper-book.hh"
 #include "parser.hh"
-#include "scm-hash.hh"
 #include "score.hh"
 #include "source.hh"
-#include "string.hh"
 #include "warn.hh"
 
-My_lily_parser::My_lily_parser (Sources *sources)
+
+Lily_parser::Lily_parser (Sources *sources)
 {
   book_count_ = 0;
   score_count_ = 0;
@@ -34,47 +32,49 @@ My_lily_parser::My_lily_parser (Sources *sources)
   default_duration_ = Duration (2,0);
   error_level_ = 0;
   last_beam_start_ = SCM_EOL;
-  header_ = SCM_EOL;
 
-  header_ = ly_make_anonymous_module ();
   smobify_self ();
 }
 
-My_lily_parser::My_lily_parser (My_lily_parser const &src)
+Lily_parser::Lily_parser (Lily_parser const &src)
 {
   book_count_ = src.book_count_;
   score_count_ = src.score_count_;
-  lexer_ = src.lexer_;
+  lexer_ = 0;
   sources_ = src.sources_;
   default_duration_ = src.default_duration_;
   error_level_ = src.error_level_;
   last_beam_start_ = src.last_beam_start_;
-  header_ = src.header_;
 
   smobify_self ();
+  if (src.lexer_)
+    lexer_ = new Lily_lexer (*src.lexer_);
+
+  scm_gc_unprotect_object (lexer_->self_scm ());
 }
 
-My_lily_parser::~My_lily_parser ()
+Lily_parser::~Lily_parser ()
 {
-  delete lexer_;
 }
 
-IMPLEMENT_SMOBS (My_lily_parser);
-IMPLEMENT_TYPE_P (My_lily_parser, "ly:my-lily-parser?");
-IMPLEMENT_DEFAULT_EQUAL_P (My_lily_parser);
+#include "ly-smobs.icc"
+
+IMPLEMENT_SMOBS (Lily_parser);
+IMPLEMENT_TYPE_P (Lily_parser, "ly:my-lily-parser?");
+IMPLEMENT_DEFAULT_EQUAL_P (Lily_parser);
 
 SCM
-My_lily_parser::mark_smob (SCM s)
+Lily_parser::mark_smob (SCM s)
 {
-  My_lily_parser *parser = (My_lily_parser*) ly_cdr (s);
-  return parser->header_;
+  Lily_parser *parser = (Lily_parser*) ly_cdr (s);
+  return (parser->lexer_) ? parser->lexer_->self_scm () : SCM_EOL;
 }
 
 int
-My_lily_parser::print_smob (SCM s, SCM port, scm_print_state*)
+Lily_parser::print_smob (SCM s, SCM port, scm_print_state*)
 {
   scm_puts ("#<my_lily_parser ", port);
-  My_lily_parser *parser = (My_lily_parser*) ly_cdr (s);
+  Lily_parser *parser = (Lily_parser*) ly_cdr (s);
   (void) parser;
   scm_puts (" >", port);
   return 1;
@@ -83,9 +83,12 @@ My_lily_parser::print_smob (SCM s, SCM port, scm_print_state*)
 
 /* Process one .ly file, or book.  */
 void
-My_lily_parser::parse_file (String init, String name, String out_name)
+Lily_parser::parse_file (String init, String name, String out_name)
 {
-  lexer_ = new My_lily_lexer (sources_);
+  lexer_ = new Lily_lexer (sources_);
+  // TODO: use $parser 
+  lexer_->set_identifier (ly_symbol2scm ("parser"),
+			  self_scm ());
   output_basename_ = out_name;
   
   lexer_->main_input_name_ = name;
@@ -94,6 +97,7 @@ My_lily_parser::parse_file (String init, String name, String out_name)
   progress_indication ("\n");
 
   set_yydebug (0);
+
   lexer_->new_input (init, sources_);
 
   /* Read .ly IN_FILE, lex, parse, write \score blocks from IN_FILE to
@@ -107,15 +111,26 @@ My_lily_parser::parse_file (String init, String name, String out_name)
     }
 
   error_level_ = error_level_ | lexer_->error_level_;
+
+  scm_gc_unprotect_object (lexer_->self_scm ());
+  lexer_ = 0;
 }
 
 void
-My_lily_parser::parse_string (String ly_code)
+Lily_parser::parse_string (String ly_code)
 {
-  My_lily_lexer *parent = lexer_;
-  lexer_ = (parent == 0 ? new My_lily_lexer (sources_)
-	    : new My_lily_lexer (*parent));
+  Lily_lexer *parent = lexer_;
+  lexer_ = (parent == 0 ? new Lily_lexer (sources_)
+	    : new Lily_lexer (*parent));
 
+
+  SCM oldmod = scm_current_module ();
+  scm_set_current_module (ly_car (lexer_->scopes_));
+  
+  // TODO: use $parser 
+  lexer_->set_identifier (ly_symbol2scm ("parser"),
+			  self_scm ());
+  
   lexer_->main_input_name_ = "<string>";
   lexer_->main_input_b_ = true;
 
@@ -142,46 +157,51 @@ My_lily_parser::parse_string (String ly_code)
       parent->error_level_ = lexer_->error_level_; 
       parent->main_input_b_ = lexer_->main_input_b_;
     }
+
+  scm_set_current_module (oldmod);
+  scm_gc_unprotect_object (lexer_->self_scm ());
+  lexer_ = 0;
 }
 
 void
-My_lily_parser::push_spot ()
+Lily_parser::push_spot ()
 {
   define_spots_.push (here_input ());
 }
 
 char const *
-My_lily_parser::here_str0 () const
+Lily_parser::here_str0 () const
 {
   return lexer_->here_str0 ();
 }
 
 void
-My_lily_parser::parser_error (String s)
+Lily_parser::parser_error (String s)
 {
   here_input ().error (s);
   error_level_ = 1;
 }
 
 Input
-My_lily_parser::pop_spot ()
+Lily_parser::pop_spot ()
 {
   return define_spots_.pop ();
 }
 
 Input
-My_lily_parser::here_input () const
+Lily_parser::here_input () const
 {
   /*
     Parsing looks ahead , so we really want the previous location of the
     lexer, not lexer_->here_input ().
   */
+  
   /*
     Actually, that gets very icky when there are white space, because
     the line-numbers are all wrong.  Let's try the character before
-    the current token. That gets the right result for
-    note/duration stuff, but doesn't mess up for errors in the 1st token of the line. 
-    
+    the current token. That gets the right result for note/duration
+    stuff, but doesn't mess up for errors in the 1st token of the
+    line.
   */
   Input hi (lexer_->here_input ());
 
@@ -203,8 +223,8 @@ My_lily_parser::here_input () const
 bool store_locations_global_b;
 
 /* Do not append `!' suffix, since 1st argument is not modified. */
-LY_DEFINE (ly_set_point_and_click, "ly:set-point-and-click", 1, 0, 0,
-	  (SCM what),
+LY_DEFINE (ly_set_point_and_click, "ly:set-point-and-click",
+	   1, 0, 0, (SCM what),
 	  "Set the options for Point-and-click source specials output. The\n"
 "argument is a symbol.  Possible options are @code{none} (no source specials),\n"
 "@code{line} and @code{line-column}")
@@ -212,9 +232,9 @@ LY_DEFINE (ly_set_point_and_click, "ly:set-point-and-click", 1, 0, 0,
   /* UGH. */
   SCM val = SCM_BOOL_F;
   if (ly_symbol2scm ("line-column") == what)
-    val = scm_c_eval_string ("line-column-location");
+    val = ly_scheme_function ("line-column-location");
   else if (what == ly_symbol2scm ("line"))
-    val = scm_c_eval_string ("line-location");
+    val = ly_scheme_function ("line-location");
 
   scm_module_define (global_lily_module, ly_symbol2scm ("point-and-click"),
 		     val);
@@ -223,22 +243,24 @@ LY_DEFINE (ly_set_point_and_click, "ly:set-point-and-click", 1, 0, 0,
 }
 
 LY_DEFINE (ly_parse_file, "ly:parse-file",
-	   1, 0, 0,
-	   (SCM name),
+	   1, 0, 0, (SCM name),
 	   "Parse a single @code{.ly} file.  "
 	   "Upon failure, throw @code{ly-file-failed} key.")
 {
   SCM_ASSERT_TYPE (ly_c_string_p (name), name, SCM_ARG1, __FUNCTION__, "string");
   char const *file = SCM_STRING_CHARS (name);
   char const *extensions[] = {"ly", "", 0};
+
   String file_name = global_path.find (file, extensions);
-  
+
   /* By default, use base name of input file for output file name,
      write output to cwd; do not use root and directory parts of input
      file name.  */
   File_name out_file_name (file_name);
-  if (file_name != "-")
-    out_file_name.ext_ = output_format_global;
+
+  global_path.append (out_file_name.dir_);
+  
+  out_file_name.ext_ = "";
   out_file_name.root_ = "";
   out_file_name.dir_ = "";
 
@@ -275,9 +297,8 @@ LY_DEFINE (ly_parse_file, "ly:parse-file",
       progress_indication (_f ("Now processing `%s'", file_name.to_str0 ()));
       progress_indication ("\n");
 
-      My_lily_parser *parser = new My_lily_parser (&sources);
-      scm_module_define (global_lily_module, ly_symbol2scm ("parser"),
-			 parser->self_scm ());
+      Lily_parser *parser = new Lily_parser (&sources);
+
       parser->parse_file (init, file_name, out_file);
 
       bool error = parser->error_level_;
@@ -291,8 +312,7 @@ LY_DEFINE (ly_parse_file, "ly:parse-file",
 }
 
 LY_DEFINE (ly_parse_string, "ly:parse-string",
-	   1, 0, 0,
-	   (SCM ly_code),
+	   1, 0, 0, (SCM ly_code),
 	   "Parse the string LY_CODE.  "
 	   "Upon failure, throw @code{ly-file-failed} key.")
 {
@@ -300,7 +320,7 @@ LY_DEFINE (ly_parse_string, "ly:parse-string",
   
   Sources sources;
   sources.set_path (&global_path);
-  My_lily_parser *parser = new My_lily_parser (&sources);
+  Lily_parser *parser = new Lily_parser (&sources);
   scm_module_define (global_lily_module, ly_symbol2scm ("parser"),
 		     parser->self_scm ());
   parser->parse_string (ly_scm2string (ly_code));
@@ -309,52 +329,112 @@ LY_DEFINE (ly_parse_string, "ly:parse-string",
   return SCM_UNSPECIFIED;
 }
 
+LY_DEFINE (ly_clone_parser, "ly:clone-parser",
+           1, 0, 0, (SCM parser_smob),
+           "Return a clone of PARSER_SMOB.")
+{
+  Lily_parser *parser = unsmob_my_lily_parser (parser_smob);
+  Lily_parser *clone = new Lily_parser (*parser);
+
+  /* FIXME: should copy scopes too. */
+  return scm_gc_unprotect_object (clone->self_scm ());
+}
+
+LY_DEFINE (ly_parser_define, "ly:parser-define",
+	   3, 0, 0, (SCM parser_smob, SCM symbol, SCM val),
+	   "Bind SYMBOL to VAL in PARSER_SMOB's module.")
+{
+  Lily_parser *parser = unsmob_my_lily_parser (parser_smob);
+  SCM_ASSERT_TYPE (ly_c_symbol_p (symbol), symbol, SCM_ARG2, __FUNCTION__, "symbol");
+  SCM_ASSERT_TYPE (parser, parser_smob, SCM_ARG2, __FUNCTION__, "parser");  
+
+  parser->lexer_->set_identifier (scm_symbol_to_string (symbol), val);
+  return SCM_UNSPECIFIED;
+}
+
+LY_DEFINE (ly_parser_lookup, "ly:parser-lookup",
+	   2, 0, 0, (SCM parser_smob, SCM symbol),
+	   "Lookup @var{symbol} in @var{parser_smob}'s module.  "
+	   "Undefined is '().")
+{
+  Lily_parser *parser = unsmob_my_lily_parser (parser_smob);
+
+  SCM_ASSERT_TYPE (ly_c_symbol_p (symbol), symbol, SCM_ARG2, __FUNCTION__, "symbol");
+  SCM_ASSERT_TYPE (parser, parser_smob, SCM_ARG2, __FUNCTION__, "parser");  
+
+  SCM val= parser->lexer_->lookup_identifier (ly_scm2string (scm_symbol_to_string (symbol)));
+  if (val != SCM_UNDEFINED)
+    return val;
+  else
+    return SCM_EOL;
+}
+
 LY_DEFINE (ly_parser_parse_string, "ly:parser-parse-string",
-	   2, 0, 0,
-	   (SCM parser_smob, SCM ly_code),
+	   2, 0, 0, (SCM parser_smob, SCM ly_code),
 	   "Parse the string LY_CODE with PARSER_SMOB."
 	   "Upon failure, throw @code{ly-file-failed} key.")
 {
-#if 0
-  SCM_ASSERT_TYPE (ly_c_parser_p (parser), music, SCM_ARG1, __FUNCTION__, "parser");
-#endif
-  SCM_ASSERT_TYPE (ly_c_string_p (ly_code), ly_code, SCM_ARG1, __FUNCTION__, "string");
+  Lily_parser *parser = unsmob_my_lily_parser (parser_smob);
 
-#if 0
-  My_lily_parser *parser = unsmob_my_lily_parser (parser_smob);
+  SCM_ASSERT_TYPE (parser, parser_smob, SCM_ARG1, __FUNCTION__, "parser");
+  SCM_ASSERT_TYPE (ly_c_string_p (ly_code), ly_code, SCM_ARG2, __FUNCTION__, "string");
+  
   parser->parse_string (ly_scm2string (ly_code));
-#else
-  My_lily_parser *parser = unsmob_my_lily_parser (parser_smob);
-  My_lily_parser *clone = new My_lily_parser (*parser);
-  clone->parse_string (ly_scm2string (ly_code));
-  clone = 0;
-#endif
   
   return SCM_UNSPECIFIED;
 }
 
-static Music_output_def*
-get_paper (My_lily_parser *parser)
+Output_def*
+get_paper (Lily_parser *parser)
 {
   SCM id = parser->lexer_->lookup_identifier ("$defaultpaper");
-  Music_output_def *paper = unsmob_music_output_def (id);
-  return paper ? paper->clone () : new Paper_def;
+  Output_def *paper = unsmob_output_def (id);
+  paper = paper ? paper->clone () : new Output_def;
+  paper->set_variable (ly_symbol2scm ("is-paper"), SCM_BOOL_T);
+
+  paper->parent_ = unsmob_output_def (parser->lexer_->lookup_identifier ("$defaultbookpaper"));
+  return paper;
+}
+
+
+Output_def*
+get_midi (Lily_parser *parser)
+{
+  SCM id = parser->lexer_->lookup_identifier ("$defaultmidi");
+  Output_def *paper = unsmob_output_def (id);
+  paper = paper ? paper->clone () : new Output_def;
+  paper->set_variable (ly_symbol2scm ("is-midi"), SCM_BOOL_T);
+  return paper;
+}
+
+
+Output_def*
+get_bookpaper (Lily_parser *parser)
+{
+  SCM id = parser->lexer_->lookup_identifier ("$defaultbookpaper");
+  Output_def *paper = unsmob_output_def (id);
+
+  paper = paper ? dynamic_cast<Output_def*> (paper->clone ()) : new Output_def;
+  paper->set_variable (ly_symbol2scm ("is-bookpaper"), SCM_BOOL_T);
+  return paper;
 }
 
+
+/* TODO: move this to Scheme?  Why take the parser arg, and all the back
+   & forth between scm and c++? */
 LY_DEFINE (ly_parser_print_score, "ly:parser-print-score",
 	   2, 0, 0,
 	   (SCM parser_smob, SCM score_smob),
 	   "Print score, i.e., the classic way.")
 {
-#if 0
-  SCM_ASSERT_TYPE (ly_c_parser_p (parser), music, SCM_ARG1, __FUNCTION__, "parser");
-  SCM_ASSERT_TYPE (ly_c_music_p (music), music, SCM_ARG1, __FUNCTION__, "music");
-#endif
-  My_lily_parser *parser = unsmob_my_lily_parser (parser_smob);
+  Lily_parser *parser = unsmob_my_lily_parser (parser_smob);
   Score *score = unsmob_score (score_smob);
 
-  SCM header = is_module (score->header_) ? score->header_
-    : parser->header_.to_SCM ();
+  SCM_ASSERT_TYPE (parser, parser_smob, SCM_ARG1, __FUNCTION__, "parser");
+  SCM_ASSERT_TYPE (score, score_smob, SCM_ARG2, __FUNCTION__, "score");
+
+  SCM header = ly_c_module_p (score->header_) ? score->header_
+    : parser->lexer_->lookup_identifier ("$globalheader");
   
   File_name outname (parser->output_basename_);
   int *c = &parser->book_count_;
@@ -363,39 +443,71 @@ LY_DEFINE (ly_parser_print_score, "ly:parser-print-score",
   (*c)++;
 
   SCM os = scm_makfrom0str (outname.to_string ().to_str0 ());
+  SCM bookpaper = get_bookpaper (parser)->self_scm ();
   for (int i = 0; i < score->defs_.size (); i++)
-    default_rendering (score->music_, score->defs_[i]->self_scm (), header,
-		       os);
+    default_rendering (score->music_, score->defs_[i]->self_scm (),
+		       bookpaper,
+		       header, os);
 
   if (score->defs_.is_empty ())
     {
-      Music_output_def *paper = get_paper (parser);
-      default_rendering (score->music_, paper->self_scm (), header, os);
+      Output_def *paper = get_paper (parser);
+      default_rendering (score->music_, paper->self_scm (),
+			 get_bookpaper (parser)->self_scm (),
+			 header, os);
       scm_gc_unprotect_object (paper->self_scm ());
     }
-  return SCM_UNDEFINED;
+  return SCM_UNSPECIFIED;
+}
+
+
+LY_DEFINE (ly_parser_set_note_names, "ly:parser-set-note-names",
+	   2, 0, 0, (SCM parser, SCM names),
+	   "Replace current note names in @var{parser}. "
+	   "@var{names} is an alist of symbols.  "
+	   "This only has effect if the current mode is notes.")
+{
+  Lily_parser *p = unsmob_my_lily_parser (parser);
+  SCM_ASSERT_TYPE(p, parser, SCM_ARG1, __FUNCTION__, "Lilypond parser");
+
+  if (p->lexer_->is_note_state ())
+    {
+      p->lexer_->pop_state ();
+      p->lexer_->push_note_state (alist_to_hashq (names));
+    }
+
+  return SCM_UNSPECIFIED;
 }
 
 LY_DEFINE (ly_parser_print_book, "ly:parser-print-book",
-	   2, 0, 0,
-	   (SCM parser_smob, SCM book_smob),
+	   2, 0, 0, (SCM parser_smob, SCM book_smob),
 	   "Print book.")
 {
-#if 0
-  SCM_ASSERT_TYPE (ly_c_parser_p (parser_smob), parser_smob, SCM_ARG1, __FUNCTION__, "parser_smob");
-  SCM_ASSERT_TYPE (ly_c_music_p (book_smob), book_smob, SCM_ARG1, __FUNCTION__, "book_smob");
-#endif
-  My_lily_parser *parser = unsmob_my_lily_parser (parser_smob);
+  Lily_parser *parser = unsmob_my_lily_parser (parser_smob);
   Book *book = unsmob_book (book_smob);
+  Output_def *bp = unsmob_output_def (parser->lexer_->lookup_identifier ("$defaultbookpaper"));
+  
+  SCM_ASSERT_TYPE (parser, parser_smob, SCM_ARG1, __FUNCTION__, "Lilypond parser");
+  SCM_ASSERT_TYPE (book, book_smob, SCM_ARG2, __FUNCTION__, "Book");
+  
+  /*  ugh. changing argument.*/
+  book->bookpaper_ = bp;
   
-  SCM header = parser->header_;
   File_name outname (parser->output_basename_);
   int *c = &parser->book_count_;
   if (*c)
     outname.base_ += "-" + to_string (*c);
   (*c)++;
-  Music_output_def *paper = get_paper (parser);
-  book->process (outname.to_string (), paper, header);
+
+  Output_def *paper = get_paper (parser);
+
+  Paper_book* pb = book->process (outname.to_string (), paper);
+
+  pb->output (outname.to_string ());
+  
   scm_gc_unprotect_object (paper->self_scm ());
-  return SCM_UNDEFINED;
+  scm_gc_unprotect_object (pb->self_scm ());
+
+  return SCM_UNSPECIFIED;
 }
+