lisp.hpp

Go to the documentation of this file.

// +-------------------------------------------------------------------------+
// |               I__n__t__e__L__i__b           0.6.10 development          |
// | Copyright (c) Andrey Vikt. Stolyarov <crocodil_AT_croco.net> 2000-2007. |
// |                                                                         |
// | This is free software. The library part is available under              |
// |                               GNU LESSER GENERAL PUBLIC LICENSE v.2.1.  |
// | GNU LGPL v2.1 is found in docs/gnu_gpl2.txt,  or at  http://www.gnu.org |
// |     Please see also docs/readme.txt and visit http://www.intelib.org    |
// |                                                                         |
// | !!! THERE IS NO WARRANTY OF ANY KIND, NEITHER EXPRESSED NOR IMPLIED !!! |
// +-------------------------------------------------------------------------+




#ifndef INTELIB_LISP_HPP_SENTRY
#define INTELIB_LISP_HPP_SENTRY


#include "../sexpress/sexpress.hpp"
#include "../sexpress/iexcept.hpp"


class LReference;

typedef LReference (*UserLispFunction)(int, const SReference *);


class LReference : public SReference {
public:
    LReference() {}
    LReference(const LReference& ref) : SReference(ref) {}
    LReference(const SReference& ref) : SReference(ref) {}
    LReference(SExpression* p) : SReference(p) {}
    LReference(UserLispFunction fun);
 
    template <class X> LReference(X &x) : SReference(x) {}
    template <class X> LReference(const X &x) : SReference(x) {}

    ~LReference() {}


    LReference Evaluate() const;


    LReference Evaluate(class LispContinuation &within) const; 


    bool IsTrue() const; 

    LReference& operator,(const SReference& ref)
        { SReference::operator,(ref); return *this; }

    LReference& operator||(const SReference& ref)
        { SReference::operator||(ref); return *this; }

    LReference operator~() const;

    bool IsEql(const SReference& other) const;
    bool IsEqual(const SReference& other) const;

#if INTELIB_TEXT_REPRESENTATIONS == 1


    SString TextRepresentation() const;
#endif
};


extern SReference *PTheLispSymbolLambda;
extern SReference *PTheLispSymbolQuote;
extern SReference *PTheLispSymbolFunction;
extern SReference *PTheLispBooleanTrue;
extern SReference *PTheLispBooleanFalse;


inline bool LReference::IsTrue() const 
{ return GetPtr() != PTheLispBooleanFalse->GetPtr(); } 

inline LReference LReference::operator~() const 
{ 
    return 
        LReference(
            new SExpressionCons(*PTheLispSymbolQuote, 
                                SReference(
                                    new SExpressionCons(*this, 
                                                        *PTheEmptyList)
                               ))
       ); 
} 




class LListConstructor : public SListConstructor {
public:
    LListConstructor() {}
    ~LListConstructor() {}
    
    LReference operator |(const LReference &t) const
        { return LReference(new SExpressionCons(t, *PTheEmptyList)); } 
    LReference operator ^(const LReference &other) const
        { return LReference(new SExpressionCons(*PTheEmptyList, other)); }

    LReference operator ~() const { return *PTheEmptyList; }
};



class LFunctionConstructor {
public:
    LFunctionConstructor() {}
    ~LFunctionConstructor() {}
    
    LReference operator ^(const LReference &op) const
        { return SReference(*PTheLispSymbolFunction, 
                            SReference(op, *PTheEmptyList)); }
};


inline LReference operator~(const SReference& r) { return ~LReference(r); }


#endif

---