1/*  Part of SWI-Prolog
    2
    3    Author:        Jan Wielemaker
    4    E-mail:        J.Wielemaker@vu.nl
    5    WWW:           http://www.swi-prolog.org
    6    Copyright (c)  2007-2016, University of Amsterdam
    7                              VU University Amsterdam
    8    All rights reserved.
    9
   10    Redistribution and use in source and binary forms, with or without
   11    modification, are permitted provided that the following conditions
   12    are met:
   13
   14    1. Redistributions of source code must retain the above copyright
   15       notice, this list of conditions and the following disclaimer.
   16
   17    2. Redistributions in binary form must reproduce the above copyright
   18       notice, this list of conditions and the following disclaimer in
   19       the documentation and/or other materials provided with the
   20       distribution.
   21
   22    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   23    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   24    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
   25    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
   26    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   27    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
   28    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   29    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   30    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   31    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   32    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   33    POSSIBILITY OF SUCH DAMAGE.
   34*/
   35
   36:- module(settings,
   37          [ setting/4,                  % :Name, +Type, +Default, +Comment
   38            setting/2,                  % :Name, ?Value
   39            set_setting/2,              % :Name, +Value
   40            set_setting_default/2,      % :Name, +Value
   41            restore_setting/1,          % :Name
   42            load_settings/1,            % +File
   43            load_settings/2,            % +File, +Options
   44            save_settings/0,
   45            save_settings/1,            % +File
   46            current_setting/1,          % Module:Name
   47            setting_property/2,         % ?Setting, ?Property
   48            list_settings/0,
   49            list_settings/1,            % +Module
   50
   51            convert_setting_text/3      % +Type, +Text, -Value
   52          ]).   53:- use_module(library(error)).   54:- use_module(library(broadcast)).   55:- use_module(library(debug)).   56:- use_module(library(option)).   57:- use_module(library(arithmetic)).   58:- set_prolog_flag(generate_debug_info, false).   59
   60/** <module> Setting management
   61
   62This library allows management  of   configuration  settings  for Prolog
   63applications. Applications define settings  in   one  or  multiple files
   64using the directive setting/4 as illustrated below:
   65
   66==
   67:- use_module(library(settings)).
   68
   69:- setting(version, atom,   '1.0', 'Current version').
   70:- setting(timeout, number,    20, 'Timeout in seconds').
   71==
   72
   73The directive is subject to   term_expansion/2,  which guarantees proper
   74synchronisation of the  database  if   source-files  are  reloaded. This
   75implies it is *not* possible to call setting/4 as a predicate.
   76
   77Settings are local to a  module.  This   implies  they  are defined in a
   78two-level namespace. Managing settings  per   module  greatly simplifies
   79assembling large applications from multiple   modules that configuration
   80through  settings.  This  settings  management  library  ensures  proper
   81access, loading and saving of settings.
   82
   83@see    library(config) distributed with XPCE provides an alternative
   84        aimed at graphical applications.
   85@author Jan Wielemaker
   86*/
   87
   88:- dynamic
   89    st_value/3,                     % Name, Module, Value
   90    st_default/3,                   % Name, Module, Value
   91    local_file/1.                   % Path
   92
   93:- multifile
   94    current_setting/6.              % Name, Module, Type, Default, Comment, Source
   95
   96:- meta_predicate
   97    setting(:, +, +, +),
   98    setting(:, ?),
   99    set_setting(:, +),
  100    set_setting_default(:, +),
  101    current_setting(:),
  102    restore_setting(:).  103
  104:- predicate_options(load_settings/2, 2, [undefined(oneof([load,error]))]).  105
  106curr_setting(Name, Module, Type, Default, Comment, Src) :-
  107    current_setting(Name, Module, Type, Default0, Comment, Src),
  108    (   st_default(Name, Module, Default1)
  109    ->  Default = Default1
  110    ;   Default = Default0
  111    ).
  112
  113%!  setting(:Name, +Type, +Default, +Comment) is det.
  114%
  115%   Define a  setting.  Name denotes  the name of the  setting, Type
  116%   its type.  Default is the  value before it is  modified. Default
  117%   can  refer  to  environment  variables and  can  use  arithmetic
  118%   expressions as defined by eval_default/4.
  119%
  120%   If a second declaration for  a   setting  is  encountered, it is
  121%   ignored  if  Type  and  Default  are    the  same.  Otherwise  a
  122%   permission_error is raised.
  123%
  124%   @param Name     Name of the setting (an atom)
  125%   @param Type     Type for setting.  One of =any= or a type defined
  126%                   by must_be/2.
  127%   @param Default  Default value for the setting.
  128%   @param Comment  Atom containing a (short) descriptive note.
  129
  130
  131setting(Name, Type, Default, Comment) :-
  132    throw(error(context_error(nodirective,
  133                              setting(Name, Type, Default, Comment)),
  134                _)).
  135
  136:- multifile
  137    system:term_expansion/2.  138
  139system:term_expansion((:- setting(QName, Type, Default, Comment)),
  140                    Expanded) :-
  141    \+ current_prolog_flag(xref, true),
  142    prolog_load_context(module, M0),
  143    strip_module(M0:QName, Module, Name),
  144    must_be(atom, Name),
  145    to_atom(Comment, CommentAtom),
  146    eval_default(Default, Module, Type, Value),
  147    check_type(Type, Value),
  148    source_location(File, Line),
  149    (   current_setting(Name, Module, OType, ODef, _, OldLoc),
  150        (   OType \=@= Type
  151        ;    ODef \=@= Default
  152        ),
  153        OldLoc \= (File:_)
  154    ->  format(string(Message),
  155               'Already defined at: ~w', [OldLoc]),
  156        throw(error(permission_error(redefine, setting, Module:Name),
  157                    context(Message, _)))
  158    ;   Expanded = settings:current_setting(Name, Module, Type, Default,
  159                                            CommentAtom, File:Line)
  160    ).
  161
  162to_atom(Atom, Atom) :-
  163    atom(Atom),
  164    !.
  165to_atom(String, Atom) :-
  166    format(atom(Atom), '~s', String).
  167
  168%!  setting(:Name, ?Value) is nondet.
  169%
  170%   True when Name is a currently   defined setting with Value. Note
  171%   that setting(Name, Value) only enumerates   the  settings of the
  172%   current  module.  All  settings   can    be   enumerated   using
  173%   setting(Module:Name, Value). This predicate is  =det= if Name is
  174%   ground.
  175%
  176%   @error  existence_error(setting, Name)
  177
  178setting(Module:Name, Value) :-
  179    (   nonvar(Name), nonvar(Module)
  180    ->  (   st_value(Name, Module, Value0)
  181        ->  Value = Value0
  182        ;   curr_setting(Name, Module, Type, Default, _, _)
  183        ->  eval_default(Default, Module, Type, Value)
  184        ;   existence_error(setting, Module:Name)
  185        )
  186    ;   current_setting(Name, Module, _, _, _, _),
  187        setting(Module:Name, Value)
  188    ).
  189
  190
  191:- dynamic
  192    setting_cache/3.  193:- volatile
  194    setting_cache/3.  195
  196%!  clear_setting_cache is det.
  197%
  198%   Clear the cache for evaluation of default values.
  199
  200clear_setting_cache :-
  201    retractall(setting_cache(_,_,_)).
  202
  203%!  eval_default(+Default, +Module, +Type, -Value) is det.
  204%
  205%   Convert the settings default value. The notation allows for some
  206%   `function-style' notations to make the library more generic:
  207%
  208%           * env(Name)
  209%           Get value from the given environment variable. The value
  210%           is handed to convert_setting_text/3 to convert the
  211%           textual representation into a Prolog term.  Raises an
  212%           existence_error of the variable is not defined.
  213%
  214%           * env(Name, Default)
  215%           As env(Name), but uses the value Default if the variable
  216%           is not defined.
  217%
  218%           * setting(Name)
  219%           Ask the value of another setting.
  220%
  221%           * Expression
  222%           If Type is numeric, evaluate the expression.  env(Var)
  223%           evaluates to the value of an environment variable.
  224%           If Type is =atom=, concatenate A+B+....  Elements of the
  225%           expression can be env(Name).
  226
  227:- multifile
  228    eval_default/3.                 % +Default, +Type, -Value
  229
  230eval_default(Default, _, _Type, Value) :-
  231    var(Default),
  232    !,
  233    Value = Default.
  234eval_default(Default, _, Type, Value) :-
  235    eval_default(Default, Type, Val),
  236    !,
  237    Value = Val.
  238eval_default(Default, _, _, Value) :-
  239    atomic(Default),
  240    !,
  241    Value = Default.
  242eval_default(Default, _, Type, Value) :-
  243    setting_cache(Default, Type, Val),
  244    !,
  245    Value = Val.
  246eval_default(env(Name), _, Type, Value) :-
  247    !,
  248    (   getenv(Name, TextValue)
  249    ->  convert_setting_text(Type, TextValue, Val),
  250        assert(setting_cache(env(Name), Type, Val)),
  251        Value = Val
  252    ;   existence_error(environment_variable, Name)
  253    ).
  254eval_default(env(Name, Default), _, Type, Value) :-
  255    !,
  256    (   getenv(Name, TextValue)
  257    ->  convert_setting_text(Type, TextValue, Val)
  258    ;   Val = Default
  259    ),
  260    assert(setting_cache(env(Name), Type, Val)),
  261    Value = Val.
  262eval_default(setting(Name), Module, Type, Value) :-
  263    !,
  264    strip_module(Module:Name, M, N),
  265    setting(M:N, Value),
  266    must_be(Type, Value).
  267eval_default(Expr, _, Type, Value) :-
  268    numeric_type(Type, Basic),
  269    !,
  270    arithmetic_expression_value(Expr, Val0),
  271    (   Basic == float
  272    ->  Val is float(Val0)
  273    ;   Basic = integer
  274    ->  Val is round(Val0)
  275    ;   Val = Val0
  276    ),
  277    assert(setting_cache(Expr, Type, Val)),
  278    Value = Val.
  279eval_default(A+B, Module, atom, Value) :-
  280    !,
  281    phrase(expr_to_list(A+B, Module), L),
  282    atomic_list_concat(L, Val),
  283    assert(setting_cache(A+B, atom, Val)),
  284    Value = Val.
  285eval_default(List, Module, list(Type), Value) :-
  286    !,
  287    eval_list_default(List, Module, Type, Val),
  288    assert(setting_cache(List, list(Type), Val)),
  289    Value = Val.
  290eval_default(Default, _, _, Default).
  291
  292
  293%!  eval_list_default(+List, +Module, +ElementType, -DefaultList)
  294%
  295%   Evaluate the default for a list of values.
  296
  297eval_list_default([], _, _, []).
  298eval_list_default([H0|T0], Module, Type, [H|T]) :-
  299    eval_default(H0, Module, Type, H),
  300    eval_list_default(T0, Module, Type, T).
  301
  302%!  expr_to_list(+Expression, +Module)// is det.
  303%
  304%   Process the components to create an  atom. Atom concatenation is
  305%   expressed as A+B. Components may refer to envrionment variables.
  306
  307expr_to_list(A+B, Module) -->
  308    !,
  309    expr_to_list(A, Module),
  310    expr_to_list(B, Module).
  311expr_to_list(env(Name), _) -->
  312    !,
  313    (   { getenv(Name, Text) }
  314    ->  [Text]
  315    ;   { existence_error(environment_variable, Name) }
  316    ).
  317expr_to_list(env(Name, Default), _) -->
  318    !,
  319    (   { getenv(Name, Text) }
  320    ->  [Text]
  321    ;   [Default]
  322    ).
  323expr_to_list(setting(Name), Module) -->
  324    !,
  325    { strip_module(Module:Name, M, N),
  326      setting(M:N, Value)
  327    },
  328    [ Value ].
  329expr_to_list(A, _) -->
  330    [A].
  331
  332%!  env(+Name:atom, -Value:number) is det.
  333%!  env(+Name:atom, +Default:number, -Value:number) is det
  334%
  335%   Evaluate  environment  variables   on    behalf   of  arithmetic
  336%   expressions.
  337
  338:- arithmetic_function(env/1).  339:- arithmetic_function(env/2).  340
  341env(Name, Value) :-
  342    (   getenv(Name, Text)
  343    ->  convert_setting_text(number, Text, Value)
  344    ;   existence_error(environment_variable, Name)
  345    ).
  346env(Name, Default, Value) :-
  347    (   getenv(Name, Text)
  348    ->  convert_setting_text(number, Text, Value)
  349    ;   Value = Default
  350    ).
  351
  352
  353%!  numeric_type(+Type, -BaseType)
  354%
  355%   True if Type is a numeric type   and  BaseType is the associated
  356%   basic Prolog type. BaseType is  one   of  =integer=,  =float= or
  357%   =number=.
  358
  359numeric_type(integer, integer).
  360numeric_type(nonneg, integer).
  361numeric_type(float, float).
  362numeric_type(between(L,_), Type) :-
  363    ( integer(L) -> Type = integer ; Type = float ).
  364
  365
  366%!  set_setting(:Name, +Value) is det.
  367%
  368%   Change a setting. Performs existence   and type-checking for the
  369%   setting. If the effective value  of   the  setting is changed it
  370%   broadcasts the event below.
  371%
  372%           settings(changed(Module:Name, Old, New))
  373%
  374%   @error  existence_error(setting, Name)
  375%   @error  type_error(Type, Value)
  376
  377set_setting(QName, Value) :-
  378    strip_module(QName, Module, Name),
  379    must_be(atom, Name),
  380    (   curr_setting(Name, Module, Type, Default0, _Comment, _Src),
  381        eval_default(Default0, Module, Type, Default)
  382    ->  setting(Module:Name, Old),
  383        (   Value == Default
  384        ->  retract_setting(Module:Name)
  385        ;   st_value(Name, Module, Value)
  386        ->  true
  387        ;   check_type(Type, Value)
  388        ->  retract_setting(Module:Name),
  389            assert_setting(Module:Name, Value)
  390        ),
  391        (   Old == Value
  392        ->  true
  393        ;   broadcast(settings(changed(Module:Name, Old, Value))),
  394            clear_setting_cache     % might influence dependent settings
  395        )
  396    ;   existence_error(setting, Name)
  397    ).
  398
  399retract_setting(Module:Name) :-
  400    retractall(st_value(Name, Module, _)).
  401
  402assert_setting(Module:Name, Value) :-
  403    assert(st_value(Name, Module, Value)).
  404
  405%!  restore_setting(:Name) is det.
  406%
  407%   Restore the value of setting Name   to  its default. Broadcast a
  408%   change like set_setting/2 if  the  current   value  is  not  the
  409%   default.
  410
  411restore_setting(QName) :-
  412    strip_module(QName, Module, Name),
  413    must_be(atom, Name),
  414    (   st_value(Name, Module, Old)
  415    ->  retract_setting(Module:Name),
  416        setting(Module:Name, Value),
  417        (   Old \== Value
  418        ->  broadcast(settings(changed(Module:Name, Old, Value)))
  419        ;   true
  420        )
  421    ;   true
  422    ).
  423
  424%!  set_setting_default(:Name, +Default) is det.
  425%
  426%   Change the default for a setting.  The   effect  is  the same as
  427%   set_setting/2, but the new value is  considered the default when
  428%   saving and restoring  a  setting.  It   is  intended  to  change
  429%   application defaults in a particular context.
  430
  431set_setting_default(QName, Default) :-
  432    strip_module(QName, Module, Name),
  433    must_be(atom, Name),
  434    (   current_setting(Name, Module, Type, Default0, _Comment, _Src)
  435    ->  retractall(settings:st_default(Name, Module, _)),
  436        retract_setting(Module:Name),
  437        (   Default == Default0
  438        ->  true
  439        ;   assert(settings:st_default(Name, Module, Default))
  440        ),
  441        eval_default(Default, Module, Type, Value),
  442        set_setting(Module:Name, Value)
  443    ;   existence_error(setting, Module:Name)
  444    ).
  445
  446
  447                 /*******************************
  448                 *             TYPES            *
  449                 *******************************/
  450
  451%!  check_type(+Type, +Term)
  452%
  453%   Type  checking  for  settings.  Currently  simply  forwarded  to
  454%   must_be/2.
  455
  456check_type(Type, Term) :-
  457    must_be(Type, Term).
  458
  459
  460                 /*******************************
  461                 *             FILE             *
  462                 *******************************/
  463
  464%!  load_settings(File) is det.
  465%!  load_settings(File, +Options) is det.
  466%
  467%   Load local settings from File. Succeeds  if File does not exist,
  468%   setting the default save-file to File.  Options are:
  469%
  470%     * undefined(+Action)
  471%     Define how to handle settings that are not defined.  When
  472%     =error=, an error is printed and the setting is ignored.
  473%     when =load=, the setting is loaded anyway, waiting for a
  474%     definition.
  475
  476load_settings(File) :-
  477    load_settings(File, []).
  478
  479load_settings(File, Options) :-
  480    absolute_file_name(File, Path,
  481                       [ access(read),
  482                         file_errors(fail)
  483                       ]),
  484    !,
  485    assert(local_file(Path)),
  486    open(Path, read, In, [encoding(utf8)]),
  487    read_setting(In, T0),
  488    call_cleanup(load_settings(T0, In, Options), close(In)),
  489    clear_setting_cache.
  490load_settings(File, _) :-
  491    absolute_file_name(File, Path,
  492                       [ access(write),
  493                         file_errors(fail)
  494                       ]),
  495    !,
  496    assert(local_file(Path)).
  497load_settings(_, _).
  498
  499load_settings(end_of_file, _, _) :- !.
  500load_settings(Setting, In, Options) :-
  501    catch(store_setting(Setting, Options), E,
  502          print_message(warning, E)),
  503    read_setting(In, Next),
  504    load_settings(Next, In, Options).
  505
  506read_setting(In, Term) :-
  507    read_term(In, Term,
  508              [ syntax_errors(dec10)
  509              ]).
  510
  511%!  store_setting(Term, +Options)
  512%
  513%   Store setting loaded from file in the Prolog database.
  514
  515store_setting(setting(Module:Name, Value), _) :-
  516    curr_setting(Name, Module, Type, Default0, _Commentm, _Src),
  517    !,
  518    eval_default(Default0, Module, Type, Default),
  519    (   Value == Default
  520    ->  true
  521    ;   check_type(Type, Value)
  522    ->  retractall(st_value(Name, Module, _)),
  523        assert(st_value(Name, Module, Value)),
  524        broadcast(settings(changed(Module:Name, Default, Value)))
  525    ).
  526store_setting(setting(Module:Name, Value), Options) :-
  527    !,
  528    (   option(undefined(load), Options, load)
  529    ->  retractall(st_value(Name, Module, _)),
  530        assert(st_value(Name, Module, Value))
  531    ;   existence_error(setting, Module:Name)
  532    ).
  533store_setting(Term, _) :-
  534    type_error(setting, Term).
  535
  536%!  save_settings is det.
  537%!  save_settings(+File) is det.
  538%
  539%   Save modified settings to File.
  540
  541save_settings :-
  542    local_file(File),
  543    !,
  544    save_settings(File).
  545
  546save_settings(File) :-
  547    absolute_file_name(File, Path,
  548                       [ access(write)
  549                       ]),
  550    !,
  551    open(Path, write, Out,
  552         [ encoding(utf8),
  553           bom(true)
  554         ]),
  555    write_setting_header(Out),
  556    forall(current_setting(Name, Module, _, _, _, _),
  557           save_setting(Out, Module:Name)),
  558    close(Out).
  559
  560
  561write_setting_header(Out) :-
  562    get_time(Now),
  563    format_time(string(Date), '%+', Now),
  564    format(Out, '/*  Saved settings~n', []),
  565    format(Out, '    Date: ~w~n', [Date]),
  566    format(Out, '*/~n~n', []).
  567
  568save_setting(Out, Module:Name) :-
  569    curr_setting(Name, Module, Type, Default, Comment, _Src),
  570    (   st_value(Name, Module, Value),
  571        \+ ( eval_default(Default, Module, Type, DefValue),
  572             debug(setting, '~w <-> ~w~n', [DefValue, Value]),
  573             DefValue =@= Value
  574           )
  575    ->  format(Out, '~n%\t~w~n', [Comment]),
  576        format(Out, 'setting(~q:~q, ~q).~n', [Module, Name, Value])
  577    ;   true
  578    ).
  579
  580%!  current_setting(?Setting) is nondet.
  581%
  582%   True if Setting is a currently defined setting
  583
  584current_setting(Setting) :-
  585    ground(Setting),
  586    !,
  587    strip_module(Setting, Module, Name),
  588    current_setting(Name, Module, _, _, _, _).
  589current_setting(Module:Name) :-
  590    current_setting(Name, Module, _, _, _, _).
  591
  592%!  setting_property(+Setting, +Property) is det.
  593%!  setting_property(?Setting, ?Property) is nondet.
  594%
  595%   Query currently defined settings.  Property is one of
  596%
  597%           * comment(-Atom)
  598%           * type(-Type)
  599%           Type of the setting.
  600%           * default(-Default)
  601%           Default value.  If this is an expression, it is
  602%           evaluated.
  603%           * source(-File:-Line)
  604%           Location where the setting is defined.
  605
  606setting_property(Setting, Property) :-
  607    ground(Setting),
  608    !,
  609    Setting = Module:Name,
  610    curr_setting(Name, Module, Type, Default, Comment, Src),
  611    !,
  612    setting_property(Property, Module, Type, Default, Comment, Src).
  613setting_property(Setting, Property) :-
  614    Setting = Module:Name,
  615    curr_setting(Name, Module, Type, Default, Comment, Src),
  616    setting_property(Property, Module, Type, Default, Comment, Src).
  617
  618setting_property(type(Type), _, Type, _, _, _).
  619setting_property(default(Default), M, Type, Default0, _, _) :-
  620    eval_default(Default0, M, Type, Default).
  621setting_property(comment(Comment), _, _, _, Comment, _).
  622setting_property(source(Src), _, _, _, _, Src).
  623
  624%!  list_settings is det.
  625%!  list_settings(+Module) is det.
  626%
  627%   List settings to =current_output=. The   second  form only lists
  628%   settings on the matching module.
  629%
  630%   @tbd    Compute the required column widths
  631
  632list_settings :-
  633    list_settings(_).
  634
  635list_settings(Spec) :-
  636    spec_term(Spec, Term),
  637    TS1 = 25,
  638    TS2 = 40,
  639    format('~`=t~72|~n'),
  640    format('~w~t~*| ~w~w~t~*| ~w~n',
  641           ['Name', TS1, 'Value (*=modified)', '', TS2, 'Comment']),
  642    format('~`=t~72|~n'),
  643    forall(current_setting(Term),
  644           list_setting(Term, TS1, TS2)).
  645
  646spec_term(M:S, M:S) :- !.
  647spec_term(M, M:_).
  648
  649
  650list_setting(Module:Name, TS1, TS2) :-
  651    curr_setting(Name, Module, Type, Default0, Comment, _Src),
  652    eval_default(Default0, Module, Type, Default),
  653    setting(Module:Name, Value),
  654    (   Value \== Default
  655    ->  Modified = (*)
  656    ;   Modified = ''
  657    ),
  658    format('~w~t~*| ~q~w~t~*| ~w~n', [Module:Name, TS1, Value, Modified, TS2, Comment]).
  659
  660
  661                 /*******************************
  662                 *            TYPES             *
  663                 *******************************/
  664
  665%!  convert_setting_text(+Type, +Text, -Value)
  666%
  667%   Converts from textual form to  Prolog   Value.  Used  to convert
  668%   values obtained from the environment.  Public to provide support
  669%   in user-interfaces to this library.
  670%
  671%   @error  type_error(Type, Value)
  672
  673:- multifile
  674    convert_text/3.                 % +Type, +Text, -Value
  675
  676convert_setting_text(Type, Text, Value) :-
  677    convert_text(Type, Text, Value),
  678    !.
  679convert_setting_text(atom, Value, Value) :-
  680    !,
  681    must_be(atom, Value).
  682convert_setting_text(boolean, Value, Value) :-
  683    !,
  684    must_be(boolean, Value).
  685convert_setting_text(integer, Atom, Number) :-
  686    !,
  687    term_to_atom(Term, Atom),
  688    Number is round(Term).
  689convert_setting_text(float, Atom, Number) :-
  690    !,
  691    term_to_atom(Term, Atom),
  692    Number is float(Term).
  693convert_setting_text(between(L,U), Atom, Number) :-
  694    !,
  695    (   integer(L)
  696    ->  convert_setting_text(integer, Atom, Number)
  697    ;   convert_setting_text(float, Atom, Number)
  698    ),
  699    must_be(between(L,U), Number).
  700convert_setting_text(Type, Atom, Term) :-
  701    term_to_atom(Term, Atom),
  702    must_be(Type, Term).
  703
  704
  705                 /*******************************
  706                 *            SANDBOX           *
  707                 *******************************/
  708
  709:- multifile
  710    sandbox:safe_meta_predicate/1.  711
  712sandbox:safe_meta_predicate(settings:setting/2)