X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fscm-option.cc;h=32cff36a22d6ef3cc914ba48e1a618e02404ce89;hb=43d1c731756070519bb1229b30c7a83f275e2c6e;hp=9c484e3d9dc6dcb1e2923e75805ab74f03cb6bd4;hpb=f8187c670aac9bf7a545c65bf2c870733494603c;p=lilypond.git diff --git a/lily/scm-option.cc b/lily/scm-option.cc index 9c484e3d9d..32cff36a22 100644 --- a/lily/scm-option.cc +++ b/lily/scm-option.cc @@ -1,17 +1,19 @@ -/* +/* scm-option.cc -- implement option setting from Scheme - + source file of the GNU LilyPond music typesetter - - (c) 2001--2002 Han-Wen Nienhuys - + + (c) 2001--2004 Han-Wen Nienhuys + */ #include +#include "parse-scm.hh" #include "string.hh" #include "lily-guile.hh" #include "scm-option.hh" #include "warn.hh" +#include "main.hh" /* This interface to option setting is meant for setting options are @@ -23,7 +25,7 @@ preferably, also dont use TESTING_LEVEL_GLOBAL, since it defeats another purpose of this very versatile interface, which is to support multiple debug/testing options concurrently. - + */ @@ -33,92 +35,128 @@ bool midi_debug_global_b; /* General purpose testing flag */ int testing_level_global; +/* + Backwards compatibility. + */ +bool lily_1_8_relative = false; +bool lily_1_8_compatibility_used = false; + /* crash if internally the wrong type is used for a grob property. */ bool internal_type_checking_global_b; + +/* + What is this function for ? + */ +LY_DEFINE (ly_option_usage, "ly:option-usage", 0, 0, 0, (SCM), + "Print ly:set-option usage") +{ + printf ( _("lilypond -e EXPR means:").to_str0 ()); + puts (""); + printf (_ (" Evalute the Scheme EXPR before parsing any .ly files.").to_str0 ()); + puts (""); + printf (_ (" Multiple -e options may be given, they will be evaluated sequentially.").to_str0 ()); + puts (""); + printf (_(" The function ly:set-option allows for access to some internal variables.").to_str0 ()); + puts ("\n"); + printf (_ ("Usage: lilypond -e \"(ly:set-option SYMBOL VAL)\"").to_str0 ()); + puts ("\n"); + printf (_ ("Use help as SYMBOL to get online help.").to_str0 ()); + + exit (0); + return SCM_UNSPECIFIED; +} + /* Add these as well: @item -T,--no-timestamps don't timestamp the output @item -t,--test -Switch on any experimental features. Not for general public use. */ - -LY_DEFINE(set_lily_option,"set-lily-option", 2, 0, 0, (SCM var, SCM val), - "Set a global option for the program. Supported options include - - -@table @code -@item help -List all options. -@item midi-debug -If set to true, generate human readable MIDI -@item internal-type-checking -Set paranoia for property assignments -@end table - -This function is useful to call from the command line: @code{lilypond -e -\"(set-lily-option 'midi-debug #t)\"}. -") +Switch on any experimental features. Not for general public use. + +*/ + + +LY_DEFINE (ly_set_option, "ly:set-option", 1, 1, 0, (SCM var, SCM val), + "Set a global option value. Supported options include\n" +"\n" +"@table @code\n" +"@item help\n" +"List all options.\n" +"@item midi-debug\n" +"If set to true, generate human readable MIDI\n" +"@item internal-type-checking\n" +"Set paranoia for property assignments\n" +"@item parse-protect\n" +"If protection is switched on, errors in inline scheme are caught in the parser. \n" +"If off, GUILE will halt on errors, and give a stack trace. Default is protected evaluation. \n" +"@item old-relative\n" +"Relative for simultaneous music functions similar to chord syntax\n" +"@item new-relative\n" +"Relative for simultaneous music functions similar to sequential music\n" +"@end table\n" +"\n" +"This function is useful to call from the command line: @code{lilypond -e\n" +"\"(ly:set-option 'midi-debug #t)\"}.\n") { - /* Scheme option usage: - lilypond -e "(set-lily-option 'help 0)" */ + if (val == SCM_UNDEFINED) + val = SCM_BOOL_T; + if (var == ly_symbol2scm ("help")) - { - printf ( _("lilypond -e EXPR means - -evalute EXPR as Scheme after init.scm has been read. In particular, -the function set-lily-option allows for access to some internal -variables. Usage: - - (set-lily-option SYMBOL VAL) - -possible options for SYMBOL are : -").to_str0 ()); - printf ( " help (any-symbol)\n" - " internal-type-checking (boolean)\n" - " midi-debug (boolean)\n" - " testing-level (int)\n"); - - exit (0); - } + /* lilypond -e "(ly:set-option 'help #t)" */ + ly_option_usage (SCM_EOL); else if (var == ly_symbol2scm ("midi-debug")) - { - midi_debug_global_b = to_boolean (val); - } + midi_debug_global_b = to_boolean (val); else if (var == ly_symbol2scm ("testing-level")) - { - testing_level_global = gh_scm2int (val); - } + testing_level_global = ly_scm2int (val); + else if (var == ly_symbol2scm ("parse-protect" )) + parse_protect_global = to_boolean (val); else if (var == ly_symbol2scm ("internal-type-checking")) + internal_type_checking_global_b = to_boolean (val); + else if (var == ly_symbol2scm ("old-relative")) { - internal_type_checking_global_b = to_boolean (val); - } - else if (var == ly_symbol2scm ("find-old-relative")) - { - /* - Seems to have been broken for some time! - - @item -Q,--find-old-relative - show all changes needed to convert a file to relative octave syntax. - - - - */ - - ; + lily_1_8_relative = true; + /* Needs to be reset for each file that uses this option. */ + lily_1_8_compatibility_used = false; } + else if (var == ly_symbol2scm ("new-relative")) + lily_1_8_relative = false; else { - warning (_("Unknown internal option!")); + if (ly_c_symbol_p (var)) + var = scm_symbol_to_string (var); + + warning (_f ("No such internal option: %s", ly_scm2string (var))); } - - return SCM_UNSPECIFIED; } - - - +LY_DEFINE (ly_get_option, "ly:get-option", 1, 0, 0, (SCM var), + "Get a global option setting. Supported options include\n" + "@table @code\n" + "@item old-relative-used\n" + "Report whether old-relative compatibility mode is necessary\n" + "@item old-relative\n" + "Report whether old-relative compatibility mode is used\n" + "@item verbose\n" + "Report whether we are running in verbose mode\n" + "@end table\n" + "\n") +{ + SCM o = SCM_UNSPECIFIED; + + if (var == ly_symbol2scm ("safe")) // heavily used; put in front. + o = ly_bool2scm (safe_global_b); + else if (var == ly_symbol2scm ("old-relative-used")) + o = ly_bool2scm (lily_1_8_compatibility_used); + else if (var == ly_symbol2scm ("old-relative")) + o = ly_bool2scm (lily_1_8_relative); + else if (var == ly_symbol2scm ("verbose")) + o = ly_bool2scm (verbose_global_b); + else + warning (_f ("No such internal option: %s", ly_scm2string (var))); + return o; +}