portable.h

Go to the documentation of this file.

#ifndef PORTABILITY_GROUP
#define PORTABILITY_GROUP

/*****************************************************************************\
*                                                                             *
*  Name   : portability definitions                                           *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1994-$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 "array.h"


// forward.
class char_star_array;

// gnarly headers that are needed for certain types of compilation...

#ifdef __UNIX__
  #include <unistd.h>
#endif
#ifndef NO_XWINDOWS
  #ifdef __XWINDOWS__
    #include <Intrinsic.h>
    #include <StringDefs.h>
    #include <Xm/Xm.h>
    #include <Xlib.h>
  #endif
#endif
#ifdef __WIN32__
  #ifndef STRICT
    #define STRICT
  #endif
  // windows headers...
  #ifndef _AFXDLL
    // include ms-windows headers only if we're not doing mfc; mfc has its own
    // special way of including the headers.
    #include <windows.h>
  #else
    #include <afx.h>
    #include <afxwin.h>
  #endif
  // winsock support...
  #undef FD_SETSIZE
  #define FD_SETSIZE 1000
    // if you don't set this, you can only select on a default of 64 sockets.
  #include <winsock2.h>
#endif

// forward.
struct timeval;
class version;

// wrapper classes defined in the sequel...
//
//   application_instance -- this program's application object; used mainly
//       in ms-windows.
//
//   window_handle -- a wrapper for the root of all objects that can be
//       referred to in the relevant windowing system.

#ifdef __UNIX__
  // the application_instance class is implemented very simply for unix;
  // it's a stand-in since unix apps don't refer to an instance handle like
  // ms-windows does.
  typedef void *application_instance;

  // some definitions to quiet complaints from win32-based code.
  #ifndef LONGINT_SIZE
    #if defined(__alpha) || (defined(__HOS_AIX__) && defined(_LP64)) \
        || defined(__sparcv9) || defined(__LP64__) 
      #define LONGINT_SIZE 8
    #else
      #define LONGINT_SIZE 4
    #endif
  #endif
  #if (LONGINT_SIZE == 4)
    // be compatible with linux's definitions on this subject.
    typedef unsigned long DWORD;
  #else
    typedef unsigned int DWORD;
  #endif

  typedef void *HANDLE;

  //temp; these just mimic function prototypes coming from non-portable code.
  typedef void *ATOM;
  typedef void *BITMAPINFO;
  typedef void *HBITMAP;
  typedef void *HDC;
  typedef void *RGBQUAD;
  #define LoadBitmap(a, b) (a)
  #define __stdcall 
  #define afx_msg

  // portability definitions for the X windowing system.
  #ifndef NO_XWINDOWS  // protects regions with similar names.
  #ifdef __XWINDOWS__
    typedef Widget window_handle;

    typedef Colormap window_colormap;

    typedef XColor window_color;

    typedef XmString window_string;

//is that really fixed?
    const int MAXIMUM_COLOR_INTENSITY = 65535;
      // largest valid value a color component (R, G or B) can have.
  #else
    // no x-windows.
    typedef void *window_handle;
  #endif
  #endif
#endif

#ifdef __WIN32__
  typedef HINSTANCE application_instance;
    // our moniker for an application's guts.

  typedef HWND window_handle;
    // our alias for window handles in win32.
#endif

// now the actual portable namespace...

namespace portable {

  // assorted useful system functions:

  version get_OS_version();

  u_int process_id();

  istring current_directory();

  istring application_name();

  istring module_name(const void *module_handle = NIL);

  u_int system_uptime();

  double rolling_uptime();

  void sleep_ms(u_int msec);

  istring env_string(const istring &variable_name);

  bool set_environ(const istring &variable_name, const istring &value);

  u_int system_error();

  istring system_error_text(u_int error_to_show);

  istring null_device();

  char_star_array break_line(istring &app, const istring &parameters);

  enum process_launch_flags {
    HIDE_APP_WINDOW = 0x1,
    AWAIT_APP_EXIT = 0x2,
    RETURN_IMMEDIATELY = 0x4,
    AWAIT_VIA_POLLING = 0x8,
    SHELL_EXECUTE = 0x10
  };

  u_int launch_process(const istring &app_name, const istring &command_line,
          int flag, u_int &child_id);

  timeval fill_timeval_ms(int milliseconds);

  // this only really helps for win32.
  extern application_instance _i_handle;
  #define DEFINE_INSTANCE_HANDLE application_instance portable::_i_handle = 0

  #define SET_INSTANCE_HANDLE(value) portable::_i_handle = value

  #define GET_INSTANCE_HANDLE() portable::_i_handle


  // Unix and Linux specific items are included here.
  #ifdef __UNIX__
    istring get_cmdline_from_proc();

    char *itoa(int to_convert, char *buffer, int radix);

    #define RGB(r, g, b) (b + (g << 8) + (r << 16))
  #endif

  // ms-windows of more modern types, i.e. win32.
  #ifdef __WIN32__

    bool event_poll(MSG &message);

//hmmm: is there an equivalent to this for unix?
    bool is_address_valid(const void *address, int size_expected,
            bool writable = false);

    #define BROADCAST_HANDLE HWND_BROADCAST

    bool has_win95_style_shell();

    enum known_operating_systems { WIN_95, WIN_NT, WIN_2K, WIN_XP, UNKNOWN_OS };
    known_operating_systems determine_OS();

    istring rc_string(u_int id, application_instance instance);

    istring rc_string(u_int id);

    void show_wait_cursor();
    void show_normal_cursor();

  #endif // win32.

} // namespace.

class char_star_array : public array<char *>
{
public:
  inline char_star_array() : array<char *>(0, NIL, SIMPLE_COPY | EXPONE
      | FLUSH_INVISIBLE) {}
  inline ~char_star_array() {
    // clean up all the memory we're holding.
    for (int i = 0; i < length(); i++) {
      delete [] (use(i));
    }
  }
};

#endif // outer guard.

---