---

more/lang/cx_locator.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: cx_locator.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $


#ifndef MORE_LANG_CX_LOCATOR_H
#define MORE_LANG_CX_LOCATOR_H

#include <stdexcept>
#include <more/gen/gc_string.h>
#include <more/lang/fwd.h>
#include <more/lang/ct_struct.h>
#include <more/lang/ct_proto.h>
#include <more/lang/cx_expr.h>
#include <more/lang/location.h>


namespace more {
namespace lang {

  /** The locator of an object inside a compound.  This can be be used
      to runtime or to gererate C source code. */
  struct cx_locator : cx_expr
  {
      typedef std::size_t size_type;
    private:
      typedef ct_struct::member_const_iterator member_const_iterator;

//     public:
//       /** Construct the identity locator operator. */
//       cx_locator(ct_type* rtt)
//        : m_cxt_locr(0),
//          m_cxt_type(0),
//          m_offset_count(0),
//          m_offset_arr(0) {}

    protected:
      /// Used for struct members and pointer derefs.
      cx_locator(cx_locator* cxt_locr,
                 ct_type const* cxt_type,
                 ct_type const* result_type,
                 size_type offset_count);

      /// Partical construction used by ct_struct::member.
      cx_locator(ct_type const* arg0_type,
                 ct_type const* result_type);

    public:
      /** The result type of the locator. */
      ct_type const* result_type() const
      {
          return static_cast<ct_proto const*>(type_of())->result_type();
      }

      /** The argument type of the locator. */
      ct_type const* arg0_type() const
      {
          return static_cast<ct_proto const*>(type_of())->arg_type(0);
      }

      virtual void print_operation_pre(std::ostream&) const = 0;
      virtual void print_operation_post(std::ostream&) const = 0;

      virtual void append_ctors_to(cx_block*);
      virtual void append_dtors_to(cx_block*);

      /** The locator of the context.  If this is a member, the
          context is a structure, if this is a pointer dereference,
          the context is a pointer, etc.  */
      cx_locator const* context_locator() const { return m_cxt_locr; }

      /** Return true iff \a loc0 and \a loc1 are equal.  The locators
          are equal if, given the same argument address, they give the
          same address.
          \pre \c loc0->type_of() and \c loc1->type_of() are the
          same. */
      friend bool
      equal(cx_locator* loc0, cx_locator* loc1)
      {
          return loc0->offset_count() == loc1->offset_count()
              && std::equal(loc0->offset_begin(), loc0->offset_end(),
                            loc1->offset_begin());
      }

    protected:
      /** Returns the type of the context of this locator.  It is
          more instructive to look at the overloads provided in
          derived classes. */
      ct_type const* context_type() const { return m_cxt_type; }

    public:
      /** Apply the locator operator to ptr. */
      void* apply(void* ptr);

      void debug_dump(std::ostream& os);

    private:
      size_type         offset_count() const { return m_offset_count; }
      size_type const*  offset_begin() const { return m_offset_arr; }
      size_type const*  offset_end() const
      {
          return m_offset_arr + m_offset_count;
      }

      // The context of this locator and its type.
      cx_locator const*         m_cxt_locr;
      ct_type const*            m_cxt_type;

      // Runtime locator: Offsets.
      // An optimalization. Each element represents a translation of
      // the address, and dereference happend _beween_ each element.
      size_type                 m_offset_count;
      size_type*                m_offset_arr;

      friend struct cx_member_locator;
      friend struct cx_deref_locator;
      friend struct rt_arg_locator;
      friend struct rt_result_locator;
  };

  /** The locator of a member in a structure. */
  struct cx_member_locator : cx_locator
  {
      cx_member_locator(ct_struct const*, ct_struct::member_const_iterator);
      cx_member_locator(cx_locator*, ct_struct::member_const_iterator);
      cx_member_locator(cx_locator*, cx_member_locator const*);

      virtual ct_type const* result_type() const;
      virtual void print_operation_pre(std::ostream&) const;
      virtual void print_operation_post(std::ostream&) const;

      ct_struct const* context_type() const
      {
          return static_cast<ct_struct const*>(m_cxt_type);
      }

    private:
      ct_struct::member_const_iterator  m_it_memb;
  };

  /** The locator of an object referred to by a pointer. */
  struct cx_deref_locator : cx_locator
  {
      explicit cx_deref_locator(ct_pointer const*);
      explicit cx_deref_locator(cx_locator*);
      cx_deref_locator(cx_locator*, cx_deref_locator const*);

      virtual ct_type const* result_type() const;
      virtual void print_operation_pre(std::ostream&) const;
      virtual void print_operation_post(std::ostream&) const;

      ct_pointer const* context_type() const
      {
          return static_cast<ct_pointer const*>(m_cxt_type);
      }
  };

  /** Handler for a location inside a location.  This is implemented
      as an \c cx_locator applied to the result of another
      <tt>cx_resolver</tt>. */
  struct cx_locator_resolver : resolver
  {
      /** Construct a sublocation \a lr of \a h. */
      cx_locator_resolver(resolver* h, cx_locator* lr)
          : m_locn(h),
            m_locr(lr) {}

      virtual ct_type const* resolve_type_of() const;
      virtual void* resolve();
      virtual bool equal_to(resolver* rhs);

    private:
      location          m_locn;
      cx_locator*       m_locr;
  };

}}

#endif

---