Subversion Repositories Kolibri OS

#define __mathuserfunc_h__

#include "lispuserfunc.h"

#include "grower.h"

/// This is the basic class which implements functions in Yacas.

/// Evaluation is done by consulting a set of rewriting rules. The

/// body of the first rule that matches, is evaluated and this gives

/// the result of evaluating the function.

{

public:

  /// Structure containing name of parameter and whether it is put on hold.

  class BranchParameter : public YacasBase

  {

  public:

    BranchParameter(LispString * aParameter = NULL, LispInt aHold=LispFalse)

        : iParameter(aParameter), iHold(aHold) {}

    LispString * iParameter;

    LispInt       iHold;

  };

  class BranchRuleBase : public YacasBase

  {

  public:

    virtual ~BranchRuleBase();

    virtual LispBoolean Matches(LispEnvironment& aEnvironment, LispPtr* aArguments) = 0;

    virtual LispInt Precedence() const = 0;

    virtual LispPtr& Body() = 0;

  };

  /// This rule matches if the predicate evaluates to #LispTrue.

  class BranchRule : public BranchRuleBase

  {

  public:

    virtual ~BranchRule();

    BranchRule(LispInt aPrecedence,LispPtr& aPredicate,LispPtr& aBody) : iPrecedence(aPrecedence),iBody(aBody),iPredicate(aPredicate)

    {

    }

    /// #iPredicate is evaluated in \a Environment. If the result

    /// IsTrue(), this function returns true.

    virtual LispBoolean Matches(LispEnvironment& aEnvironment, LispPtr* aArguments);

    virtual LispInt Precedence() const;

    virtual LispPtr& Body();

  protected:

    BranchRule() : iPrecedence(0),iBody(),iPredicate() {};

  protected:

    LispInt iPrecedence;

    LispPtr iBody;

    LispPtr iPredicate;

  };

  class BranchRuleTruePredicate : public BranchRule

  {

  public:

    BranchRuleTruePredicate(LispInt aPrecedence,LispPtr& aBody)

    {

      iPrecedence = aPrecedence;

      iBody = (aBody);

    }

    /// Return #LispTrue, always.

    virtual LispBoolean Matches(LispEnvironment& aEnvironment, LispPtr* aArguments);

  };

  class BranchPattern : public BranchRuleBase

  {

  public:

    /// Destructor.

    /// This function contains no code.

    virtual ~BranchPattern();

    /// \param aPrecedence precedence of the rule

    /// \param aPredicate generic object of type \c Pattern

    /// \param aBody body of the rule

    BranchPattern(LispInt aPrecedence,LispPtr& aPredicate,LispPtr& aBody) : iPrecedence(aPrecedence),iBody(aBody),iPredicate(aPredicate),iPatternClass(NULL)

    {

      GenericClass *gen = aPredicate->Generic();

      DYNCAST(PatternClass,"\"Pattern\"",pat,gen)

      Check(pat,KLispErrInvalidArg);

      iPatternClass = pat;

    }

    virtual LispBoolean Matches(LispEnvironment& aEnvironment, LispPtr* aArguments);

    virtual LispInt Precedence() const;

    virtual LispPtr& Body();

    BranchPattern(const BranchPattern& aOther) : iPrecedence(0),iBody(),iPredicate(),iPatternClass(NULL)

    {

      // copy constructor not written yet, hence the assert

      LISPASSERT(0);

    }

    BranchPattern& operator=(const BranchPattern& aOther)

    {

      // copy constructor not written yet, hence the assert

      LISPASSERT(0);

      return *this;

    }

    /// The precedence of this rule.

    LispInt iPrecedence;

    LispPtr iBody;

    LispPtr iPredicate;

    PatternClass *iPatternClass;

  };

  /// \param aParameters linked list constaining the names of the arguments

  ///

  /// #iParamList and #iParameters are set from \a aParameters.

  BranchingUserFunction(LispPtr& aParameters);

  /// There is no code inside this function.

  virtual ~BranchingUserFunction();

  /// \param aResult (on output) the result of the evaluation

  /// \param aEnvironment the underlying Lisp environment

  /// \param aArguments the arguments to the function

  ///

  /// First, all arguments are evaluated by the evaluator associated

  /// to \a aEnvironment, unless the \c iHold flag of the

  /// corresponding parameter is true. Then a new LispLocalFrame is

  /// constructed, in which the actual arguments are assigned to the

  /// names of the formal arguments, as stored in \c iParameter. Then

  /// all rules in #iRules are tried one by one. The body of the

  /// first rule that matches is evaluated, and the result is put in

  /// \a aResult. If no rule matches, \a aResult will recieve a new

  /// expression with evaluated arguments.

  virtual void Evaluate(LispPtr& aResult,LispEnvironment& aEnvironment, LispPtr& aArguments);

  /// \param aVariable name of argument to put un hold

  ///

  /// The \c iHold flag of the corresponding argument is set. This

  /// implies that this argument is not evaluated by Evaluate().

  virtual void HoldArgument(LispString * aVariable);

  virtual LispInt IsArity(LispInt aArity) const;

  LispInt Arity() const;

  /// \sa InsertRule()

  virtual void DeclareRule(LispInt aPrecedence, LispPtr& aPredicate, LispPtr& aBody);

  /// \sa InsertRule()

  virtual void DeclareRule(LispInt aPrecedence, LispPtr& aBody);

  /// \sa InsertRule()

  void DeclarePattern(LispInt aPrecedence, LispPtr& aPredicate, LispPtr& aBody);

  /// This function does the real work for DeclareRule() and

  /// DeclarePattern(): it inserts the rule in #iRules, while

  /// keeping it sorted. The algorithm is \f$O(\log n)\f$, where

  /// \f$n\f$ denotes the number of rules.

  void InsertRule(LispInt aPrecedence,BranchRuleBase* newRule);

  virtual LispPtr& ArgList();

  /// List of arguments, with corresponding \c iHold property.

  CArrayGrower > iParameters;

  CDeletingArrayGrower >     iRules;

  LispPtr iParamList;

};

{

public:

  ListedBranchingUserFunction(LispPtr& aParameters);

  virtual LispInt IsArity(LispInt aArity) const;

  virtual void Evaluate(LispPtr& aResult,LispEnvironment& aEnvironment, LispPtr& aArguments);

};

{

public:

  MacroUserFunction(LispPtr& aParameters);

  virtual void Evaluate(LispPtr& aResult,LispEnvironment& aEnvironment, LispPtr& aArguments);

};

{

public:

  ListedMacroUserFunction(LispPtr& aParameters);

  virtual LispInt IsArity(LispInt aArity) const;

  virtual void Evaluate(LispPtr& aResult,LispEnvironment& aEnvironment, LispPtr& aArguments);

};