lily/my-lily-parser.cc

   1 /*
   2   my-lily-parser.cc -- implement My_lily_parser
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c)  1997--1998 Han-Wen Nienhuys <hanwen@stack.nl>
   7 */
   8
   9 #include "my-lily-parser.hh"
  10 #include "my-lily-lexer.hh"
  11 #include "debug.hh"
  12 #include "main.hh"
  13 #include "music-list.hh"
  14 #include "musical-request.hh"
  15 #include "command-request.hh"
  16 #include "parser.hh"
  17 #include "header.hh"
  18 #include "file-results.hh"
  19
  20 My_lily_parser::My_lily_parser (Sources * source_l)
  21 {
  22   first_b_ = true;
  23   source_l_ = source_l;
  24   lexer_p_ = 0;
  25   abbrev_beam_type_i_ = 0;
  26   default_duration_.durlog_i_ = 2;
  27   default_octave_i_ = 0;
  28   textstyle_str_="roman";               // in lexer?
  29   error_level_i_ = 0;
  30   last_duration_mode_b_ = true;
  31   fatal_error_i_ = 0;
  32   default_header_p_ =0;
  33 }
  34
  35 My_lily_parser::~My_lily_parser()
  36 {
  37   delete lexer_p_;
  38   delete default_header_p_;
  39 }
  40
  41
  42 void
  43 My_lily_parser::clear_notenames()
  44 {
  45   lexer_p_->clear_notenames();
  46 }
  47
  48 void
  49 My_lily_parser::set_version_check (bool ig)
  50 {
  51   ignore_version_b_ = ig;
  52 }
  53
  54 void
  55 My_lily_parser::parse_file (String init, String s)
  56 {
  57   lexer_p_ = new My_lily_lexer;
  58   init_str_ = init;
  59   lexer_p_->main_input_str_ = s;
  60
  61   *mlog << _("Parsing ... ");
  62
  63   init_parse_b_ = false;
  64   set_yydebug (!monitor->silent_b ("Parser") && check_debug);
  65   lexer_p_->new_input (init, source_l_);
  66   do_yyparse ();
  67
  68
  69   if (!define_spot_array_.empty())
  70     {
  71       warning (_("Braces don't match."));
  72       error_level_i_ = 1;
  73     }
  74
  75   inclusion_global_array = lexer_p_->filename_str_arr_;
  76 }
  77
  78 void
  79 My_lily_parser::remember_spot()
  80 {
  81   define_spot_array_.push (here_input());
  82 }
  83
  84 char const *
  85 My_lily_parser::here_ch_C() const
  86 {
  87   return lexer_p_->here_ch_C();
  88 }
  89
  90 void
  91 My_lily_parser::parser_error (String s)
  92 {
  93   here_input().error (s);
  94   if (fatal_error_i_)
  95     exit (fatal_error_i_);
  96   error_level_i_ = 1;
  97   exit_status_i_ = 1;
  98 }
  99
 100 void
 101 My_lily_parser::set_duration_mode (String s)
 102 {
 103   s = s.upper_str();
 104   last_duration_mode_b_ = (s== "LAST");
 105 }
 106
 107 void
 108 My_lily_parser::set_abbrev_beam (int type_i)
 109 {
 110   abbrev_beam_type_i_ = type_i;
 111 }
 112
 113 void
 114 My_lily_parser::set_default_duration (Duration const *d)
 115 {
 116   last_duration_mode_b_ = false;
 117   default_duration_ = *d;
 118 }
 119
 120
 121 void
 122 My_lily_parser::set_last_duration (Duration const *d)
 123 {
 124   if (last_duration_mode_b_)
 125     {
 126       default_duration_ = *d;
 127       /*
 128         forget plet part,
 129         sticky plet factor only within plet brackets
 130        */
 131       default_duration_.set_plet (1, 1);
 132     }
 133 }
 134
 135
 136 Chord*
 137 My_lily_parser::get_word_element (Text_def* tdef_p, Duration * duration_p)
 138 {
 139   Chord* velt_p = new Request_chord;
 140
 141   Lyric_req* lreq_p = new Lyric_req (tdef_p);
 142
 143   lreq_p->duration_ = *duration_p;
 144   lreq_p->set_spot (here_input());
 145
 146   velt_p->add (lreq_p);
 147
 148   delete  duration_p;
 149   return velt_p;
 150 }
 151
 152 Chord *
 153 My_lily_parser::get_rest_element (String s,  Duration * duration_p)
 154 {
 155   Chord* velt_p = new Request_chord;
 156   velt_p->set_spot (here_input());
 157
 158   if (s=="s")
 159     { /* Space */
 160       Skip_req * skip_p = new Skip_req;
 161       skip_p->duration_ = *duration_p;
 162
 163       skip_p->set_spot (here_input());
 164       velt_p->add (skip_p);
 165     }
 166   else if ((duration_p->plet_.type_i_ == 1) && (duration_p->plet_.iso_i_ > 1))
 167     {
 168       Multi_measure_rest_req* m = new Multi_measure_rest_req;
 169       // these shouldn't be necessary anymore
 170 //      plet_.iso_i_ = 1;
 171 //      default_duration_.plet_.iso_i_ = 1;
 172       m->duration_ = *duration_p;
 173       m->set_spot (here_input());
 174       velt_p->add (m);
 175     }
 176   else
 177     {
 178       Rest_req * rest_req_p = new Rest_req;
 179       rest_req_p->duration_ = *duration_p;
 180       rest_req_p->set_spot (here_input());
 181
 182       velt_p->add (rest_req_p);
 183     }
 184
 185   delete duration_p;
 186   return velt_p;
 187 }
 188
 189 Chord *
 190 My_lily_parser::get_note_element (Note_req *rq, Duration * duration_p)
 191 {
 192   Chord*v = new Request_chord;
 193   v->set_spot (here_input ());
 194
 195   v->add (rq);
 196
 197   // too bad parser reads (default) duration via member access,
 198   // this hack will do for now..
 199   if (abbrev_beam_type_i_)
 200     {
 201       assert (!duration_p->plet_b ());
 202       duration_p->set_plet (1, 2);
 203     }
 204   rq->set_duration (*duration_p);
 205   rq->set_spot (here_input ());
 206   delete duration_p ;
 207   return v;
 208 }
 209
 210 Array<Request*>*
 211 My_lily_parser::get_parens_request (int t)
 212 {
 213   Array<Request*>& reqs = *new Array<Request*>;
 214   switch (t)
 215     {
 216     case '~':
 217       reqs.push (new Tie_req);
 218       break;
 219     case BEAMPLET:
 220     case MAEBTELP:
 221       {
 222         Plet_req* p = new Plet_req;
 223         p->plet_i_ = plet_.type_i_;
 224         reqs.push (p);
 225       }
 226       /* fall through */
 227     case '[':
 228     case ']':
 229       {
 230         if (!abbrev_beam_type_i_)
 231           {
 232             reqs.push (new Beam_req);
 233           }
 234         else
 235           {
 236             Abbreviation_beam_req* a = new Abbreviation_beam_req;
 237             a->type_i_ = abbrev_beam_type_i_;
 238             if (t==']')
 239               abbrev_beam_type_i_ = 0;
 240             reqs.push (a);
 241           }
 242       }
 243       break;
 244
 245     case '>':
 246     case '!':
 247     case '<':
 248       reqs.push (new Span_dynamic_req);
 249       break;
 250
 251     case PLET:
 252     case TELP:
 253       {
 254         Plet_req* p = new Plet_req;
 255         p->plet_i_ = plet_.type_i_;
 256         reqs.push (p);
 257       }
 258       break;
 259     case ')':
 260     case '(':
 261       {
 262         reqs.push (new Slur_req);
 263       }
 264       break;
 265     default:
 266       assert (false);
 267       break;
 268     }
 269
 270   switch (t)
 271     {
 272     case BEAMPLET:
 273       reqs.top ()->span()->spantype = Span_req::START;
 274       /* fall through */
 275     case '<':
 276     case '>':
 277     case '(':
 278     case '[':
 279     case PLET:
 280       reqs[0]->span ()->spantype = Span_req::START;
 281       break;
 282     case MAEBTELP:
 283       reqs.top ()->span()->spantype = Span_req::STOP;
 284       /* fall through */
 285     case '!':
 286     case ')':
 287     case ']':
 288       reqs[0]->span ()->spantype = Span_req::STOP;
 289       break;
 290
 291     default:
 292       break;
 293     }
 294
 295   for (int i = 0; i < reqs.size (); i++)
 296     if (reqs[i]->musical ()->span_dynamic ())
 297       {
 298         Span_dynamic_req* s_l= (reqs[i]->musical ()->span_dynamic ()) ;
 299         s_l->dynamic_dir_ = (t == '<') ? UP:DOWN;
 300       }
 301
 302   // ugh? don't we do this in the parser too?
 303   reqs[0]->set_spot (here_input());
 304   return &reqs;
 305 }
 306
 307 void
 308 My_lily_parser::add_requests (Chord*v)
 309 {
 310   for (int i = 0; i < pre_reqs.size(); i++)
 311     {
 312       v->add (pre_reqs[i]);
 313     }
 314   pre_reqs.clear();
 315   for (int i = 0; i <post_reqs.size(); i++)
 316     {
 317       v->add (post_reqs[i]);
 318     }
 319   post_reqs.clear();
 320 }
 321
 322 Input
 323 My_lily_parser::pop_spot()
 324 {
 325   return define_spot_array_.pop();
 326 }
 327
 328 Input
 329 My_lily_parser::here_input() const
 330 {
 331   Source_file * f_l= lexer_p_->source_file_l();
 332   return Input (f_l, here_ch_C());
 333 }
 334
 335 void
 336 My_lily_parser::add_notename (String s, Melodic_req * m_p)
 337 {
 338   lexer_p_->add_notename (s, m_p);
 339 }