scheme.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_SCHEME_HPP_SENTRY
#define INTELIB_SCHEME_HPP_SENTRY

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



class SchReference : public SReference {
public:
    SchReference() {}
    SchReference(const SchReference& ref) : SReference(ref) {}
    SchReference(const SReference& ref) : SReference(ref) {}
    SchReference(SExpression* p) : SReference(p) {}

    //SchReference(UserLispFunction fun);
 
    template <class X> SchReference(X &x) : SReference(x) {}
    template <class X> SchReference(const X &x) : SReference(x) {}

    ~SchReference() {}


    SchReference Evaluate() const; 

    SchReference Evaluate(class SchemeContinuation &cont) const; 


    bool IsTrue() const; 

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

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

    SchReference operator~() const;

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

#if INTELIB_TEXT_REPRESENTATIONS == 1

    SString TextRepresentation() const;
#endif
};



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

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

extern SReference *PTheSchemeSymbolQuote;
extern SReference *PTheSchemeBooleanTrue;
extern SReference *PTheSchemeBooleanFalse;

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

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


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



#endif

---