---

more/lang/ct_type.h

Go to the documentation of this file.

//  Copyright (C) 2001--2002  Petter Urkedal (petter.urkedal@matfys.lth.se)
//
//  This file is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: ct_type.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $


#ifndef MORE_LANG_CT_TYPE_H
#define MORE_LANG_CT_TYPE_H

#include <more/bits/config.h>

#ifdef HAVE_LIBFFI
#  include <ffi.h>

// If defined, ct_type::ffi_type_of() will be defined.
#  define MORE_LANG_PROVIDE_FFI

// If defined, use libffi for type properties and function calls.
// Requires that MORE_LANG_PROVIDE_FFI is defined.
//# define MORE_LANG_USE_FFI

#endif

#ifdef HAVE_BDWGC
#  define MORE_LANG_USE_GC
#  include <bdwgc/gc_cpp.h>
#  include <more/gen/memory.h>
#  include <more/gen/gc_string.h>
#endif

#include <iosfwd>
#include <cstdlib>
#include <cstring>
#include <more/lang/fwd.h>
#include <more/io/fwd.h>
#include <more/gen/string.h>
#include <more/gen/identifier.h>
#include <more/math/hash.h>
#include <typeinfo>


namespace more {
namespace lang {

  using std::size_t;
#ifdef MORE_LANG_USE_GC
  using gen::gc_string;
  using gen::gc_wstring;
#endif
  using gen::identifier;

  /** Type used for function pointers with unknown prototype. */
  typedef void (*fn_ptr_t)();

  /** \class ct_type ct_type.h more/lang/ct_type.h
      Abstract base class for runtime type representation. */
  struct ct_type
#ifdef MORE_LANG_USE_GC
      : gc
#endif
  {
      typedef std::size_t       size_type;
      typedef short             alignment_type; // as used in ffi_type
      typedef math::hash<192>   hash_type;

      typedef unsigned short    printopt_type;
      static printopt_type const printopt_low_precedence        = 1;
      static printopt_type const printopt_space_before_name     = 2;
      static printopt_type const printopt_space_after_name      = 4;
      static printopt_type const printopt_function_args         = 8;
      static printopt_type const printopt_lang_cxx              = 16;

      /** Construct a type with CV qualified variants.  This
          constructor give tho non-const and non-volatile variant.
          The other variants can be obtained with to_cv. */
      ct_type();

#ifdef MORE_LANG_USE_FFI
      /** Construct a type with fixed CV qualifiers.  The only case
          for this ctor is ct_proto which is always const and
          non-volatile. */
      ct_type(bool const_p, bool volatile_p);
#else
      ct_type(size_type, alignment_type);
      ct_type(size_type, alignment_type, bool const_p, bool volatile_p);
#endif

      virtual ~ct_type();

      /** Return an ct_type identical to this. */
      virtual ct_type*  clone() const = 0;

      /** Return the ffi_type of this type (cf libffi). */
#ifdef MORE_LANG_PROVIDE_FFI
      virtual ffi_type* ffi_type_of() const = 0;
#endif
#if 0
      virtual void      construct(void* p) const = 0;
#endif
      /** Constructor the object at \a p as a copy of \a src. */
      virtual void      construct_copy(void* p, void* src) const = 0;

      /** Destruct the object at \a p. */
      virtual void      destruct(void* p) const = 0;

      /** True iff the objects at \a p0 and \a p1 are equal. */
      virtual bool      equal(void* p0, void* p1) const = 0;

      /** Print the object in human readable form.
          It is not very important to reimplement this. */
      virtual void      print_object(std::ostream&, void*) const;

      /** Print a declaration of \a var with the type described by \c
          this.  If var = 0, just print the type.  No semicolon is
          added. */
      void      print_declaration(std::ostream&, printopt_type,
                                  char const* var = 0) const;

      /** Print the part of the declaration which precedes the
          variable or function name. */
      virtual void      print_declaration_pre(std::ostream&,
                                              printopt_type) const = 0;
      /** Print the part of the declaration which succeeds the
          variable or function name. */
      virtual void      print_declaration_post(std::ostream&,
                                               printopt_type) const = 0;
    protected:
      /** Print only the const and volatile keywords. This is helper
          mostly for internal use. */
      void              print_declaration_cv(std::ostream&,
                                             printopt_type) const;
    public:
      virtual void      hash(hash_type&) const = 0;
      virtual bool      equal_to(ct_type const*) const = 0;

      bool              is_const() const        { return m_is_const; }
      bool              is_volatile() const     { return m_is_volatile; }

      /** Return an clone of \a rtt with different CV equalifiers. */
      friend ct_type const*
      to_cv(ct_type const* rtt, bool const_p, bool volatile_p);

      virtual bool      is_builtin() const;
      virtual bool      is_number() const;

      // Properties according to numeric_limits
      // XXX rt_value* min() const
      // XXX rt_value* max() const
      virtual int       digits() const;
      virtual int       digits10() const;
      virtual bool      is_integer() const;
      virtual bool      is_exact() const;
      virtual int       radix() const;
      // rt_value* epsilon() const
      // rt_value* round_error() const
      virtual int       min_exponent() const;
      virtual int       min_exponent10() const;
      virtual int       max_exponent() const;
      virtual int       max_exponent10() const;
      virtual bool      has_infinity() const;
      virtual bool      has_quiet_NaN() const;
      virtual bool      has_signaling_NaN() const;
      virtual std::float_denorm_style has_denorm() const;
      virtual bool      has_denorm_loss() const;
      // T infinity() const
      // T quiet_NaN() const
      // T signaling_NaN() const
      // T denorm_min() const
      virtual bool      is_iec559() const;
      virtual bool      is_bounded() const;
      virtual bool      is_modulo() const;
      virtual bool      traps() const;
      virtual bool      tinyness_before() const;
      virtual std::float_round_style round_style() const;

      virtual ct_type const* promoted() const;

#if 0 // c_name
      identifier        c_name() const          { return m_c_name; }
      void              set_c_name(char const* str) { m_c_name = str; }
#endif

      char const*       c_error_value() const   { return 0; }

#ifdef MORE_LANG_USE_FFI
      size_type         size()      const { return ffi_type_of()->size; }
      alignment_type    alignment() const { return ffi_type_of()->alignment; }
#else
      size_type         size()      const { req_fin(); return m_size; }
      alignment_type    alignment() const { req_fin(); return m_alignment; }
#endif

    private:
#ifndef MORE_LANG_USE_FFI
      void req_fin() const
      {
          if (m_size == size_type(-1))
              throw std::logic_error("more::lang::ct_type: "
                                     "Access of unfinished type description.");
      }
    protected:
      void set_size_and_alignment(size_type size, alignment_type alignment)
      {
          if (m_size != size_type(-1))
              throw std::logic_error("more::lang::ct_type: "
                                     "Tried to redefine size and alignment.");
          m_size = size;
          m_alignment = alignment;
      }
    private:
      size_type         m_size;
      alignment_type    m_alignment;
#endif

      unsigned int      m_is_const      : 1;
      unsigned int      m_is_volatile   : 1;
      ct_type**         m_cv_array;
    protected:
      static char const* s_private_pfx;
  };

