X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fincludable-lexer.cc;h=15d52a3ae9b50368536bf60a38fc967053d23bad;hb=86713eefa608f7dc738420ce0225c2a92c4539b2;hp=e2bd367808db455e0f3885353f1232ce3e9fcb6d;hpb=7aabfb20c46e0a1de41698ddc6859ccd3a6dea85;p=lilypond.git diff --git a/lily/includable-lexer.cc b/lily/includable-lexer.cc index e2bd367808..15d52a3ae9 100644 --- a/lily/includable-lexer.cc +++ b/lily/includable-lexer.cc @@ -1,154 +1,165 @@ /* - includable-lexer.cc -- implement Includable_lexer + This file is part of LilyPond, the GNU music typesetter. - source file of the LilyPond music typesetter + Copyright (C) 1997--2011 Han-Wen Nienhuys - (c) 1997--2003 Han-Wen Nienhuys + LilyPond is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + LilyPond is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . */ +#include "includable-lexer.hh" + #include +using namespace std; +#include "config.hh" +#include "file-name.hh" #include "file-path.hh" -#include "includable-lexer.hh" +#include "international.hh" +#include "main.hh" #include "source-file.hh" -#include "source.hh" +#include "sources.hh" #include "warn.hh" -#include "main.hh" #ifndef YY_BUF_SIZE #define YY_BUF_SIZE 16384 #endif #ifndef YY_START -#define YY_START\ - ((yy_start - 1) / 2) +#define YY_START \ + ((yy_start - 1) / 2) #define YYSTATE YY_START #endif +/* Flex >= 2.5.29 has include stack; but we don't use that yet. */ +#if !HAVE_FLEXLEXER_YY_CURRENT_BUFFER +#define yy_current_buffer \ + (yy_buffer_stack != 0 ? yy_buffer_stack[yy_buffer_stack_top] : 0) +#endif + +extern bool relative_includes; + Includable_lexer::Includable_lexer () { +#if HAVE_FLEXLEXER_YY_CURRENT_BUFFER yy_current_buffer = 0; - allow_includes_b_ = true; +#endif } -/** set the new input to s, remember old file. -*/ +/** Set the new input file to NAME, remember old file. */ void -Includable_lexer::new_input (String s, Sources * global_sources) +Includable_lexer::new_input (string name, Sources *sources) { - if (!allow_includes_b_) - { - LexerError ("include files are disallowed."); - return; - } - - Source_file * sl = global_sources->get_file (s); - if (!sl) + string current_dir = dir_name (main_input_name_); + if (relative_includes) + current_dir = include_stack_.size () ? dir_name (include_stack_.back ()->name_string ()) : ""; + + Source_file *file = sources->get_file (name, current_dir); + if (!file) { - String msg = _f ("can't find file: `%s'", s); - msg += "\n"; - msg += _f ("(search path: `%s')", global_sources->path_C_->string ().to_str0 ()); + string msg = _f ("cannot find file: `%s'", name); msg += "\n"; - LexerError (msg.to_str0 ()); - + msg += _f ("(search path: `%s')", + (current_dir.length () ? (current_dir + PATHSEP) : "") + sources->path_->to_string ().c_str ()); + LexerError (msg.c_str ()); return; } - filename_strings_.push (sl->name_string ()); + file_name_strings_.push_back (file->name_string ()); - char_count_stack_.push (0); + char_count_stack_.push_back (0); if (yy_current_buffer) - state_stack_.push (yy_current_buffer); + state_stack_.push_back (yy_current_buffer); - if (verbose_global_b) - progress_indication (String ("[") + s); - - include_stack_.push (sl); + debug_output (string (state_stack_.size (), ' ') // indentation! + + string ("[") + file->name_string ()); - /* - ugh. We'd want to create a buffer from the bytes directly. + include_stack_.push_back (file); - Whoops. The size argument to yy_create_buffer is not the - filelength but a BUFFERSIZE. Maybe this is why reading stdin fucks up. + /* Ugh. We'd want to create a buffer from the bytes directly. - */ - yy_switch_to_buffer (yy_create_buffer (sl->get_istream (), YY_BUF_SIZE)); + Whoops. The size argument to yy_create_buffer is not the + filelength but a BUFFERSIZE. Maybe this is why reading stdin fucks up. */ + yy_switch_to_buffer (yy_create_buffer (file->get_istream (), YY_BUF_SIZE)); } -/* - Unused. - */ void -Includable_lexer::new_input (String name, String data, Sources* sources) +Includable_lexer::new_input (string name, string data, Sources *sources) { - Source_file* file = new Source_file (name, data); + Source_file *file = new Source_file (name, data); sources->add (file); - filename_strings_.push (name); + file_name_strings_.push_back (name); - char_count_stack_.push (0); + char_count_stack_.push_back (0); if (yy_current_buffer) - state_stack_.push (yy_current_buffer); + state_stack_.push_back (yy_current_buffer); - if (verbose_global_b) - progress_indication (String ("[") + name); - include_stack_.push (file); + debug_output (string (state_stack_.size (), ' ') // indentation! + + string ("[") + name); + include_stack_.push_back (file); yy_switch_to_buffer (yy_create_buffer (file->get_istream (), YY_BUF_SIZE)); } +void +Includable_lexer::add_string_include (string data) +{ + pending_string_includes_.push_back (data); +} + /** pop the inputstack. conceptually this is a destructor, but it - does not destruct the Source_file that Includable_lexer::new_input creates. */ + does not destruct the Source_file that Includable_lexer::new_input + creates. */ bool Includable_lexer::close_input () { - include_stack_.pop (); - char_count_stack_.pop (); - if (verbose_global_b) - progress_indication ("]"); + include_stack_.pop_back (); + char_count_stack_.pop_back (); + debug_output ("]", false); yy_delete_buffer (yy_current_buffer); +#if HAVE_FLEXLEXER_YY_CURRENT_BUFFER yy_current_buffer = 0; +#endif if (state_stack_.empty ()) { +#if HAVE_FLEXLEXER_YY_CURRENT_BUFFER yy_current_buffer = 0; +#endif return false; } - else - { - yy_switch_to_buffer (state_stack_.pop ()); - return true; - } + yy_switch_to_buffer (state_stack_.back ()); + state_stack_.pop_back (); + return true; } -char const* +char const * Includable_lexer::here_str0 () const { if (include_stack_.empty ()) return 0; - return include_stack_.top ()->to_str0 () + char_count_stack_.top (); + return include_stack_.back ()->c_str () + char_count_stack_.back (); } Includable_lexer::~Includable_lexer () { while (!include_stack_.empty ()) - { - close_input (); - } -} -/** - Since we don't create the buffer state from the bytes directly, we - don't know about the location of the lexer. Add this as a - YY_USER_ACTION */ -void -Includable_lexer::add_lexed_char (int count) -{ - char_count_stack_.top () += count; + close_input (); } -Source_file* +Source_file * Includable_lexer::get_source_file () const { if (include_stack_.empty ()) return 0; - else - return include_stack_.top (); + return include_stack_.back (); }