-- Basic LispM evaluator, based on the following rules:
--
-- - LispM constants, i.e. booleans, numbers, characters, builtins and
--  closures are returned as they are.
--
-- - Symbols have their values looked up in the current (lexical) Env
--  or, if not found, in the (dynamic) Global_Env; the first value found
--  is returned; if no bindings are found, an error message is returned.
--
-- - Cons objects are interpreted as function applications, i.e. for any
--  list L, car(L) is evaluated and applied upon cdr(L); if car(L) is
--  not a closure or a builtin, then an error message is returned.
--
-- A large subset of this module is dedicated to the implementation of
--  builtin functions and keywords. An explicit distinction between
--  keywords and functions is not made at this point, i.e. the
--  distinction is implicit in e.g. the way arguments are evaluated.

with LispM; use LispM;

package Evaler is
   
   -- Arithmetic and logic functions
   type ALUFunc is (ALU_Add, ALU_Sub, ALU_Mul, ALU_Div);
   -- Unary predicates
   type UPred is (UPred_Pair, UPred_Bool, UPred_Num, UPred_Sym,
                  UPred_Nil, UPred_List);
   -- And/or conditional forms
   type AndOr is (AndOr_And, AndOr_Or);
   
   -- Application routines for builtin functions. These should be
   --  self-explanatory.
   procedure Apply_ALU_Func(Func : in ALUFunc;
                            Args : in MemPtr;
                            Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_UPred(Pred : in UPred;
                         Args : in MemPtr;
                         Env : in MemPtr;
                         OutP : out MemPtr);
   procedure Apply_AndOr(Cond : in AndOr;
                         Args : in MemPtr;
                         Env : in MemPtr;
                         OutP : out MemPtr);

   procedure Apply_QuoteB(Args : in MemPtr; OutP : out MemPtr);
   procedure Apply_EvalB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_IfB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_ConsB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_CarB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_CdrB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_ListB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_ApplyB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_DefineB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_SetB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_EqnB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_EqB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_EqvB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_NotB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_LambdaB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_LetB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_ReverseB(Args, Env : in MemPtr; OutP : out MemPtr);
   procedure Apply_AppendB(Args, Env : in MemPtr; OutP : out MemPtr);
   
   -- Application routine for closures
   procedure Apply_Closure(Op, Args, Env : in MemPtr; OutP : out MemPtr);
   
   -- Apply function with name identified by Op, on Args.
   procedure Apply_Func(Op, Args, Env : in MemPtr;
                        Meta : in Boolean;
                        OutP : out MemPtr);
   
   -- Evaluate a list element by element.
   procedure Eval_List(List, Env : in MemPtr; OutP : out MemPtr);
   
   -- Eval S-expression
   procedure Eval(InP, Env : in MemPtr; OutP : out MemPtr);
   
   -- Other usefuls: reverse append, reverse in place, boolean
   --  value. XXX: move these somewhere else.
   procedure Rev_Append(A, B : in MemPtr; OutP : out MemPtr);   
   procedure Rev_In_Place(List, Default : in MemPtr; OutP : out MemPtr);
   function Boolean_Value(P : MemPtr) return Boolean;
end Evaler;