2 This file is part of LilyPond, the GNU music typesetter.
4 Copyright (C) 1997--2010 Han-Wen Nienhuys <hanwen@xs4all.nl>
6 LilyPond is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 LilyPond is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
20 #include "lily-lexer.hh"
26 #include "context.hh" // for nested_property_alist
27 #include "international.hh"
28 #include "interval.hh"
33 #include "scm-hash.hh"
34 #include "source-file.hh"
36 #include "program-option.hh"
37 #include "lily-parser.hh"
39 static Keyword_ent the_key_tab
[]
42 {"addlyrics", ADDLYRICS
},
44 {"alternative", ALTERNATIVE
},
46 {"bookpart", BOOKPART
},
48 {"chordmode", CHORDMODE
},
50 {"consists", CONSISTS
},
53 {"defaultchild", DEFAULTCHILD
},
55 {"description", DESCRIPTION
},
56 {"drummode", DRUMMODE
},
58 {"figuremode", FIGUREMODE
},
60 {"grobdescriptions", GROBDESCRIPTIONS
},
64 {"lyricmode", LYRICMODE
},
66 {"lyricsto", LYRICSTO
},
69 {"markuplines", MARKUPLINES
},
73 {"notemode", NOTEMODE
},
75 {"override", OVERRIDE
},
78 {"relative", RELATIVE
},
84 {"sequential", SEQUENTIAL
},
86 {"simultaneous", SIMULTANEOUS
},
91 {"transpose", TRANSPOSE
},
98 Lily_lexer::Lily_lexer (Sources
*sources
, Lily_parser
*parser
)
101 keytable_
= new Keyword_table (the_key_tab
);
102 chordmodifier_tab_
= SCM_EOL
;
103 pitchname_tab_stack_
= SCM_EOL
;
107 is_main_input_
= false;
108 start_module_
= SCM_EOL
;
109 chord_repetition_
= Chord_repetition ();
112 add_scope (ly_make_anonymous_module (false));
113 push_note_state (scm_c_make_hash_table (0));
114 chordmodifier_tab_
= scm_make_vector (scm_from_int (1), SCM_EOL
);
117 Lily_lexer::Lily_lexer (Lily_lexer
const &src
, Lily_parser
*parser
)
118 : Includable_lexer ()
121 keytable_
= (src
.keytable_
) ? new Keyword_table (*src
.keytable_
) : 0;
122 chordmodifier_tab_
= src
.chordmodifier_tab_
;
123 pitchname_tab_stack_
= src
.pitchname_tab_stack_
;
124 sources_
= src
.sources_
;
125 start_module_
= SCM_EOL
;
126 chord_repetition_
= src
.chord_repetition_
;
128 error_level_
= src
.error_level_
;
129 is_main_input_
= src
.is_main_input_
;
135 SCM scopes
= SCM_EOL
;
137 for (SCM s
= src
.scopes_
; scm_is_pair (s
); s
= scm_cdr (s
))
139 SCM newmod
= ly_make_anonymous_module (false);
140 ly_module_copy (newmod
, scm_car (s
));
141 *tail
= scm_cons (newmod
, SCM_EOL
);
142 tail
= SCM_CDRLOC (*tail
);
146 push_note_state (scm_c_make_hash_table (0));
149 Lily_lexer::~Lily_lexer ()
155 Lily_lexer::add_scope (SCM module
)
157 ly_reexport_module (scm_current_module ());
158 if (!scm_is_pair (scopes_
))
159 start_module_
= scm_current_module ();
161 for (SCM s
= scopes_
; scm_is_pair (s
); s
= scm_cdr (s
))
162 ly_use_module (module
, scm_car (s
));
163 scopes_
= scm_cons (module
, scopes_
);
165 set_current_scope ();
168 Lily_lexer::has_scope () const
170 return scm_is_pair (scopes_
);
174 Lily_lexer::remove_scope ()
176 SCM sc
= scm_car (scopes_
);
177 scopes_
= scm_cdr (scopes_
);
178 set_current_scope ();
183 Lily_lexer::set_current_scope ()
185 SCM old
= scm_current_module ();
187 if (scm_is_pair (scopes_
))
188 scm_set_current_module (scm_car (scopes_
));
190 scm_set_current_module (start_module_
);
196 Lily_lexer::lookup_keyword (string s
)
198 return keytable_
->lookup (s
.c_str ());
202 Lily_lexer::keyword_list () const
209 for (vsize i
= 0; i
< keytable_
->table_
.size (); i
++)
211 *tail
= scm_acons (scm_from_locale_string (keytable_
->table_
[i
].name_
),
212 scm_from_int (keytable_
->table_
[i
].tokcode_
),
215 tail
= SCM_CDRLOC (*tail
);
222 Lily_lexer::lookup_identifier_symbol (SCM sym
)
224 for (SCM s
= scopes_
; scm_is_pair (s
); s
= scm_cdr (s
))
226 SCM var
= ly_module_lookup (scm_car (s
), sym
);
227 if (var
!= SCM_BOOL_F
)
228 return scm_variable_ref (var
);
231 return SCM_UNDEFINED
;
235 Lily_lexer::lookup_identifier (string name
)
237 return lookup_identifier_symbol (ly_symbol2scm (name
.c_str ()));
241 Lily_lexer::start_main_input ()
243 yy_flex_debug
= get_program_option ("debug-lexer");
244 parser_
->set_yydebug (get_program_option ("debug-parser"));
246 new_input (main_input_name_
, sources_
);
248 scm_module_define (scm_car (scopes_
),
249 ly_symbol2scm ("input-file-name"),
250 ly_string2scm (main_input_name_
));
254 Lily_lexer::new_input (string str
, string d
, Sources
*ss
)
256 Includable_lexer::new_input (str
, d
, ss
);
260 Lily_lexer::new_input (string str
, Sources
*ss
)
262 if (is_main_input_
&& be_safe_global
)
264 LexerError (_ ("include files are not allowed in safe mode").c_str ());
268 Includable_lexer::new_input (str
, ss
);
271 // PATH is either a single symbol (or string) or a list of symbols
272 // giving the path to a nested property. A symbol is treated the same
273 // as a list of length 1.
275 Lily_lexer::set_identifier (SCM path
, SCM val
)
278 if (scm_is_string (path
))
279 sym
= scm_string_to_symbol (path
);
280 else if (scm_is_pair (path
))
282 sym
= scm_car (path
);
283 path
= scm_cdr (path
);
286 if (scm_is_symbol (sym
))
288 if (lookup_keyword (ly_symbol2string (sym
)) >= 0)
290 string symstr
= ly_symbol2string (sym
);
291 warning (_f ("identifier name is a keyword: `%s'", symstr
.c_str ()));
294 SCM mod
= scm_car (scopes_
);
296 if (scm_is_pair (path
))
298 SCM prev
= scm_module_lookup (mod
, sym
);
299 if (prev
!= SCM_UNDEFINED
)
300 val
= nested_property_alist (prev
, path
, val
);
302 scm_module_define (mod
, sym
, val
);
305 programming_error ("identifier is not a symbol");
309 Lily_lexer::LexerError (char const *s
)
311 if (include_stack_
.empty ())
312 message (_f ("error at EOF: %s", s
) + "\n");
316 Input
spot (*lexloc_
);
322 Lily_lexer::escaped_char (char c
) const
339 Lily_lexer::here_input () const
341 return Input (*lexloc_
);
345 Lily_lexer::prepare_for_next_token ()
347 last_input_
= here_input ();
351 Since we don't create the buffer state from the bytes directly, we
352 don't know about the location of the lexer. Add this as a
355 Lily_lexer::add_lexed_char (int count
)
357 char const *start
= here_str0 ();
358 lexloc_
->set (get_source_file (),
359 start
, start
+ count
);
360 char_count_stack_
.back () += count
;
363 #include "ly-smobs.icc"
365 IMPLEMENT_SMOBS (Lily_lexer
);
366 IMPLEMENT_TYPE_P (Lily_lexer
, "ly:lily-lexer?");
367 IMPLEMENT_DEFAULT_EQUAL_P (Lily_lexer
);
370 Lily_lexer::mark_smob (SCM s
)
372 ASSERT_LIVE_IS_ALLOWED ();
374 Lily_lexer
*lexer
= (Lily_lexer
*) SCM_CELL_WORD_1 (s
);
376 scm_gc_mark (lexer
->chordmodifier_tab_
);
378 scm_gc_mark (lexer
->parser_
->self_scm ());
379 scm_gc_mark (lexer
->pitchname_tab_stack_
);
380 scm_gc_mark (lexer
->start_module_
);
381 return lexer
->scopes_
;
385 Lily_lexer::print_smob (SCM s
, SCM port
, scm_print_state
*)
387 Lily_lexer
*lexer
= Lily_lexer::unsmob (s
);
389 scm_puts ("#<Lily_lexer ", port
);
390 scm_display (lexer
->scopes_
, port
);
391 scm_puts (" >", port
);