  /** Return true if \a t0 and \a t1 are equal, taking into account CV
      qualifiers. */
  inline bool
  equal(ct_type const* t0, ct_type const* t1)
  {
      return t0->equal_to(t1);
  }

  /** \class ct_pointer ct_type.h more/lang/ct_type.h
      The runtime representation of a pointer type. */
  struct ct_pointer : ct_type
  {
      explicit ct_pointer(ct_type const* t);
      virtual ~ct_pointer();
      virtual ct_pointer* clone() const;

#ifdef MORE_LANG_PROVIDE_FFI
      virtual ffi_type* ffi_type_of()                   const;
#endif
      virtual void      construct_copy(void*, void*)    const;
      virtual void      destruct(void*)                 const;
      virtual bool      equal(void*, void*)             const;
      virtual void      print_object(std::ostream&, void*) const;
      virtual void      print_declaration_pre(std::ostream&,
                                              printopt_type) const;
      virtual void      print_declaration_post(std::ostream&,
                                               printopt_type) const;
      virtual void      hash(hash_type&) const;
      virtual bool      equal_to(ct_type const*) const;

      ct_type const*    deref_type() const { return m_deref_type; }
      void*             deref(void* p) { return *(void**)p; }

    private:
      ct_type const* m_deref_type;
  };


  /** \class ct_array ct_type.h more/lang/ct_type.h
      The runtime representation of an array type. */
  struct ct_array : ct_type
  {
      ct_array(ct_type const* t, std::size_t);
      virtual ~ct_array();
      virtual ct_array* clone() const;

#ifdef MORE_LANG_PROVIDE_FFI
      virtual ffi_type* ffi_type_of()                   const;
#endif
      virtual void      construct_copy(void*, void*)    const;
      virtual void      destruct(void*)                 const;
      virtual bool      equal(void*, void*)             const;
      virtual void      print_object(std::ostream&, void*) const;
      virtual void      print_declaration_pre(std::ostream&,
                                              printopt_type) const;
      virtual void      print_declaration_post(std::ostream&,
                                               printopt_type) const;
      virtual void      hash(hash_type&) const;
      virtual bool      equal_to(ct_type const*) const;

      ct_type const*    element_type() const { return m_element_type; }
      void*             element(void*, std::size_t) const;

    private:
      ct_type const*    m_element_type;
      size_t            m_count;
#ifdef MORE_LANG_PROVIDE_FFI
      mutable ffi_type  m_ffi_type;
#endif
  };




  //--------------------------------------------------------------------
  //                          ct_type_of
  //--------------------------------------------------------------------

  ///\if bits
  template<typename T>
    struct _ct_type
    {
        static ct_type const* get() { return s_value; }
        static void set(ct_type const* s) { s_value = s; }
        static ct_type const* s_value;
    };
  template<typename T>
    ct_type const* _ct_type<T>::s_value = 0;

  template<typename T>
    struct _ct_type<T const>
    {
        static ct_type const*
        get()
        {
            static ct_type const* t = 0;
            if (!t)
                t = to_cv(_ct_type<T>::get(), true, false);
            return t;
        }
    };

