Replace WORD token in parser and lexer with SYMBOL

[lilypond.git] / lily / lexer.ll

diff --git a/lily/lexer.ll b/lily/lexer.ll
index ab6794a21ef138b8dce8488bb703a0fc375977bc..93184ebe085dc2d432274a06d4eeb887e565fe01 100644 (file)
--- a/lily/lexer.ll
+++ b/lily/lexer.ll
@@ -2,7 +2,7 @@
 /*
   This file is part of LilyPond, the GNU music typesetter.
 
 /*
   This file is part of LilyPond, the GNU music typesetter.
 

-  Copyright (C) 1996--2014 Han-Wen Nienhuys <hanwen@xs4all.nl>
+  Copyright (C) 1996--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>

                  Jan Nieuwenhuizen <janneke@gnu.org>
 
   LilyPond is free software: you can redistribute it and/or modify
                  Jan Nieuwenhuizen <janneke@gnu.org>
 
   LilyPond is free software: you can redistribute it and/or modify


@@ -30,9 +30,9 @@
 /*
   backup rules
 
 /*
   backup rules
 

-  after making a change to the lexer rules, run 
+  after making a change to the lexer rules, run

       flex -b <this lexer file>
       flex -b <this lexer file>

-  and make sure that 
+  and make sure that

       lex.backup
   contains no backup states, but only the reminder
       Compressed tables always back up.
       lex.backup
   contains no backup states, but only the reminder
       Compressed tables always back up.


@@ -69,9 +69,9 @@ using namespace std;
 #include "pitch.hh"
 #include "source-file.hh"
 #include "std-string.hh"
 #include "pitch.hh"
 #include "source-file.hh"
 #include "std-string.hh"

-#include "string-convert.hh"

 #include "version.hh"
 #include "warn.hh"
 #include "version.hh"
 #include "warn.hh"

+#include "lily-imports.hh"

 
 /*
 RH 7 fix (?)
 
 /*
 RH 7 fix (?)


@@ -120,7 +120,7 @@ SCM (* scm_parse_error_handler) (void *);
 %option debug
 %option yyclass="Lily_lexer"
 %option stack
 %option debug
 %option yyclass="Lily_lexer"
 %option stack

-%option never-interactive 
+%option never-interactive

 %option warn
 
 %x chords
 %option warn
 
 %x chords


@@ -157,8 +157,8 @@ A           [a-zA-Z\200-\377]
 AA             {A}|_
 N              [0-9]
 ANY_CHAR       (.|\n)
 AA             {A}|_
 N              [0-9]
 ANY_CHAR       (.|\n)

-WORD           {A}([-_]{A}|{A})*
-COMMAND                \\{WORD}
+SYMBOL         {A}([-_]{A}|{A})*
+COMMAND                \\{SYMBOL}

 /* SPECIAL category is for every letter that needs to get passed to
  * the parser rather than being redefinable by the user */
 SPECIAL                [-+*/=<>{}!?_^'',.:]
 /* SPECIAL category is for every letter that needs to get passed to
  * the parser rather than being redefinable by the user */
 SPECIAL                [-+*/=<>{}!?_^'',.:]


