]> git.donarmstrong.com Git - lilypond.git/blob - lily/lily-lexer.cc
Issue 4082/3: Run scripts/auxiliar/smob-convert.sh
[lilypond.git] / lily / lily-lexer.cc
1 /*
2   This file is part of LilyPond, the GNU music typesetter.
3
4   Copyright (C) 1997--2014 Han-Wen Nienhuys <hanwen@xs4all.nl>
5
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.
10
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.
15
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/>.
18 */
19
20 #include "lily-lexer.hh"
21
22 #include <cctype>
23 #include <sstream>
24 using namespace std;
25
26 #include "context.hh" // for nested_property_alist
27 #include "international.hh"
28 #include "interval.hh"
29 #include "keyword.hh"
30 #include "main.hh"
31 #include "moment.hh"
32 #include "parser.hh"
33 #include "scm-hash.hh"
34 #include "source-file.hh"
35 #include "warn.hh"
36 #include "program-option.hh"
37 #include "lily-parser.hh"
38
39 static Keyword_ent the_key_tab[]
40 =
41 {
42   {"accepts", ACCEPTS},
43   {"addlyrics", ADDLYRICS},
44   {"alias", ALIAS},
45   {"alternative", ALTERNATIVE},
46   {"book", BOOK},
47   {"bookpart", BOOKPART},
48   {"change", CHANGE},
49   {"chordmode", CHORDMODE},
50   {"chords", CHORDS},
51   {"consists", CONSISTS},
52   {"context", CONTEXT},
53   {"default", DEFAULT},
54   {"defaultchild", DEFAULTCHILD},
55   {"denies", DENIES},
56   {"description", DESCRIPTION},
57   {"drummode", DRUMMODE},
58   {"drums", DRUMS},
59   {"figuremode", FIGUREMODE},
60   {"figures", FIGURES},
61   {"header", HEADER},
62   {"layout", LAYOUT},
63   {"lyricmode", LYRICMODE},
64   {"lyrics", LYRICS},
65   {"lyricsto", LYRICSTO},
66   {"markup", MARKUP},
67   {"markuplist", MARKUPLIST},
68   {"midi", MIDI},
69   {"name", NAME},
70   {"new", NEWCONTEXT},
71   {"notemode", NOTEMODE},
72   {"override", OVERRIDE},
73   {"paper", PAPER},
74   {"remove", REMOVE},
75   {"repeat", REPEAT},
76   {"rest", REST},
77   {"revert", REVERT},
78   {"score", SCORE},
79   {"sequential", SEQUENTIAL},
80   {"set", SET},
81   {"simultaneous", SIMULTANEOUS},
82   {"tempo", TEMPO},
83   {"type", TYPE},
84   {"unset", UNSET},
85   {"with", WITH},
86   {0, 0}
87 };
88
89 Lily_lexer::Lily_lexer (Sources *sources, Lily_parser *parser)
90 {
91   parser_ = parser;
92   keytable_ = new Keyword_table (the_key_tab);
93   chordmodifier_tab_ = SCM_EOL;
94   pitchname_tab_stack_ = SCM_EOL;
95   sources_ = sources;
96   scopes_ = SCM_EOL;
97   error_level_ = 0;
98   is_main_input_ = false;
99   main_input_level_ = 0;
100   start_module_ = SCM_EOL;
101   extra_tokens_ = SCM_EOL;
102   smobify_self ();
103
104   add_scope (ly_make_module (false));
105   push_note_state (SCM_EOL);
106   chordmodifier_tab_ = scm_make_vector (scm_from_int (1), SCM_EOL);
107 }
108
109 Lily_lexer::Lily_lexer (Lily_lexer const &src, Lily_parser *parser,
110                         SCM override_input)
111   : Includable_lexer ()
112 {
113   parser_ = parser;
114   keytable_ = (src.keytable_) ? new Keyword_table (*src.keytable_) : 0;
115   chordmodifier_tab_ = src.chordmodifier_tab_;
116   pitchname_tab_stack_ = src.pitchname_tab_stack_;
117   sources_ = src.sources_;
118   scopes_ = src.scopes_;
119   start_module_ = SCM_EOL;
120
121   error_level_ = 0;
122   is_main_input_ = src.is_main_input_;
123   main_input_level_ = 0;
124
125   extra_tokens_ = SCM_EOL;
126   if (Input::unsmob (override_input))
127     override_input_ = *Input::unsmob (override_input);
128
129   smobify_self ();
130
131   push_note_state (SCM_EOL);
132 }
133
134 Lily_lexer::~Lily_lexer ()
135 {
136   delete keytable_;
137 }
138
139 void
140 Lily_lexer::add_scope (SCM module)
141 {
142   ly_reexport_module (scm_current_module ());
143   if (!scm_is_pair (scopes_))
144     start_module_ = scm_current_module ();
145
146   for (SCM s = scopes_; scm_is_pair (s); s = scm_cdr (s))
147     ly_use_module (module, scm_car (s));
148   scopes_ = scm_cons (module, scopes_);
149
150   set_current_scope ();
151 }
152 bool
153 Lily_lexer::has_scope () const
154 {
155   return scm_is_pair (scopes_);
156 }
157
158 SCM
159 Lily_lexer::remove_scope ()
160 {
161   SCM sc = scm_car (scopes_);
162   scopes_ = scm_cdr (scopes_);
163   set_current_scope ();
164   return sc;
165 }
166
167 SCM
168 Lily_lexer::set_current_scope ()
169 {
170   SCM old = scm_current_module ();
171
172   if (scm_is_pair (scopes_))
173     scm_set_current_module (scm_car (scopes_));
174   else
175     scm_set_current_module (start_module_);
176
177   return old;
178 }
179
180 int
181 Lily_lexer::lookup_keyword (const string &s)
182 {
183   return keytable_->lookup (s.c_str ());
184 }
185
186 SCM
187 Lily_lexer::keyword_list () const
188 {
189   if (!keytable_)
190     return SCM_EOL;
191
192   SCM l = SCM_EOL;
193   SCM *tail = &l;
194   for (vsize i = 0; i < keytable_->table_.size (); i++)
195     {
196       *tail = scm_acons (scm_from_locale_string (keytable_->table_[i].name_),
197                          scm_from_int (keytable_->table_[i].tokcode_),
198                          SCM_EOL);
199
200       tail = SCM_CDRLOC (*tail);
201     }
202
203   return l;
204 }
205
206 SCM
207 Lily_lexer::lookup_identifier_symbol (SCM sym)
208 {
209   for (SCM s = scopes_; scm_is_pair (s); s = scm_cdr (s))
210     {
211       SCM var = ly_module_lookup (scm_car (s), sym);
212       if (var != SCM_BOOL_F)
213         return scm_variable_ref (var);
214     }
215
216   return SCM_UNDEFINED;
217 }
218
219 SCM
220 Lily_lexer::lookup_identifier (const string &name)
221 {
222   return lookup_identifier_symbol (ly_symbol2scm (name.c_str ()));
223 }
224
225 void
226 Lily_lexer::start_main_input ()
227 {
228   yy_flex_debug = get_program_option ("debug-lexer");
229   parser_->set_yydebug (get_program_option ("debug-parser"));
230
231   new_input (main_input_name_, sources_);
232
233   scm_module_define (scm_car (scopes_),
234                      ly_symbol2scm ("input-file-name"),
235                      ly_string2scm (main_input_name_));
236 }
237
238 void
239 Lily_lexer::new_input (const string &str, string d, Sources *ss)
240 {
241   Includable_lexer::new_input (str, d, ss);
242 }
243
244 void
245 Lily_lexer::new_input (const string &str, Sources *ss)
246 {
247   if (is_main_input_ && be_safe_global)
248     {
249       LexerError (_ ("include files are not allowed in safe mode").c_str ());
250       return;
251     }
252
253   Includable_lexer::new_input (str, ss);
254 }
255
256 // PATH is either a single symbol (or string) or a list of symbols
257 // giving the path to a nested property.  A symbol is treated the same
258 // as a list of length 1.
259 void
260 Lily_lexer::set_identifier (SCM path, SCM val)
261 {
262   SCM sym = path;
263   if (scm_is_string (path))
264     sym = scm_string_to_symbol (path);
265   else if (scm_is_pair (path))
266     {
267       sym = scm_car (path);
268       path = scm_cdr (path);
269     }
270
271   if (scm_is_symbol (sym))
272     {
273       if (lookup_keyword (ly_symbol2string (sym)) >= 0)
274         {
275           string symstr = ly_symbol2string (sym);
276           warning (_f ("identifier name is a keyword: `%s'", symstr.c_str ()));
277         }
278
279       SCM mod = scm_car (scopes_);
280
281       if (scm_is_pair (path))
282         {
283           SCM prev = ly_module_lookup (mod, sym);
284           if (prev != SCM_BOOL_F)
285             val = nested_property_alist (scm_variable_ref (prev), path, val);
286         }
287       scm_module_define (mod, sym, val);
288     }
289   else
290     programming_error ("identifier is not a symbol");
291 }
292
293 void
294 Lily_lexer::LexerError (char const *s)
295 {
296   if (include_stack_.empty ())
297     non_fatal_error (s, _f ("%s:EOF", s));
298   else
299     {
300       error_level_ |= 1;
301       Input spot (*lexloc_);
302       spot.error (s);
303     }
304 }
305
306 void
307 Lily_lexer::LexerWarning (char const *s)
308 {
309   if (include_stack_.empty ())
310     warning (s, _f ("%s:EOF", s));
311   else
312     {
313       Input spot (*lexloc_);
314       spot.warning (s);
315     }
316 }
317
318 char
319 Lily_lexer::escaped_char (char c) const
320 {
321   switch (c)
322     {
323     case 'n':
324       return '\n';
325     case 't':
326       return '\t';
327     case '\'':
328     case '\"':
329     case '\\':
330       return c;
331     }
332   return 0;
333 }
334
335 Input
336 Lily_lexer::here_input () const
337 {
338   return Input (*lexloc_);
339 }
340
341 Input const &
342 Lily_lexer::override_input (Input const &in) const
343 {
344   return override_input_.get_source_file ()
345     ? override_input_ : in;
346 }
347
348 void
349 Lily_lexer::prepare_for_next_token ()
350 {
351   last_input_ = here_input ();
352 }
353
354 /**
355    Since we don't create the buffer state from the bytes directly, we
356    don't know about the location of the lexer. Add this as a
357    YY_USER_ACTION */
358 void
359 Lily_lexer::add_lexed_char (int count)
360 {
361   char const *start = here_str0 ();
362   lexloc_->set (get_source_file (),
363                 start, start + count);
364   char_count_stack_.back () += count;
365 }
366
367
368 const char Lily_lexer::type_p_name_[] = "ly:lily-lexer?";
369
370 SCM
371 Lily_lexer::mark_smob (SCM s)
372 {
373   ASSERT_LIVE_IS_ALLOWED (s);
374
375   Lily_lexer *lexer = (Lily_lexer *) SCM_CELL_WORD_1 (s);
376
377   scm_gc_mark (lexer->chordmodifier_tab_);
378   if (lexer->parser_)
379     scm_gc_mark (lexer->parser_->self_scm ());
380   scm_gc_mark (lexer->pitchname_tab_stack_);
381   scm_gc_mark (lexer->start_module_);
382   scm_gc_mark (lexer->extra_tokens_);
383   return lexer->scopes_;
384 }
385
386 int
387 Lily_lexer::print_smob (SCM s, SCM port, scm_print_state *)
388 {
389   Lily_lexer *lexer = Lily_lexer::unsmob (s);
390
391   scm_puts ("#<Lily_lexer ", port);
392   scm_display (lexer->scopes_, port);
393   scm_puts (" >", port);
394   return 1;
395 }
396
397 bool
398 Lily_lexer::is_clean () const
399 {
400   return include_stack_.empty ();
401 }