X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Finput.cc;h=9ba376763861cbd58fbff6d3dadf7a216bdbdabd;hb=af5feffffa6ba56bd1fce2f79b1015cd933fcd21;hp=1ff4e8624431809cb2092c3b175a54af61ac75b7;hpb=3f374e66968308461daa390a7aeed0b013bfe33d;p=lilypond.git diff --git a/lily/input.cc b/lily/input.cc index 1ff4e86244..9ba3767638 100644 --- a/lily/input.cc +++ b/lily/input.cc @@ -1,85 +1,221 @@ /* - input.cc -- implement Input + 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 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 "proto.hh" + #include "input.hh" -#include "string.hh" -#include "source.hh" + +#include +using namespace std; + +#include "international.hh" +#include "program-option.hh" #include "source-file.hh" +#include "sources.hh" +#include "warn.hh" -Input::Input(Sources*s, char const *cl) +Input::Input (Input const &i) { - sources_l_=s; - defined_ch_C_=cl; + source_file_ = i.source_file_; + start_ = i.start_; + end_ = i.end_; } -Input::Input() +Input::Input () { - sources_l_ = 0; - defined_ch_C_ = 0; + source_file_ = 0; + start_ = 0; + end_ = 0; } -Input::Input(Input const &s) +Input +Input::spot () const { - sources_l_ = s.sources_l_; - defined_ch_C_ = s.defined_ch_C_; + return *this; } void -Input::set_spot(Input const &i) +Input::set_spot (Input const &i) { - *this = i; + *this = i; } void -Input::message(String message_str)const -{ - String str = ""; - Source_file* sourcefile_l=0; - - if (sources_l_) - sourcefile_l = sources_l_->sourcefile_l( defined_ch_C_ ); - - if ( sourcefile_l ) { - str += sourcefile_l->file_line_no_str(defined_ch_C_) + String(": "); - } - - str += message_str; - if ( sourcefile_l ) { - str += ":\n"; - str += sourcefile_l->error_str( defined_ch_C_); - } - /* - if ( busy_parsing() ) - cerr << endl; - */ - cerr << str << endl; +Input::step_forward () +{ + if (end_ == start_) + end_++; + start_++; } void -Input::warning( String message_str)const +Input::set_location (Input const &i_start, Input const &i_end) { - message( "warning: " + message_str); + source_file_ = i_start.source_file_; + start_ = i_start.start_; + end_ = i_end.end_; +} + +/* + Produce GNU-compliant error message. Correcting lilypond source is + such a breeze if you ('re edidor) know (s) the error column too + + Format: + + [file:line:column:][warning:]message +*/ +string +Input::message_string (string msg) const +{ + if (source_file_) + return msg + "\n" + source_file_->quote_input (start_); + else + return msg; +} + +string +Input::message_location () const +{ + return (source_file_) ? location_string () : ""; } void -Input::error(String s)const +Input::error (string s) const +{ + ::non_fatal_error (message_string (s), message_location ()); + // UGH, fix naming or usage (use non_fatal_error in most places, instead) + // exit (1); +} + +void +Input::programming_error (string s) const +{ + ::programming_error (message_string (s), message_location ()); +} + +void +Input::non_fatal_error (string s) const +{ + ::non_fatal_error (message_string (s), message_location ()); +} + +void +Input::warning (string s) const +{ + ::warning (message_string (s), message_location ()); +} + +void +Input::message (string s) const +{ + ::message (message_string (s), true, message_location ()); +} + +void +Input::debug_output (string s) const +{ + ::debug_output (message_string (s), true, message_location ()); +} + +string +Input::location_string () const +{ + if (source_file_) + return source_file_->file_line_column_string (start_); + return " (" + _ ("position unknown") + ")"; +} + +string +Input::line_number_string () const +{ + if (source_file_) + return to_string (source_file_->get_line (start_)); + return "?"; +} + +string +Input::file_string () const +{ + if (source_file_) + return source_file_->name_string (); + return ""; +} + +int +Input::line_number () const +{ + if (source_file_) + return source_file_->get_line (start_); + return 0; +} + +int +Input::column_number () const +{ + int line, chr, col, offset = 0; + source_file_->get_counts (start_, &line, &chr, &col, &offset); + + return col; +} + +int +Input::end_line_number () const +{ + if (source_file_) + return source_file_->get_line (end_); + return 0; +} + +int +Input::end_column_number () const +{ + int line, chr, col, offset = 0; + source_file_->get_counts (end_, &line, &chr, &col, &offset); + + return col; +} + +void +Input::get_counts (int *line, int *chr, int *col, int *offset) const +{ + source_file_->get_counts (start_, line, chr, col, offset); +} + +void +Input::set (Source_file *sf, char const *start, char const *end) +{ + source_file_ = sf; + start_ = start; + end_ = end; +} + +Source_file * +Input::get_source_file () const +{ + return source_file_; +} + +char const * +Input::start () const { - message("error: "+ s); - exit (1); + return start_; } -String -Input::location_str()const +char const * +Input::end () const { - Source_file * sourcefile_l=0; - if (sources_l_) - sourcefile_l = sources_l_->sourcefile_l (defined_ch_C_); - if (sourcefile_l) - return sourcefile_l->file_line_no_str(defined_ch_C_); - else - return "(location unknown)"; + return end_; }