sexpress.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_SEXPRESS_HPP_SENTRY
#define INTELIB_SEXPRESS_HPP_SENTRY

#include "refcount.hpp"


extern const char *the_intelib_title;

extern const char *the_intelib_copyright;

extern const int the_intelib_numberic_version;

/* ------------------------------------------------------- */
/* The main defaults                                       */

#ifndef INTELIB_INTEGER_T 

#define INTELIB_INTEGER_T int
#endif 
 
#ifndef INTELIB_FLOAT_T

#define INTELIB_FLOAT_T float
#endif 

#ifndef INTELIB_SIMPLE_STRING_LIMIT

#define INTELIB_SIMPLE_STRING_LIMIT sizeof(char*)
#endif
 
#ifndef INTELIB_TEXT_REPRESENTATIONS

#define INTELIB_TEXT_REPRESENTATIONS 1
#endif

#if INTELIB_TEXT_REPRESENTATIONS == 1
#  ifndef INTELIB_INTEGER_FORMAT

#  define INTELIB_INTEGER_FORMAT "%d"
#  endif
#  ifndef INTELIB_FLOAT_FORMAT

#  define INTELIB_FLOAT_FORMAT "%f"
#  endif
#endif

#ifndef INTELIB_RUNTIME_CHECKS

#define INTELIB_RUNTIME_CHECKS 1
#endif

#ifndef INTELIB_DEBUG_COUNTERS


#define INTELIB_DEBUG_COUNTERS 0
#endif

typedef INTELIB_INTEGER_T intelib_integer_t;

typedef INTELIB_FLOAT_T intelib_float_t;


const unsigned int intelib_simple_string_limit 
                          = INTELIB_SIMPLE_STRING_LIMIT;

/* ------------------------------------------------------- */


class IntelibTypeId {
    const IntelibTypeId *prev;
    bool changeable;
public:

    IntelibTypeId() 
        : changeable(false) { prev = 0; }
    IntelibTypeId(const IntelibTypeId *previous) 
        : changeable(previous->changeable) { prev = previous; }
    IntelibTypeId(const IntelibTypeId *previous, bool a_changeable) 
        : changeable(a_changeable) { prev = previous; }
    ~IntelibTypeId() {}

    const IntelibTypeId* Prev() const { return prev; } 

    bool IsSubtypeOf(const IntelibTypeId &op) const; 
    bool operator==(const IntelibTypeId &op) const
       { return &op == this; } 
    bool operator!=(const IntelibTypeId &op) const
       { return &op != this; } 

    bool IsChangeable() const { return changeable; }

#if INTELIB_DEBUG_COUNTERS == 1
    mutable long object_counter; 
#endif
private:
    // disallow copying
    IntelibTypeId(const IntelibTypeId &) {} 
};

#if INTELIB_TEXT_REPRESENTATIONS == 1
class SString; // we need it before it is defined, for text representations
#endif


class SExpression : public GarbageSafe {
    const IntelibTypeId *term_type_id;
public:

    static IntelibTypeId TypeId;


    SExpression(const IntelibTypeId &the_type);

protected:

    virtual ~SExpression();
public:
    const IntelibTypeId& TermType() const { return *term_type_id; }

    bool IsChangeable() const { return term_type_id->IsChangeable(); }


    virtual SExpression* Clone() const { return 0; }
     

#if INTELIB_TEXT_REPRESENTATIONS == 1


    virtual class SString TextRepresentation() const = 0;
#endif


    virtual bool SpecificEql(const SExpression* /*other*/) const 
        { return false; }
private:
    SExpression(const SExpression&) {}
    void operator = (const SExpression&) {}

#if INTELIB_DEBUG_COUNTERS == 1
public:
    static long object_counter; 
#endif
};


class SExpressionInt : public SExpression {
    intelib_integer_t data;
public:
    static IntelibTypeId TypeId;
    SExpressionInt() : SExpression(TypeId) { data = 0; }
    SExpressionInt(char d) : SExpression(TypeId) { data = d; }
    SExpressionInt(short int d) : SExpression(TypeId) { data = d; }
    SExpressionInt(int d) : SExpression(TypeId) { data = d; }
    SExpressionInt(long int d) : SExpression(TypeId) { data = d; }
    SExpressionInt(long long int d) : SExpression(TypeId) { data = d; }
    SExpressionInt(unsigned char d) : SExpression(TypeId) { data = d; }
    SExpressionInt(unsigned short int d) : SExpression(TypeId) { data = d; }
    SExpressionInt(unsigned int d) : SExpression(TypeId) { data = d; }
    SExpressionInt(unsigned long int d) : SExpression(TypeId) { data = d; }
    SExpressionInt(unsigned long long int d) 
        : SExpression(TypeId) { data = d; }
 
