X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Finput.cc;h=b6aed9e2d1296b74182d9aca7f2921c6f9a04001;hb=4d405ef96a8a62771d7d9a283ff5369a772e89d8;hp=83ae50a43c3257b53f52d66f7fe9cb2e70104da4;hpb=e24df7c27635dc996c466295eacf2981bddccaf7;p=lilypond.git diff --git a/lily/input.cc b/lily/input.cc index 83ae50a43c..b6aed9e2d1 100644 --- a/lily/input.cc +++ b/lily/input.cc @@ -1,17 +1,33 @@ /* - input.cc -- implement Input + 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--2005 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 "input.hh" #include +using namespace std; -#include "source.hh" +#include "international.hh" +#include "lily-imports.hh" +#include "program-option.hh" #include "source-file.hh" +#include "sources.hh" +#include "warn.hh" Input::Input (Input const &i) { @@ -43,8 +59,8 @@ void Input::step_forward () { if (end_ == start_) - end_ ++; - start_ ++; + end_++; + start_++; } void @@ -58,109 +74,101 @@ Input::set_location (Input const &i_start, Input const &i_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 + Format: - */ -void -Input::message (String message_string) const + [file:line:column:][warning:]message +*/ +string +Input::message_string (const string &msg) const { - String str; - - /* - marked "Work in prgress" in GNU iostream - libg++ 2.7.2.8 - libstdc++ 2.8.1 - - why not just return always -1 (unknown), - iso breaking the interface? + if (source_file_) + return msg + "\n" + source_file_->quote_input (start_); + else + return msg; +} - int col = cerr.rdbuf ()->column (); +string +Input::message_location () const +{ + return (source_file_) ? location_string () : ""; +} - */ +void +Input::error (const string &s) const +{ + ::error (message_string (s), message_location ()); +} - // well, we don't want to loose first warning... - int col = 1; - if (col > 0) - str += "\n"; - - if (source_file_) - str += location_string () + String (": "); +void +Input::programming_error (const string &s) const +{ + ::programming_error (message_string (s), message_location ()); +} - str += message_string; - if (source_file_) - { - str += ":\n"; - str += source_file_->error_string (start_); - } - fprintf (stderr, "%s\n", str.to_str0 ()); - fflush (stderr); +void +Input::non_fatal_error (const string &s) const +{ + ::non_fatal_error (message_string (s), message_location ()); } void -Input::warning (String message_string) const +Input::warning (const string &s) const { - message (_ ("warning: ") + message_string); + ::warning (message_string (s), message_location ()); } + void -Input::error (String s) const +Input::message (const string &s) const { - message (_ ("error: ")+ s); + ::message (message_string (s), true, message_location ()); } void -Input::non_fatal_error (String s) const +Input::debug_output (const string &s) const { - message (_ ("non fatal error: ") + s); + ::debug_output (message_string (s), true, message_location ()); } -String + +string Input::location_string () const { if (source_file_) return source_file_->file_line_column_string (start_); - else - return " (" + _ ("position unknown") + ")"; + return " (" + _ ("position unknown") + ")"; } -String +string Input::line_number_string () const { if (source_file_) - return to_string (source_file_->get_line (start_)); - else - return "?"; + return ::to_string (source_file_->get_line (start_)); + return "?"; } -String +string Input::file_string () const { if (source_file_) return source_file_->name_string (); - else - return ""; + return ""; } - int Input::line_number () const { if (source_file_) return source_file_->get_line (start_); - else - return 0; - + return 0; } int Input::column_number () const { - if (source_file_) - return source_file_->get_column (start_); - else - return 0; + int line, chr, col, offset = 0; + source_file_->get_counts (start_, &line, &chr, &col, &offset); + return col; } int @@ -168,17 +176,147 @@ Input::end_line_number () const { if (source_file_) return source_file_->get_line (end_); - else - return 0; - + return 0; } int Input::end_column_number () const { - if (source_file_) - return source_file_->get_column (end_); - else - return 0; + 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 +{ + return start_; +} + +char const * +Input::end () const +{ + return end_; +} + +static SCM +with_location_hook_0 (void *it) +{ + SCM *args = static_cast (it); + return scm_call_0 (args[0]); +} + +SCM +with_location (SCM loc, SCM proc) +{ + return scm_c_with_fluid (Lily::f_location, + unsmob (loc) ? loc : SCM_BOOL_F, + with_location_hook_0, + static_cast (&proc)); +} + +static SCM +with_location_hook_1 (void *it) +{ + SCM *args = static_cast (it); + return scm_call_1 (args[0], args[1]); +} + +SCM +with_location (SCM loc, SCM proc, SCM arg1) +{ + SCM args[] = { proc, arg1 }; + return scm_c_with_fluid (Lily::f_location, + unsmob (loc) ? loc : SCM_BOOL_F, + with_location_hook_1, + static_cast (&args)); +} + +static SCM +with_location_hook_2 (void *it) +{ + SCM *args = static_cast (it); + return scm_call_2 (args[0], args[1], args[2]); +} + +SCM +with_location (SCM loc, SCM proc, SCM arg1, SCM arg2) +{ + SCM args[] = { proc, arg1, arg2 }; + return scm_c_with_fluid (Lily::f_location, + unsmob (loc) ? loc : SCM_BOOL_F, + with_location_hook_2, + static_cast (&args)); +} + +static SCM +with_location_hook_3 (void *it) +{ + SCM *args = static_cast (it); + return scm_call_3 (args[0], args[1], args[2], args[3]); +} + +SCM +with_location (SCM loc, SCM proc, SCM arg1, SCM arg2, SCM arg3) +{ + SCM args[] = { proc, arg1, arg2, arg3 }; + return scm_c_with_fluid (Lily::f_location, + unsmob (loc) ? loc : SCM_BOOL_F, + with_location_hook_3, + static_cast (&args)); +} + +static SCM +with_location_hook_4 (void *it) +{ + SCM *args = static_cast (it); + return scm_call_4 (args[0], args[1], args[2], args[3], args[4]); +} + +SCM +with_location (SCM loc, SCM proc, SCM arg1, SCM arg2, SCM arg3, SCM arg4) +{ + SCM args[] = { proc, arg1, arg2, arg3, arg4 }; + return scm_c_with_fluid (Lily::f_location, + unsmob (loc) ? loc : SCM_BOOL_F, + with_location_hook_4, + static_cast (&args)); +} + +static SCM +with_location_hook_n (void *it) +{ + SCM *args = static_cast (it); + return scm_apply_0 (args[0], args[1]); +} + +SCM +with_location (SCM loc, SCM proc, SCM arg1, SCM arg2, SCM arg3, SCM arg4, SCM arg5) +{ + SCM args[] = { proc, scm_list_5 (arg1, arg2, arg3, arg4, arg5) }; + return scm_c_with_fluid (Lily::f_location, + unsmob (loc) ? loc : SCM_BOOL_F, + with_location_hook_n, + static_cast (&args)); }