---

more/lang/ct_struct.h

Go to the documentation of this file.

//  Copyright (C) 2001  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_struct.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $


#ifndef MORE_LANG_CT_STRUCT_H
#define MORE_LANG_CT_STRUCT_H

#include <more/lang/ct_type.h>
#include <more/gen/string.h>
#include <stdexcept>
#include <list>

namespace more {
namespace lang {

  /** \class ct_incomplete ct_struct.h more/lang/ct_struct.h
   **
   ** A type which can only be passed as a pointer. */
  struct ct_incomplete : ct_type
  {
      /** Construct a type constructor for an incomplete type with
          name \a c_name. */
      explicit ct_incomplete(char const* c_name)
#ifdef MORE_LANG_USE_FFI
          : m_c_name(c_name) {}
#else
          : ct_type(0, 0),
            m_c_name(c_name) {}
#endif

      /** Return a clone of the type description.  This should never
          be needed for this subclass. */
      virtual ct_incomplete* clone() const;

      /** Return the type name provided at construction. */
      char const* c_name() const { return m_c_name; }

#ifdef MORE_LANG_PROVIDE_FFI
      /** The \c ffi_type of this \c ct_type. */
      virtual ffi_type* ffi_type_of() const;
#endif

      /** Throw an exception. */
      virtual void      construct_copy(void*, void*)    const;

      /** Throw an exception. */
      virtual void      destruct(void*)                 const;

      /** Throw an exception. */
      virtual bool      equal(void*, void*)             const;

      /** Print the type name. */
      virtual void print_declaration_pre(std::ostream&, printopt_type) const;

      /** Do nothing. */
      virtual void print_declaration_post(std::ostream&, printopt_type) const;

      /** Trow an exception. */
      virtual void      hash(hash_type&) const;

      /** True if the type names are equal. */
      virtual bool      equal_to(ct_type const*) const;

    private:
      char const* m_c_name;
  };

  /** \class ct_struct ct_struct.h more/lang/ct_struct.h
   **
   ** The layout of a store which is of ct_struct type.  Classes are
   ** built on top of this. */
  struct ct_struct : ct_type
  {
      /** \class member ct_struct.h more/lang/ct_struct.h
       **
       ** A descriptor of a member of a structure. */
      struct member
      {
          typedef std::size_t size_type;

          static const size_type no_offset = (size_type)-1;
        private:
          member() {}
          member(ct_type const* t, char const* c_name, member* link = 0)
              : m_ct_type(t),
                m_c_name(c_name),
                m_base_link(link) {}

        public:
          /// The \c ct_type of this member.
          ct_type const* type_of()      const { return m_ct_type; }

          /// The \c offset of this member.
          /// \pre The \c ct_struct containig this member must be frozen.
          size_type     offset()        const { return m_offset; }

          /// The C identifier of this member, if applicable.
          char const*   c_name()        const { return m_c_name; }

          /// Return \c p translated \c offset() bytes.
          void*         apply(void* p)  const { return (char*)p + m_offset; }

        private:
          ct_type const*        m_ct_type;
          char const*           m_c_name;
          size_type             m_offset;
          member*               m_base_link;

          friend class ct_struct;
      };

    private:
#ifdef MORE_LANG_USE_GC
      typedef std::list< member, more::gen::gc_allocator<member> > container;
#else
      typedef std::list<member> container;
#endif

    public:
      typedef std::size_t size_type;

      /// A bidirectionaly iterator over the range of members.
      typedef container::iterator member_iterator;

      /// A bidirectionaly iterator over the range of const members.
      typedef container::const_iterator member_const_iterator;

      /** Construct a new struct. Do not provide a name for types to
          be defined in a package. */
      explicit ct_struct(char const* c_name = 0);

      virtual ~ct_struct();

      /// Return a clone of structure description.
      virtual ct_struct* clone() const;

      /// Inform that the description is completed.
      void freeze()
      {
          if (!is_frozen()) finish();
      }

      /// True if \c freeze() was called.
      bool              is_frozen() const { return m_is_frozen; }

      /// Append a named member to the structure.
      member_iterator   append(ct_type const*, char const*);

      /// Append an anonymous member to the structure.
      member_iterator   append(ct_type const* t)
      {
          return append(t, more::gen::struniq_dense(member_count()));
      }

      /// Append an inherited type to the structure.  This inheritance
      /// is not layout compatible with C++.
      member_iterator   append_inherited(ct_type const* t);

      /** Find an inherited type \a t as any subtype of \c this.  If
          such a type is fond, return the \c ct_struct which contains
          it and its member descriptor.  If the type is ambiguous,
          return the uppermost \a ct_struct which contain all
          occurances of \a t, and 0 for the member descriptor.  If
          there is no such subtype, return zero for both the structure
          and member descriptor.
          \pre \c this and \a t are not the same. */
      std::pair<ct_struct const*, member const*>
                        find_inherited_rec(ct_type const* t) const;

      /** Project \a ptr of pointer to \a this type to a pointer to
          inherited type \a t.  Return 0 if \a t is not an inherited
          type.  */
      void*             proj(void* ptr, ct_type const* t) const;

      /// @{
      /// The range over members, including inheritance members.
      member_iterator   member_begin() { return m_lst.begin(); }
      member_iterator   member_end() { return m_lst.end(); }
      member_const_iterator member_begin() const { return m_lst.begin(); }
      member_const_iterator member_end() const { return m_lst.end(); }
      /// @}

      /// The number of members, including inheritance members.
      size_type         member_count() const { return m_lst.size(); }

      bool              is_optimized() const { return m_do_optimize; }

      /// The C identifier of this type.
      identifier        c_name() const { return m_c_name; }

      /// Set the C identifier for this type.
      void              set_c_name(identifier id) { m_c_name = id; }

#ifdef MORE_LANG_PROVIDE_FFI
      /// The libffi description of this type.
      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      hash(hash_type&)                const;
      virtual bool      equal_to(ct_type const*)        const;

      /** Prints a forward declaration as C/C++ source code. */
      void              print_forward(std::ostream&, printopt_type=0) const;

      virtual void print_declaration_pre(std::ostream&, printopt_type) const;
      virtual void print_declaration_post(std::ostream&, printopt_type) const;

      /** Prints the definition as C/C++ source code. For C
          print_forward must also be called before print_definition to
          create a valid source file.  For both languages it is a good
          idea to print all forward declarations first in case a
          structure contains a pointer to a type defined after its
          definition. */
      void              print_definition(std::ostream&, printopt_type=0) const;

    private:
      void finish();
      void req_not_frozen() const;
      void req_frozen() const
      {
          if (!is_frozen())
              throw std::logic_error("more::lang::ct_struct: Is not frozen.");
      }

      identifier        m_c_name;
      container         m_lst;
      member*           m_base_link;
      unsigned int      m_is_frozen : 1;
      unsigned int      m_do_optimize : 1;
#ifdef MORE_LANG_PROVIDE_FFI
      mutable ffi_type  m_ffi_type;
#endif

      static size_type const s_capacity_init = 32;
  };

}}
#endif

---