---

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

/** \file more/lang/package.h
 **
 ** Definitions of \c package an \c cx_package_variable. */


#ifndef MORE_LANG_PACKAGE_H
#define MORE_LANG_PACKAGE_H

#include <more/gen/memory.h>
#include <more/lang/fwd.h>
#include <more/lang/cx_expr.h>
#include <more/lang/ct_proto.h>
#include <more/lang/ct_struct.h>
#include <more/lang/location.h>
#include <more/lang/stdint.h>
#include <ltdl.h>
#include <set>
#include <map>


namespace more {
namespace lang {

  /** \class cx_package_variable package.h more/lang/package.h
   **
   ** The representation of a global C variable with a definition. */
  struct cx_package_variable : cx_identifier, resolver
  {
      /** Construct a package variable bound to \a val. */
      explicit cx_package_variable(cx_expr* val);

    protected:
      /** Construct a package variable with no binding.  The subclass
          must override the \c make_definiens member function. */
      explicit cx_package_variable(ct_type const* t);

      ~cx_package_variable();

    public:
      virtual ct_type const* resolve_type_of() const;

      /** Return the definiens of the variable's definition. */
      cx_expr* definiens()
      {
          if (!m_val) {
              m_includes.clear();
              m_val = make_definiens();
          }
          return m_val;
      }

      /** Set the version of the symbol.  This is used to avoid
          recompilation of code that is unchanged, and works only if
          the \c package is constructed with \c split_p=true. */
      void set_version(unsigned long version)
      {
          m_has_version = 1;
          m_version = version;
      }

      /** Print the definition of the variable. */
      void print_definition(std::ostream& os);

      /** Appends ctors of the variable and its definition. */
      virtual void append_ctors_to(cx_block* blk);

      /** Appends dtors of the variable and its definition. */
      virtual void append_dtors_to(cx_block* blk);

    protected:
      /** Add an #include directive to the implementation file. */
      void include(std::string const& name) { m_includes.insert(name); }

      /** Try to resolve the location by writing out the source,
          compile and dynamically link it in. */
      virtual void* resolve();

      /** Create the definition of \a idr.  The constructors and
          destructors of the defined variable, if any, will be put
          into separate functions, which will be run when the library
          is <tt>lt_dlopen</tt>ed or <tt>lt_dlclose</tt>d. */
      virtual cx_expr* make_definiens();

      /** Return the equality of \c this and \c rhs as pointers. */
      virtual bool equal_to(resolver* rhs);

    private:
      cx_expr*          m_val;
      package*          m_pkg;

      // Used to store the old m_ptr that must be copied when
      // relinking this value.
      void*             m_old_ptr;

      location*         m_client;

      unsigned long     m_version;
      unsigned int      m_has_version : 1;

      // Non-zero if m_ptr points to a dlsym.
      unsigned int      m_is_dlsym : 1;

      // Non-zero if a public definition.
      unsigned int      m_export_p : 1;

      std::set<std::string> m_includes;

      friend class package;
  };


