Fix compiler warnings. Refactor the intercepts overrun code so that it

should work properly on big endian machines as well as little endian
machines.

Subversion-branch: /trunk/chocolate-doom
Subversion-revision: 1074

2 files changed, 83 insertions, 65 deletions

diff --git a/src/i_system.c b/src/i_system.c
index 5273a2f9..79fc711e 100644
--- a/src/i_system.c
+++ b/src/i_system.c
@@ -34,6 +34,8 @@
 #ifdef _WIN32
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
+#else
+#include <unistd.h>
 #endif
 
 #include "deh_main.h"
diff --git a/src/p_maputl.c b/src/p_maputl.c
index babe7f28..4ab5d1d5 100644
--- a/src/p_maputl.c
+++ b/src/p_maputl.c
@@ -745,100 +745,116 @@ extern fixed_t bulletslope;
 
 typedef struct
 {
-  int len;
-  int *adr;
+    int len;
+    void *addr;
+    boolean int16_array;
 } intercepts_overrun_t;
 
 // Intercepts memory table.  This is where various variables are located
 // in memory in Vanilla Doom.  When the intercepts table overflows, we
 // need to write to them.
 //
-// These are treated as ints when writing, which is okay in most cases,
-// as most of them are ints.  However, there is one potential 
-// cross-platform issue when overwriting the playerstarts[] array, as
-// this contains 16-bit integers, and these fields may get the wrong
-// values.
+// Almost all of the values to overwrite are 32-bit integers, except for
+// playerstarts, which is effectively an array of 16-bit integers and
+// must be treated differently.
 
 static intercepts_overrun_t intercepts_overrun[] =
 {
-	{4,   NULL},
-	{4,   NULL},     //&earlyout},
-	{4,   NULL},     //&intercept_p},
-	{4,   &lowfloor},
-	{4,   &openbottom},
-	{4,   &opentop},
-	{4,   &openrange},
-	{4,   NULL},
-	{120, NULL},     //&activeplats},
-	{8,   NULL},
-	{4,   &bulletslope},
-	{4,   NULL},     //&swingx},
-	{4,   NULL},     //&swingy},
-	{4,   NULL},
-	{40,  (int*)&playerstarts},
-	{4,   NULL},     //&blocklinks},
-	{4,   &bmapwidth},
-	{4,   NULL},     //&blockmap},
-	{4,   &bmaporgx},
-	{4,   &bmaporgy},
-	{4,   NULL},     //&blockmaplump},
-	{4,   &bmapheight},
-	{0,   NULL}
+    {4,   NULL,                          false},
+    {4,   NULL, /* &earlyout, */         false},
+    {4,   NULL, /* &intercept_p, */      false},
+    {4,   &lowfloor,                     false},
+    {4,   &openbottom,                   false},
+    {4,   &opentop,                      false},
+    {4,   &openrange,                    false},
+    {4,   NULL,                          false},
+    {120, NULL, /* &activeplats, */      false},
+    {8,   NULL,                          false},
+    {4,   &bulletslope,                  false},
+    {4,   NULL, /* &swingx, */           false},
+    {4,   NULL, /* &swingy, */           false},
+    {4,   NULL,                          false},
+    {40,  &playerstarts,                 true},
+    {4,   NULL, /* &blocklinks, */       false},
+    {4,   &bmapwidth,                    false},
+    {4,   NULL, /* &blockmap, */         false},
+    {4,   &bmaporgx,                     false},
+    {4,   &bmaporgy,                     false},
+    {4,   NULL, /* &blockmaplump, */     false},
+    {4,   &bmapheight,                   false},
+    {0,   NULL,                          false},
 };
 
 // Overwrite a specific memory location with a value.
 
 static void InterceptsMemoryOverrun(int location, int value)
 {
-	int i, offset;
+    int i, offset;
+    int index;
+    void *addr;
 
-	i = 0;
-	offset = 0;
+    i = 0;
+    offset = 0;
 
-	// Search down the array until we find the right entry
+    // Search down the array until we find the right entry
 
-	while (intercepts_overrun[i].len != 0)
-	{
-		if (offset + intercepts_overrun[i].len > location)
-		{
-			if (intercepts_overrun[i].adr != NULL)
-			{
-				intercepts_overrun[i].adr[(location - offset) / 4]
-				    = value;
-			}
-			break;
-		}
-
-		offset += intercepts_overrun[i].len;
-		++i;
-	}
+    while (intercepts_overrun[i].len != 0)
+    {
+        if (offset + intercepts_overrun[i].len > location)
+        {
+            addr = intercepts_overrun[i].addr;
+
+            // Write the value to the memory location.
+            // 16-bit and 32-bit values are written differently.
+
+            if (addr != NULL)
+            {
+                if (intercepts_overrun[i].int16_array)
+                {
+                    index = (location - offset) / 2;
+                    ((short *) addr)[index] = value & 0xffff;
+                    ((short *) addr)[index + 1] = (value >> 16) & 0xffff;
+                }
+                else
+                {
+                    index = (location - offset) / 4;
+                    ((int *) addr)[index] = value;
+                }
+            }
+
+            break;
+        }
+
+        offset += intercepts_overrun[i].len;
+        ++i;
+    }
 }
 
 // Emulate overruns of the intercepts[] array.
 
 static void InterceptsOverrun(int num_intercepts, intercept_t *intercept)
 {
-	int location;
+    int location;
 
-	if (num_intercepts <= MAXINTERCEPTS_ORIGINAL)
-	{
-		// No overrun
+    if (num_intercepts <= MAXINTERCEPTS_ORIGINAL)
+    {
+        // No overrun
 
-		return;
-	}
+        return;
+    }
 
-	location = (num_intercepts - MAXINTERCEPTS_ORIGINAL - 1) * 12;
+    location = (num_intercepts - MAXINTERCEPTS_ORIGINAL - 1) * 12;
 
-	// Overwrite memory that is overwritten in Vanilla Doom, using
-	// the values from the intercept structure.
-	//
-	// Note: the ->d.{thing,line} member should really have its
-	// address translated into the correct address value for 
-	// Vanilla Doom.
+    // Overwrite memory that is overwritten in Vanilla Doom, using
+    // the values from the intercept structure.
+    //
+    // Note: the ->d.{thing,line} member should really have its
+    // address translated into the correct address value for 
+    // Vanilla Doom.
 
-	InterceptsMemoryOverrun(location, intercept->frac);
-	InterceptsMemoryOverrun(location + 4, intercept->isaline);
-	InterceptsMemoryOverrun(location + 8, (int) intercept->d.thing);
+    InterceptsMemoryOverrun(location, intercept->frac);
+    InterceptsMemoryOverrun(location + 4, intercept->isaline);
+    InterceptsMemoryOverrun(location + 8, (int) intercept->d.thing);
 }