lsymbol.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_LSYMBOL_HPP_SENTRY
#define INTELIB_LSYMBOL_HPP_SENTRY


#include "lisp.hpp"
//#include "lcont.hpp"
#include "../sexpress/gensref.hpp"


#ifndef INTELIB_LISP_LIBRARY_DEFINES_SYMBOLS
#define INTELIB_LISP_LIBRARY_DEFINES_SYMBOLS 1
#endif


class LExpressionSymbol : public SExpressionLabel {
    LReference dynamic_value;
    LReference associated_function;
    bool is_dynamic : 2;
    bool is_constant : 2;
protected:
    LExpressionSymbol(const char *a_name, const IntelibTypeId &t) 
        : SExpressionLabel(t, a_name), 
          dynamic_value(), is_dynamic(false), is_constant(false) {}
    ~LExpressionSymbol() {}
public:
    static IntelibTypeId TypeId;
    LExpressionSymbol(const char *a_name) 
        : SExpressionLabel(TypeId, a_name), 
          dynamic_value(), is_dynamic(false), is_constant(false) {}

    const LReference& GetDynamicValue() const { return dynamic_value; } 
    LReference& GetDynamicValueRef() { return dynamic_value; } 
    void SetDynamicValue(const SReference &val);
    const LReference& GetFunction() const { return associated_function; } 
    LReference& GetFunctionRef() { return associated_function; } 
    void SetFunction(const LReference &val) { associated_function = val; }
 
    bool IsDynamic() const { return is_dynamic; }
    bool IsConstant() const { return is_constant; }
    void SetDynamicBinding(bool dyn = true) { is_dynamic = dyn; }
    void SetConstant(bool cnst = true) { is_constant = cnst; }
};

class IntelibX_lisp_not_a_symbol : public IntelibX {
public:
    IntelibX_lisp_not_a_symbol(SReference a_param);
};

typedef GenericSReference<LExpressionSymbol,IntelibX_lisp_not_a_symbol>
LSymbolRef;


class LSymbol : public LSymbolRef {
public:
    LSymbol(const char *s) : LSymbolRef(new LExpressionSymbol(s)) {}
    LSymbol(LExpressionSymbol *ts) : LSymbolRef(ts) {}
    ~LSymbol();

private:
    // made private to prevent the user from mistakes and
    //   to make sure this always points to LExpressionSymbol object.
    void operator =(const LReference& ref) {}
    LSymbol(const LSymbol&) {}
};



template <class F>           // F must be a descender of LExpressionForm
class LFunctionalSymbol : public LSymbol {
public:
    LFunctionalSymbol(const char *name = 0) : LSymbol(name) 
      { (*this)->SetFunction(LReference(::new F())); }
    ~LFunctionalSymbol() {}
private:
    LFunctionalSymbol(const LFunctionalSymbol<F>& t) : LSymbol(0) {}
          /* LSymbol(0) is just to make stupid compiler happy */
};





class LSymbolQuote : public LSymbol {
public:
    LSymbolQuote();
};

class LSymbolFunction : public LSymbol {
public:
    LSymbolFunction();
};

class LSymbolLambda : public LSymbol {
public:
    LSymbolLambda();
};

class LSymbolT : public LSymbol {
public:
    LSymbolT();
};

class LSymbolNIL : public LSymbol {
public:
    LSymbolNIL();
};

extern struct LLibraryProvidedSymbols {
    LSymbolQuote Quote;
    LSymbolFunction Function;
    LSymbolLambda Lambda;
    LSymbolT SymT;
    LSymbolNIL SymNil;
} TheLibraryProvidedSymbols;

#if INTELIB_LISP_LIBRARY_DEFINES_SYMBOLS == 1
#define QUOTE (TheLibraryProvidedSymbols.Quote)
#define FUNCTION (TheLibraryProvidedSymbols.Function)
#define LAMBDA (TheLibraryProvidedSymbols.Lambda)
#define T (TheLibraryProvidedSymbols.SymT)
#define NIL (TheLibraryProvidedSymbols.SymNil)
#endif

class IntelibX_symbol_has_no_value : public IntelibX {
public:
    IntelibX_symbol_has_no_value(SReference a_param);
};

class IntelibX_cant_change_constant : public IntelibX {
public:
    IntelibX_cant_change_constant(SReference a_param);
};


#endif // sentry

---