    intelib_integer_t GetValue() const { return data; }

#if INTELIB_TEXT_REPRESENTATIONS == 1

    virtual SString TextRepresentation() const;
#endif

protected:
    virtual ~SExpressionInt() {}
    
    virtual bool SpecificEql(const SExpression* other) const;
};


class SExpressionFloat : public SExpression {
    intelib_float_t data;
public:
    static IntelibTypeId TypeId;
    SExpressionFloat() : SExpression(TypeId) { data = 0; }
    SExpressionFloat(float d) : SExpression(TypeId) { data = d; }
    SExpressionFloat(double d) : SExpression(TypeId) { data = d; }
    SExpressionFloat(long double d) : SExpression(TypeId) { data = d; }
 
    intelib_float_t GetValue() const { return data; }

#if INTELIB_TEXT_REPRESENTATIONS == 1

    virtual SString TextRepresentation() const;
#endif

protected:
    virtual ~SExpressionFloat() {}
    
    virtual bool SpecificEql(const SExpression* other) const;
};


class SExpressionChar : public SExpression {
    char s[2];
public: 
    static IntelibTypeId TypeId;

    SExpressionChar(int c) : SExpression(TypeId) { s[0] = c; s[1] = 0; }

protected:
    ~SExpressionChar() {}
    virtual bool SpecificEql(const SExpression* other) const;

public:
    char GetValue() const { return s[0]; }
    const char *GetString() const { return s; }

#if INTELIB_TEXT_REPRESENTATIONS == 1

    virtual SString TextRepresentation() const;
#endif
};



class SExpressionString : public SExpression {

    bool is_indirect;
    union {
        char *p;
        char s[intelib_simple_string_limit];
    } str;
    void StringSetup(const char *s); 
public: 
    static IntelibTypeId TypeId;

    SExpressionString() : SExpression(TypeId) 
             { is_indirect = 0; str.s[0] = 0; } // just empty string
    SExpressionString(const char *s); 

    SExpressionString(const char *s1, const char *s2);

protected:

    SExpressionString(const IntelibTypeId &tid, const char *s);
    ~SExpressionString();    

public:
    const char* GetValue() const
      { return is_indirect ? str.p : str.s; }

#if INTELIB_TEXT_REPRESENTATIONS == 1

    virtual SString TextRepresentation() const;
#endif

protected:
    virtual bool SpecificEql(const SExpression* other) const;
};


class SExpressionClassicAtom : public SExpressionString {
public:
    static IntelibTypeId TypeId;
    SExpressionClassicAtom(const char *s) : SExpressionString(TypeId, s) {}
    virtual SString TextRepresentation() const; 
      // Note we don't need to write specific SpecificEql function. 
      // It's version of SExpressionString will perfectly serve us.
protected:
    ~SExpressionClassicAtom() {}
};



#if INTELIB_TEXT_REPRESENTATIONS == 1
class SExpressionLabel : public SExpression {
    char *name;
protected:
    SExpressionLabel(const IntelibTypeId &the_type, const char *a_name);
public:
    static IntelibTypeId TypeId;
    SExpressionLabel(const char *a_name);
    virtual SString TextRepresentation() const;
    const char* GetName() const { return name; }
protected:
    ~SExpressionLabel();
};
#else
class SExpressionLabel : public SExpression {
protected:
    SExpressionLabel(const IntelibTypeId &the_type, const char*)
        : SExpression(the_type) {}
    ~SExpressionLabel() {}
public:
    static IntelibTypeId TypeId;
    SExpressionLabel(const char* /*a_name*/) : SExpression(TypeId) {}
    const char* GetName() const { return ""; }
};
#endif



class SReference : public GenericReference<SExpression> {
public:

    SReference() {}       

    SReference(const SExpression *tp) : GenericReference<SExpression>(tp) {} 

