710 lines
18 KiB
C++
710 lines
18 KiB
C++
/** \file lispenvironment.h
|
|
* General environment access.
|
|
*
|
|
*/
|
|
|
|
|
|
#ifndef __lispenvironment_h__
|
|
#define __lispenvironment_h__
|
|
|
|
#include "yacasbase.h"
|
|
#include "lispobject.h"
|
|
#include "lisphash.h"
|
|
#include "lispevalhash.h"
|
|
#include "lispcleanupstack.h"
|
|
#include "deffile.h"
|
|
#include "lispio.h"
|
|
#include "stringio.h"
|
|
#include "lispglobals.h"
|
|
#include "xmltokenizer.h"
|
|
#include "errors.h"
|
|
|
|
class CCompressedArchive; /* defined in archiver.h */
|
|
|
|
class LispDefFiles;
|
|
class InputDirectories : public CDeletingArrayGrower<LispString *, ArrOpsDeletingPtr<LispString> >
|
|
{
|
|
};
|
|
|
|
class LispInput;
|
|
class LispOutput;
|
|
class LispPrinter;
|
|
class LispOperators;
|
|
class LispUserFunctions;
|
|
class LispUserFunction;
|
|
class LispMultiUserFunction;
|
|
class LispEvaluatorBase;
|
|
class BasicEvaluator;
|
|
class DefaultDebugger;
|
|
class LispEnvironment;
|
|
|
|
|
|
/// The Lisp environment.
|
|
/// This huge class is the central class of the Yacas program. It
|
|
/// implements a dialect of Lisp.
|
|
|
|
class LispEnvironment : public YacasBase
|
|
{
|
|
public:
|
|
/// \name Constructor and destructor
|
|
//@{
|
|
LispEnvironment(YacasCoreCommands &aCoreCommands,
|
|
LispUserFunctions& aUserFunctions,
|
|
LispGlobal& aGlobals,
|
|
LispHashTable& aHashTable,
|
|
LispOutput* aOutput,
|
|
LispPrinter& aPrinter,
|
|
LispOperators &aPreFixOperators,
|
|
LispOperators &aInFixOperators,
|
|
LispOperators &aPostFixOperators,
|
|
LispOperators &aBodiedOperators,
|
|
LispInput* aCurrentInput,
|
|
LispInt aStackSize);
|
|
~LispEnvironment();
|
|
//@}
|
|
|
|
public:
|
|
/// \name Lisp variables
|
|
//@{
|
|
|
|
/// Assign a value to a Lisp variable.
|
|
/// \param aString name of the variable
|
|
/// \param aValue value to be assigned to \a aString
|
|
///
|
|
/// If there is a local variable with the name \a aString, the
|
|
/// object \a aValue is assigned to it. Otherwise, a
|
|
/// LispGlobalVariable is constructed, and it is associated with
|
|
/// \a aValue in #iGlobals.
|
|
/// \sa FindLocal
|
|
void SetVariable(LispString * aString, LispPtr& aValue, LispBoolean aGlobalLazyVariable);
|
|
|
|
/// In debug mode, DebugModeVerifySettingGlobalVariables raises a warning if a global variable is set.
|
|
void DebugModeVerifySettingGlobalVariables(LispPtr & aVariable, LispBoolean aGlobalLazyVariable);
|
|
|
|
/// Get the value assigned to a variable.
|
|
/// \param aVariable name of the variable
|
|
/// \param aResult (on exit) value of \a aVariable
|
|
///
|
|
/// - If there is a local variable with the name \a aString,
|
|
/// \a aResult is set to point to the value assigned to this local
|
|
/// variable.
|
|
/// - If there is a global variable \a aString and its
|
|
/// #iEvalBeforeReturn is false, its value is returned via
|
|
/// \a aResult.
|
|
/// - If there is a global variable \a aString and its
|
|
/// #iEvalBeforeReturn is true, its value is evaluated. The
|
|
/// result is assigned back to the variable, its
|
|
/// #iEvalBeforeReturn is set to false, and a copy of the result
|
|
/// is returned in \a aResult.
|
|
/// - Otherwise, \a aResult is set to #NULL.
|
|
void GetVariable(LispString * aVariable,LispPtr& aResult);
|
|
|
|
void UnsetVariable(LispString * aString);
|
|
void PushLocalFrame(LispBoolean aFenced);
|
|
void PopLocalFrame();
|
|
void NewLocal(LispString * aVariable,LispObject* aValue);
|
|
void CurrentLocals(LispPtr& aResult);
|
|
//@}
|
|
|
|
public:
|
|
/// \name Lisp functions
|
|
//@{
|
|
|
|
/// Return the #iCoreCommands attribute.
|
|
inline YacasCoreCommands& CoreCommands();
|
|
|
|
/// Add a command to the list of core commands.
|
|
/// \param aEvaluatorFunc C function evaluating the core command
|
|
/// \param aString name of the command
|
|
/// \param aNrArgs number of arguments
|
|
/// \param aFlags flags, see YacasEvaluator::FunctionFlags
|
|
void SetCommand(YacasEvalCaller aEvaluatorFunc, LispChar * aString,LispInt aNrArgs,LispInt aFlags);
|
|
|
|
void RemoveCommand(LispChar * aString);
|
|
void RemoveCoreCommand(LispChar * aString);
|
|
|
|
inline LispHashTable& HashTable();
|
|
LispUserFunction* UserFunction(LispPtr& aArguments);
|
|
LispUserFunction* UserFunction(LispString * aName,LispInt aArity);
|
|
|
|
/// Return LispMultiUserFunction with given name.
|
|
/// \param aArguments name of the multi user function
|
|
///
|
|
/// The table of user functions, #iUserFunctions, is consulted. If
|
|
/// a user function with the given name exists, it is returned.
|
|
/// Otherwise, a new LispMultiUserFunction is constructed, added
|
|
/// to #iUserFunctions, and returned.
|
|
LispMultiUserFunction* MultiUserFunction(LispString * aArguments);
|
|
|
|
LispDefFiles& DefFiles();
|
|
void DeclareRuleBase(LispString * aOperator, LispPtr& aParameters,
|
|
LispInt aListed);
|
|
void DeclareMacroRuleBase(LispString * aOperator, LispPtr& aParameters,
|
|
LispInt aListed);
|
|
void DefineRule(LispString * aOperator,LispInt aArity,
|
|
LispInt aPrecedence, LispPtr& aPredicate,
|
|
LispPtr& aBody);
|
|
void DefineRulePattern(LispString * aOperator,LispInt aArity,
|
|
LispInt aPrecedence, LispPtr& aPredicate,
|
|
LispPtr& aBody);
|
|
|
|
|
|
void UnFenceRule(LispString * aOperator,LispInt aArity);
|
|
void Retract(LispString * aOperator,LispInt aArity);
|
|
void HoldArgument(LispString * aOperator,LispString * aVariable);
|
|
//@}
|
|
|
|
LispString * FindCachedFile(LispChar * aFileName);
|
|
|
|
public:
|
|
/// \name Precision
|
|
//@{
|
|
|
|
/// set precision to a given number of decimal digits
|
|
void SetPrecision(LispInt aPrecision);
|
|
inline LispInt Precision(void) const;
|
|
inline LispInt BinaryPrecision(void) const;
|
|
//@}
|
|
|
|
public:
|
|
inline void SetPrettyPrinter(LispString * aPrettyPrinter);
|
|
inline LispString * PrettyPrinter(void);
|
|
|
|
inline void SetPrettyReader(LispString * aPrettyReader);
|
|
inline LispString * PrettyReader(void);
|
|
|
|
public:
|
|
LispInt GetUniqueId();
|
|
public:
|
|
LispPrinter& CurrentPrinter();
|
|
|
|
public:
|
|
/// \name Operators
|
|
//@{
|
|
LispOperators& PreFix();
|
|
LispOperators& InFix();
|
|
LispOperators& PostFix();
|
|
LispOperators& Bodied();
|
|
//@}
|
|
|
|
public:
|
|
/// \name Input and output
|
|
//@{
|
|
LispInput* CurrentInput();
|
|
void SetCurrentInput(LispInput* aInput);
|
|
public:
|
|
LispOutput* CurrentOutput();
|
|
void SetCurrentOutput(LispOutput* aOutput);
|
|
public:
|
|
void SetUserError(LispChar * aErrorString);
|
|
LispChar * ErrorString(LispInt aError);
|
|
//@}
|
|
|
|
protected:
|
|
/// current precision for user interaction, in decimal and in binary
|
|
LispInt iPrecision;
|
|
LispInt iBinaryPrecision;
|
|
public:
|
|
InputDirectories iInputDirectories;
|
|
DeletingLispCleanup iCleanup;
|
|
LispInt iEvalDepth;
|
|
LispInt iMaxEvalDepth;
|
|
CCompressedArchive *iArchive;
|
|
LispEvaluatorBase* iEvaluator;
|
|
|
|
public: // Error information when some error occurs.
|
|
InputStatus iInputStatus;
|
|
LispInt iSecure;
|
|
public: // pre-found
|
|
RefPtr<LispObject> iTrue;
|
|
RefPtr<LispObject> iFalse;
|
|
|
|
RefPtr<LispObject> iEndOfFile;
|
|
RefPtr<LispObject> iEndStatement;
|
|
RefPtr<LispObject> iProgOpen;
|
|
RefPtr<LispObject> iProgClose;
|
|
RefPtr<LispObject> iNth;
|
|
RefPtr<LispObject> iBracketOpen;
|
|
RefPtr<LispObject> iBracketClose;
|
|
RefPtr<LispObject> iListOpen;
|
|
RefPtr<LispObject> iListClose;
|
|
RefPtr<LispObject> iComma;
|
|
RefPtr<LispObject> iList;
|
|
RefPtr<LispObject> iProg;
|
|
|
|
LispInt iLastUniqueId;
|
|
|
|
public: // Error reporting
|
|
LispString iError;
|
|
StringOutput iErrorOutput;
|
|
DefaultDebugger* iDebugger;
|
|
|
|
private:
|
|
LispPtr *FindLocal(LispString * aVariable);
|
|
|
|
private:
|
|
|
|
class LispLocalVariable : public YacasBase
|
|
{
|
|
public:
|
|
LispLocalVariable(LispString * aVariable,
|
|
LispObject* aValue)
|
|
: iNext(NULL), iVariable(aVariable),iValue(aValue)
|
|
{
|
|
++aVariable->iReferenceCount;
|
|
};
|
|
~LispLocalVariable()
|
|
{
|
|
--iVariable->iReferenceCount;
|
|
}
|
|
private:
|
|
LispLocalVariable(const LispLocalVariable& aOther) : iNext(NULL), iVariable(NULL),iValue(NULL)
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
}
|
|
LispLocalVariable& operator=(const LispLocalVariable& aOther)
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
return *this;
|
|
}
|
|
|
|
public:
|
|
LispLocalVariable* iNext;
|
|
LispString * iVariable;
|
|
LispPtr iValue;
|
|
};
|
|
class LocalVariableFrame : public YacasBase
|
|
{
|
|
public:
|
|
LocalVariableFrame(LocalVariableFrame *aNext,
|
|
LispLocalVariable* aFirst)
|
|
: iNext(aNext), iFirst(aFirst), iLast(aFirst) { }
|
|
void Add(LispLocalVariable* aNew)
|
|
{
|
|
aNew->iNext = iFirst;
|
|
iFirst = aNew;
|
|
}
|
|
~LocalVariableFrame()
|
|
{
|
|
LispLocalVariable* t = iFirst;
|
|
LispLocalVariable* next;
|
|
while (t != iLast)
|
|
{
|
|
next = t->iNext;
|
|
delete t;
|
|
t = next;
|
|
}
|
|
}
|
|
|
|
private:
|
|
LocalVariableFrame(const LocalVariableFrame& aOther) : iNext(NULL),iFirst(NULL),iLast(NULL)
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
}
|
|
LocalVariableFrame& operator=(const LocalVariableFrame& aOther)
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
return *this;
|
|
}
|
|
public:
|
|
LocalVariableFrame *iNext;
|
|
LispLocalVariable* iFirst;
|
|
LispLocalVariable* iLast;
|
|
};
|
|
public: //Well... only because I want to be able to show the stack to the outside world...
|
|
LocalVariableFrame *iLocalsList;
|
|
LispOutput* iInitialOutput;
|
|
private:
|
|
|
|
/// Hash of core commands with associated YacasEvaluator
|
|
YacasCoreCommands& iCoreCommands;
|
|
|
|
LispUserFunctions& iUserFunctions;
|
|
LispHashTable& iHashTable;
|
|
LispDefFiles iDefFiles;
|
|
LispPrinter& iPrinter;
|
|
LispOutput* iCurrentOutput;
|
|
|
|
/// Hash of global variables with their values
|
|
LispGlobal& iGlobals;
|
|
|
|
LispOperators& iPreFixOperators;
|
|
LispOperators& iInFixOperators;
|
|
LispOperators& iPostFixOperators;
|
|
LispOperators& iBodiedOperators;
|
|
|
|
LispInput* iCurrentInput;
|
|
|
|
LispChar * theUserError;
|
|
|
|
LispString * iPrettyReader;
|
|
LispString * iPrettyPrinter;
|
|
public:
|
|
LispTokenizer iDefaultTokenizer;
|
|
CommonLispTokenizer iCommonLispTokenizer;
|
|
XmlTokenizer iXmlTokenizer;
|
|
LispTokenizer* iCurrentTokenizer;
|
|
|
|
public:
|
|
/** YacasArgStack implements a stack of pointers to objects that can be used to pass
|
|
* arguments to functions, and receive results back.
|
|
*/
|
|
class YacasArgStack
|
|
{
|
|
public:
|
|
YacasArgStack(LispInt aStackSize) : iStack(),iStackCnt(0)
|
|
{
|
|
iStack.ResizeTo( aStackSize );
|
|
}
|
|
inline LispInt GetStackTop() const {return iStackCnt;}
|
|
inline void RaiseStackOverflowError() const
|
|
{
|
|
RaiseError("Argument stack reached maximum. Please extend argument stack with --stack argument on the command line.");
|
|
}
|
|
inline void PushArgOnStack(LispObject* aObject)
|
|
{
|
|
if (iStackCnt >= iStack.Size())
|
|
{
|
|
RaiseStackOverflowError();
|
|
}
|
|
//LISPASSERT(iStackCnt>=0 /*&& iStackCnt<iStack.Size()*/);
|
|
iStack[iStackCnt] = (aObject);
|
|
iStackCnt++;
|
|
}
|
|
inline void PushNulls(LispInt aNr)
|
|
{
|
|
LispInt aStackCnt = iStackCnt + aNr;
|
|
if (aStackCnt > iStack.Size() || aStackCnt < 0)
|
|
{
|
|
RaiseStackOverflowError();
|
|
}
|
|
iStackCnt = aStackCnt;
|
|
}
|
|
inline LispPtr& GetElement(LispInt aPos)
|
|
{
|
|
LISPASSERT(0<=aPos && aPos<iStackCnt);
|
|
//LISPASSERT(aPos>=0 && aPos<iStack.Size());
|
|
return iStack[aPos];
|
|
}
|
|
inline void PopTo(LispInt aTop)
|
|
{
|
|
LISPASSERT(0<=aTop && aTop<=iStackCnt);
|
|
while (iStackCnt>aTop)
|
|
{
|
|
iStackCnt--;
|
|
iStack[iStackCnt] = (NULL);
|
|
}
|
|
}
|
|
protected:
|
|
// Invariants:
|
|
// 0 <= iStackCnt <= iStack.Size()
|
|
// iStack[iStackCnt..iStack.Size()-1] = NULL
|
|
LispPtrArray iStack;
|
|
LispInt iStackCnt; // number of items on the stack
|
|
};
|
|
YacasArgStack iStack;
|
|
|
|
private:
|
|
|
|
inline LispEnvironment(const LispEnvironment& aOther)
|
|
:
|
|
iPrecision(0), // default user precision of 10 decimal digits
|
|
iBinaryPrecision(0), // same as 34 bits
|
|
iInputDirectories(),
|
|
iCleanup(),
|
|
iEvalDepth(0),
|
|
iMaxEvalDepth(0),
|
|
iArchive(NULL),
|
|
iEvaluator(NULL),
|
|
iInputStatus(),
|
|
iSecure(0),
|
|
iTrue(),
|
|
iFalse(),
|
|
iEndOfFile(),
|
|
iEndStatement(),
|
|
iProgOpen(),
|
|
iProgClose(),
|
|
iNth(),
|
|
iBracketOpen(),
|
|
iBracketClose(),
|
|
iListOpen(),
|
|
iListClose(),
|
|
iComma(),
|
|
iList(),
|
|
iProg(),
|
|
iLastUniqueId(0),
|
|
iError(),
|
|
iErrorOutput(aOther.iErrorOutput),
|
|
iDebugger(NULL),
|
|
iLocalsList(NULL),
|
|
iInitialOutput(aOther.iInitialOutput),
|
|
iCoreCommands(aOther.iCoreCommands),
|
|
iUserFunctions(aOther.iUserFunctions),
|
|
iHashTable(aOther.iHashTable),
|
|
iDefFiles(),
|
|
iPrinter(aOther.iPrinter),
|
|
iCurrentOutput(aOther.iCurrentOutput),
|
|
iGlobals(aOther.iGlobals),
|
|
iPreFixOperators(aOther.iPreFixOperators),
|
|
iInFixOperators(aOther.iInFixOperators),
|
|
iPostFixOperators(aOther.iPostFixOperators),
|
|
iBodiedOperators(aOther.iBodiedOperators),
|
|
iCurrentInput(aOther.iCurrentInput),
|
|
theUserError(NULL),
|
|
iPrettyReader(NULL),
|
|
iPrettyPrinter(NULL),
|
|
iDefaultTokenizer(),
|
|
iCommonLispTokenizer(),
|
|
iXmlTokenizer(),
|
|
iCurrentTokenizer(NULL),
|
|
iStack(0)
|
|
{
|
|
// copy constructor has not been made yet, hence the assert
|
|
LISPASSERT(0);
|
|
}
|
|
LispEnvironment& operator=(const LispEnvironment& aOther)
|
|
{
|
|
// copy constructor has not been made yet, hence the assert
|
|
LISPASSERT(0);
|
|
return *this;
|
|
}
|
|
|
|
};
|
|
|
|
inline LispInt LispEnvironment::Precision(void) const
|
|
{
|
|
return iPrecision;
|
|
}
|
|
|
|
inline LispInt LispEnvironment::BinaryPrecision(void) const
|
|
{
|
|
return iBinaryPrecision;
|
|
}
|
|
|
|
|
|
|
|
inline YacasCoreCommands& LispEnvironment::CoreCommands()
|
|
{
|
|
return iCoreCommands;
|
|
}
|
|
|
|
|
|
inline LispHashTable& LispEnvironment::HashTable()
|
|
{
|
|
return iHashTable;
|
|
}
|
|
|
|
|
|
|
|
// Local lisp stack, unwindable by the exception handler
|
|
class LispLocalFrame : public LispBase
|
|
{
|
|
public:
|
|
LispLocalFrame(LispEnvironment& aEnvironment, LispBoolean aFenced)
|
|
: iEnvironment(aEnvironment)
|
|
{
|
|
iEnvironment.PushLocalFrame(aFenced);
|
|
SAFEPUSH(iEnvironment,*this);
|
|
};
|
|
virtual ~LispLocalFrame()
|
|
{
|
|
SAFEPOP(iEnvironment);
|
|
Delete();
|
|
};
|
|
virtual void Delete();
|
|
private:
|
|
LispEnvironment& iEnvironment;
|
|
};
|
|
|
|
|
|
|
|
class LispSecureFrame : public LispBase
|
|
{
|
|
public:
|
|
LispSecureFrame(LispEnvironment& aEnvironment)
|
|
: iEnvironment(aEnvironment),iPreviousSecure(aEnvironment.iSecure)
|
|
{
|
|
iEnvironment.iSecure = 1;
|
|
SAFEPUSH(iEnvironment,*this);
|
|
};
|
|
virtual ~LispSecureFrame()
|
|
{
|
|
SAFEPOP(iEnvironment);
|
|
Delete();
|
|
};
|
|
virtual void Delete();
|
|
private:
|
|
LispEnvironment& iEnvironment;
|
|
LispInt iPreviousSecure;
|
|
};
|
|
|
|
|
|
// LispLocalInput takes ownership over the LispInput class
|
|
class LispLocalInput : public LispBase
|
|
{
|
|
public:
|
|
LispLocalInput(LispEnvironment& aEnvironment, LispInput* aInput)
|
|
: iEnvironment(aEnvironment),iPreviousInput(iEnvironment.CurrentInput())
|
|
{
|
|
iEnvironment.SetCurrentInput(aInput);
|
|
SAFEPUSH(iEnvironment,*this);
|
|
};
|
|
virtual ~LispLocalInput()
|
|
{
|
|
SAFEPOP(iEnvironment);
|
|
Delete();
|
|
};
|
|
virtual void Delete();
|
|
private:
|
|
LispLocalInput(const LispLocalInput& aOther): iEnvironment(aOther.iEnvironment),iPreviousInput(iEnvironment.CurrentInput())
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
};
|
|
LispLocalInput& operator=(const LispLocalInput& aOther)
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
return *this;
|
|
};
|
|
|
|
private:
|
|
LispEnvironment& iEnvironment;
|
|
LispInput* iPreviousInput;
|
|
};
|
|
|
|
|
|
// LispLocalInput takes ownership over the LispInput class
|
|
class LispLocalOutput : public LispBase
|
|
{
|
|
public:
|
|
LispLocalOutput(LispEnvironment& aEnvironment, LispOutput* aOutput)
|
|
: iEnvironment(aEnvironment), iPreviousOutput(iEnvironment.CurrentOutput())
|
|
{
|
|
iPreviousOutput = iEnvironment.CurrentOutput();
|
|
iEnvironment.SetCurrentOutput(aOutput);
|
|
SAFEPUSH(iEnvironment,*this);
|
|
};
|
|
virtual ~LispLocalOutput()
|
|
{
|
|
SAFEPOP(iEnvironment);
|
|
Delete();
|
|
};
|
|
virtual void Delete();
|
|
private:
|
|
LispLocalOutput(const LispLocalOutput& aOther): iEnvironment(aOther.iEnvironment), iPreviousOutput(iEnvironment.CurrentOutput())
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
}
|
|
LispLocalOutput& operator=(const LispLocalOutput& aOther)
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
return *this;
|
|
}
|
|
private:
|
|
LispEnvironment& iEnvironment;
|
|
LispOutput* iPreviousOutput;
|
|
};
|
|
|
|
|
|
class LispLocalEvaluator : public YacasBase
|
|
{
|
|
public:
|
|
LispLocalEvaluator(LispEnvironment& aEnvironment,LispEvaluatorBase* aNewEvaluator);
|
|
~LispLocalEvaluator();
|
|
|
|
private:
|
|
LispLocalEvaluator(const LispLocalEvaluator& aOther) : iPreviousEvaluator(NULL), iEnvironment(aOther.iEnvironment)
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
}
|
|
LispLocalEvaluator& operator=(const LispLocalEvaluator& aOther)
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
LispEvaluatorBase* iPreviousEvaluator;
|
|
LispEnvironment& iEnvironment;
|
|
};
|
|
|
|
class LispLocalTrace : public YacasBase
|
|
{
|
|
public:
|
|
LispLocalTrace(LispUserFunction* aUserFunc);
|
|
~LispLocalTrace();
|
|
private:
|
|
LispLocalTrace(const LispLocalTrace& aOther) : iUserFunc(NULL)
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
}
|
|
LispLocalTrace& operator=(const LispLocalTrace& aOther)
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
return *this;
|
|
}
|
|
private:
|
|
LispUserFunction* iUserFunc;
|
|
};
|
|
|
|
class LocalArgs : public YacasBase
|
|
{
|
|
public:
|
|
LocalArgs(LispPtr* aPtrs) : iPtrs(aPtrs) {};
|
|
~LocalArgs()
|
|
{
|
|
if (iPtrs)
|
|
delete[] iPtrs;
|
|
}
|
|
private:
|
|
LocalArgs(const LocalArgs& aOther) : iPtrs(NULL)
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
}
|
|
LocalArgs& operator=(const LocalArgs& aOther)
|
|
{
|
|
// copy constructor not written yet, hence the assert
|
|
LISPASSERT(0);
|
|
return *this;
|
|
}
|
|
private:
|
|
LispPtr* iPtrs;
|
|
};
|
|
|
|
|
|
|
|
inline void LispEnvironment::SetPrettyReader(LispString * aPrettyReader)
|
|
{
|
|
iPrettyReader = aPrettyReader;
|
|
}
|
|
inline LispString * LispEnvironment::PrettyReader(void)
|
|
{
|
|
return iPrettyReader;
|
|
}
|
|
|
|
inline void LispEnvironment::SetPrettyPrinter(LispString * aPrettyPrinter)
|
|
{
|
|
iPrettyPrinter = aPrettyPrinter;
|
|
}
|
|
inline LispString * LispEnvironment::PrettyPrinter(void)
|
|
{
|
|
return iPrettyPrinter;
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
|