class_location.h

Go to the documentation of this file.

// $Header$
//
// Copyright (C) 2000 - 2004, by
//
// Carlo Wood, Run on IRC <carlo@alinoe.com>
// RSA-1024 0x624ACAD5 1997-01-26                    Sign & Encrypt
// Fingerprint16 = 32 EC A7 B6 AC DB 65 A6  F6 F6 55 DD 1C DC FF 61
//
// This file may be distributed under the terms of the Q Public License
// version 1.0 as appearing in the file LICENSE.QPL included in the
// packaging of this file.
//

#ifndef LIBCWD_CLASS_LOCATION_H
#define LIBCWD_CLASS_LOCATION_H

#ifndef LIBCWD_CONFIG_H
#include <libcwd/config.h>
#endif

#if CWDEBUG_LOCATION

#ifndef LIBCWD_PRIVATE_STRUCT_TSD_H
#include <libcwd/private_struct_TSD.h>
#endif
#ifndef LIBCWD_CLASS_OBJECT_FILE_H
#include <libcwd/class_object_file.h>
#endif
#ifndef LIBCW_LOCKABLE_AUTO_PTR_H
#include <libcwd/lockable_auto_ptr.h>
#endif
#ifndef LIBCW_STRING
#define LIBCW_STRING
#include <string>
#endif
#ifndef LIBCW_IOSFWD
#define LIBCW_IOSFWD
#include <iosfwd>
#endif

namespace libcwd {

// Forward declaration.
class location_ct;

  namespace _private_ {

enum hidden_st {
  filtered_location,
  unfiltered_location,
  new_location
};

// Forward declaration.
template<class OSTREAM>
  void print_location_on(OSTREAM& os, location_ct const& location);

  } // namespace _private_
} // namespace libcwd

// This header file uses hidden_st
#ifndef LIBCWD_CLASS_ALLOC_FILTER_H
#include <libcwd/class_alloc_filter.h>
#endif

namespace libcwd {

extern char const* const unknown_function_c;

class location_ct {
protected:
  lockable_auto_ptr<char, true> M_filepath;     
  union {
    char* M_filename;                           
    void const* M_initialization_delayed;       
    void const* M_unknown_pc;                   
  };
  unsigned int M_line;                          
  char const* M_func;                           
  object_file_ct const* M_object_file;          
  bool M_known;                                 
private:
#if CWDEBUG_ALLOC
  friend class alloc_filter_ct;
  mutable _private_::hidden_st M_hide;          // Indicates if this location is filtered by the current filter.
#endif

protected:
  // M_func can point to one of these constants, or to libcwd::unknown_function_c
  // or to a static string with the mangled function name.
  static char const* const S_uninitialized_location_ct_c;
  static char const* const S_pre_ios_initialization_c;
  static char const* const S_pre_libcwd_initialization_c;
  static char const* const S_cleared_location_ct_c;

public:
  explicit location_ct(void const* addr);
      // Construct a location object for address `addr'.
#if LIBCWD_THREAD_SAFE
  explicit location_ct(void const* addr LIBCWD_COMMA_TSD_PARAM);
      // Idem, but with passing the TSD.
#endif
  ~location_ct();

  location_ct();

  location_ct(location_ct const& location);

  location_ct& operator=(location_ct const& location);          // Assignment operator

  void lock_ownership() { if (M_known) M_filepath.lock(); }

  void pc_location(void const* pc);

  // Only public because libcwd calls it directly.
  void M_pc_location(void const* addr LIBCWD_COMMA_TSD_PARAM);

  void clear();

public:
  // Accessors
  bool is_known() const;

  std::string file() const;

  unsigned int line() const;

  char const* mangled_function_name() const;

  size_t filename_length() const { return M_known ? strlen(M_filename) : 0; }
  size_t filepath_length() const { return M_known ? strlen(M_filepath.get()) : 0; }

  object_file_ct const* object_file() const { return M_object_file; }

  // Printing
  void print_filepath_on(std::ostream& os) const;
  void print_filename_on(std::ostream& os) const;
  template<class OSTREAM>
    friend void _private_::print_location_on(OSTREAM& os, location_ct const& location);
#if (__GNUC__ == 3 && __GNUC_MINOR__ < 4)
  // This doesn't need to be a friend, but g++ 3.3.x and lower are broken.
  // We need to declare an operator<< this way as a workaround.
  friend std::ostream&
  operator<<(std::ostream& os, location_ct const& location)
  {
    _private_::print_location_on(os, location);
    return os;
  }
#endif

  // This is used in list_allocations_on.
  bool initialization_delayed() const { return (!M_object_file && (M_func == S_pre_ios_initialization_c || M_func == S_pre_libcwd_initialization_c)); }
  void const* unknown_pc() const { return (!M_object_file && M_func == unknown_function_c) ? M_unknown_pc : initialization_delayed() ? M_initialization_delayed : 0; }
#if CWDEBUG_ALLOC
  void handle_delayed_initialization(alloc_filter_ct const& filter);
  bool hide_from_alloc_list() const { return M_hide == _private_::filtered_location; }
  bool new_location() const { return M_hide == _private_::new_location; }
  void synchronize_with(alloc_filter_ct const&) const;
#endif
};

//#if (__GNUC__ > 3 || __GNUC_MINOR__ >= 4)
//extern std::ostream& operator<<(std::ostream& os, location_ct const& location);
//#endif

location_format_t location_format(location_format_t format);
 // End of group 'group_locations'

} // namespace libcwd

#endif // CWDEBUG_LOCATION
#endif // LIBCWD_CLASS_LOCATION_H