From: fluffymormegil <mpread@chiark.greenend.org.uk>
Date: Sun, 15 May 2011 01:26:27 +0000 (+0100)
Subject: libmormegil is now bug-free enough to be a dependency of dungeonbash
X-Git-Url: http://git.blackswordsonics.com/?a=commitdiff_plain;h=bcdb7db02a3859f8f0faeb7ccc012655b3bb3f51;p=libmormegil

libmormegil is now bug-free enough to be a dependency of dungeonbash
---

diff --git a/Makefile b/Makefile
index cfe2fff..c13e4c3 100644
--- a/Makefile
+++ b/Makefile
@@ -62,10 +62,10 @@ $(OBJ_BUILDDIR)/%.o: src/%.c
 $(OBJ_BUILDDIR)/%.o: src/%.cc
 	$(CXX) $(CXXFLAGS) $(COMMON_FLAGS) -c $< -o $@
 
-$(LIBMORMEGIL_SHARED): $(LIBOBJS)
+$(LIBMORMEGIL_SHARED_BUILT): $(LIBOBJS)
 	gcc $(LINKSTEP_FLAGS) -Wl,-soname,$(LIBMORMEGIL_SONAME) $^ -o $@
 
-$(LIBMORMEGIL_STATIC): $(LIBOBJS)
+$(LIBMORMEGIL_STATIC_BUILT): $(LIBOBJS)
 	ar rcs $@ $^
 
 clean:
