uPDF with buttons

git-svn-id: svn://kolibrios.org@4680 a494cfbc-eb01-0410-851d-a64ba20cac60

contrib/media/updf/include/lispuserfunc.h

@@ -0,0 +1,127 @@
+
+
+#ifndef __lispuserfunc_h__
+#define __lispuserfunc_h__
+
+#include "yacasbase.h"
+#include "lispobject.h"
+#include "lispenvironment.h"
+#include "lisphash.h"
+#include "grower.h"
+#include "evalfunc.h"
+
+/// Abstract class providing the basic user function API.
+/// Instances of this class are associated to the name of the function
+/// via an associated hash table. When obtained, they can be used to
+/// evaluate the function with some arguments.
+
+class LispUserFunction : public EvalFuncBase
+{
+public:
+    LispUserFunction() : iFenced(LispTrue),iTraced(LispFalse) {};
+    virtual ~LispUserFunction();
+    virtual void Evaluate(LispPtr& aResult,LispEnvironment& aEnvironment,
+                  LispPtr& aArguments)=0;
+    virtual void HoldArgument(LispString * aVariable) = 0;
+    virtual void DeclareRule(LispInt aPrecedence, LispPtr& aPredicate,
+                             LispPtr& aBody) = 0;
+    virtual void DeclareRule(LispInt aPrecedence, LispPtr& aBody) = 0;
+    virtual void DeclarePattern(LispInt aPrecedence, LispPtr& aPredicate,
+                             LispPtr& aBody) = 0;
+    virtual LispPtr& ArgList() = 0;
+
+public: //unfencing
+    inline void UnFence() {iFenced = LispFalse;};
+    inline LispBoolean Fenced() {return iFenced;};
+public: //tracing
+    inline void Trace() {iTraced = LispTrue;};
+    inline void UnTrace() {iTraced = LispFalse;};
+    inline LispBoolean Traced() {return iTraced;};
+private:
+    LispBoolean iFenced;
+    LispBoolean iTraced;
+};
+
+
+/// User function with a specific arity.
+/// This is still an abstract class, but the arity (number of
+/// arguments) of the function is now fixed.
+
+class LispArityUserFunction : public LispUserFunction
+{
+public:
+    virtual LispInt Arity() const = 0;
+    virtual LispInt IsArity(LispInt aArity) const = 0;
+};
+
+
+class LispDefFile;
+
+
+/// Set of LispArityUserFunction's.
+/// By using this class, you can associate multiple functions (with
+/// different arities) to one name. A specific LispArityUserFunction
+/// can be selected by providing its name. Additionally, the name of
+/// the file in which the function is defined, can be specified.
+
+class LispMultiUserFunction : public YacasBase
+{
+public:
+  /// Constructor.
+  LispMultiUserFunction() : iFunctions(),iFileToOpen(NULL) {};
+
+  /** When adding a multi-user function to the association hash table, the copy constructor is used.
+   *  We should at least make sure that iFunctions is empty, so there is no copying needed (for efficiency).
+   *  Casually having a copy-constructor on CDeletingArrayGrower should be avoided, to make sure it is
+   *  not used accidentally.
+   */
+  inline LispMultiUserFunction(const LispMultiUserFunction& aOther) : iFunctions(), iFileToOpen(NULL)
+  {
+    LISPASSERT(aOther.iFileToOpen == 0);
+    LISPASSERT(aOther.iFunctions.Size() == 0);
+  }
+  inline LispMultiUserFunction& operator=(const LispMultiUserFunction& aOther)
+  {
+    // copy constructor not written yet, hence the assert
+    LISPASSERT(aOther.iFileToOpen == 0);
+    LISPASSERT(aOther.iFunctions.Size() == 0);
+
+    LISPASSERT(iFileToOpen == 0);
+    LISPASSERT(iFunctions.Size() == 0);
+    return *this;
+  }
+
+  /// Return user function with given arity.
+  LispUserFunction* UserFunc(LispInt aArity);
+
+  /// Destructor.
+  virtual ~LispMultiUserFunction();
+
+  /// Specify that some argument should be held.
+  virtual void HoldArgument(LispString * aVariable);
+
+  /// Add another LispArityUserFunction to #iFunctions.
+  virtual void DefineRuleBase(LispArityUserFunction* aNewFunction);
+
+  /// Delete tuser function with given arity.
+  virtual void DeleteBase(LispInt aArity);
+
+private:
+  /// Set of LispArityUserFunction's provided by this LispMultiUserFunction.
+  CDeletingArrayGrower<LispArityUserFunction*, ArrOpsDeletingPtr<LispArityUserFunction> > iFunctions;
+
+public:
+  /// File to read for the definition of this function.
+  LispDefFile* iFileToOpen;
+};
+
+
+/// Associated hash of LispMultiUserFunction objects.
+
+class LispUserFunctions : public LispAssociatedHash<LispMultiUserFunction>
+{
+};
+
+
+#endif
+