@@ -188,7 +188,7 @@ BOM_UTF8    \357\273\277
    /* Use the trailing context feature. Otherwise, the BOM will not be
       found if the file starts with an identifier definition. */
 <INITIAL,chords,lyrics,figures,notes>{BOM_UTF8}/.* {
    /* Use the trailing context feature. Otherwise, the BOM will not be
       found if the file starts with an identifier definition. */
 <INITIAL,chords,lyrics,figures,notes>{BOM_UTF8}/.* {

-  if (this->lexloc_->line_number () != 1 || this->lexloc_->column_number () != 0)
+  if (lexloc_->line_number () != 1 || lexloc_->column_number () != 0)

     {
       LexerWarning (_ ("stray UTF-8 BOM encountered").c_str ());
       // exit (1);
     {
       LexerWarning (_ ("stray UTF-8 BOM encountered").c_str ());
       // exit (1);


@@ -244,7 +244,7 @@ BOM_UTF8    \357\273\277
        s = s.substr (0, s.rfind ('\"'));
 
        yy_pop_state ();
        s = s.substr (0, s.rfind ('\"'));
 
        yy_pop_state ();

-       this->here_input().get_source_file ()->name_ = s;
+       here_input().get_source_file ()->name_ = s;

        message (_f ("Renaming input to: `%s'", s.c_str ()));
        progress_indication ("\n");
        scm_module_define (scm_car (scopes_),
        message (_f ("Renaming input to: `%s'", s.c_str ()));
        progress_indication ("\n");
        scm_module_define (scm_car (scopes_),


@@ -258,7 +258,7 @@ BOM_UTF8    \357\273\277
        sscanf (YYText (), "%d", &i);
 
        yy_pop_state ();
        sscanf (YYText (), "%d", &i);
 
        yy_pop_state ();

-       this->here_input ().get_source_file ()->set_line (here_input ().start (), i);
+       here_input ().get_source_file ()->set_line (here_input ().start (), i);

 }
 
 <version>{ANY_CHAR}    {
 }
 
 <version>{ANY_CHAR}    {


@@ -330,12 +330,11 @@ BOM_UTF8  \357\273\277
          }
 }
 <incl>(\$|#) { // scm for the filename
          }
 }
 <incl>(\$|#) { // scm for the filename

-       int n = 0;

        Input hi = here_input();
        hi.step_forward ();
        Input hi = here_input();
        hi.step_forward ();

-       SCM sval = ly_parse_scm (hi.start (), &n, hi,
-               be_safe_global && is_main_input_, parser_);
-       sval = eval_scm (sval);
+       SCM sval = ly_parse_scm (hi, be_safe_global && is_main_input_, parser_);
+       sval = eval_scm (sval, hi);
+       int n = hi.end () - hi.start ();

 
        for (int i = 0; i < n; i++)
        {
 
        for (int i = 0; i < n; i++)
        {


@@ -348,7 +347,7 @@ BOM_UTF8    \357\273\277
                yy_pop_state ();
        } else {
                LexerError (_ ("string expected after \\include").c_str ());
                yy_pop_state ();
        } else {
                LexerError (_ ("string expected after \\include").c_str ());

-               if (sval != SCM_UNDEFINED) {
+               if (!SCM_UNBNDP (sval)) {

                        SCM err = scm_current_error_port ();
                        scm_puts ("This value was found instead: ", err);
                        scm_display (sval, err);
                        SCM err = scm_current_error_port ();
                        scm_puts ("This value was found instead: ", err);
                        scm_display (sval, err);


@@ -363,14 +362,14 @@ BOM_UTF8  \357\273\277
 
     /* Flex picks the longest matching pattern including trailing
      * contexts.  Without the backup pattern, r-. does not trigger the
 
     /* Flex picks the longest matching pattern including trailing
      * contexts.  Without the backup pattern, r-. does not trigger the

-     * {RESTNAME} rule but rather the {WORD}/[-_] rule coming later,
+     * {RESTNAME} rule but rather the {SYMBOL}/[-_] rule coming later,

      * needed for avoiding backup states.
      */
 
 <chords,notes,figures>{RESTNAME}/[-_]  |  // pseudo backup rule
 <chords,notes,figures>{RESTNAME}       {
        char const *s = YYText ();
      * needed for avoiding backup states.
      */
 
 <chords,notes,figures>{RESTNAME}/[-_]  |  // pseudo backup rule
 <chords,notes,figures>{RESTNAME}       {
        char const *s = YYText ();

-       yylval = scm_from_locale_string (s);
+       yylval = scm_from_ascii_string (s);

        return RESTNAME;
 }
 <chords,notes,figures>q/[-_]   | // pseudo backup rule
        return RESTNAME;
 }
 <chords,notes,figures>q/[-_]   | // pseudo backup rule


@@ -385,15 +384,14 @@ BOM_UTF8  \357\273\277
        return MULTI_MEASURE_REST;
 }
 <INITIAL,chords,figures,lyrics,markup,notes>#  { //embedded scm
        return MULTI_MEASURE_REST;
 }
 <INITIAL,chords,figures,lyrics,markup,notes>#  { //embedded scm

-       int n = 0;

        Input hi = here_input();
        hi.step_forward ();
        Input hi = here_input();
        hi.step_forward ();

-       SCM sval = ly_parse_scm (hi.start (), &n, hi,
-               be_safe_global && is_main_input_, parser_);
+       SCM sval = ly_parse_scm (hi, be_safe_global && is_main_input_, parser_);

 
 

-       if (sval == SCM_UNDEFINED)
+       if (SCM_UNBNDP (sval))

                error_level_ = 1;
 
                error_level_ = 1;
 

+       int n = hi.end () - hi.start ();

        for (int i = 0; i < n; i++)
        {
                yyinput ();
        for (int i = 0; i < n; i++)
        {
                yyinput ();


@@ -405,11 +403,11 @@ BOM_UTF8  \357\273\277
 }
 
 <INITIAL,chords,figures,lyrics,markup,notes>\$ { //immediate scm
 }
 
 <INITIAL,chords,figures,lyrics,markup,notes>\$ { //immediate scm

-       int n = 0;

        Input hi = here_input();
        hi.step_forward ();
        Input hi = here_input();
        hi.step_forward ();

-       SCM sval = ly_parse_scm (hi.start (), &n, hi,
-               be_safe_global && is_main_input_, parser_);
+       SCM sval = ly_parse_scm (hi, be_safe_global && is_main_input_, parser_);
+
+       int n = hi.end () - hi.start ();

 
        for (int i = 0; i < n; i++)
        {
 
        for (int i = 0; i < n; i++)
        {


@@ -417,14 +415,14 @@ BOM_UTF8  \357\273\277
        }
        char_count_stack_.back () += n;
 
        }
        char_count_stack_.back () += n;
 

-       sval = eval_scm (sval, '$');
+       sval = eval_scm (sval, hi, '$');

 
        int token = scan_scm_id (sval);
        if (!scm_is_eq (yylval, SCM_UNSPECIFIED))
                return token;
 }
 
 
        int token = scan_scm_id (sval);
        if (!scm_is_eq (yylval, SCM_UNSPECIFIED))
                return token;
 }
 

-<INITIAL,notes,lyrics>{ 
+<INITIAL,notes,lyrics,chords>{

        \<\<    {
                 yylval = SCM_UNSPECIFIED;
                return DOUBLE_ANGLE_OPEN;
        \<\<    {
                 yylval = SCM_UNSPECIFIED;
                return DOUBLE_ANGLE_OPEN;


@@ -435,7 +433,7 @@ BOM_UTF8    \357\273\277
        }
 }
 
        }
 }
 

-<INITIAL,notes>{
+<INITIAL,notes,chords>{

        \<      {
                 yylval = SCM_UNSPECIFIED;
                return ANGLE_OPEN;
        \<      {
                 yylval = SCM_UNSPECIFIED;
                return ANGLE_OPEN;


@@ -478,8 +476,8 @@ BOM_UTF8    \357\273\277
 }
 
 <notes,figures>{
 }
 
 <notes,figures>{

-       {WORD}/[-_]     | // backup rule
-       {WORD}  {
+       {SYMBOL}/[-_]   | // backup rule
+       {SYMBOL}        {

                return scan_bare_word (YYText_utf8 ());
        }
        \\\"    {
                return scan_bare_word (YYText_utf8 ());
        }
        \\\"    {


@@ -511,11 +509,11 @@ BOM_UTF8  \357\273\277
 <quote,commandquote>{
        \\{ESCAPED}     {
                 char c = escaped_char (YYText ()[1]);
 <quote,commandquote>{
        \\{ESCAPED}     {
                 char c = escaped_char (YYText ()[1]);

-               yylval = scm_cons (scm_from_locale_stringn (&c, 1),
+               yylval = scm_cons (scm_from_ascii_stringn (&c, 1),

                                    yylval);
        }
        [^\\""]+        {
                                    yylval);
        }
        [^\\""]+        {

-                yylval = scm_cons (scm_from_locale_string (YYText_utf8 ()),
+                yylval = scm_cons (scm_from_utf8_string (YYText_utf8 ()),

                                    yylval);
        }
        \"      {
                                    yylval);
        }
        \"      {


@@ -536,7 +534,7 @@ BOM_UTF8    \357\273\277
                return STRING;
        }
        \\      {
                return STRING;
        }
        \\      {

-                yylval = scm_cons (scm_from_locale_string (YYText ()),
+                yylval = scm_cons (scm_from_ascii_string (YYText ()),

                                    yylval);
        }
 }
                                    yylval);
        }
 }


@@ -585,7 +583,7 @@ BOM_UTF8    \357\273\277
                s = lyric_fudge (s);
                yylval = ly_string2scm (s);
 
                s = lyric_fudge (s);
                yylval = ly_string2scm (s);
 

-               return STRING;
+               return SYMBOL;

        }
        /* This should really just cover {} */
        [{}] {
        }
        /* This should really just cover {} */
        [{}] {


@@ -594,8 +592,8 @@ BOM_UTF8    \357\273\277
        }
 }
 <chords>{
        }
 }
 <chords>{

-       {WORD}/[-_]     | // backup rule
-       {WORD}  {
+       {SYMBOL}/[-_]   | // backup rule
+       {SYMBOL}        {

                return scan_bare_word (YYText_utf8 ());
        }
        \\\"    {
                return scan_bare_word (YYText_utf8 ());
        }
        \\\"    {


@@ -691,9 +689,9 @@ BOM_UTF8    \357\273\277
                for (; scm_is_pair(s); s = scm_cdr(s)) {
                  SCM predicate = scm_car(s);
 
                for (; scm_is_pair(s); s = scm_cdr(s)) {
                  SCM predicate = scm_car(s);
 

-                 if (predicate == ly_lily_module_constant ("markup-list?"))
+                 if (scm_is_eq (predicate, SCM (Lily::markup_list_p)))

                    push_extra_token (here_input (), EXPECT_MARKUP_LIST);
                    push_extra_token (here_input (), EXPECT_MARKUP_LIST);

-                 else if (predicate == ly_lily_module_constant ("markup?"))
+                 else if (scm_is_eq (predicate, SCM (Lily::markup_p)))

                    push_extra_token (here_input (), EXPECT_MARKUP);
                  else
                    push_extra_token (here_input (), EXPECT_SCM, predicate);
                    push_extra_token (here_input (), EXPECT_MARKUP);
                  else
                    push_extra_token (here_input (), EXPECT_SCM, predicate);


@@ -704,7 +702,7 @@ BOM_UTF8    \357\273\277
                string s (YYText_utf8 ()); 
 
                yylval = ly_string2scm (s);
                string s (YYText_utf8 ()); 
 
                yylval = ly_string2scm (s);

-               return STRING;
+               return SYMBOL;

        }
        [{}]  {
                 yylval = SCM_UNSPECIFIED;
        }
        [{}]  {
                 yylval = SCM_UNSPECIFIED;


@@ -758,8 +756,8 @@ BOM_UTF8    \357\273\277
 }
 
 <INITIAL>{
 }
 
 <INITIAL>{

-       {WORD}/[-_]     | // backup rule
-       {WORD}  {
+       {SYMBOL}/[-_]   | // backup rule
+       {SYMBOL}        {

                return scan_bare_word (YYText_utf8 ());
        }
        \\\"    {
                return scan_bare_word (YYText_utf8 ());
        }
        \\\"    {


@@ -812,12 +810,12 @@ BOM_UTF8  \357\273\277
 
 %%
 
 
 %%
 

-/* Make the lexer generate a token of the given type as the next token. 
+/* Make the lexer generate a token of the given type as the next token.

  TODO: make it possible to define a value for the token as well */
 void
 Lily_lexer::push_extra_token (Input const &where, int token_type, SCM scm)
 {
  TODO: make it possible to define a value for the token as well */
 void
 Lily_lexer::push_extra_token (Input const &where, int token_type, SCM scm)
 {

-       extra_tokens_ = scm_cons (scm_cons2 (make_input (where),
+       extra_tokens_ = scm_cons (scm_cons2 (where.smobbed_copy (),

                                             scm_from_int (token_type),
                                             scm), extra_tokens_);
 }
                                             scm_from_int (token_type),
                                             scm), extra_tokens_);
 }


@@ -829,7 +827,7 @@ Lily_lexer::pop_extra_token ()
                return -1;
 
   /* produce requested token */
                return -1;
 
   /* produce requested token */

-       yylloc = *unsmob_input (scm_caar (extra_tokens_));
+       yylloc = *unsmob<Input> (scm_caar (extra_tokens_));

        int type = scm_to_int (scm_cadar (extra_tokens_));
        yylval = scm_cddar (extra_tokens_);
        extra_tokens_ = scm_cdr (extra_tokens_);
        int type = scm_to_int (scm_cadar (extra_tokens_));
        yylval = scm_cddar (extra_tokens_);
        extra_tokens_ = scm_cdr (extra_tokens_);


@@ -916,35 +914,35 @@ Lily_lexer::scan_escaped_word (const string &str)
                return i;
 
        SCM sid = lookup_identifier (str);
                return i;
 
        SCM sid = lookup_identifier (str);

-       if (Music *m = unsmob_music (sid))
+       if (Music *m = unsmob<Music> (sid))

        {
                m->set_spot (override_input (here_input ()));
        }
 
        {
                m->set_spot (override_input (here_input ()));
        }
 

-       if (sid != SCM_UNDEFINED)
+       if (!SCM_UNBNDP (sid))

                return scan_scm_id (sid);
 
                return scan_scm_id (sid);
 

-       string msg (_f ("unknown escaped string: `\\%s'", str));        
+       string msg (_f ("unknown escaped string: `\\%s'", str));

        LexerError (msg.c_str ());
 
        yylval = ly_string2scm (str);
 
        LexerError (msg.c_str ());
 
        yylval = ly_string2scm (str);
 

-       return STRING;
+       return STRING; // SYMBOL would cause additional processing

 }
 
 int
 Lily_lexer::scan_shorthand (const string &str)
 {
        SCM sid = lookup_identifier (str);
 }
 
 int
 Lily_lexer::scan_shorthand (const string &str)
 {
        SCM sid = lookup_identifier (str);

-       if (Music *m = unsmob_music (sid))
+       if (Music *m = unsmob<Music> (sid))

        {
                m->set_spot (override_input (here_input ()));
        }
 
        {
                m->set_spot (override_input (here_input ()));
        }
 

-       if (sid != SCM_UNDEFINED)
+       if (!SCM_UNBNDP (sid))

                return scan_scm_id (sid);
 
                return scan_scm_id (sid);
 

-       string msg (_f ("undefined character or shorthand: %s", str));  
+       string msg (_f ("undefined character or shorthand: %s", str));

        LexerError (msg.c_str ());
 
        yylval = ly_string2scm (str);
        LexerError (msg.c_str ());
 
        yylval = ly_string2scm (str);


@@ -955,13 +953,13 @@ Lily_lexer::scan_shorthand (const string &str)
 int
 Lily_lexer::scan_scm_id (SCM sid)
 {
 int
 Lily_lexer::scan_scm_id (SCM sid)
 {

-       if (is_music_function (sid))
+       if (Music_function *fun = unsmob<Music_function> (sid))

        {
                int funtype = SCM_FUNCTION;
 
                yylval = sid;
 
        {
                int funtype = SCM_FUNCTION;
 
                yylval = sid;
 

-               SCM s = get_music_function_signature (sid);
+               SCM s = fun->get_signature ();

                SCM cs = scm_car (s);
 
                if (scm_is_pair (cs))
                SCM cs = scm_car (s);
 
                if (scm_is_pair (cs))


@@ -969,9 +967,9 @@ Lily_lexer::scan_scm_id (SCM sid)
                        cs = SCM_CAR (cs);
                }
 
                        cs = SCM_CAR (cs);
                }
 

-               if (scm_is_eq (cs, ly_lily_module_constant ("ly:music?")))
+               if (scm_is_eq (cs, SCM (Lily::ly_music_p)))

                        funtype = MUSIC_FUNCTION;
                        funtype = MUSIC_FUNCTION;

-               else if (scm_is_eq (cs, ly_lily_module_constant ("ly:event?")))
+               else if (scm_is_eq (cs, SCM (Lily::ly_event_p)))

                        funtype = EVENT_FUNCTION;
                else if (ly_is_procedure (cs))
                        funtype = SCM_FUNCTION;
                        funtype = EVENT_FUNCTION;
                else if (ly_is_procedure (cs))
                        funtype = SCM_FUNCTION;


@@ -988,7 +986,7 @@ Lily_lexer::scan_scm_id (SCM sid)
                                optional = SCM_CDR (cs);
                                cs = SCM_CAR (cs);
                        }
                                optional = SCM_CDR (cs);
                                cs = SCM_CAR (cs);
                        }

-                       
+

                        if (ly_is_procedure (cs))
                                push_extra_token (here_input (), EXPECT_SCM, cs);
                        else
                        if (ly_is_procedure (cs))
                                push_extra_token (here_input (), EXPECT_SCM, cs);
                        else


@@ -1006,30 +1004,41 @@ Lily_lexer::scan_scm_id (SCM sid)
 }
 
 int
 }
 
 int

-Lily_lexer::scan_bare_word (const string &str)
+Lily_lexer::scan_word (SCM & output, SCM sym)

 {
 {

-       SCM sym = ly_symbol2scm (str.c_str ());

        if ((YYSTATE == notes) || (YYSTATE == chords)) {
                SCM handle = SCM_BOOL_F;
                if (scm_is_pair (pitchname_tab_stack_))
                        handle = scm_hashq_get_handle (scm_cdar (pitchname_tab_stack_), sym);
        if ((YYSTATE == notes) || (YYSTATE == chords)) {
                SCM handle = SCM_BOOL_F;
                if (scm_is_pair (pitchname_tab_stack_))
                        handle = scm_hashq_get_handle (scm_cdar (pitchname_tab_stack_), sym);

-               
+

                if (scm_is_pair (handle)) {
                if (scm_is_pair (handle)) {

-                       yylval = scm_cdr (handle);
-                       if (unsmob_pitch (yylval))
+                       output = scm_cdr (handle);
+                       if (unsmob<Pitch> (yylval))

                            return (YYSTATE == notes) ? NOTENAME_PITCH : TONICNAME_PITCH;
                        else if (scm_is_symbol (yylval))
                            return DRUM_PITCH;
                }
                else if ((YYSTATE == chords)
                            return (YYSTATE == notes) ? NOTENAME_PITCH : TONICNAME_PITCH;
                        else if (scm_is_symbol (yylval))
                            return DRUM_PITCH;
                }
                else if ((YYSTATE == chords)

-                       && (handle = scm_hashq_get_handle (chordmodifier_tab_, sym))!= SCM_BOOL_F)
+                       && scm_is_true (handle = scm_hashq_get_handle (chordmodifier_tab_, sym)))

                {
                {

-                   yylval = scm_cdr (handle);
+                   output = scm_cdr (handle);

                    return CHORD_MODIFIER;
                }
        }
                    return CHORD_MODIFIER;
                }
        }

+       output = SCM_UNDEFINED;
+       return -1;
+}
+
+int
+Lily_lexer::scan_bare_word (const string &str)
+{
+       int state = scan_word (yylval, ly_symbol2scm (str.c_str ()));
+       if (state >= 0)
+       {
+               return state;
+       }

        yylval = ly_string2scm (str);
        yylval = ly_string2scm (str);

-       return STRING;
+       return SYMBOL;

 }
 
 int
 }
 
 int


@@ -1070,14 +1079,14 @@ Lily_lexer::is_figure_state () const
 // this function is private.
 
 SCM
 // this function is private.
 
 SCM

-Lily_lexer::eval_scm (SCM readerdata, char extra_token)
+Lily_lexer::eval_scm (SCM readerdata, Input hi, char extra_token)

 {
        SCM sval = SCM_UNDEFINED;
 
        if (!SCM_UNBNDP (readerdata))
        {
 {
        SCM sval = SCM_UNDEFINED;
 
        if (!SCM_UNBNDP (readerdata))
        {

-               sval = ly_eval_scm (scm_car (readerdata),
-                                   *unsmob_input (scm_cdr (readerdata)),
+               sval = ly_eval_scm (readerdata,
+                                   hi,

                                    be_safe_global && is_main_input_,
                                    parser_);
        }
                                    be_safe_global && is_main_input_,
                                    parser_);
        }


@@ -1098,12 +1107,12 @@ Lily_lexer::eval_scm (SCM readerdata, char extra_token)
                             p = scm_cdr (p))
                        {
                                SCM v = scm_car (p);
                             p = scm_cdr (p))
                        {
                                SCM v = scm_car (p);

-                               if (Music *m = unsmob_music (v))
+                               if (Music *m = unsmob<Music> (v))

                                {
                                {

-                                       if (!unsmob_input (m->get_property ("origin")))
+                                       if (!unsmob<Input> (m->get_property ("origin")))

                                                m->set_spot (override_input (here_input ()));
                                }
                                                m->set_spot (override_input (here_input ()));
                                }

-                                       
+

                                int token;
                                switch (extra_token) {
                                case '$':
                                int token;
                                switch (extra_token) {
                                case '$':


@@ -1123,9 +1132,9 @@ Lily_lexer::eval_scm (SCM readerdata, char extra_token)
                        sval = SCM_UNSPECIFIED;
        }
 
                        sval = SCM_UNSPECIFIED;
        }
 

-       if (Music *m = unsmob_music (sval))
+       if (Music *m = unsmob<Music> (sval))

        {
        {

-               if (!unsmob_input (m->get_property ("origin")))
+               if (!unsmob<Input> (m->get_property ("origin")))

                        m->set_spot (override_input (here_input ()));
        }
 
                        m->set_spot (override_input (here_input ()));
        }
 


@@ -1243,7 +1252,7 @@ Lily_lexer::YYText_utf8 ()
 
 /*
  urg, belong to string (_convert)
 
 /*
  urg, belong to string (_convert)

- and should be generalised 
+ and should be generalised

  */
 void
 strip_leading_white (string&s)
  */
 void
 strip_leading_white (string&s)


@@ -1259,8 +1268,8 @@ strip_leading_white (string&s)
 void
 strip_trailing_white (string&s)
 {
 void
 strip_trailing_white (string&s)
 {

-       ssize i = s.length ();  
-       while (i--) 
+       ssize i = s.length ();
+       while (i--)

                if (!isspace (s[i]))
                        break;
 
                if (!isspace (s[i]))
                        break;
 


@@ -1277,8 +1286,13 @@ is_valid_version (string s)
 {
   Lilypond_version current ( MAJOR_VERSION "." MINOR_VERSION "." PATCH_LEVEL );
   Lilypond_version ver (s);
 {
   Lilypond_version current ( MAJOR_VERSION "." MINOR_VERSION "." PATCH_LEVEL );
   Lilypond_version ver (s);

-  if (int (ver) < oldest_version)
-       {       
+  if (!ver)
+  {
+         non_fatal_error (_f ("Invalid version string \"%s\"", s));
+         return false;
+  }
+  if (ver < oldest_version)
+       {

                non_fatal_error (_f ("file too old: %s (oldest supported: %s)", ver.to_string (), oldest_version.to_string ()));
                non_fatal_error (_ ("consider updating the input with the convert-ly script"));
                return false;
                non_fatal_error (_f ("file too old: %s (oldest supported: %s)", ver.to_string (), oldest_version.to_string ()));
                non_fatal_error (_ ("consider updating the input with the convert-ly script"));
                return false;


@@ -1291,7 +1305,7 @@ is_valid_version (string s)
        }
   return true;
 }
        }
   return true;
 }

-       
+

 
 /*
   substitute _
 
 /*
   substitute _


@@ -1318,23 +1332,20 @@ scan_fraction (string frac)
        string left = frac.substr (0, i);
        string right = frac.substr (i + 1, (frac.length () - i + 1));
 
        string left = frac.substr (0, i);
        string right = frac.substr (i + 1, (frac.length () - i + 1));
 

-       int n = String_convert::dec2int (left);
-       int d = String_convert::dec2int (right);
-       return scm_cons (scm_from_int (n), scm_from_int (d));
+       return scm_cons (scm_c_read_string (left.c_str ()),
+                        scm_c_read_string (right.c_str ()));

 }
 
 SCM
 lookup_markup_command (string s)
 {
 }
 
 SCM
 lookup_markup_command (string s)
 {

-       SCM proc = ly_lily_module_constant ("lookup-markup-command");
-       return scm_call_1 (proc, ly_string2scm (s));
+       return Lily::lookup_markup_command (ly_string2scm (s));

 }
 
 SCM
 lookup_markup_list_command (string s)
 {
 }
 
 SCM
 lookup_markup_list_command (string s)
 {

-       SCM proc = ly_lily_module_constant ("lookup-markup-list-command");
-       return scm_call_1 (proc, ly_string2scm (s));
+       return Lily::lookup_markup_list_command (ly_string2scm (s));

 }
 
 /* Shut up lexer warnings.  */
 }
 
 /* Shut up lexer warnings.  */