lily/lexer.ll

   1 %{ // -*-Fundamental-*-
   2 /*
   3   lexer.l -- implement the Flex lexer
   4
   5   source file of the LilyPond music typesetter
   6
   7   (c) 1996--2002 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   8            Jan Nieuwenhuizen <janneke@gnu.org>
   9 */
  10
  11
  12 /*
  13   backup rules
  14
  15   after making a change to the lexer rules, run
  16       flex -b <this lexer file>
  17   and make sure that
  18       lex.backup
  19   contains no backup states, but only the reminder
  20       Compressed tables always back up.
  21  (don-t forget to rm lex.yy.cc :-)
  22  */
  23
  24
  25 #include <stdio.h>
  26 #include <ctype.h>
  27 #include <errno.h>
  28
  29 #include <iostream>
  30
  31 #include "parse-scm.hh"
  32 #include "lily-guile.hh"
  33 #include "string.hh"
  34 #include "string-convert.hh"
  35 #include "my-lily-lexer.hh"
  36 #include "input-file-results.hh"
  37 #include "interval.hh"
  38 #include "lily-guile.hh"
  39 #include "parser.hh"
  40 #include "warn.hh"
  41 #include "main.hh"
  42 #include "version.hh"
  43 #include "lilypond-input-version.hh"
  44 #include "translator-def.hh"
  45 #include "identifier-smob.hh"
  46
  47 /*
  48 RH 7 fix (?)
  49 */
  50 #define isatty HORRIBLEKLUDGE
  51
  52 void strip_trailing_white (String&);
  53 void strip_leading_white (String&);
  54 String lyric_fudge (String s);
  55
  56
  57 bool
  58 valid_version_b (String s);
  59
  60
  61
  62 #define start_quote()   \
  63         yy_push_state (quote);\
  64         yylval.string = new String
  65
  66 #define yylval \
  67         (*(YYSTYPE*)lexval)
  68
  69 #define YY_USER_ACTION  add_lexed_char (YYLeng ());
  70 /*
  71
  72 LYRICS          ({AA}|{TEX})[^0-9 \t\n\f]*
  73
  74 */
  75
  76
  77 SCM scan_fraction (String);
  78 SCM (* scm_parse_error_handler) (void *);
  79
  80
  81 %}
  82
  83 %option c++
  84 %option noyywrap
  85 %option nodefault
  86 %option debug
  87 %option yyclass="My_lily_lexer"
  88 %option stack
  89 %option never-interactive
  90 %option warn
  91
  92 %x version
  93 %x chords
  94 %x incl
  95 %x lyrics
  96 %x notes
  97 %x figures
  98 %x quote
  99 %x longcomment
 100
 101
 102 A               [a-zA-Z]
 103 AA              {A}|_
 104 N               [0-9]
 105 AN              {AA}|{N}
 106 PUNCT           [?!:'`]
 107 ACCENT          \\[`'"^]
 108 NATIONAL        [\001-\006\021-\027\031\036\200-\377]
 109 TEX             {AA}|-|{PUNCT}|{ACCENT}|{NATIONAL}
 110 WORD            {A}{AN}*
 111 ALPHAWORD       {A}+
 112 DIGIT           {N}
 113 UNSIGNED        {N}+
 114 E_UNSIGNED      \\{N}+
 115 FRACTION        {N}+\/{N}+
 116 INT             -?{UNSIGNED}
 117 REAL            ({INT}\.{N}*)|(-?\.{N}+)
 118 KEYWORD         \\{WORD}
 119 WHITE           [ \n\t\f\r]
 120 HORIZONTALWHITE         [ \t]
 121 BLACK           [^ \n\t\f\r]
 122 RESTNAME        [rs]
 123 NOTECOMMAND     \\{A}+
 124 LYRICS          ({AA}|{TEX})[^0-9 \t\n\f]*
 125 ESCAPED         [nt\\'"]
 126 EXTENDER        __
 127 HYPHEN          --
 128 %%
 129
 130
 131 <*>\r           {
 132         // windows-suck-suck-suck
 133 }
 134
 135 <INITIAL,chords,incl,lyrics,notes,figures>{
 136   "%{"  {
 137         yy_push_state (longcomment);
 138   }
 139   %[^{\n].*\n   {
 140   }
 141   %[^{\n]       { // backup rule
 142   }
 143   %\n   {
 144   }
 145   %[^{\n].*     {
 146   }
 147   {WHITE}+      {
 148
 149   }
 150 }
 151
 152 <INITIAL,chords,lyrics,notes,figures>\\version{WHITE}*  {
 153         yy_push_state (version);
 154 }
 155 <version>\"[^"]*\"     { /* got the version number */
 156         String s (YYText ()+1);
 157         s = s.left_string (s.index_last ('\"'));
 158
 159         yy_pop_state ();
 160         if (!valid_version_b (s))
 161                 return INVALID;
 162 }
 163 <version>.      {
 164         LexerError ("No quoted string found after \\version");
 165         yy_pop_state ();
 166 }
 167 <longcomment>{
 168         [^\%]*          {
 169         }
 170         \%*[^}%]*               {
 171
 172         }
 173         "%"+"}"         {
 174                 yy_pop_state ();
 175         }
 176         <<EOF>>         {
 177                 LexerError (_ ("EOF found inside a comment").to_str0 ());
 178                 if (! close_input ())
 179                   yyterminate (); // can't move this, since it actually rets a YY_NULL
 180         }
 181 }
 182
 183
 184 <INITIAL,chords,lyrics,notes,figures>\\maininput           {
 185         if (!main_input_b_)
 186         {
 187                 start_main_input ();
 188                 main_input_b_ = true;
 189         }
 190         else
 191                 error (_ ("\\maininput disallowed outside init files"));
 192 }
 193
 194 <INITIAL,chords,lyrics,figures,notes>\\include           {
 195         yy_push_state (incl);
 196 }
 197 <incl>\"[^"]*\";?   { /* got the include file name */
 198         String s (YYText ()+1);
 199         s = s.left_string (s.index_last ('"'));
 200
 201         new_input (s, &global_input_file->sources_ );
 202         yy_pop_state ();
 203 }
 204 <incl>\\{BLACK}*;?{WHITE} { /* got the include identifier */
 205         String s = YYText () + 1;
 206         strip_trailing_white (s);
 207         if (s.length () && (s[s.length () - 1] == ';'))
 208           s = s.left_string (s.length () - 1);
 209
 210         SCM sid = lookup_identifier (s);
 211         if (gh_string_p (sid)) {
 212                 new_input (ly_scm2string (sid), &global_input_file->sources_);
 213                 yy_pop_state ();
 214         } else {
 215             String msg (_f ("wrong or undefined identifier: `%s'", s ));
 216
 217             LexerError (msg.to_str0 ());
 218             SCM err = scm_current_error_port ();
 219             scm_puts ("This value was found in the table: ", err);
 220             scm_display (sid, err);
 221           }
 222 }
 223 <incl>\"[^"]*   { // backup rule
 224         error (_ ("Missing end quote"));
 225         exit (1);
 226 }
 227 <chords,notes,figures>{RESTNAME}        {
 228         const char *s = YYText ();
 229         yylval.scm = scm_makfrom0str (s);
 230         return RESTNAME;
 231 }
 232 <chords,notes,figures>R         {
 233         return MULTI_MEASURE_REST;
 234 }
 235 <INITIAL,chords,lyrics,notes,figures>\\\${BLACK}*{WHITE}        {
 236         String s=YYText () + 2;
 237         s=s.left_string (s.length () - 1);
 238         return scan_escaped_word (s);
 239 }
 240 <INITIAL,chords,lyrics,notes,figures>\${BLACK}*{WHITE}          {
 241         String s=YYText () + 1;
 242         s=s.left_string (s.length () - 1);
 243         return scan_bare_word (s);
 244 }
 245 <INITIAL,chords,lyrics,notes,figures>\\\${BLACK}*               { // backup rule
 246         error (_("white expected"));
 247         exit (1);
 248 }
 249 <INITIAL,chords,lyrics,notes,figures>\${BLACK}*         { // backup rule
 250         error (_("white expected"));
 251         exit (1);
 252 }
 253
 254 <INITIAL,chords,lyrics,notes,figures>#  { //embedded scm
 255         //char const* s = YYText () + 1;
 256         char const* s = here_str0 ();
 257         int n = 0;
 258         if (main_input_b_ && safe_global_b) {
 259                 error (_ ("Can't evaluate Scheme in safe mode"));
 260                 yylval.scm =  SCM_EOL;
 261                 return SCM_T;
 262         }
 263         SCM sval = ly_parse_scm (s, &n, here_input());
 264
 265         for (int i=0; i < n; i++)
 266         {
 267                 yyinput ();
 268         }
 269         char_count_stack_.top () += n;
 270
 271         if (unpack_identifier (sval) != SCM_UNDEFINED)
 272         {
 273                 yylval.scm = unpack_identifier(sval);
 274                 return identifier_type (yylval.scm);
 275         }
 276
 277         yylval.scm = sval;
 278         return SCM_T;
 279 }
 280 <INITIAL,notes>{
 281         \<\<   {
 282                 return CHORD_OPEN;
 283         }
 284         \>\>   {
 285                 return CHORD_CLOSE;
 286         }
 287 }
 288 <figures>{
 289         _       {
 290                 return FIGURE_SPACE;
 291         }
 292         \>              {
 293                 return FIGURE_CLOSE;
 294         }
 295         \<      {
 296                 return FIGURE_OPEN;
 297         }
 298 }
 299
 300 <notes,figures>{
 301         {ALPHAWORD}     {
 302                 return scan_bare_word (YYText ());
 303         }
 304
 305         {NOTECOMMAND}   {
 306                 return scan_escaped_word (YYText () + 1);
 307         }
 308         {FRACTION}      {
 309                 yylval.scm =  scan_fraction (YYText ());
 310                 return FRACTION;
 311         }
 312
 313         {DIGIT}         {
 314                 yylval.i = String_convert::dec2int (String (YYText ()));
 315                 return DIGIT;
 316         }
 317         {UNSIGNED}              {
 318                 yylval.i = String_convert::dec2int (String (YYText ()));
 319                 return UNSIGNED;
 320         }
 321         {E_UNSIGNED}    {
 322                 yylval.i = String_convert::dec2int (String (YYText () +1));
 323                 return E_UNSIGNED;
 324         }
 325
 326         \" {
 327                 start_quote ();
 328         }
 329 }
 330
 331 \"              {
 332         start_quote ();
 333 }
 334 <quote>{
 335         \\{ESCAPED}     {
 336                 *yylval.string += to_string (escaped_char (YYText ()[1]));
 337         }
 338         [^\\"]+ {
 339                 *yylval.string += YYText ();
 340         }
 341         \"      {
 342
 343                 yy_pop_state ();
 344
 345                 /* yylval is union. Must remember STRING before setting SCM*/
 346                 String *sp = yylval.string;
 347                 yylval.scm = scm_makfrom0str (sp->to_str0 ());
 348                 delete sp;
 349                 return STRING;
 350         }
 351         .       {
 352                 *yylval.string += YYText ();
 353         }
 354 }
 355
 356 <lyrics>{
 357         \" {
 358                 start_quote ();
 359         }
 360         {FRACTION}      {
 361                 yylval.scm =  scan_fraction (YYText ());
 362                 return FRACTION;
 363         }
 364         {UNSIGNED}              {
 365                 yylval.i = String_convert::dec2int (String (YYText ()));
 366                 return UNSIGNED;
 367         }
 368         {NOTECOMMAND}   {
 369                 return scan_escaped_word (YYText () + 1);
 370         }
 371         {LYRICS} {
 372                 /* ugr. This sux. */
 373                 String s (YYText ());
 374                 if (s == "__")
 375                         return yylval.i = EXTENDER;
 376                 if (s == "--")
 377                         return yylval.i = HYPHEN;
 378                 s = lyric_fudge (s);
 379
 380                 char c = s[s.length () - 1];
 381                 if (c == '{' ||  c == '}') // brace open is for not confusing dumb tools.
 382                         here_input ().warning (
 383                                 _ ("Brace found at end of lyric.  Did you forget a space?"));
 384                 yylval.scm = scm_makfrom0str (s.to_str0 ());
 385
 386
 387                 return STRING;
 388         }
 389         . {
 390                 return YYText ()[0];
 391         }
 392 }
 393 <chords>{
 394         {ALPHAWORD}     {
 395                 return scan_bare_word (YYText ());
 396         }
 397         {NOTECOMMAND}   {
 398                 return scan_escaped_word (YYText () + 1);
 399         }
 400         {FRACTION}      {
 401                 yylval.scm =  scan_fraction (YYText ());
 402                 return FRACTION;
 403         }
 404         {UNSIGNED}              {
 405                 yylval.i = String_convert::dec2int (String (YYText ()));
 406                 return UNSIGNED;
 407         }
 408         \" {
 409                 start_quote ();
 410         }
 411         -  {
 412                 return CHORD_MINUS;
 413         }
 414         :  {
 415                 return CHORD_COLON;
 416         }
 417         \/\+ {
 418                 return CHORD_BASS;
 419         }
 420         \/  {
 421                 return CHORD_SLASH;
 422         }
 423         \^  {
 424                 return CHORD_CARET;
 425         }
 426         . {
 427                 return YYText ()[0];
 428         }
 429 }
 430
 431
 432
 433
 434 <<EOF>> {
 435
 436
 437         if (! close_input ()) {
 438           yyterminate (); // can't move this, since it actually rets a YY_NULL
 439         }
 440 }
 441
 442
 443 {WORD}  {
 444         return scan_bare_word (YYText ());
 445 }
 446 {KEYWORD}       {
 447         return scan_escaped_word (YYText () + 1);
 448 }
 449 {REAL}          {
 450         Real r;
 451         int cnv=sscanf (YYText (), "%lf", &r);
 452         assert (cnv == 1);
 453
 454         yylval.scm = gh_double2scm (r);
 455         return REAL;
 456 }
 457
 458 {UNSIGNED}      {
 459         yylval.i = String_convert::dec2int (String (YYText ()));
 460         return UNSIGNED;
 461 }
 462
 463
 464 [{}]    {
 465
 466         return YYText ()[0];
 467 }
 468 [*:=]           {
 469         char c = YYText ()[0];
 470
 471         return c;
 472 }
 473
 474 <INITIAL,notes,figures>.        {
 475         return YYText ()[0];
 476 }
 477
 478 <INITIAL,lyrics,notes,figures>\\. {
 479     char c= YYText ()[1];
 480
 481     switch (c) {
 482     case '>':
 483         return E_BIGGER;
 484     case '<':
 485         return E_SMALLER;
 486     case '!':
 487         return E_EXCLAMATION;
 488     case '(':
 489         return E_OPEN;
 490     case ')':
 491         return E_CLOSE;
 492     case '[':
 493         return E_LEFTSQUARE;
 494     case ']':
 495         return E_RIGHTSQUARE;
 496     case '~':
 497         return E_TILDE;
 498     case '\\':
 499         return E_BACKSLASH;
 500
 501     default:
 502         return E_CHAR;
 503     }
 504 }
 505
 506 <*>.            {
 507         String msg = _f ("invalid character: `%c'", YYText ()[0]);
 508         LexerError (msg.to_str0 ());
 509         return YYText ()[0];
 510 }
 511
 512 %%
 513
 514 void
 515 My_lily_lexer::push_note_state ()
 516 {
 517         yy_push_state (notes);
 518 }
 519
 520 void
 521 My_lily_lexer::push_figuredbass_state()
 522 {
 523         yy_push_state (figures);
 524 }
 525 void
 526 My_lily_lexer::push_chord_state ()
 527 {
 528         yy_push_state (chords);
 529 }
 530
 531 void
 532 My_lily_lexer::push_lyric_state ()
 533 {
 534         yy_push_state (lyrics);
 535 }
 536
 537 void
 538 My_lily_lexer::pop_state ()
 539 {
 540         yy_pop_state ();
 541 }
 542
 543 int
 544 My_lily_lexer::identifier_type(SCM sid)
 545 {
 546         int k = try_special_identifiers(&yylval.scm , sid);
 547         return k >= 0  ? k : SCM_IDENTIFIER;
 548 }
 549
 550
 551 int
 552 My_lily_lexer::scan_escaped_word (String str)
 553 {
 554         // use more SCM for this.
 555
 556         SCM sym = ly_symbol2scm (str.to_str0 ());
 557
 558         int l = lookup_keyword (str);
 559         if (l != -1) {
 560                 return l;
 561         }
 562         SCM sid = lookup_identifier (str);
 563         if (sid != SCM_UNDEFINED)
 564         {
 565                 yylval.scm = sid;
 566                 return identifier_type (sid);
 567         }
 568
 569         if ((YYSTATE != notes) && (YYSTATE != chords)) {
 570                 SCM pitch = scm_hashq_get_handle (pitchname_tab_, sym);
 571
 572                 if (gh_pair_p (pitch))
 573                 {
 574                         yylval.scm = ly_cdr (pitch);
 575                         return NOTENAME_PITCH;
 576                 }
 577         }
 578         String msg (_f ("unknown escaped string: `\\%s'", str));
 579         LexerError (msg.to_str0 ());
 580
 581         yylval.scm = scm_makfrom0str (str.to_str0 ());
 582
 583         return STRING;
 584 }
 585
 586 int
 587 My_lily_lexer::scan_bare_word (String str)
 588 {
 589         SCM sym = ly_symbol2scm (str.to_str0 ());
 590         if ((YYSTATE == notes) || (YYSTATE == chords)) {
 591                 SCM pitch = scm_hashq_get_handle (pitchname_tab_, sym);
 592                 if (gh_pair_p (pitch)) {
 593                     yylval.scm = ly_cdr (pitch);
 594                     return (YYSTATE == notes) ? NOTENAME_PITCH : TONICNAME_PITCH;
 595                 } else if ((pitch = scm_hashq_get_handle (chordmodifier_tab_, sym))!= SCM_BOOL_F)
 596                 {
 597                     yylval.scm = ly_cdr (pitch);
 598                     return CHORDMODIFIER_PITCH;
 599                 }
 600         }
 601
 602         yylval.scm = scm_makfrom0str (str.to_str0 ());
 603         return STRING;
 604 }
 605
 606 bool
 607 My_lily_lexer::note_state_b () const
 608 {
 609         return YY_START == notes;
 610 }
 611
 612 bool
 613 My_lily_lexer::chord_state_b () const
 614 {
 615         return YY_START == chords;
 616 }
 617
 618 bool
 619 My_lily_lexer::lyric_state_b () const
 620 {
 621         return YY_START == lyrics;
 622 }
 623
 624 bool
 625 My_lily_lexer::figure_state_b () const
 626 {
 627         return YY_START == figures;
 628 }
 629
 630 /*
 631  urg, belong to String (_convert)
 632  and should be generalised
 633  */
 634 void
 635 strip_leading_white (String&s)
 636 {
 637         int i=0;
 638         for (;  i < s.length (); i++)
 639                 if (!isspace (s[i]))
 640                         break;
 641
 642         s = s.nomid_string (0, i);
 643 }
 644
 645 void
 646 strip_trailing_white (String&s)
 647 {
 648         int i=s.length ();
 649         while (i--)
 650                 if (!isspace (s[i]))
 651                         break;
 652
 653         s = s.left_string (i+1);
 654 }
 655
 656
 657
 658 /* 1.3.146 == removal of ; */
 659 Lilypond_version oldest_version ("1.3.146");
 660
 661
 662 bool
 663 valid_version_b (String s)
 664 {
 665   Lilypond_version current ( MAJOR_VERSION "." MINOR_VERSION "." PATCH_LEVEL );
 666   Lilypond_version ver (s);
 667   if (! ((ver >= oldest_version) && (ver <= current)))
 668         {
 669                 non_fatal_error (_f ("Incorrect lilypond version: %s (%s, %s)", ver.string (), oldest_version.string (), current.string ()));
 670                 non_fatal_error (_ ("Consider updating the input with the convert-ly script"));
 671                 return false;
 672     }
 673   return true;
 674 }
 675
 676
 677 String
 678 lyric_fudge (String s)
 679 {
 680   char  * chars  =s.get_copy_str0 ();
 681
 682   for (char * p = chars; *p ; p++)
 683     {
 684       if (*p == '_' && (p == chars || *(p-1) != '\\'))
 685         *p = ' ';
 686     }
 687
 688   s = String (chars);
 689   delete[] chars;
 690
 691   int i =0;
 692   if ((i=s.index ("\\,")) != -1)   // change "\," to TeX's "\c "
 693     {
 694       * (s.get_str0 () + i + 1) = 'c';
 695       s = s.left_string (i+2) + " " + s.right_string (s.length ()-i-2);
 696     }
 697
 698   return s;
 699 }
 700
 701 /*
 702 Convert "NUM/DEN" into a '(NUM . DEN) cons.
 703 */
 704 SCM
 705 scan_fraction (String frac)
 706 {
 707         int i = frac.index ('/');
 708         int l = frac.length ();
 709         String left = frac.left_string (i);
 710         String right = frac.right_string (l - i - 1);
 711
 712         int n = String_convert::dec2int (left);
 713         int d = String_convert::dec2int (right);
 714         return gh_cons (gh_int2scm (n), gh_int2scm (d));
 715 }
 716
 717 /* avoid silly flex induced gcc warnings */
 718 static void yy_push_state (int) {;}
 719 static void yy_pop_state () {;}
 720 static int yy_top_state () { return 0; }
 721
 722 static void
 723 avoid_silly_flex_induced_gcc_warnings ()
 724 {
 725         (void)yy_start_stack_ptr;
 726         (void)yy_start_stack_depth;
 727         (void)yy_start_stack;
 728         yy_push_state (0);
 729         yy_pop_state ();
 730         yy_top_state ();
 731         avoid_silly_flex_induced_gcc_warnings ();
 732 }