toplevel.pl

:- module(
  toplevel,
  [
    execute_command/1,
    toplevel/0,
    quit/0,
    command/1
  ]).


toplevel :-
  loop.


loop :-
  repeat,
  \+ read_execute_print.


read_execute_print :-
  read_command(Command),
  (
    Command = end_of_file
  ->
    nl,
    quit
  ;
    execute_command(Command)
  ).


:- dynamic(prompt/1).


prompt('biocham: ').


set_prompt(NewPrompt) :-
  retract(prompt(_OldPrompt)),
  asserta(prompt(NewPrompt)).


read_command(Command) :-
  prompt(Prompt),
  read_history('', '', [], Prompt, Command, VariableNames),
  name_variables_and_anonymous(Command, VariableNames).


execute_command(Command) :-
  catch(
    (
      command(Command)
    ->
      true
    ;
      throw(error(prolog_failure))
    ),
    Exception,
    print_exception(Exception)
  ).


print_exception(Exception) :-
  (
    Exception = error(Error),
    error_message(Error, Message)
  ->
    format('~w\n', Message)
  ;
    format('Uncaught exception: ~p\n', Exception)
  ).


error_message(unknown_command(Command), Message) :-
  format(atom(Message), 'Unknown command: ~p', [Command]).


error_message(prolog_failure, Message) :-
  format(atom(Message), 'Prolog failure', []).


check_types(Command, ArgumentTypes, NewCommand) :-
  Command =.. [Functor | Arguments],
  findall(
    NewArgument,
    (
      nth0(Index, Arguments, Argument),
      nth0(Index, ArgumentTypes, ArgumentType),
      (
        var(ArgumentType)
      ->
        NewArgument = Argument
      ;
        catch(
          (
            check_type(ArgumentType, Argument, NewArgument)
          ->
            true
          ;
            throw(error(failure))
          ),
          error(Type),
          throw(error(invalid_type(Argument, Type)))
        )
      )
    ),
    NewArguments
  ),
  NewCommand =.. [Functor | NewArguments].


command(Command) :-
  functor(Command, Functor, Arity),
  (
    (
      predicate_info(Functor/Arity, ArgumentTypes, yes, _)
    ->
      Command0 = Command
    ;
      between(1, Arity, Arity0),
      predicate_info(Functor/Arity0, ArgumentTypes, variantargs, _)
    ->
      Command =.. [Functor | Arguments],
      PrefixLength is Arity0 - 1,
      length(Prefix, PrefixLength),
      append(Prefix, Tail, Arguments),
      append(Prefix, [Tail], NewArguments),
      Command0 =.. [Functor | NewArguments]
    )
  ->
    check_types(Command0, ArgumentTypes, NewCommand),
    NewCommand
  ;
    rule(Command)
  ->
    add_rule(Command)
  ;
    throw(error(unknown_command(Functor/Arity)))
  ).


quit :-
  biocham_command,
  doc('quits the interpreter.'),
  halt.