X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fmy-lily-parser.cc;h=f3cdf87abaaa5ab9183586980a0e509094a2fc3b;hb=9efbad2d9487a05b04423e7e9f062968e8f8eaf4;hp=9924a78a7e39f2405ff44c5c5d24c0c89abf962e;hpb=a41a7fb966e8552cc8da7c4eab1b60eb7b8eff3a;p=lilypond.git diff --git a/lily/my-lily-parser.cc b/lily/my-lily-parser.cc index 9924a78a7e..f3cdf87aba 100644 --- a/lily/my-lily-parser.cc +++ b/lily/my-lily-parser.cc @@ -1,230 +1,326 @@ /* - my-lily-parser.cc -- implement + my-lily-parser.cc -- implement My_lily_parser - source file of the LilyPond music typesetter + source file of the GNU LilyPond music typesetter - (c) 1997 Han-Wen Nienhuys + (c) 1997--1998 Han-Wen Nienhuys */ #include "my-lily-parser.hh" #include "my-lily-lexer.hh" #include "debug.hh" #include "main.hh" -#include "voice-element.hh" +#include "music-list.hh" #include "musical-request.hh" #include "command-request.hh" +#include "parser.hh" +#include "scope.hh" +#include "file-results.hh" +#include "midi-def.hh" +#include "paper-def.hh" +#include "identifier.hh" + +My_lily_parser::My_lily_parser (Sources * source_l) +{ + first_b_ = true; + source_l_ = source_l; + lexer_p_ = 0; + abbrev_beam_type_i_ = 0; + default_duration_.durlog_i_ = 2; + default_abbrev_i_ = 0; + error_level_i_ = 0; + fatal_error_i_ = 0; + default_header_p_ =0; +} -void -My_lily_parser::set_debug() +My_lily_parser::~My_lily_parser() { -#ifndef NPRINT - String s = ""; - if (init_parse_b_) - s = "Init"; - set_yydebug( !monitor->silence(s+"Parser") && check_debug); - lexer_p_->set_debug( !monitor->silence(s+"Lexer") && check_debug); -#endif + delete lexer_p_; + delete default_header_p_; } + + + void -My_lily_parser::print_declarations() -{ -#ifndef NPRINT - String s = ""; - if (init_parse_b_) - s = "Init"; - if (!monitor->silence(s+"Declarations") && check_debug) { - lexer_p_->print_declarations(init_parse_b_); - } -#endif +My_lily_parser::set_version_check (bool ig) +{ + ignore_version_b_ = ig; } void -My_lily_parser::parse_file(String init, String s) +My_lily_parser::parse_file (String init, String s) { - *mlog << "Parsing ... "; - lexer_p_ = new My_lily_lexer; + lexer_p_ = new My_lily_lexer; + init_str_ = init; + lexer_p_->main_input_str_ = s; - set_debug(); + *mlog << _ ("Parsing..."); - lexer_p_->new_input(init, source_l_); - do_yyparse(); - print_declarations(); - - init_parse_b_ = false; - lexer_p_->new_input(s, source_l_); - do_yyparse(); + init_parse_b_ = false; + set_yydebug (!monitor->silent_b ("Parser") && check_debug); + lexer_p_->new_input (init, source_l_); + do_yyparse (); + if (!define_spot_array_.empty()) + { + warning (_ ("braces don't match")); + error_level_i_ = 1; + } - if(!define_spot_array_.empty()) - warning("Braces don't match.",0); + inclusion_global_array = lexer_p_->filename_str_arr_; } -My_lily_parser::~My_lily_parser() -{ - delete lexer_p_; -} - void My_lily_parser::remember_spot() { - define_spot_array_.push(here_ch_C()); + define_spot_array_.push (here_input()); } -char const * -My_lily_parser::here_ch_C()const +char const * +My_lily_parser::here_ch_C() const { - return lexer_p_->here_ch_C(); + return lexer_p_->here_ch_C(); } void -My_lily_parser::parser_error(String s) +My_lily_parser::parser_error (String s) { - lexer_p_->LexerError(s); - - if ( fatal_error_i_ ) - exit( fatal_error_i_ ); - error_level_i_ = 1; + here_input().error (s); + if (fatal_error_i_) + exit (fatal_error_i_); + error_level_i_ = 1; + exit_status_i_ = 1; } void -My_lily_parser::set_duration_mode(String s) +My_lily_parser::set_abbrev_beam (int type_i) { - s = s.upper_str(); - last_duration_mode = (s== "LAST"); + abbrev_beam_type_i_ = type_i; } + void -My_lily_parser::set_last_duration(Duration const *d) +My_lily_parser::set_last_duration (Duration const *d) { - if (last_duration_mode) - default_duration_ = *d; + default_duration_ = *d; + + /* + forget plet part, + but keep sticky plet factor within plet brackets + */ + default_duration_.plet_ = plet_; } -Voice_element* -My_lily_parser::get_word_element(Text_def* tdef_p, Duration * duration_p) +Simultaneous_music* +My_lily_parser::get_word_element (String s, Duration * duration_p) { - Voice_element* velt_p = new Voice_element; - - Lyric_req* lreq_p = new Lyric_req(tdef_p); + Simultaneous_music* velt_p = new Request_chord; - lreq_p->duration_ = *duration_p; - lreq_p->defined_ch_C_ = here_ch_C(); + Lyric_req* lreq_p = new Lyric_req; + lreq_p ->text_str_ = s; + lreq_p->duration_ = *duration_p; + lreq_p->set_spot (here_input()); - velt_p->add(lreq_p); + velt_p->add_music (lreq_p); - delete duration_p; - return velt_p; + delete duration_p; + return velt_p; } -Voice_element * -My_lily_parser::get_rest_element(String, Duration * duration_p ) -{ - Voice_element* velt_p = new Voice_element; - velt_p->defined_ch_C_ = lexer_p_->here_ch_C(); - Rest_req * rest_req_p = new Rest_req; - rest_req_p->duration_ = *duration_p; - rest_req_p->defined_ch_C_ = here_ch_C(); +Simultaneous_music * +My_lily_parser::get_rest_element (String s, Duration * duration_p) +{ + Simultaneous_music* velt_p = new Request_chord; + velt_p->set_spot (here_input()); - velt_p->add(rest_req_p); - delete duration_p; - return velt_p; -} + if (s=="s") + { /* Space */ + Skip_req * skip_p = new Skip_req; + skip_p->duration_ = *duration_p; -Voice_element * -My_lily_parser::get_note_element(Note_req *rq, Duration * duration_p ) -{ - Voice_element*v = new Voice_element; - v->defined_ch_C_ = here_ch_C(); - - if (duration_p->type_i_ >= 2) { - Stem_req * stem_req_p = new Stem_req(); - stem_req_p->duration_ = *duration_p; - - stem_req_p->defined_ch_C_ = here_ch_C(); - v->add(stem_req_p); + skip_p->set_spot (here_input()); + velt_p->add_music (skip_p); } + else + { + Rest_req * rest_req_p = new Rest_req; + rest_req_p->duration_ = *duration_p; + rest_req_p->set_spot (here_input()); - rq->set_duration(*duration_p); - rq->defined_ch_C_ = here_ch_C(); - + velt_p->add_music (rest_req_p); + } - v->add(rq); - delete duration_p ; - return v; + delete duration_p; + return velt_p; } -Request* -My_lily_parser::get_parens_request(char c) +Simultaneous_music * +My_lily_parser::get_note_element (Note_req *rq, Duration * duration_p) { - Request* req_p=0; - switch (c) { - case '|': - req_p = new Barcheck_req; - break; + Simultaneous_music*v = new Request_chord; + v->set_spot (here_input ()); - case '[': - case ']': + v->add_music (rq); + + // too bad parser reads (default) duration via member access, + // this hack will do for now.. + if (abbrev_beam_type_i_) { - Beam_req*b = new Beam_req; - int p_i=default_duration_.plet_.type_i_ ; // ugh . Should junk? - if (p_i!= 1) - b->nplet = p_i; - req_p = b; + assert (!duration_p->plet_b ()); + duration_p->set_plet (1, 2); } - break; - + rq->duration_ = *duration_p; + rq->set_spot (here_input ()); + delete duration_p ; + return v; +} +Array* +My_lily_parser::get_parens_request (int t) +{ + Array& reqs = *new Array; + switch (t) + { + case '~': + reqs.push (new Tie_req); + break; + case BEAMPLET: + case MAEBTELP: + { + Plet_req* p = new Plet_req; + p->plet_i_ = plet_.type_i_; + reqs.push (p); + } + /* fall through */ + case '[': + case ']': + { + if (!abbrev_beam_type_i_) + { + reqs.push (new Beam_req); + } + else + { + Abbreviation_beam_req* a = new Abbreviation_beam_req; + a->type_i_ = abbrev_beam_type_i_; + if (t==']') + abbrev_beam_type_i_ = 0; + reqs.push (a); + } + } + break; + + case '>': + case '!': + case '<': + reqs.push (new Span_dynamic_req); + break; + + case PLET: + case TELP: + { + Plet_req* p = new Plet_req; + p->plet_i_ = plet_.type_i_; + reqs.push (p); + } + break; case ')': case '(': - req_p = new Slur_req; - break; + { + reqs.push (new Slur_req); + } + break; default: - assert(false); - break; + assert (false); + break; } - - switch (c) { + + switch (t) + { + case BEAMPLET: + dynamic_cast (reqs.top ())->spantype = Span_req::START; + /* fall through */ + case '<': + case '>': case '(': case '[': - req_p->span()->spantype = Span_req::START; - break; + case PLET: + dynamic_cast (reqs.top ())->spantype = Span_req::START; + break; + case MAEBTELP: + dynamic_cast (reqs.top ())->spantype = Span_req::STOP; + /* fall through */ + case '!': case ')': case ']': - req_p->span()->spantype = Span_req::STOP; - break; - + dynamic_cast (reqs[0])->spantype = Span_req::STOP; + break; + default: - break; + break; } - req_p->defined_ch_C_ = here_ch_C(); - return req_p; -} + for (int i = 0; i < reqs.size (); i++) + if (dynamic_cast (reqs[i])) + { + Span_dynamic_req* s_l= dynamic_cast (reqs[i]); + s_l->dynamic_dir_ = (t == '<') ? UP:DOWN; + } -My_lily_parser::My_lily_parser(Sources * source_l) -{ - source_l_ = source_l; - lexer_p_ = 0; - default_duration_.type_i_ = 4; - default_octave_i_ = 3; // retain old default - textstyle_str_="roman"; // in lexer? - error_level_i_ = 0; - last_duration_mode = false; - defined_ch_C_ = 0; - fatal_error_i_ = 0; + // ugh? don't we do this in the parser too? + reqs[0]->set_spot (here_input()); + return &reqs; } void -My_lily_parser::add_requests(Voice_element*v) +My_lily_parser::add_requests (Simultaneous_music*v) { - for (int i = 0; i < pre_reqs.size(); i++) { - v->add(pre_reqs[i]); + for (int i = 0; i < pre_reqs.size(); i++) + { + v->add_music (pre_reqs[i]); } - pre_reqs.set_size(0); - for (int i = 0; i add(post_reqs[i]); + pre_reqs.clear(); + for (int i = 0; i add_music (post_reqs[i]); } - post_reqs.set_size(0); + + post_reqs.clear(); } + +Input +My_lily_parser::pop_spot() +{ + return define_spot_array_.pop(); +} + +Input +My_lily_parser::here_input() const +{ + Source_file * f_l= lexer_p_->source_file_l(); + return Input (f_l, here_ch_C()); +} + +void +My_lily_parser::add_notename (String s, Musical_pitch p) +{ + lexer_p_->add_notename (s, p); + +} + +Paper_def* +My_lily_parser::default_paper_p () +{ + Identifier *id = lexer_p_->lookup_identifier ("$defaultpaper"); + return id ? id->access_Paper_def () : new Paper_def ; +} + +Midi_def* +My_lily_parser::default_midi_p () +{ + Identifier *id = lexer_p_->lookup_identifier ("$defaultmidi"); + return id ? id->access_Midi_def () : new Midi_def ; +} +