function.h

Go to the documentation of this file.

#ifndef FUNCTIONS_GROUP
#define FUNCTIONS_GROUP

/*****************************************************************************\
*                                                                             *
*  Name   : functions                                                         *
*  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 "callstack_tracker.h"
#include "chaos.h"

#include <string.h>  //memcpy.

template <class type> inline type maximum(type a, type b)
        { return (a > b)? a : b; }
template <class type> inline type minimum(type a, type b)
        { return (a < b)? a : b; }

template <class type> inline type absolute_value(type a)
        { return (a >= 0)? a : -a; }

template <class type> inline bool positive(type a) { return a > 0; }
template <class type> inline bool non_positive(type a) { return a <= 0; }
template <class type> inline bool negative(type a) { return a < 0; }
template <class type> inline bool non_negative(type a) { return a >= 0; }

namespace basis {
  // the following comparisons are borrowed from the STL.  they provide the
  // full set of numerical operators for any object that defines the operators
  // for equality comparison (==) and less than (<).
  template <class T1, class T2>
  inline bool operator != (const T1 &x, const T2 &y) { return !(x == y); }
  template <class T1, class T2>
  inline bool operator > (const T1 &x, const T2 &y) { return y < x; }
  template <class T1, class T2>
  inline bool operator <= (const T1 &x, const T2 &y) { return !(y < x); }
  template <class T1, class T2>
  inline bool operator >= (const T1 &x, const T2 &y) { return !(x < y); }
}

template <class type> inline bool range_check(const type &c, const type &low,
    const type &high) { return (c >= low) && (c <= high); }

template <class type> inline type square(const type &a) { return a * a; }

template <class type> inline void flip_increasing(type &a, type &b)
      { if (b < a) { type tmp = a; a = b; b = tmp; } }

template <class type> inline void flip_decreasing(type &a, type &b)
      { if (b > a) { type tmp = a; a = b; b = tmp; } }

template <class type> inline void swap_values(type &a, type &b)
      { type tmp = a; a = b; b = tmp; }

template <class type> inline type sign(type a)
      { if (a < 0) return -1; else if (a > 0) return 1; else return 0; }

template <class type> inline void shuffle_list(type *list, int elems) {
  const chaos rando;
  for (int i = 0; i < elems; i++) {  // iterate on list.
    int new_posn = rando.inclusive(0, elems - 1);  // pick a new slot.
    if (new_posn == i) continue;  // no change here.
    // exchange the current item with the random slot number's item.
    type hold = list[i];
    list[i] = list[new_posn];
    list[new_posn] = hold;
  }
}


template <class type>
inline type number_of_packets(type message_size, type packet_size)
{ return message_size / packet_size + ((message_size % packet_size) != 0); }

template <class type>
inline type last_packet_size(type message_size, type packet_size)
{ return message_size % packet_size? message_size % packet_size : packet_size; }
  /*< The companion call to number_of_packets; it returns the size of the last
  packet in the sequence of packets, taking into account the special case
  where the message_size divides evenly. */


// helpful coding / debugging macros:


template<class contents>
inline void WHACK(contents * &ptr) { if (ptr) { delete ptr; ptr = NIL; } }

#define GC_WHACK(ptr) \
  delete ptr; \
  ptr = NIL

#ifndef low_byte
  #define low_byte(w) ((byte)(w))
#endif
#ifndef high_byte
  #define high_byte(w) ((byte)(uint16(w) >> 8))
#endif

#ifndef low_short
  #define low_short(l) ((u_short)(l))
#endif
#ifndef high_short
  #define high_short(l) ((u_short)(u_int(l) >> 16))
#endif


#define __WHERE__ isprintf("%s [line %d]", __FILE__, __LINE__)


#define FUNCDEF(func_in) \
  const char *func = (const char *)func_in; \
  frame_tracking_instance __trail_of_function(static_class_name(), func, \
      __FILE__, __LINE__, true)

#define BASE_FUNCTION(func) istring just_function = istring(func); \
  istring function_name = static_class_name(); \
  function_name += istring("::") + just_function

#define FUNCTION(func) BASE_FUNCTION(func); \
  function_name += ": "; \
  update_current_stack_frame_line_number(__LINE__)

#define BASE_INSTANCE_FUNCTION(func) istring just_function = istring(func); \
  istring function_name = instance_name(); \
  function_name += istring("::") + just_function

#define INSTANCE_FUNCTION(func) BASE_INSTANCE_FUNCTION(func); \
  function_name += ": "; \
  update_current_stack_frame_line_number(__LINE__)


template <class contents>
void memory_assign(contents *destination, const contents *source, int length) {
  #ifdef SYSV
    ::memcpy((void *)source, (void *)destination, length);
  #else
    ::memcpy((void *)destination, (void *)source, length);
  #endif
}


template <class contents>
void object_assign(contents *destination, const contents *source) {
  if (!destination || !source) return;
  memory_assign(destination, source, sizeof(contents));
}

template <class type> type &bogonic() { static type _bogon; return _bogon; }



#endif

---