  template<typename T>
    struct _ct_type<T volatile>
    {
        static ct_type const*
        get()
        {
            static ct_type const* t = 0;
            if (!t)
                t = to_cv(_ct_type<T>::get(), false, true);
            return t;
        }
    };

  template<typename T>
    struct _ct_type<T const volatile>
    {
        static ct_type const*
        get()
        {
            static ct_type const* t = 0;
            if (!t)
                t = to_cv(_ct_type<T>::get(), true, true);
            return t;
        }
    };

  template<typename T>
    struct _ct_type<T*>
    {
        static ct_type const*
        get()
        {
            static ct_pointer* t = 0;
            if (!t) {
#ifdef MORE_LANG_USE_GC
                t = new(UseGC) ct_pointer(_ct_type<T>::get());
#else
                t = new ct_pointer(_ct_type<T>::get());
#endif
            }
            return t;
        }
    };

  template<typename T, std::size_t N>
    struct _ct_type<T[N]>
    {
        static ct_type const*
        get()
        {
            static ct_array* t = 0;
            if (!t) {
#ifdef MORE_LANG_USE_GC
                t = new(UseGC) ct_array(_ct_type<T>::get(), N);
#else
                t = new ct_array(_ct_type<T>::get(), N);
#endif
            }
            return t;
        }
    };

  template<typename T, std::size_t N>
    struct _ct_type<T const[N]>
    {
        static ct_type const*
        get()
        {
            static ct_type const* t = 0;
            if (!t)
                t = to_cv(_ct_type<T[N]>::get(), true, false);
            return t;
        }
    };

  template<typename T, std::size_t N>
    struct _ct_type<T volatile[N]>
    {
        static ct_type const*
        get()
        {
            static ct_type const* t = 0;
            if (!t)
                t = to_cv(_ct_type<T[N]>::get(), false, true);
            return t;
        }
    };

  template<typename T, std::size_t N>
    struct _ct_type<T const volatile[N]>
    {
        static ct_type const*
        get()
        {
            static ct_type const* t = 0;
            if (!t)
                t = to_cv(_ct_type<T[N]>::get(), true, true);
            return t;
        }
    };


  template<> struct _ct_type<void>              { static ct_type* get(); };
//   template<> struct _ct_type<bool>           { static ct_type* get(); };
  template<> struct _ct_type<char>              { static ct_type* get(); };
  template<> struct _ct_type<signed char>       { static ct_type* get(); };
  template<> struct _ct_type<unsigned char>     { static ct_type* get(); };
  template<> struct _ct_type<short>             { static ct_type* get(); };
  template<> struct _ct_type<unsigned short>    { static ct_type* get(); };
  template<> struct _ct_type<int>               { static ct_type* get(); };
  template<> struct _ct_type<unsigned int>      { static ct_type* get(); };
  template<> struct _ct_type<long>              { static ct_type* get(); };
  template<> struct _ct_type<unsigned long>     { static ct_type* get(); };
#ifdef CXX_HAVE_LONG_LONG
  template<> struct _ct_type<long long>         { static ct_type* get(); };
  template<> struct _ct_type<unsigned long long>{ static ct_type* get(); };
#endif
  template<> struct _ct_type<float>             { static ct_type* get(); };
  template<> struct _ct_type<double>            { static ct_type* get(); };
  template<> struct _ct_type<long double>       { static ct_type* get(); };

#ifdef MORE_LANG_USE_GC
  template<> struct _ct_type<gc_wstring>        { static ct_type* get(); };
  template<> struct _ct_type<gc_string>         { static ct_type* get(); };
  template<> struct _ct_type<identifier>        { static ct_type* get(); };
  template<> struct _ct_type<io::sourceref>     { static ct_type* get(); };
#endif
  ///\endif

  /** Returns the ct_type descriptor of \a T.  If T is not a builtin
      type, or a pointer to or array of such, \c register_ct_type_of
      must be called once first with the same type argument to
      register the type descriptor. */
  template<typename T>
    inline ct_type const*
    ct_type_of()
    {
        if (ct_type const* t = _ct_type<T>::get())
            return t;
        else
            throw std::logic_error("more::lang::ct_type_of<\""
                                   + std::string(typeid(T).name())
                                   + "\">: Type is not registered.");
    }

  /** Return type \c ct_type descriptor of \a T. */
  template<typename T>
    inline ct_type const*
    ct_type_of(T x)
    {
        return _ct_type<T>::get();
    }

  /** Provide a type descriptor \a t for the type \a T. */
  template<typename T>
    inline void
    register_ct_type_of(ct_type const* t)
    {
        if (_ct_type<T>::get())
            throw std::logic_error("more::lang::register_ct_type_of: "
                                   "Multiple definitions of type "
                                   "description.");
        _ct_type<T>::set(t);
    }

  /** Return result type of a binary arithmetic operation on \a x and
      \a y, or 0 if invalid.  The result is detemined by type
      promotion and coversion rule. */
  ct_type const* arithmetic_result_type(ct_type const* x, ct_type const* y);

}}
#endif

---