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 <figures>{
 281         _       {
 282                 return FIGURE_SPACE;
 283         }
 284         \>              {
 285                 return FIGURE_CLOSE;
 286         }
 287         \<      {
 288                 return FIGURE_OPEN;
 289         }
 290 }
 291 <notes,figures>{
 292         {ALPHAWORD}     {
 293                 return scan_bare_word (YYText ());
 294         }
 295
 296         {NOTECOMMAND}   {
 297                 return scan_escaped_word (YYText () + 1);
 298         }
 299         {FRACTION}      {
 300                 yylval.scm =  scan_fraction (YYText ());
 301                 return FRACTION;
 302         }
 303
 304         {DIGIT}         {
 305                 yylval.i = String_convert::dec2int (String (YYText ()));
 306                 return DIGIT;
 307         }
 308         {UNSIGNED}              {
 309                 yylval.i = String_convert::dec2int (String (YYText ()));
 310                 return UNSIGNED;
 311         }
 312         {E_UNSIGNED}    {
 313                 yylval.i = String_convert::dec2int (String (YYText () +1));
 314                 return E_UNSIGNED;
 315         }
 316
 317         \" {
 318                 start_quote ();
 319         }
 320 }
 321
 322 \"              {
 323         start_quote ();
 324 }
 325 <quote>{
 326         \\{ESCAPED}     {
 327                 *yylval.string += to_string (escaped_char (YYText ()[1]));
 328         }
 329         [^\\"]+ {
 330                 *yylval.string += YYText ();
 331         }
 332         \"      {
 333
 334                 yy_pop_state ();
 335
 336                 /* yylval is union. Must remember STRING before setting SCM*/
 337                 String *sp = yylval.string;
 338                 yylval.scm = scm_makfrom0str (sp->to_str0 ());
 339                 delete sp;
 340                 return STRING;
 341         }
 342         .       {
 343                 *yylval.string += YYText ();
 344         }
 345 }
 346
 347 <lyrics>{
 348         \" {
 349                 start_quote ();
 350         }
 351         {FRACTION}      {
 352                 yylval.scm =  scan_fraction (YYText ());
 353                 return FRACTION;
 354         }
 355         {UNSIGNED}              {
 356                 yylval.i = String_convert::dec2int (String (YYText ()));
 357                 return UNSIGNED;
 358         }
 359         {NOTECOMMAND}   {
 360                 return scan_escaped_word (YYText () + 1);
 361         }
 362         {LYRICS} {
 363                 /* ugr. This sux. */
 364                 String s (YYText ());
 365                 if (s == "__")
 366                         return yylval.i = EXTENDER;
 367                 if (s == "--")
 368                         return yylval.i = HYPHEN;
 369                 s = lyric_fudge (s);
 370
 371                 char c = s[s.length () - 1];
 372                 if (c == '{' ||  c == '}') // brace open is for not confusing dumb tools.
 373                         here_input ().warning (
 374                                 _ ("Brace found at end of lyric.  Did you forget a space?"));
 375                 yylval.scm = scm_makfrom0str (s.to_str0 ());
 376
 377
 378                 return STRING;
 379         }
 380         . {
 381                 return YYText ()[0];
 382         }
 383 }
 384 <chords>{
 385         {ALPHAWORD}     {
 386                 return scan_bare_word (YYText ());
 387         }
 388         {NOTECOMMAND}   {
 389                 return scan_escaped_word (YYText () + 1);
 390         }
 391         {FRACTION}      {
 392                 yylval.scm =  scan_fraction (YYText ());
 393                 return FRACTION;
 394         }
 395         {UNSIGNED}              {
 396                 yylval.i = String_convert::dec2int (String (YYText ()));
 397                 return UNSIGNED;
 398         }
 399         \" {
 400                 start_quote ();
 401         }
 402         -  {
 403                 return CHORD_MINUS;
 404         }
 405         :  {
 406                 return CHORD_COLON;
 407         }
 408         \/\+ {
 409                 return CHORD_BASS;
 410         }
 411         \/  {
 412                 return CHORD_SLASH;
 413         }
 414         \^  {
 415                 return CHORD_CARET;
 416         }
 417         . {
 418                 return YYText ()[0];
 419         }
 420 }
 421
 422 <<EOF>> {
 423
 424
 425         if (! close_input ()) {
 426           yyterminate (); // can't move this, since it actually rets a YY_NULL
 427         }
 428 }
 429
 430
 431 {WORD}  {
 432         return scan_bare_word (YYText ());
 433 }
 434 {KEYWORD}       {
 435         return scan_escaped_word (YYText () + 1);
 436 }
 437 {REAL}          {
 438         Real r;
 439         int cnv=sscanf (YYText (), "%lf", &r);
 440         assert (cnv == 1);
 441
 442         yylval.scm = gh_double2scm (r);
 443         return REAL;
 444 }
 445
 446 {UNSIGNED}      {
 447         yylval.i = String_convert::dec2int (String (YYText ()));
 448         return UNSIGNED;
 449 }
 450
 451
 452 [{}]    {
 453
 454         return YYText ()[0];
 455 }
 456 [*:=]           {
 457         char c = YYText ()[0];
 458
 459         return c;
 460 }
 461
 462 <INITIAL,notes,figures>.        {
 463         return YYText ()[0];
 464 }
 465
 466 <INITIAL,lyrics,notes,figures>\\. {
 467     char c= YYText ()[1];
 468
 469     switch (c) {
 470     case '>':
 471         return E_BIGGER;
 472     case '<':
 473         return E_SMALLER;
 474     case '!':
 475         return E_EXCLAMATION;
 476     case '(':
 477         return E_OPEN;
 478     case ')':
 479         return E_CLOSE;
 480     case '[':
 481         return E_LEFTSQUARE;
 482     case ']':
 483         return E_RIGHTSQUARE;
 484     case '~':
 485         return E_TILDE;
 486     case '\\':
 487         return E_BACKSLASH;
 488
 489     default:
 490         return E_CHAR;
 491     }
 492 }
 493
 494 <*>.            {
 495         String msg = _f ("invalid character: `%c'", YYText ()[0]);
 496         LexerError (msg.to_str0 ());
 497         return YYText ()[0];
 498 }
 499
 500 %%
 501
 502 void
 503 My_lily_lexer::push_note_state ()
 504 {
 505         yy_push_state (notes);
 506 }
 507
 508 void
 509 My_lily_lexer::push_figuredbass_state()
 510 {
 511         yy_push_state (figures);
 512 }
 513 void
 514 My_lily_lexer::push_chord_state ()
 515 {
 516         yy_push_state (chords);
 517 }
 518
 519 void
 520 My_lily_lexer::push_lyric_state ()
 521 {
 522         yy_push_state (lyrics);
 523 }
 524
 525 void
 526 My_lily_lexer::pop_state ()
 527 {
 528         yy_pop_state ();
 529 }
 530
 531 int
 532 My_lily_lexer::identifier_type(SCM sid)
 533 {
 534         int k = try_special_identifiers(&yylval.scm , sid);
 535         return k >= 0  ? k : SCM_IDENTIFIER;
 536 }
 537
 538
 539 int
 540 My_lily_lexer::scan_escaped_word (String str)
 541 {
 542         // use more SCM for this.
 543
 544         SCM sym = ly_symbol2scm (str.to_str0 ());
 545
 546         int l = lookup_keyword (str);
 547         if (l != -1) {
 548                 return l;
 549         }
 550         SCM sid = lookup_identifier (str);
 551         if (sid != SCM_UNDEFINED)
 552         {
 553                 yylval.scm = sid;
 554                 return identifier_type (sid);
 555         }
 556
 557         if ((YYSTATE != notes) && (YYSTATE != chords)) {
 558                 SCM pitch = scm_hashq_get_handle (pitchname_tab_, sym);
 559
 560                 if (gh_pair_p (pitch))
 561                 {
 562                         yylval.scm = ly_cdr (pitch);
 563                         return NOTENAME_PITCH;
 564                 }
 565         }
 566         String msg (_f ("unknown escaped string: `\\%s'", str));
 567         LexerError (msg.to_str0 ());
 568
 569         yylval.scm = scm_makfrom0str (str.to_str0 ());
 570
 571         return STRING;
 572 }
 573
 574 int
 575 My_lily_lexer::scan_bare_word (String str)
 576 {
 577         SCM sym = ly_symbol2scm (str.to_str0 ());
 578         if ((YYSTATE == notes) || (YYSTATE == chords)) {
 579                 SCM pitch = scm_hashq_get_handle (pitchname_tab_, sym);
 580                 if (gh_pair_p (pitch)) {
 581                     yylval.scm = ly_cdr (pitch);
 582                     return (YYSTATE == notes) ? NOTENAME_PITCH : TONICNAME_PITCH;
 583                 } else if ((pitch = scm_hashq_get_handle (chordmodifier_tab_, sym))!= SCM_BOOL_F)
 584                 {
 585                     yylval.scm = ly_cdr (pitch);
 586                     return CHORDMODIFIER_PITCH;
 587                 }
 588         }
 589
 590         yylval.scm = scm_makfrom0str (str.to_str0 ());
 591         return STRING;
 592 }
 593
 594 bool
 595 My_lily_lexer::note_state_b () const
 596 {
 597         return YY_START == notes;
 598 }
 599
 600 bool
 601 My_lily_lexer::chord_state_b () const
 602 {
 603         return YY_START == chords;
 604 }
 605
 606 bool
 607 My_lily_lexer::lyric_state_b () const
 608 {
 609         return YY_START == lyrics;
 610 }
 611
 612 bool
 613 My_lily_lexer::figure_state_b () const
 614 {
 615         return YY_START == figures;
 616 }
 617
 618 /*
 619  urg, belong to String (_convert)
 620  and should be generalised
 621  */
 622 void
 623 strip_leading_white (String&s)
 624 {
 625         int i=0;
 626         for (;  i < s.length (); i++)
 627                 if (!isspace (s[i]))
 628                         break;
 629
 630         s = s.nomid_string (0, i);
 631 }
 632
 633 void
 634 strip_trailing_white (String&s)
 635 {
 636         int i=s.length ();
 637         while (i--)
 638                 if (!isspace (s[i]))
 639                         break;
 640
 641         s = s.left_string (i+1);
 642 }
 643
 644
 645
 646 /* 1.3.146 == removal of ; */
 647 Lilypond_version oldest_version ("1.3.146");
 648
 649
 650 bool
 651 valid_version_b (String s)
 652 {
 653   Lilypond_version current ( MAJOR_VERSION "." MINOR_VERSION "." PATCH_LEVEL );
 654   Lilypond_version ver (s);
 655   if (! ((ver >= oldest_version) && (ver <= current)))
 656         {
 657                 non_fatal_error (_f ("Incorrect lilypond version: %s (%s, %s)", ver.string (), oldest_version.string (), current.string ()));
 658                 non_fatal_error (_ ("Consider updating the input with the convert-ly script"));
 659                 return false;
 660     }
 661   return true;
 662 }
 663
 664
 665 String
 666 lyric_fudge (String s)
 667 {
 668   char  * chars  =s.get_copy_str0 ();
 669
 670   for (char * p = chars; *p ; p++)
 671     {
 672       if (*p == '_' && (p == chars || *(p-1) != '\\'))
 673         *p = ' ';
 674     }
 675
 676   s = String (chars);
 677   delete[] chars;
 678
 679   int i =0;
 680   if ((i=s.index ("\\,")) != -1)   // change "\," to TeX's "\c "
 681     {
 682       * (s.get_str0 () + i + 1) = 'c';
 683       s = s.left_string (i+2) + " " + s.right_string (s.length ()-i-2);
 684     }
 685
 686   return s;
 687 }
 688
 689 /*
 690 Convert "NUM/DEN" into a '(NUM . DEN) cons.
 691 */
 692 SCM
 693 scan_fraction (String frac)
 694 {
 695         int i = frac.index ('/');
 696         int l = frac.length ();
 697         String left = frac.left_string (i);
 698         String right = frac.right_string (l - i - 1);
 699
 700         int n = String_convert::dec2int (left);
 701         int d = String_convert::dec2int (right);
 702         return gh_cons (gh_int2scm (n), gh_int2scm (d));
 703 }
 704 #if 0
 705 /* avoid silly flex induced gcc warnings */
 706 static void yy_push_state (int) {;}
 707 static void yy_pop_state () {;}
 708 static int yy_top_state () { return 0; }
 709
 710 static void
 711 avoid_silly_flex_induced_gcc_warnings ()
 712 {
 713         (void)yy_start_stack_ptr;
 714         (void)yy_start_stack_depth;
 715         (void)yy_start_stack;
 716         yy_push_state (0);
 717         yy_pop_state ();
 718         yy_top_state ();
 719         avoid_silly_flex_induced_gcc_warnings ();
 720 }
 721 #endif