X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fmy-lily-lexer.cc;h=2a8d3e8cb567aadc936a2f4c7e2090c6a0e2e05e;hb=ed463da03e0dd394c86ccd89fdea435b53b622b7;hp=deb6ff27891c50d2a015595ca806a1f2dbae0983;hpb=0f7b7e90fb80f52206e3bca71357eb2a4d481235;p=lilypond.git diff --git a/lily/my-lily-lexer.cc b/lily/my-lily-lexer.cc index deb6ff2789..2a8d3e8cb5 100644 --- a/lily/my-lily-lexer.cc +++ b/lily/my-lily-lexer.cc @@ -3,225 +3,221 @@ source file of the GNU LilyPond music typesetter - (c) 1997--1999 Han-Wen Nienhuys + (c) 1997--2003 Han-Wen Nienhuys */ -#include #include -#include "notename-table.hh" +#include + +#include "lily-proto.hh" +#include "scm-hash.hh" #include "interval.hh" -#include "identifier.hh" +#include "input-file-results.hh" +#include "lily-guile.hh" #include "parser.hh" #include "keyword.hh" #include "my-lily-lexer.hh" -#include "debug.hh" +#include "warn.hh" #include "source-file.hh" #include "main.hh" -#include "scope.hh" #include "input.hh" +#include "moment.hh" +#include "ly-modules.hh" + static Keyword_ent the_key_tab[]={ - {"autochange", AUTOCHANGE}, - {"spanrequest", SPANREQUEST}, - {"simultaneous", SIMULTANEOUS}, - {"sequential", SEQUENTIAL}, + {"acciaccatura", ACCIACCATURA}, {"accepts", ACCEPTS}, + {"addlyrics", ADDLYRICS}, + {"alias", ALIAS}, {"alternative", ALTERNATIVE}, + {"apply", APPLY}, + {"applycontext", APPLYCONTEXT}, + {"applyoutput", APPLYOUTPUT}, + {"appoggiatura", APPOGGIATURA}, + {"autochange", AUTOCHANGE}, {"bar", BAR}, {"breathe", BREATHE}, - {"cadenza", CADENZA}, + {"change", CHANGE}, {"chordmodifiers", CHORDMODIFIERS}, {"chords", CHORDS}, {"clef", CLEF}, - {"cm", CM_T}, {"consists", CONSISTS}, {"consistsend", CONSISTSEND}, {"context", CONTEXT}, - {"duration", DURATION}, - {"font", FONT}, + {"default", DEFAULT}, + {"denies", DENIES}, + {"description", DESCRIPTION}, + {"figures",FIGURES}, {"grace", GRACE}, + {"grobdescriptions", GROBDESCRIPTIONS}, {"header", HEADER}, - {"in", IN_T}, - {"lyrics", LYRICS}, {"key", KEY}, - {"keysignature", KEYSIGNATURE}, + {"lyrics", LYRICS}, + {"lyricsto", NEWADDLYRICS}, {"mark", MARK}, - {"musicalpitch", MUSICAL_PITCH}, - {"time", TIME_T}, - {"times", TIMES}, + {"markup", MARKUP}, {"midi", MIDI}, - {"mm", MM_T}, {"name", NAME}, - {"notenames", NOTENAMES}, + {"new", NEWCONTEXT}, + {"newpartcombine", NEWPARTCOMBINE}, {"notes", NOTES}, - {"partial", PARTIAL}, + {"octave", OCTAVE}, + {"once", ONCE}, + {"override", OVERRIDE}, {"paper", PAPER}, - {"penalty", PENALTY}, + {"partcombine", PARTCOMBINE}, + {"partial", PARTIAL}, + {"pitchnames", PITCHNAMES}, {"property", PROPERTY}, - {"pt", PT_T}, {"relative", RELATIVE}, {"remove", REMOVE}, {"repeat", REPEAT}, - {"repetitions", REPETITIONS}, - {"addlyrics", ADDLYRICS}, - {"scm", SCM_T}, - {"scmfile", SCMFILE}, + {"rest", REST}, + {"revert", REVERT}, {"score", SCORE}, - {"script", SCRIPT}, - {"shape", SHAPE}, + {"sequential", SEQUENTIAL}, + {"set", SET}, + {"simultaneous", SIMULTANEOUS}, {"skip", SKIP}, - {"textscript", TEXTSCRIPT}, + {"tag", TAG}, {"tempo", TEMPO}, + {"time", TIME_T}, + {"times", TIMES}, {"translator", TRANSLATOR}, {"transpose", TRANSPOSE}, {"type", TYPE}, - {"version", VERSION}, + {"unset", UNSET}, + {"with", WITH}, {0,0} }; -My_lily_lexer::My_lily_lexer() -{ - keytable_p_ = new Keyword_table (the_key_tab); - toplevel_scope_p_ = new Scope; - scope_l_arr_.push (toplevel_scope_p_); - errorlevel_i_ = 0; - note_tab_p_ = new Notename_table; - chordmodifier_tab_p_ = new Notename_table; - main_input_b_ = false; -} - -int -My_lily_lexer::lookup_keyword (String s) -{ - return keytable_p_->lookup (s.ch_C ()); -} -Identifier* -My_lily_lexer::lookup_identifier (String s) +My_lily_lexer::My_lily_lexer () { - SCM sym = ly_symbol (s.ch_C()); + // yy_flex_debug = 1; - for (int i = scope_l_arr_.size (); i--; ) - if (scope_l_arr_[i]->elem_b (sym)) - return scope_l_arr_[i]->elem(sym); - return 0; -} - -void -My_lily_lexer::start_main_input () -{ - if (!lily_monitor->silent_b ("InitDeclarations") && check_debug) - print_declarations (true); - if (!lily_monitor->silent_b ("InitLexer") && check_debug) - set_debug (1); + keytable_ = new Keyword_table (the_key_tab); - - new_input (main_input_str_, source_global_l); - if (safe_global_b) - allow_includes_b_ = false; + chordmodifier_tab_ = scm_make_vector (gh_int2scm (1), SCM_EOL); + pitchname_tab_ = scm_make_vector (gh_int2scm (1), SCM_EOL); + + scopes_ = SCM_EOL; - print_declarations(true); + add_scope(ly_make_anonymous_module()); + errorlevel_ =0; + + main_input_b_ = false; } void -My_lily_lexer::set_identifier (String name_str, Identifier* i, bool ) +My_lily_lexer::add_scope (SCM module) { - Identifier *old =0; - if (scope_l_arr_.top ()->elem_b (name_str)) - old = scope_l_arr_.top ()->elem(name_str); - - - if (old) + ly_reexport_module (scm_current_module()); + scm_set_current_module (module); + for (SCM s = scopes_; gh_pair_p (s); s = gh_cdr (s)) { -#if 0 - if (unique_b) - old->warning(_f ("redeclaration of `\\%s'", name_str)); -#endif - delete old; - } - if (lookup_keyword (name_str) >= 0) - { - warning ( _f ("Identifier name is a keyword: `%s'", name_str)); + /* + UGH. how to do this more neatly? + */ + SCM expr = scm_list_n (ly_symbol2scm ("module-use!"), + module, scm_list_n (ly_symbol2scm ("module-public-interface"), + gh_car (s), SCM_UNDEFINED), + SCM_UNDEFINED); + + scm_primitive_eval(expr); } - scope_l_arr_.top ()->elem (name_str) = i; + scopes_ = scm_cons (module, scopes_); } -My_lily_lexer::~My_lily_lexer() +SCM +My_lily_lexer::remove_scope () { - delete chordmodifier_tab_p_; - delete keytable_p_; - delete toplevel_scope_p_ ; - delete note_tab_p_; + SCM sc = gh_car (scopes_); + scopes_ = gh_cdr (scopes_); + scm_set_current_module (gh_car (scopes_)); + + return sc; } -void -My_lily_lexer::print_declarations (bool ) const + +int +My_lily_lexer::lookup_keyword (String s) { - for (int i=scope_l_arr_.size (); i--; ) - { - DOUT << "Scope no. " << i << '\n'; - scope_l_arr_[i]->print (); - } + return keytable_->lookup (s.to_str0 ()); } -void -My_lily_lexer::LexerError (char const *s) +SCM +My_lily_lexer::lookup_identifier (String s) { - if (include_stack_.empty()) - { - *mlog << _f ("error at EOF: %s", s) << endl; - } - else + SCM sym = ly_symbol2scm (s.to_str0()); + for (SCM s = scopes_; gh_pair_p (s); s = gh_cdr (s)) { - errorlevel_i_ |= 1; - Input spot (source_file_l(),here_ch_C()); - spot.error (s); + SCM var = ly_module_lookup (gh_car (s), sym); + if (var != SCM_BOOL_F) + return scm_variable_ref(var); } -} -Musical_pitch -My_lily_lexer::lookup_notename (String s) -{ - return (*note_tab_p_)[s]; + return SCM_UNDEFINED; } -Musical_pitch -My_lily_lexer::lookup_chordmodifier (String s) -{ - return (*chordmodifier_tab_p_)[s]; -} +void +My_lily_lexer::start_main_input () +{ + new_input (main_input_name_, &global_input_file->sources_); + allow_includes_b_ = allow_includes_b_ && ! (safe_global_b); -bool -My_lily_lexer::notename_b (String s) const -{ - return note_tab_p_->elem_b (s); + scm_module_define (gh_car (scopes_), + ly_symbol2scm ("input-file-name"), + scm_makfrom0str (main_input_name_.to_str0())); } void -My_lily_lexer::set_notename_table (Notename_table *p) +My_lily_lexer::set_identifier (SCM name, SCM s) { - delete note_tab_p_; - note_tab_p_ = p; + assert (gh_string_p (name)); + + if (lookup_keyword (ly_scm2string (name)) >= 0) + { + size_t sz; + char * str = gh_scm2newstr (name, &sz) ; + warning (_f ("Identifier name is a keyword: `%s'", str)); + free (str); + } + + SCM sym = scm_string_to_symbol (name); + SCM mod = gh_car (scopes_); + + scm_module_define (mod, sym, s); } -bool -My_lily_lexer::chordmodifier_b (String s) const +My_lily_lexer::~My_lily_lexer () { - return chordmodifier_tab_p_->elem_b (s); + delete keytable_; } + + void -My_lily_lexer::set_chordmodifier_table (Notename_table *p) +My_lily_lexer::LexerError (char const *s) { - delete chordmodifier_tab_p_; - chordmodifier_tab_p_ = p; + if (include_stack_.empty ()) + { + progress_indication (_f ("error at EOF: %s", s)+ String ("\n")); + } + else + { + errorlevel_ |= 1; + Input spot (get_source_file (), here_str0 ()); + spot.error (s); + } } char -My_lily_lexer::escaped_char(char c) const +My_lily_lexer::escaped_char (char c) const { - switch(c) + switch (c) { case 'n': return '\n'; @@ -239,6 +235,12 @@ My_lily_lexer::escaped_char(char c) const Input My_lily_lexer::here_input () const { - Source_file * f_l= source_file_l (); - return Input (f_l, (char*)here_ch_C ()); + Source_file * f= get_source_file (); + return Input (f, (char*)here_str0 ()); +} + +void +My_lily_lexer::prepare_for_next_token () +{ + last_input_ = here_input(); }