X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fincludable-lexer.cc;h=772adeee854d315eda5bc5df5afc43046c589cd3;hb=9e781b7dc83b60a543ce218aa1a5f139f74c760f;hp=e38dbd363ece5611f35a7376c49de590a85477ae;hpb=91ad96d55a9848ab482d0946987aaa68af76d357;p=lilypond.git diff --git a/lily/includable-lexer.cc b/lily/includable-lexer.cc index e38dbd363e..772adeee85 100644 --- a/lily/includable-lexer.cc +++ b/lily/includable-lexer.cc @@ -1,151 +1,159 @@ /* - 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--2014 Han-Wen Nienhuys - (c) 1997--2002 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 "source-file.hh" -#include "source.hh" -#include "debug.hh" +#include "international.hh" #include "main.hh" +#include "source-file.hh" +#include "sources.hh" +#include "warn.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 (const string &name, Sources *sources) { - if (!allow_includes_b_) - { - LexerError ("include files are disallowed."); - return; - } - - Source_file * sl = global_sources->get_file_l (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_->str ().ch_C ()); + string msg = _f ("cannot find file: `%s'", name); msg += "\n"; - LexerError (msg.ch_C ()); - + msg += _f ("(search path: `%s')", + (current_dir.length () ? (current_dir + PATHSEP) : "") + sources->path_->to_string ().c_str ()); + LexerError (msg.c_str ()); return; } - filename_str_arr_.push (sl->name_str ()); + 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); - - if (verbose_global_b) - progress_indication (String ("[") + s); - - include_stack_.push (sl); + state_stack_.push_back (yy_current_buffer); - /* - ugh. We'd want to create a buffer from the bytes directly. + debug_output (string (state_stack_.size (), ' ') // indentation! + + string ("[") + file->name_string ()); - Whoops. The size argument to yy_create_buffer is not the - filelength but a BUFFERSIZE. Maybe this is why reading stdin fucks up. + include_stack_.push_back (file); - */ - yy_switch_to_buffer (yy_create_buffer (sl->istream_l (), YY_BUF_SIZE)); + /* Ugh. We'd want to create a buffer from the bytes directly. + 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)); } + void -Includable_lexer::new_input (String name, String data, Sources* sources) +Includable_lexer::new_input (const 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_str_arr_.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->istream_l (), YY_BUF_SIZE)); + yy_switch_to_buffer (yy_create_buffer (file->get_istream (), YY_BUF_SIZE)); } /** 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* -Includable_lexer::here_ch_C () const +char const * +Includable_lexer::here_str0 () const { if (include_stack_.empty ()) return 0; - return include_stack_.top ()->ch_C () + 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* -Includable_lexer::source_file_l () const +Source_file * +Includable_lexer::get_source_file () const { if (include_stack_.empty ()) return 0; - else - return include_stack_.top (); + return include_stack_.back (); }