--- rxvt-unicode/src/rxvtutil.h	2004/08/15 00:37:04	1.1
+++ rxvt-unicode/src/rxvtutil.h	2014/10/23 22:39:40	1.59
@@ -1,29 +1,81 @@
 #ifndef RXVT_UTIL_H
 #define RXVT_UTIL_H
 
-extern class byteorder {
-  static unsigned int e; // at least 32 bits
-public:
-  byteorder ();
-
-  static bool big_endian    () { return e == 0x11223344; };
-  static bool network       () { return e == 0x11223344; };
-  static bool little_endian () { return e == 0x44332211; };
-  static bool vax           () { return e == 0x44332211; };
-} byteorder;
+#include <new>
+#include <stdlib.h>
+#include <string.h>
+#include "ecb.h"
+#include "estl.h"
+
+#include "emman.h"
+
+// increases code size unless -fno-enforce-eh-specs
+#if __GNUC__
+# define NOTHROW
+# define THROW(x)
+#else
+# define NOTHROW  throw()
+# define THROW(x) throw x
+#endif
 
-template<typename T, typename U> static inline T min (T a, U b) { return a < b ? a : b; }
-template<typename T, typename U> static inline T max (T a, U b) { return a > b ? a : b; }
+// various utility functions
+template<typename T, typename U> static inline void min_it (T &a, U b) { a = a < (T)b ? a : (T)b; }
+template<typename T, typename U> static inline void max_it (T &a, U b) { a = a > (T)b ? a : (T)b; }
+
+template<typename T, typename U, typename V> static inline T    clamp    (T  v, U a, V b) { return v < (T)a ? a : v >(T)b ? b : v; }
+template<typename T, typename U, typename V> static inline void clamp_it (T &v, U a, V b) {    v = v < (T)a ? a : v >(T)b ? b : v; }
+
+template<typename T> static inline T squared_diff (T a, T b) { return (a - b) * (a - b); }
+
+// linear interpolation
+template<typename T, typename U, typename P>
+static inline T
+lerp (T a, U b, P p)
+{
+  return (long(a) * long(100 - p) + long(b) * long(p) + 50) / 100;
+}
 
-#include "simplevec.h"
+// return a very temporary (and never deallocated) buffer. keep small.
+void *rxvt_temp_buf (int len);
 
 template<typename T>
-struct vector : simplevec<T>
-{ };
+static inline T *
+rxvt_temp_buf (int len)
+{
+  return (T *)rxvt_temp_buf (len * sizeof (T));
+}
+
+// in range including end
+#define IN_RANGE_INC(val,beg,end) \
+  ((unsigned int)(val) - (unsigned int)(beg) <= (unsigned int)(end) - (unsigned int)(beg))
+
+// in range excluding end
+#define IN_RANGE_EXC(val,beg,end) \
+  ((unsigned int)(val) - (unsigned int)(beg) <  (unsigned int)(end) - (unsigned int)(beg))
+
+// for m >= -n, ensure remainder lies between 0..n-1
+#define MOD(m,n) (((m) + (n)) % (n))
+
+// makes dynamically allocated objects zero-initialised
+struct zero_initialized
+{
+  void *operator new (size_t s);
+  void operator delete (void *p, size_t s);
+};
+
+struct stringvec : simplevec<char *>
+{
+  ~stringvec ()
+  {
+    for (char **c = begin (); c != end (); c++)
+      free (*c);
+  }
+};
 
 #if 0
 template<typename T>
-struct rxvt_vec : simplevec<void *> {
+struct rxvt_vec : simplevec<void *>
+{
   typedef T *iterator;
 
   void push_back (T d) { simplevec<void *>::push_back ((void *)d); }
@@ -37,23 +89,30 @@
 };
 #endif
 
-template <typename I, typename T>
-I find (I first, I last, const T& value)
+inline void *
+operator new (size_t size) throw (std::bad_alloc)
 {
-  while (first != last && *first != value)
-    ++first;
+  // TODO: use rxvt_malloc
+  return malloc (size);
+}
 
-  return first;
+inline void
+operator delete (void *p) throw ()
+{
+  free (p);
 }
 
 template<typename T>
-struct auto_ptr {
+struct auto_ptr
+{
   T *p;
 
-  auto_ptr () : p (0) { }
+  auto_ptr ()     : p (0) { }
+
+  explicit
   auto_ptr (T *a) : p (a) { }
 
-  auto_ptr (auto_ptr<T> &a)
+  auto_ptr (auto_ptr &a)
   {
     p = a.p;
     a.p = 0;
@@ -71,32 +130,31 @@
     delete p;
   }
 
-  // void because it makes sense in our context
-  void operator = (T *a)
+  void reset (T *a)
   {
     delete p;
     p = a;
   }
 
-  void operator = (auto_ptr &a)
+  // void because it makes sense in our context
+  void operator =(auto_ptr &a)
   {
-    *this = a.p;
-    a.p = 0;
+    reset (a.release ());
   }
 
   template<typename A>
-  void operator = (auto_ptr<A> &a)
+  void operator =(auto_ptr<A> &a)
   {
-    *this = a.p;
-    a.p = 0;
+    reset (a.release ());
   }
 
-  operator T * () const { return p; }
+  T *operator ->() const { return p; }
+  T &operator *() const { return *p; }
 
-  T *operator -> () const { return p; }
-  T &operator * () const { return *p; }
+  operator T *()  { return p; }
+  T *get () const { return p; }
 
-  T *get ()
+  T *release()
   {
     T *r = p;
     p = 0;
@@ -106,13 +164,5 @@
 
 typedef auto_ptr<char> auto_str;
 
-struct stringvec : simplevec<char *>
-{
-  ~stringvec ()
-  {
-    for (char **c = begin (); c != end (); c++)
-      delete [] *c;
-  }
-};
 #endif