X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fincludable-lexer.cc;h=8567ec91718c470e0e24741902d85911dff391b3;hb=47db9a3883d726ca53e2133a3b2298f78dd6a32e;hp=a99a2f7595672da936149dec3de6b82e1d6e6bf8;hpb=7e72a1e50e94a7f9738d62599de79fe7745f600c;p=lilypond.git diff --git a/lily/includable-lexer.cc b/lily/includable-lexer.cc index a99a2f7595..8567ec9171 100644 --- a/lily/includable-lexer.cc +++ b/lily/includable-lexer.cc @@ -1,166 +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--2015 Han-Wen Nienhuys - (c) 1997--2004 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 -#include "config.h" +using namespace std; -#include "includable-lexer.hh" +#include "config.hh" + +#include "file-name.hh" #include "file-path.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. */ -#ifndef HAVE_FLEXLEXER_YY_CURRENT_BUFFER -#define yy_current_buffer \ +#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 () { -#ifdef HAVE_FLEXLEXER_YY_CURRENT_BUFFER +#if HAVE_FLEXLEXER_YY_CURRENT_BUFFER yy_current_buffer = 0; #endif - allow_includes_b_ = true; } -/** 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 not allowed").to_str0 ()); - 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); + string msg = _f ("cannot find file: `%s'", name); msg += "\n"; - msg += _f ("(search path: `%s')", global_sources->path_C_->to_string ().to_str0 ()); - 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 (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_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)); } /** 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); -#ifdef HAVE_FLEXLEXER_YY_CURRENT_BUFFER +#if HAVE_FLEXLEXER_YY_CURRENT_BUFFER yy_current_buffer = 0; -#endif +#endif if (state_stack_.empty ()) { -#ifdef HAVE_FLEXLEXER_YY_CURRENT_BUFFER +#if HAVE_FLEXLEXER_YY_CURRENT_BUFFER yy_current_buffer = 0; -#endif +#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 (); }