definitions.h

Go to the documentation of this file.

#ifndef BASIS_DEFINITIONS_GROUP
#define BASIS_DEFINITIONS_GROUP

/*****************************************************************************\
*                                                                             *
*  Name   : definitions                                                       *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1991-$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 support that we always like to see.
#include <ctype.h>
#ifndef EMBEDDED_BUILD
  #include <new>
#else
  #include <string.h>
#endif

#ifdef __WIN32__
  #ifndef CLAM_BUILT
    #include <__build_configuration.h>
  #endif
#endif



#ifndef HOOPLE_CODEBASE
  #define HOOPLE_CODEBASE
#endif

// postpone this until we have turned on the codebase flag.
#include "outcome.h"


const char *software_product_name();

#ifndef NIL
  #define NIL 0
#endif

#ifndef NULL
  #define NULL 0
#endif

#ifndef BITS_PER_BYTE
  #define BITS_PER_BYTE 8
#endif

#ifndef PI_APPROX 
  #define PI_APPROX 3.14159265358
#endif


#ifndef formal
  #define formal(parameter)
#endif

#ifndef byte
  typedef unsigned char byte;
#endif

#if defined(UNICODE) && defined(__WIN32__)
  typedef wchar_t flexichar;
#else
  // this version simply defangs any conversions.
  typedef char flexichar;
#endif

#ifndef u_int
  typedef unsigned int u_int;
#endif
#ifndef u_short
  typedef unsigned short u_short;
#endif
#ifndef u_long
  typedef unsigned long u_long;
#endif

// we define some maximum and minimum values that are helpful.  note that this
// assumes a platform where the "int" type is 32 bits.  also note that this no
// longer supports antiquated platforms like windows 3.x or pc dos.
#ifndef MAXINT
  #define MAXINT 0x7fffffff
#endif
#ifndef MININT
  #define MININT 0x80000000
#endif
#ifndef MAXLONG
  #define MAXLONG 0x7fffffff
#endif
#ifndef MINLONG
  #define MINLONG 0x80000000
#endif
#ifndef MAXCHAR
  #define MAXCHAR 0x7f
#endif
#ifndef MINCHAR
  #define MINCHAR 0x80
#endif
#ifndef MAXSHORT
  #define MAXSHORT 0x7fff
#endif
#ifndef MINSHORT
  #define MINSHORT 0x8000
#endif
#ifndef MAXBYTE
  #define MAXBYTE 0xff
#endif
#ifndef MINBYTE
  #define MINBYTE 0x00
#endif

// Provide definitions for integers with platform independent specific sizes.
// Note that these may have to be adjusted for 64 bit platforms.
typedef char int8;
typedef unsigned char uint8;
typedef signed short int16;
typedef unsigned short uint16;
typedef signed long int32;
typedef unsigned long uint32;


// useful time constants.

// the _ms suffix indicates that these are measured in milliseconds.
const int SECOND_ms = 1000;  
const int MINUTE_ms = 60 * SECOND_ms;  
const int HOUR_ms = 60 * MINUTE_ms;  
const int DAY_ms = 24 * HOUR_ms;  

// the _s suffix indicates that these are measured in seconds.
const int MINUTE_s = 60;  
const int HOUR_s = 60 * MINUTE_s;  
const int DAY_s = 24 * HOUR_s;  

// useful general constants.

const int KILOBYTE = 1024;  
const int MEGABYTE = KILOBYTE * KILOBYTE;  
const int GIGABYTE = MEGABYTE * KILOBYTE;  
inline double TERABYTE() { return double(GIGABYTE) * double(KILOBYTE); }



// these forwards are so commonly used that they have made it into being
// part of the HOOPLE API.  they are all defined in basis headers.

class byte_array;
class byte_sequence;
class chaos;
class int_array;
class int_set;
class istring;
class istring_object;
class mutex;
class string_array;
class unichar_sequence;



#define DEFINE_FILTER(NAME, CURRENT_VALUE, INFO_STRING) \
  NAME = CURRENT_VALUE



#define DEFINE_EVENT(NAME, CURRENT_VALUE, INFO_STRING) \
  NAME = CURRENT_VALUE



struct common {


  enum outcomes {
    DEFINE_API_OUTCOME(OKAY, 0, "Everything is just fine"),
    DEFINE_API_OUTCOME(NOT_IMPLEMENTED, -1, "The invoked method is "
        "unimplemented"),
    DEFINE_API_OUTCOME(OUT_OF_RANGE, -2, "The value specified was out "
        "of bounds"),
    DEFINE_API_OUTCOME(NOT_FOUND, -3, "The item sought is not present"),
    DEFINE_API_OUTCOME(BAD_INPUT, -4, "Precondition failure--the parameters "
        "were inappropriate"),
    DEFINE_API_OUTCOME(BAD_TYPE, -5, "The objects are of incompatible types"),
    DEFINE_API_OUTCOME(IS_FULL, -6, "There is no room in the storage facility"),
    DEFINE_API_OUTCOME(IS_EMPTY, -7, "The container is empty currently"),
    DEFINE_API_OUTCOME(IS_NEW, -8, "The item is new"),
    DEFINE_API_OUTCOME(EXISTING, -9, "The item was already present"),
    DEFINE_API_OUTCOME(FAILURE, -10, "A failure has occurred"),
    DEFINE_API_OUTCOME(OUT_OF_MEMORY, -11, "There is not enough memory for the "
        "request according to the operating system"),
    DEFINE_API_OUTCOME(ACCESS_DENIED, -12, "The request was denied, possibly "
        "by the operating system"),
    DEFINE_API_OUTCOME(IN_USE, -13, "The object is already in exclusive use"),
    DEFINE_API_OUTCOME(UNINITIALIZED, -14, "The object has not been "
        "constructed properly"),
    DEFINE_API_OUTCOME(TIMED_OUT, -15, "The allowed time has now elapsed"),
    DEFINE_API_OUTCOME(GARBAGE, -16, "The request or response has been "
        "corrupted"),
    DEFINE_API_OUTCOME(NO_SPACE, -17, "A programmatic limit on storage space "
        "has been reached"),
    DEFINE_API_OUTCOME(DISALLOWED, -18, "The method denied the request"),
    DEFINE_API_OUTCOME(INCOMPLETE, -19, "The operation did not finish or the "
        "object is not completed"),
    DEFINE_API_OUTCOME(NO_HANDLER, -20, "The object type passed in was not "
        "understood by the invoked method"),
    DEFINE_API_OUTCOME(NONE_READY, -21, "There were no objects available"),
    DEFINE_API_OUTCOME(INVALID, -22, "That request or object was invalid"),
    DEFINE_API_OUTCOME(PARTIAL, -23, "The request was only partially finished"),
    DEFINE_API_OUTCOME(NO_LICENSE, -24, "The software license does not permit"
        "this request"),
    DEFINE_API_OUTCOME(UNEXPECTED, -25, "This item was unexpected, although "
        "not necessarily erroneous"),
    DEFINE_API_OUTCOME(ENCRYPTION_MISMATCH, -26, "The request failed due to a "
        "mismatch between encryption expected and encryption provided")
  };

  static const char *outcome_name(const outcome &to_name);

  enum list_positions {
    HEAD = -298,   
    TAIL,          
    MIDDLE         
  };

  enum how_to_copy { NEW_AT_END, NEW_AT_BEGINNING, DONT_COPY }; 


  enum filters {
    DEFINE_FILTER(NEVER_PRINT, -1, "Indicates that the diagnostic entry "
        "should be dropped"),
    DEFINE_FILTER(ALWAYS_PRINT, 0, "Indicates that the diagnostic entry "
        "should always be recorded"),
    DEFINE_FILTER(NETWORK_LOGGING, 1, "Extra logging of network events "
        "will be performed"),
    DEFINE_FILTER(UNUSUAL_LOGGING, 2, "Logging of unusual but not "
        "necessarily erroneous events"),

    // these must be updated if the above ordering or contents change.
    FIRST_LOW_LEVEL_FILTER = NETWORK_LOGGING,
    LAST_LOW_LEVEL_FILTER = UNUSUAL_LOGGING
  };

  static int_set low_level_filters();
};


// this declares the program-wide argument storage area.  these hang onto argc
// and argv if a program uses our macros for main.  visual c++ provides these
// (unless the program is linked erroneously, mixing statically and dynamically
// linked libraries), but we define them for unix & linux.  the HOOPLE_MAIN
// macro (see <opsystem/application_base.h>) sets them from the initial
// program arguments, although you can do that manually also.

#ifdef __UNIX__
  extern int __argc;
  extern char **__argv;
  #define DEFINE_ARGC_AND_ARGV int __argc = 0; char **__argv = NIL
#elif defined(__WIN32__)
  #include <stdlib.h>
    // the macros are defined in a fairly hard to untangle way in this header.
  #define DEFINE_ARGC_AND_ARGV 
    // the allocation of these two is already provided by ms-c.
#else
  // guessing this will be okay for other platforms.
  extern int __argc;
  extern char **__argv;
  #define DEFINE_ARGC_AND_ARGV int __argc = 0; char **__argv = NIL
#endif


#ifdef ENABLE_MEMORY_HOOK

// this section is what hooks us into the memory allocation scheme of c++.
// the new macro replaces standard ::new with our version so that we can track
// the file and line number along with the memory itself.

#define _AFX_NO_DEBUG_CRT
  // turn off debugging memory hooks for win32 since ours is enabled.

#ifndef __WIN32__
  void *operator new(size_t size, char *file, int line) throw (std::bad_alloc);

  inline void* operator new [] (size_t size, char *file, int line)
      throw (std::bad_alloc) { return ::operator new(size, file, line); }

  void operator delete (void *ptr) throw ();

  inline void operator delete [] (void *ptr) throw ()
  { ::operator delete(ptr); }
#else
  // win32 has different needs.
  void *operator new(size_t size, char *file, int line);
  inline void* operator new [] (size_t size, char *file, int line)
      { return ::operator new(size, file, line); }
  void operator delete (void *ptr);
  inline void operator delete [] (void *ptr) { ::operator delete(ptr); }
  inline void operator delete (void *ptr, char *file, int line)
      { ::operator delete(ptr); }
  inline void operator delete [] (void *ptr, char *file, int line)
      { ::operator delete(ptr); }
#endif

#define HOOPLE_NEW new(__FILE__, __LINE__)

#define new HOOPLE_NEW

#endif // ENABLE_MEMORY_HOOK


// compiler specific sections lie ahead.

#if defined(__WIN32__) || defined(_MSC_VER)
  // general windows defs.

  // allows older-style borland windows flags to work with mfc.
  #ifndef WIN32
    #define WIN32
  #endif
  #ifndef __WIN32__
    #define __WIN32__
  #endif
  #ifndef _WIN32
    #define _WIN32
  #endif
  #ifndef _Windows
    #define _Windows
  #endif
  #ifndef _WINDOWS
    #define _WINDOWS
  #endif

  #ifdef _MSC_VER
    // support for ms visual c++ compiler.

    // this special block is required for debugging builds to operate correctly.
    #ifdef _AFXDLL
      #ifdef _DEBUG
        #ifndef ENABLE_MEMORY_HOOK
          // this is needed for the ms memory debugging version.
          #include <afx.h>
          #define new DEBUG_NEW
            // redefine the new operator for debugging.
        #endif
      #endif
  
      // NOTE: if you are having compilation problems related to a line in
      // a header that has "new" in it, try modifying the file where the
      // problem occurs by putting this before the usages of "new":
      //     #include <basis/trap_new.addin>
      // and by putting this at the end of the file:
      //     #include <basis/untrap_new.addin>
      // this will turn off the new macro for the area between the includes.

      // the following blocks take care of getting us hooked into the modern
      // form of the common controls properly.
      #ifdef _M_IX86
        #pragma comment(linker,"/manifestdependency:\"type='win32' "   \
          "name='Microsoft.Windows.Common-Controls' "                \
          "version='6.0.0.0' "                                       \
          "processorArchitecture='x86' "                             \
          "publicKeyToken='6595b64144ccf1df' "                       \
          "language='*'\"")
      #endif

      #ifdef _M_AMD64
         #pragma comment(linker,"/manifestdependency:\"type='win32' "   \
          "name='Microsoft.Windows.Common-Controls' "                \
          "version='6.0.0.0' "                                       \
          "processorArchitecture='amd64' "                           \
          "publicKeyToken='6595b64144ccf1df' "                       \
          "language='*'\"")
      #endif

      #ifdef _M_IA64
         #pragma comment(linker,"/manifestdependency:\"type='win32' "   \
          "name='Microsoft.Windows.Common-Controls' "                \
          "version='6.0.0.0' "                                       \
          "processorArchitecture='ia64' "                            \
          "publicKeyToken='6595b64144ccf1df' "                       \
          "language='*'\"")
      #endif

    #endif
  
    // turns off annoying complaints from visual c++.
    #pragma warning(disable : 4251 4275 4003 4800 4355 4786 4290 4996 4407)
    #pragma warning(error : 4172)
      // 4251 and 4275 turn off warnings regarding statically linked code
      //    not being marked with dll import/export flags.
      // 4003 turns off warnings about insufficient number of parameters passed
      //    to a macro.
      // 4800 turns off the warning about conversion from int to bool not being
      //    efficient.
      // 4355 turns off the warning re 'this' used in base member init list.
      // 4786 turns off the warning about 'identifier' was truncated to 'number' 
      //    characters in the debug information which frequenly happens when 
      //    STL pair and set templates are expanded.
      // 4172 is made an error because this warning is emitted for a dangerous
      //    condition; the address of a local variable is being returned, making
      //    the returned object junk in almost all cases.

  #endif  // visual c++.
  
#elif defined(__UNIX__)
  #define LOBYTE(to_chop) (byte(to_chop))
  #define HIBYTE(to_chop) (byte(0xff & (u_short(to_chop) >> 8)))
#else
  // otherwise we know nothing about the compiler environment.
  // we'll go ahead and define a bool type in case the compiler hasn't.
  typedef int bool;  // simple bool type for compilers without it.
  enum _boolean_enumeration_ { false, true };
#endif

#endif // outer guard.

---