    SReference(const SReference &other) 
        : GenericReference<SExpression>
          (static_cast<const GenericReference<SExpression>&>(other)){}
    ~SReference() {}
   

    SReference(char c);
    SReference(signed char c);
    SReference(unsigned char c);
    SReference(signed short i);
    SReference(unsigned short i);
    SReference(signed int i);
    SReference(unsigned int i);
    SReference(signed long i);
    SReference(unsigned long i);
    SReference(signed long long i);
    SReference(unsigned long long i);
    SReference(float f);
    SReference(double f);
    SReference(long double f);
    SReference(const char *s);
    SReference(const unsigned char *s);

    SReference(const class SListConstructor &); 
    SReference(const SReference &car, const SReference &cdr);

    SReference& operator=(const SReference &other)
      { GenericReference<SExpression>::operator=(other); return *this; }
    void operator=(SExpression* newterm)
      { GenericReference<SExpression>::operator=(newterm); }

    SExpression* GetPtr() const 
      { return (SExpression*)GenericReference<SExpression>::GetPtr(); }


    SReference& AddAnotherItemToList(const SReference &right); 

    SReference& ChangeListEnd(const SReference &new_last); 

    SReference MakeCons(const SReference &right) const;


    SReference& operator,(const SReference &r) 
        { return AddAnotherItemToList(r); }

    SReference& operator||(const SReference &t) 
        { return ChangeListEnd(t); }

    SReference operator^(const SReference &t) const 
        { return MakeCons(t); }

    bool operator == (const SReference &other) const
      { return GetPtr() == other.GetPtr(); }
    bool operator != (const SReference &other) const 
      { return GetPtr() != other.GetPtr(); }
    bool operator == (const SExpression *other) const
      { return GetPtr() == other; }
    bool operator != (const SExpression *other) const
      { return GetPtr() != other; }

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

    SReference& Car() const; 
    SReference& Cdr() const;
    SReference& CCar() const; 
    SReference& CCdr() const;
    intelib_float_t GetFloat() const;
    intelib_integer_t GetInt() const;
    const char* GetString() const;
    char GetSingleChar() const;

    template<class Tp> Tp* DynamicCastGetPtr() const;
    template<class Tp> Tp* SimpleCastGetPtr() const;

    SReference Clone() const;
    SReference CopyList() const;
    SReference CopyTree() const;

    bool IsEmptyList() const; 

};


class SLabel : public SReference {
public:
    SLabel(const char *name) : SReference(new SExpressionLabel(name)) {}
private: /* note all operations prohibited */
    SLabel(const SLabel &) {}
    void operator=(const SLabel &) {}
    void operator=(const SReference &) {}
    void operator=(const SExpression*) {}
};


class SExpressionCons : public SExpression {
    SReference car;
    SReference cdr;
protected:
    SExpressionCons(const SReference &acar, const SReference &acdr,
                    const IntelibTypeId &tid)
           : SExpression(tid), car(acar), cdr(acdr) {}
public:
    static IntelibTypeId TypeId;

    SExpressionCons(const SReference &acar, const SReference &acdr)
           : SExpression(TypeId), car(acar), cdr(acdr) {}
    ~SExpressionCons(){} 

    SReference& Car() { return car; }
    SReference& Cdr() { return cdr; }
    const SReference& Car() const { return car; }
    const SReference& Cdr() const { return cdr; }

    virtual SExpression* Clone() const; 

#if INTELIB_TEXT_REPRESENTATIONS == 1

    SString CoreTextRepresentation(const char *delim, 
                                   const char *dotdelim,
                                   SString (*repfun)(const SReference &)=0) 
            const;
    virtual SString TextRepresentation() const;
#endif
};



extern SReference *PTheEmptyList;



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


template<class Tp> Tp* SReference::DynamicCastGetPtr() const
{
    if(GetPtr() && GetPtr()->TermType().IsSubtypeOf(Tp::TypeId)) 
        return (Tp*)GetPtr(); 
    else
        return 0;
}

template<class Tp> Tp* SReference::SimpleCastGetPtr() const
{
    if(GetPtr() && &(GetPtr()->TermType()) == &(Tp::TypeId)) 
        return (Tp*)GetPtr(); 
    else
        return 0;
}



#endif

---