@@ -110,11 +110,11 @@ install-headers:
 	mkdir -p $(DESTDIR)$(oldincludedir)/libmormegil
 	install -t $(DESTDIR)$(oldincludedir)/libmormegil include/libmormegil/*
 	mkdir -p $(DESTDIR)$(includedir)/libmormegil
-	install -t $(DESTDIR)$(includedir)/libmormegil include/libmormegil/*
+	install -m 0644 -t $(DESTDIR)$(includedir)/libmormegil include/libmormegil/*
 else
 install-headers:
 	mkdir -p $(DESTDIR)$(includedir)/libmormegil
-	install -t $(DESTDIR)$(includedir)/libmormegil include/libmormegil/* 
+	install -m 0644 -t $(DESTDIR)$(includedir)/libmormegil include/libmormegil/* 
 endif
 
 # vim:noexpandtab:fo=croq
diff --git a/include/libmormegil/Coord.hh b/include/libmormegil/Coord.hh
index 4169a3f..f2045db 100644
--- a/include/libmormegil/Coord.hh
+++ b/include/libmormegil/Coord.hh
@@ -44,31 +44,44 @@ namespace libmormegil
             return *this;
         }
 
-        ref operator *=(const basic_offset<T>& right)
+        ref operator *=(const_ref right)
         {
             y *= right.y;
             x *= right.x;
             return *this;
         }
 
-        bool operator <(const basic_offset<T>& right) const
+        basic_offset<T> operator -() const
+        {
+            basic_offset<T> tmp = { -y, -x };
+            return tmp;
+        }
+
+
+        bool operator <(const_ref right) const
         {
             return (y < right.y) || ((y == right.y) && (x < right.x));
         }
 
-        bool operator ==(const basic_offset<T>& right) const
+        bool operator ==(const_ref right) const
         {
             return (y == right.y) && (x == right.x);
         }
 
-        bool operator >(const basic_offset<T>& right) const
+        bool operator !=(const_ref right) const
+        {
+            return (y != right.y) || (x != right.x);
+        }
+
+        bool operator >(const_ref right) const
         {
             return (y > right.y) || ((y == right.y) && (x > right.x));
         }
 
-        int length_taxi() { return abs(y) + abs(x); }
-        int lengthsq() { return y * y + x * x; }
-        int length_inf() { return std::min(abs(y), abs(x)); }
+        int length_taxi() const { return abs(y) + abs(x); }
+        int lengthsq() const { return y * y + x * x; }
+        int length_inf() const { return std::max(abs(y), abs(x)); }
+        bool cardinal() const { return (abs(y) == abs(x)) || (y && !x) || (x && !y); }
     };
 
     template<typename T> struct basic_coord
@@ -110,6 +123,17 @@ namespace libmormegil
             return (y == right.y) && (x == right.x);
         }
 
+        bool operator !=(const_ref right) const
+        {
+            return (y != right.y) || (x != right.x);
+        }
+
+        basic_coord<T> operator -() const
+        {
+            basic_coord<T> tmp = { -y, -x };
+            return tmp;
+        }
+
         bool operator >(const_ref right) const
         {
             return (y > right.y) || ((y == right.y) && (x > right.x));
@@ -141,11 +165,62 @@ namespace libmormegil
             return std::max(abs(y), abs(x));
         }
     };
+    template<typename T> inline basic_coord<T> operator +(const basic_coord<T>& left, const basic_offset<T>& right)
+    {
+        basic_coord<T> tmp = { left.y + right.y, left.x + right.x };
+        return tmp;
+    }
+    template<typename T> inline basic_coord<T> operator -(const basic_coord<T>& left, const basic_offset<T>& right)
+    {
+        basic_coord<T> tmp = { left.y - right.y, left.x - right.x };
+        return tmp;
+    }
 
     typedef basic_offset<int32_t> Offset;
     typedef basic_coord<int32_t> Coord;
     typedef basic_offset<int64_t> Offset64;
     typedef basic_coord<int64_t> Coord64;
+    
+    template<> inline Offset abs<Offset>(const Offset& t)
+    {
+        Offset tmp = { abs(t.y), abs(t.x) };
+        return tmp;
+    }
+    template<> inline Offset64 abs<Offset64>(const Offset64& t)
+    {
+        Offset64 tmp = { abs(t.y), abs(t.x) };
+        return tmp;
+    }
+    template<> inline Coord abs<Coord>(const Coord& t)
+    {
+        Coord tmp = { abs(t.y), abs(t.x) };
+        return tmp;
+    }
+    template<> inline Coord64 abs<Coord64>(const Coord64& t)
+    {
+        Coord64 tmp = { abs(t.y), abs(t.x) };
+        return tmp;
+    }
+    template<> inline Offset sign<Offset>(const Offset& t)
+    {
+        Offset tmp = { sign(t.y), sign(t.x) };
+        return tmp;
+    }
+    template<> inline Offset64 sign<Offset64>(const Offset64& t)
+    {
+        Offset64 tmp = { sign(t.y), sign(t.x) };
+        return tmp;
+    }
+    template<> inline Coord sign<Coord>(const Coord& t)
+    {
+        Coord tmp = { sign(t.y), sign(t.x) };
+        return tmp;
+    }
+    template<> inline Coord64 sign<Coord64>(const Coord64& t)
+    {
+        Coord64 tmp = { sign(t.y), sign(t.x) };
+        return tmp;
+    }
 }
 #endif // libmormegil_Coord_hh
 
diff --git a/include/libmormegil/abs.hh b/include/libmormegil/abs.hh
index dc520a9..30fbb2a 100644
--- a/include/libmormegil/abs.hh
+++ b/include/libmormegil/abs.hh
@@ -12,7 +12,7 @@ namespace libmormegil
 {
     template<typename T> inline T abs(const T& i)
     {
-        i < T(0) ? -i : i;
+        return i < T(0) ? -i : i;
     }
 }
 #endif // libmormegil_abs_hh
diff --git a/include/libmormegil/mathops.hh b/include/libmormegil/mathops.hh
new file mode 100644
index 0000000..6c37e84
--- /dev/null
+++ b/include/libmormegil/mathops.hh
@@ -0,0 +1,17 @@
+// libmormegil/mathops.hh
+//
+// In jurisdictions where this file would be adjuged to contain copyrightable
+// material, it is copyright 2011 Martin Read, and released to the public
+// under the terms of the Creative Commons Public Domain Dedication (cc-0).
+// It is provided without any warranty, express or implied.
+
+#ifndef libmormegil_mathops_hh
+#define libmormegil_mathops_hh
+
+#include <libmormegil/abs.hh>
+#include <libmormegil/divup.hh>
+#include <libmormegil/sign.hh>
+
+#endif // libmormegil_mathops_hh
+
+// vim:ts=8:sw=4:expandtab:fo=c
diff --git a/include/libmormegil/serial.hh b/include/libmormegil/serial.hh
index e0fcd3c..3ad6e68 100644
--- a/include/libmormegil/serial.hh
+++ b/include/libmormegil/serial.hh
@@ -14,8 +14,25 @@
 
 namespace libmormegil
 {
+    inline void checked_fwrite(const void *buf, size_t sz, size_t count, FILE *fp)
+    {
+        int i = fwrite(buf, sz, count, fp);
+        if (i != count)
+        {
+            throw(errno);
+        }
+    }
+
+    inline void checked_fread(void *buf, size_t sz, size_t count, FILE *fp)
+    {
+        int i = fread(buf, sz, count, fp);
+        if (i != count)
+        {
+            throw(errno);
+        }
+    }
 
-    inline int serialize(FILE *fp, const int64_t *data)
+    inline int serialize_uc(FILE *fp, int64_t data)
     {
         unsigned char buf[8];
         for (int i = 0; i < 8; ++i)
@@ -25,7 +42,7 @@ namespace libmormegil
         return fwrite(buf, 8, 1, fp);
     }
 
-    inline int serialize(FILE *fp, const int32_t *data)
+    inline int serialize_uc(FILE *fp, int32_t data)
     {
         unsigned char buf[4];
         for (int i = 0; i < 4; ++i)
@@ -35,7 +52,7 @@ namespace libmormegil
         return fwrite(buf, 4, 1, fp);
     }
 
-    inline int serialize(FILE *fp, const int16_t *data)
+    inline int serialize_uc(FILE *fp, int16_t data)
     {
         unsigned char buf[2];
         for (int i = 0; i < 2; ++i)
@@ -45,7 +62,7 @@ namespace libmormegil
         return fwrite(buf, 2, 1, fp);
     }
 
-    inline int serialize(FILE *fp, const uint64_t *data)
+    inline int serialize_uc(FILE *fp, uint64_t data)
     {
         unsigned char buf[8];
         for (int i = 0; i < 8; ++i)
@@ -55,7 +72,7 @@ namespace libmormegil
         return fwrite(buf, 8, 1, fp);
     }
 
-    inline int serialize(FILE *fp, const uint32_t *data)
+    inline int serialize_uc(FILE *fp, uint32_t data)
     {
         unsigned char buf[4];
         for (int i = 0; i < 4; ++i)
@@ -65,7 +82,7 @@ namespace libmormegil
         return fwrite(buf, 4, 1, fp);
     }
 
-    inline int serialize(FILE *fp, const uint16_t *data)
+    inline int serialize_uc(FILE *fp, uint16_t data)
     {
         unsigned char buf[2];
         for (int i = 0; i < 2; ++i)
@@ -75,39 +92,46 @@ namespace libmormegil
         return fwrite(buf, 2, 1, fp);
     }
 
-    inline int serialize(FILE *fp, Coord const *data)
+    inline int serialize_uc(FILE *fp, bool data)
+    {
+        unsigned char buf;
+        buf = data ? 1 : 0;
+        return fwrite(&buf, 1, 1, fp);
+    }
+
+    inline int serialize_uc(FILE *fp, Coord const& data)
     {
         int i1, i2;
-        i1 = serialize(fp, &data->y);
-        i2 = serialize(fp, &data->x);
+        i1 = serialize_uc(fp, data.y);
+        i2 = serialize_uc(fp, data.x);
         return (i1 > 0) && (i2 > 0) ? 0 : -1;
     }
 
-    inline int serialize(FILE *fp, Coord64 const *data)
+    inline int serialize_uc(FILE *fp, Coord64 const& data)
     {
         int i1, i2;
-        i1 = serialize(fp, &data->y);
-        i2 = serialize(fp, &data->x);
+        i1 = serialize_uc(fp, data.y);
+        i2 = serialize_uc(fp, data.x);
         return (i1 > 0) && (i2 > 0) ? 0 : -1;
     }
 
-    inline int serialize(FILE *fp, Offset64 const *data)
+    inline int serialize_uc(FILE *fp, Offset64 const& data)
     {
         int i1, i2;
-        i1 = serialize(fp, &data->y);
-        i2 = serialize(fp, &data->x);
+        i1 = serialize_uc(fp, data.y);
+        i2 = serialize_uc(fp, data.x);
         return (i1 > 0) && (i2 > 0) ? 0 : -1;
     }
 
-    inline int serialize(FILE *fp, Offset const *data)
+    inline int serialize_uc(FILE *fp, Offset const& data)
     {
         int i1, i2;
-        i1 = serialize(fp, &data->y);
-        i2 = serialize(fp, &data->x);
+        i1 = serialize_uc(fp, data.y);
+        i2 = serialize_uc(fp, data.x);
         return (i1 > 0) && (i2 > 0) ? 0 : -1;
     }
 
-    inline int deserialize(FILE *fp, int64_t *data)
+    inline int deserialize_uc(FILE *fp, int64_t *data)
     {
         unsigned char buf[8];
         int64_t tmp;
@@ -125,7 +149,7 @@ namespace libmormegil
         return r;
     }
 
-    inline int deserialize(FILE *fp, int32_t *data)
+    inline int deserialize_uc(FILE *fp, int32_t *data)
     {
         unsigned char buf[4];
         int32_t tmp;
@@ -142,7 +166,7 @@ namespace libmormegil
         return r;
     }
 
-    inline int deserialize(FILE *fp, int16_t *data)
+    inline int deserialize_uc(FILE *fp, int16_t *data)
     {
         unsigned char buf[2];
         int32_t tmp;
@@ -159,7 +183,7 @@ namespace libmormegil
         return r;
     }
 
-    inline int deserialize(FILE *fp, uint64_t *data)
+    inline int deserialize_uc(FILE *fp, uint64_t *data)
     {
         unsigned char buf[8];
         uint64_t tmp;
@@ -177,7 +201,7 @@ namespace libmormegil
         return r;
     }
 
-    inline int deserialize(FILE *fp, uint32_t *data)
+    inline int deserialize_uc(FILE *fp, uint32_t *data)
     {
         unsigned char buf[4];
         uint32_t tmp;
@@ -194,7 +218,7 @@ namespace libmormegil
         return r;
     }
 
-    inline int deserialize(FILE *fp, uint16_t *data)
+    inline int deserialize_uc(FILE *fp, uint16_t *data)
     {
         unsigned char buf[2];
         uint32_t tmp;
@@ -211,38 +235,255 @@ namespace libmormegil
         return r;
     }
 
-    inline int deserialize(FILE *fp, Coord *data)
+    inline int deserialize_uc(FILE *fp, bool *data)
+    {
+        unsigned char buf;
+        int r = fread(&buf, 1, 1, fp);
+        if (r > 0)
+        {
+            *data = bool(buf);
+        }
+        return r;
+    }
+
+    inline int deserialize_uc(FILE *fp, Coord *data)
     {
         int i1, i2;
-        i1 = deserialize(fp, &data->y);
-        i2 = deserialize(fp, &data->x);
+        i1 = deserialize_uc(fp, &data->y);
+        i2 = deserialize_uc(fp, &data->x);
         return (i1 > 0) && (i2 > 0) ? 0 : -1;
     }
 
-    inline int deserialize(FILE *fp, Coord64 *data)
+    inline int deserialize_uc(FILE *fp, Coord64 *data)
     {
         int i1, i2;
-        i1 = deserialize(fp, &data->y);
-        i2 = deserialize(fp, &data->x);
+        i1 = deserialize_uc(fp, &data->y);
+        i2 = deserialize_uc(fp, &data->x);
         return (i1 > 0) && (i2 > 0) ? 0 : -1;
     }
 
-    inline int deserialize(FILE *fp, Offset *data)
+    inline int deserialize_uc(FILE *fp, Offset *data)
     {
         int i1, i2;
-        i1 = deserialize(fp, &data->y);
-        i2 = deserialize(fp, &data->x);
+        i1 = deserialize_uc(fp, &data->y);
+        i2 = deserialize_uc(fp, &data->x);
         return (i1 > 0) && (i2 > 0) ? 0 : -1;
     }
 
-    inline int deserialize(FILE *fp, Offset64 *data)
+    inline int deserialize_uc(FILE *fp, Offset64 *data)
     {
         int i1, i2;
-        i1 = deserialize(fp, &data->y);
-        i2 = deserialize(fp, &data->x);
+        i1 = deserialize_uc(fp, &data->y);
+        i2 = deserialize_uc(fp, &data->x);
         return (i1 > 0) && (i2 > 0) ? 0 : -1;
     }
 
+    inline void serialize(FILE *fp, int64_t data)
+    {
+        unsigned char buf[8];
+        for (int i = 0; i < 8; ++i)
+        {
+            buf[i] = data >> ((7 - i) << 3);
+        }
+        checked_fwrite(buf, 8, 1, fp);
+    }
+
+    inline void serialize(FILE *fp, int32_t data)
+    {
+        unsigned char buf[4];
+        for (int i = 0; i < 4; ++i)
+        {
+            buf[i] = data >> ((3 - i) << 3);
+        }
+        checked_fwrite(buf, 4, 1, fp);
+    }
+
+    inline void serialize(FILE *fp, int16_t data)
+    {
+        unsigned char buf[2];
+        for (int i = 0; i < 2; ++i)
+        {
+            buf[i] = data >> ((1 - i) << 3);
+        }
+        checked_fwrite(buf, 2, 1, fp);
+    }
+
+    inline void serialize(FILE *fp, uint64_t data)
+    {
+        unsigned char buf[8];
+        for (int i = 0; i < 8; ++i)
+        {
+            buf[i] = data >> ((7 - i) << 3);
+        }
+        checked_fwrite(buf, 8, 1, fp);
+    }
+
+    inline void serialize(FILE *fp, uint32_t data)
+    {
+        unsigned char buf[4];
+        for (int i = 0; i < 4; ++i)
+        {
+            buf[i] = data >> ((3 - i) << 3);
+        }
+        checked_fwrite(buf, 4, 1, fp);
+    }
+
+    inline void serialize(FILE *fp, uint16_t data)
+    {
+        unsigned char buf[2];
+        for (int i = 0; i < 2; ++i)
+        {
+            buf[i] = data >> ((1 - i) << 3);
+        }
+        checked_fwrite(buf, 2, 1, fp);
+    }
+
+    inline int serialize(FILE *fp, bool data)
+    {
+        unsigned char buf;
+        buf = data ? 1 : 0;
+        checked_fwrite(&buf, 1, 1, fp);
+    }
+
+    inline void serialize(FILE *fp, Coord const& data)
+    {
+        serialize(fp, data.y);
+        serialize(fp, data.x);
+    }
+
+    inline void serialize(FILE *fp, Coord64 const& data)
+    {
+        serialize(fp, data.y);
+        serialize(fp, data.x);
+    }
+
+    inline void serialize(FILE *fp, Offset64 const& data)
+    {
+        serialize(fp, data.y);
+        serialize(fp, data.x);
+    }
+
+    inline void serialize(FILE *fp, Offset const& data)
+    {
+        serialize(fp, data.y);
+        serialize(fp, data.x);
+    }
+
+    inline void deserialize(FILE *fp, int64_t *data)
+    {
+        unsigned char buf[8];
+        int64_t tmp;
+        checked_fread(buf, 8, 1, fp);
+        tmp = 0;
+        for (int i = 0; i < 8; ++i)
+        {
+            tmp <<= 8;
+            tmp |= buf[i];
+        }
+        *data = tmp;
+    }
+
+    inline void deserialize(FILE *fp, int32_t *data)
+    {
+        unsigned char buf[4];
+        int32_t tmp;
+        checked_fread(buf, 4, 1, fp);
+        for (int i = 0; i < 4; ++i)
+        {
+            tmp <<= 8;
+            tmp |= buf[i];
+        }
+        *data = tmp;
+    }
+
+    inline void deserialize(FILE *fp, int16_t *data)
+    {
+        unsigned char buf[2];
+        int32_t tmp;
+        checked_fread(buf, 2, 1, fp);
+        for (int i = 0; i < 2; ++i)
+        {
+            tmp <<= 8;
+            tmp |= buf[i];
+        }
+        *data = tmp;
+    }
+
+    inline void deserialize(FILE *fp, uint64_t *data)
+    {
+        unsigned char buf[8];
+        uint64_t tmp;
+        checked_fread(buf, 8, 1, fp);
+        tmp = 0;
+        for (int i = 0; i < 8; ++i)
+        {
+            tmp <<= 8;
+            tmp |= buf[i];
+        }
+        *data = tmp;
+    }
+
+    inline void deserialize(FILE *fp, uint32_t *data)
+    {
+        unsigned char buf[4];
+        uint32_t tmp;
+        checked_fread(buf, 4, 1, fp);
+        for (int i = 0; i < 4; ++i)
+        {
+            tmp <<= 8;
+            tmp |= buf[i];
+        }
+        *data = tmp;
+    }
+
+    inline void deserialize(FILE *fp, uint16_t *data)
+    {
+        unsigned char buf[2];
+        uint32_t tmp;
+        checked_fread(buf, 2, 1, fp);
+        for (int i = 0; i < 2; ++i)
+        {
+            tmp <<= 8;
+            tmp |= buf[i];
+        }
+        *data = tmp;
+    }
+
+    inline int deserialize(FILE *fp, bool *data)
+    {
+        unsigned char buf;
+        checked_fread(&buf, 1, 1, fp);
+        *data = bool(buf);
+    }
+
+    inline void deserialize(FILE *fp, Coord *data)
+    {
+        int i1, i2;
+        deserialize(fp, &data->y);
+        deserialize(fp, &data->x);
+    }
+
+    inline void deserialize(FILE *fp, Coord64 *data)
+    {
+        int i1, i2;
+        deserialize(fp, &data->y);
+        deserialize(fp, &data->x);
+    }
+
+    inline void deserialize(FILE *fp, Offset *data)
+    {
+        int i1, i2;
+        deserialize(fp, &data->y);
+        deserialize(fp, &data->x);
+    }
+
+    inline void deserialize(FILE *fp, Offset64 *data)
+    {
+        int i1, i2;
+        deserialize(fp, &data->y);
+        deserialize(fp, &data->x);
+    }
+
 }
 
 #endif
diff --git a/include/libmormegil/sign.hh b/include/libmormegil/sign.hh
index 754dbe1..5ee887d 100644
--- a/include/libmormegil/sign.hh
+++ b/include/libmormegil/sign.hh
@@ -9,7 +9,8 @@
 #define libmormegil_sign_hh
 
 namespace libmormegil
-    template<typename T> inline bool sign(const T& i)
+{
+    template<typename T> inline T sign(const T& i)
     {
         return (i < T(0)) ? -1 : (i > T(0)) ? 1 : 0;
     }
diff --git a/lib/libmormegil.a b/lib/libmormegil.a
new file mode 100644
index 0000000..b69c3b1
Binary files /dev/null and b/lib/libmormegil.a differ