  /** \class package package.h more/lang/package.h
   **
   ** A package of C function and type definitions.  An internal
   ** package has access to a writable directory determined by the
   ** package name, where it can place source code and do
   ** compilations.  An external package acts as a wrapper for an \c
   ** lt_dlhandle (see libltdl in the GNU Libtool). */
  struct package
      : gc_cleanup
  {
      /// Type used for flags.
      typedef uint_least16_t flag_type;

      /// Allow compilations to be done for this package.
      static flag_type const flag_compile       = 1 << 0;

      /// Split source files into one per symbol and compile separately.
      static flag_type const flag_split         = 1 << 2;

      /// Create a header file.
      static flag_type const flag_create_header = 1 << 3;

      /// Include header files in source file.
      static flag_type const flag_use_headers   = 1 << 4;

      /// Mask of backend language specification
      static flag_type const flag_lang_mask = 3 << 8;

      /// Generate C code.
      static flag_type const flag_lang_c        = 1 << 8;

      /// Generate C++ code (unfinished).
      static flag_type const flag_lang_cxx      = 2 << 8;

      /** If generating C++ code, don't use extern "C" linkage for
       ** exported names.  Note that C++ mangeling is not handled, so
       ** with this flag set, the generated symbols can not be linked
       ** into the application. */
      static flag_type const flag_cxx_symbols = 1 << 10;

      /// FYI, the default flags for internal packages.
      static flag_type const flags_intern_default
          = flag_compile | flag_create_header | flag_use_headers | flag_lang_c;

      /// FYI, the default flags for external packages.
      static flag_type const flags_extern_default = 0;

    private:
      struct ct_struct_ptr_less
      {
          bool operator()(ct_struct* x, ct_struct* y) const
          {
              return x->c_name() < y->c_name();
          }
      };
      typedef std::set<package*>                        requires_container;
      typedef requires_container::iterator              requires_iterator;
      typedef std::set< gen::hidden_ptr<package> >      required_by_container;
      typedef required_by_container::iterator           required_by_iterator;
      typedef std::set<ct_struct*, ct_struct_ptr_less>  struct_container;
      typedef std::map<identifier, cx_package_variable*> definition_container;
      typedef definition_container::iterator            definition_iterator;

    public:
      /** Construct a package rooted at \a cxt named \a idr.  If \a
          split_p, use one source file per symbol. \a cxt may be 0.
          The flags are set to <tt>flags_intern_default & ~flags_clear
          | flags_set</tt>.  */
      package(package* cxt, identifier idr,
              flag_type flags_set = 0, flag_type flags_clear = 0);

      /** Construct an external package \a idr rooted at \a cxt with
          symbols from \a h.  The destructor will call \c
          lt_dlclose(h).  \a cxt may be 0.  The flags are set to
          <tt>flags_extern_default & ~flags_clear |
          flags_set</tt>.  */
      package(package* cxt, identifier idr, lt_dlhandle h,
              flag_type flags_set = 0, flag_type flags_clear = 0);

      /** Construct an external package \a idr rooted at \a cxt with
          symbols from \c lt_dlopenext(file). \a cxt may be 0.  The
          flags are set to <tt>flags_extern_default & ~flags_clear |
          flags_set</tt>.  */
      package(package* cxt, identifier idr, char const* file,
              flag_type flags_set = 0, flag_type flags_clear = 0);

      /** Destruct the package, this should be called by the collector. */
      ~package();

      /** Return the flags. */
      flag_type flags() const { return m_flags; }

      /** True if this is an external package. */
      bool is_extern() const { return m_extern_p; }

      /** Define the variable \a pv in \a this package under the name
          \a idr.  The package name and names of parent packages will
          be prepended to the name.  If \a export_p is true, the name
          will have external linkage. */
      void define(identifier idr, cx_package_variable* pv, bool export_p);

      /** Define the variable of \a locn in \a this package under the
          name \a idr.  See the other overload for details.  \pre \c
          locn->get_resolver() is a \c cx_package_variable. */
      void define(identifier idr, location& locn, bool export_p);

      /** Undefine the variable with the name \a idr. */
      void undefine(identifier idr);

      /** Bind \a idr to \a tp is this package.  The definition of the
          type is written out if needed. */
      void define_type(identifier idr, ct_struct* tp, bool export_p);

      /** Return the \c cx_package_variable of \a idfr or 0 if none. */
      cx_package_variable*
      lookup(identifier idr)
      {
          definition_iterator it = m_defs.find(idr);
          if (it == m_defs.end())
              return 0;
          else
              return it->second;
      }

      /** Resolve the fully named symbol \a sym. */
      void*
      resolve_no_prefix(char const* sym)
      {
          if (m_dlhandle) {
              if (void* ptr = lt_dlsym(m_dlhandle, sym))
                  return ptr;
          }
          return link(sym);
      }

      /** Resolve \a sym adding the package prefix if applicable. */
      void*
      resolve(char const* sym)
      {
          return resolve_no_prefix(mk_c_name(sym).c_str());
      }

      /** Create sources now.  This is normally done
          automatically.  */
      void create_sources();

      /** Create sources and (re-)compile all symbols now.  This is
          normally done automatically when an identifier is
          requested. */
      void compile();

      /** Return a path for the package with components separated by
       ** \a sep. */
      gen::gc_string mk_path(char const* sep) const;

    private:
      void* link(char const* sym);
      void unlink();
      bool use_cxx_symbols() const { return m_flags & flag_cxx_symbols; }

      gen::gc_string mk_c_name(gen::gc_string) const;
      gen::gc_string include_name() const;
      char const* top_builddir() const { return "bld"; } //XXX

      // The package which contains the definition of this package.
      package*                  m_context;

      // The name of the C++ namespace or a string to mangle into
      // public C identifiers.
      identifier                m_c_name;

      // The definitions in this package.
      definition_container      m_defs;

      // Type definitions.
      struct_container          m_structs;

      // Packages that this package depends on.
      requires_container        m_requires;

      // Packages depending on this package.  This container contains
      // "hidden_ptr"s that are erased by the package when it is
      // freed.
      required_by_container     m_required_by;

      // The compilation state.  Always non-zero for an internal package.
      compilation*              m_comp;

      // Used if split_p to create the initializer and finalizer code.
      std::set<identifier>      m_inits;
      std::set<identifier>      m_finalizers;

      // This is defined to the shared library handle afer
      // compilation with open_p = true.
      lt_dlhandle               m_dlhandle;

      // Function to call before closing the library.
      gen::gc_string            m_name_init;
      gen::gc_string            m_name_fin;
      void                      (*m_finalizer)();

      // Set if the package is external, i.e. constructed with an
      // lt_dlhandle.
      unsigned int              m_extern_p : 1;

      // Debugging flag set if a package which this depends on was
      // deleted.  This should only happend when this packages is also
      // scheduled for cleanup.
      unsigned int              m_dropped_dep : 1;

      // Failed to lt_dlclose previous revision of the libtool library.
      unsigned int              m_dl_not_closed : 1;

      flag_type                 m_flags;

      friend class cx_package_variable;
  };

  /// \internal
  package* bits_package();

  /** An anonymous package containing the symbols of the running
   ** program.
   **
   ** \pre The program must be compiled with \c -export-dynamic or \c
   ** -dlopen self (see the Libtool documentation).
   **
   ** \exception std::runtime_error if dlopen-ing itself is not
   ** possible. */
  package* self_package();
}}

#endif

---