debugger.cpp

Go to the documentation of this file.

#ifndef DEBUGGER_IMPLEMENTATION_FILE
#define DEBUGGER_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : debugger                                                          *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1995-$now By Author.  This program 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 is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "debugger.h"
#include "win_ext.rh"

#include <basis/convert_utf.h>
#include <basis/function.h>
#include <basis/istring.h>
#include <basis/packable.h>
#include <basis/portable.h>

debugger::debugger(void *recipient, synchronicity synch,
    line_ending ending, time_stamp_method stamp)
: log_base(),
  _recipient(recipient),
  _synch(synch),
  _stamp(stamp)
{
  eol(ending);
}

debugger::~debugger() {}

const u_int &debugger::EVENT()
{
#ifdef __WIN32__
  // this string is used to register a unique windows message that is used
  // for communication between the debugger object and a debugger object.
  const char *DEBUG_UNIQUIFIER = "dbg_interprocess_event";
  static u_int ev = RegisterWindowMessage(to_unicode_temp(DEBUG_UNIQUIFIER));
#else
  static u_int ev = 0;
#endif
  return ev;
}

outcome debugger::log(u_int string_table_id, void *instance, int filter)
{
#ifdef __WIN32__
  return log(portable::rc_string(string_table_id,
      (application_instance)instance), filter);
#else
  if (string_table_id || instance || filter) {}
  return common::NOT_IMPLEMENTED;
#endif
}

void *debugger::recipient() const { return _recipient; }

byte_array *debugger::create_debug_message(const istring &info,
    line_ending ending, int filter, time_stamp_method stamp)
{
  // the format for the debugging info structure is:
  //    short ending;  // how to end the line.
  //    int filter;  // what filter to apply.
  //    byte message[];  // the actual message as a packed istring.

  byte_array *to_send = new byte_array;
  basis::attach(*to_send, short(ending));
  basis::attach(*to_send, filter);
  istring real_info;
  if (info.t() && (stamp == ADD_STAMP) )
    real_info = timestamp(true, true);
  real_info += info;
  real_info.pack(*to_send);
  return to_send;
}

istring debugger::crack_debug_message(void *lparam,
    line_ending &ending, int &filter)
{
  // the message to print is extracted from the global chunk.
  byte_array *received = (byte_array *)lparam;
  // snag the ending.
  short the_end;
  basis::detach(*received, the_end);
  ending = line_ending(the_end);
  // grab the filter.
  basis::detach(*received, filter);
  // and finally, the data.
  istring to_return;
  to_return.unpack(*received);
  WHACK(received);  // get rid of the storage.
  return to_return;
}

outcome debugger::log(const istring &info, int filter)
{
  // break out if there's no window to send to (we've done the stream and file
  // printing already).
  if (!_recipient) return common::BAD_INPUT;
#ifdef __WIN32__
  if (!IsWindow((HWND)_recipient)) {
    // this handle is no longer valid.
    _recipient = NIL;
    return common::BAD_INPUT;
  }
  HGLOBAL holder = create_debug_message(info, eol(), filter, _stamp);
  // send the info.
  if (_synch == immediate)
    ::SendMessage((window_handle)_recipient, debugger::EVENT(), 0,
        (LPARAM)holder);
  else
    ::PostMessage((window_handle)_recipient, debugger::EVENT(), 0,
        (LPARAM)holder);
  return common::OKAY;
#else
  if (!info || filter) {}
  return common::NOT_IMPLEMENTED;
#endif
}


#endif //DEBUGGER_IMPLEMENTATION_FILE

---