cleanup

svn-id: r10267

8 files changed, 763 insertions, 854 deletions

diff --git a/sword2/layers.cpp b/sword2/layers.cpp
index 9dfa9ad121..187f78c480 100644
--- a/sword2/layers.cpp
+++ b/sword2/layers.cpp
@@ -17,55 +17,44 @@
  * $Header$
  */
 
-//------------------------------------------------------------------------------------
-//high level layer initialising
+// high level layer initialising
 
-//the system supports:
-//		1 optional background parallax layer
-//		1 not optional normal backdrop layer
-//		3 normal sorted layers
-//		up to 2 foreground parallax layers
-
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
+// the system supports:
+//	1 optional background parallax layer
+//	1 not optional normal backdrop layer
+//	3 normal sorted layers
+//	up to 2 foreground parallax layers
 
 #include "stdafx.h"
-#include "driver/driver96.h"
 #include "build_display.h"
-#include "console.h"
 #include "debug.h"
 #include "header.h"
 #include "layers.h"
-#include "memory.h"
-#include "object.h"
 #include "protocol.h"
 #include "resman.h"
 #include "sound.h"	// (James22july97) for Clear_fx_queue() called from FN_init_background()
 
-//------------------------------------------------------------------------------------
+// this_screen describes the current back buffer and its in-game scroll
+// positions, etc.
 
+screen_info this_screen;
 
-screen_info	this_screen;	//this_screen describes the current back buffer and its in-game scroll positions, etc.
-//------------------------------------------------------------------------------------
-int32 FN_init_background(int32 *params)	//Tony11Sept96
-{
-//param	0 res id of normal background layer - cannot be 0
-//param	1 1 yes 0 no for a new palette
-//this screen defines the size of the back buffer
+int32 FN_init_background(int32 *params)	{	// Tony11Sept96
+	// param     0 res id of normal background layer - cannot be 0
+	// param     1 1 yes 0 no for a new palette
+	// this screen defines the size of the back buffer
 
 	_multiScreenHeader *screenLayerTable;	// James 06feb97
-	_screenHeader	*screen_head;
-	_layerHeader	*layer;
- 	_spriteInfo		spriteInfo;
-	uint32	j;
-	uint8	*file;
-	uint32	rv;
-
+	_screenHeader *screen_head;
+	_layerHeader *layer;
+ 	_spriteInfo spriteInfo;
+	uint32 j;
+	uint8 *file;
+	uint32 rv;
 
+#ifdef _SWORD2_DEBUG
 	//--------------------------------------
 	// Write to walkthrough file (zebug0.txt)
-	#ifdef _SWORD2_DEBUG
 	Zdebug(0,"=====================================");
 	Zdebug(0,"CHANGED TO LOCATION \"%s\"", FetchObjectName(*params));
 	Zdebug(0,"=====================================");
@@ -74,222 +63,192 @@ int32 FN_init_background(int32 *params)	//Tony11Sept96
 	Zdebug("=====================================");
 	Zdebug("CHANGED TO LOCATION \"%s\"", FetchObjectName(*params));
 	Zdebug("=====================================");
-	#endif
  	//--------------------------------------
+#endif
 
-	Clear_fx_queue();		// stops all fx & clears the queue (James22july97)
-
+	// stop all fx & clears the queue (James22july97)
+	Clear_fx_queue();
 
 #ifdef _SWORD2_DEBUG
 	Zdebug("FN_init_background(%d)", *params);
 
-	if	(!*params)
-	{
-		Con_fatal_error("ERROR: FN_set_background cannot have 0 for background layer id! (%s line=%u)",__FILE__,__LINE__);
+	if (!*params) {
+		Con_fatal_error("ERROR: FN_set_background cannot have 0 for background layer id! (%s line=%u)", __FILE__, __LINE__);
 	}
-#endif // _SWORD2_DEBUG
+#endif
 
-
-	//-------------------------------------------------------
 	// if the screen is still fading down then wait for black
 	WaitForFade();
 
-	//-------------------------------------------------------
-
-	if (this_screen.mask_flag)	// if last screen was using a shading mask (see below) (James 08apr97)
-	{
+	// if last screen was using a shading mask (see below) (James 08apr97)
+	if (this_screen.mask_flag) {
 		rv = CloseLightMask();
-
 		if (rv)
 			ExitWithReport("Driver Error %.8x [%s line %u]", rv, __FILE__, __LINE__);
 	}
 	
-	//--------------------------------------------------------
 	// New stuff for faster screen drivers (James 06feb97)
 
-	if (this_screen.background_layer_id)	// for drivers: close the previous screen if one is open
+	// for drivers: close the previous screen if one is open
+	if (this_screen.background_layer_id)
 		CloseBackgroundLayer();
 
-	//--------------------------------------------------------
-
+	this_screen.background_layer_id = *params;	// set the res id
+	this_screen.new_palette = *(params + 1);	// yes or no - palette is taken from layer file
 
-	this_screen.background_layer_id=*params;	//set the res id
-	this_screen.new_palette = *(params+1);	//yes or no - palette is taken from layer file
+	// ok, now read the resource and pull out all the normal sort layer
+	// info/and set them up at the beginning of the sort list - why do it
+	// each cycle
 
-
-//ok, now read the resource and pull out all the normal sort layer info
-//and set them up at the beginning of the sort list - why do it each cycle
-
-
-	file = res_man.Res_open(this_screen.background_layer_id);	//file points to 1st byte in the layer file
+	// file points to 1st byte in the layer file
+	file = res_man.Res_open(this_screen.background_layer_id);
 	
 	screen_head = FetchScreenHeader(file);
 
-	this_screen.number_of_layers= screen_head->noLayers;	//set number of special sort layers
+	//set number of special sort layers
+	this_screen.number_of_layers = screen_head->noLayers;
 	this_screen.screen_wide = screen_head->width;
 	this_screen.screen_deep = screen_head->height;
 
 	Zdebug("res test layers=%d width=%d depth=%d", screen_head->noLayers, screen_head->width, screen_head->height);
 
-	SetLocationMetrics(screen_head->width, screen_head->height);	//initialise the driver back buffer
-
+	//initialise the driver back buffer
+	SetLocationMetrics(screen_head->width, screen_head->height);
 
-	if	(screen_head->noLayers)
-		for	(j=0;j<screen_head->noLayers;j++)
-		{
-			layer=FetchLayerHeader(file,j);	//get layer header for layer j
+	if (screen_head->noLayers) {
+		for (j = 0; j < screen_head->noLayers; j++) {
+			// get layer header for layer j
+			layer = FetchLayerHeader(file, j);
 
-//			add into the sort list
+			// add into the sort list
 
-			sort_list[j].sort_y = layer->y+layer->height;	//need this for sorting - but leave the rest blank, we'll take from the header at print time
-			sort_list[j].layer_number=j+1;	//signifies a layer
+			// need this for sorting - but leave the rest blank,
+			// we'll take from the header at print time
+			sort_list[j].sort_y = layer->y + layer->height;
+			// signifies a layer
+			sort_list[j].layer_number = j + 1;
 
 			Zdebug("init layer %d", j);
 		}
+	}
 
+	// using the screen size setup the scrolling variables
 
+	// if layer is larger than physical screen
+	if (screen_head->width > screenWide || screen_head->height > screenDeep) {
+		// switch on scrolling (2 means first time on screen)
+		this_screen.scroll_flag = 2;
 
-//using the screen size setup the scrolling variables
-
-	if( ((screen_head->width) > screenWide) || (screen_head->height>screenDeep) )	// if layer is larger than physical screen
-	{
-		this_screen.scroll_flag = 2;	//switch on scrolling (2 means first time on screen)
+		// note, if we've already set the player up then we could do
+		// the initial scroll set here
 
-//	note, if we've already set the player up then we could do the initial scroll set here
+		// reset scroll offsets
 
-		this_screen.scroll_offset_x = 0;	//reset scroll offsets
+		this_screen.scroll_offset_x = 0;
 		this_screen.scroll_offset_y = 0;
 
-//		calc max allowed offsets (to prevent scrolling off edge) - MOVE TO NEW_SCREEN in GTM_CORE.C !!
-		this_screen.max_scroll_offset_x = screen_head->width-screenWide;		// NB. min scroll offsets are both zero
-		this_screen.max_scroll_offset_y = screen_head->height-(screenDeep-(RDMENU_MENUDEEP*2));	// 'screenDeep' includes the menu's, so take away 80 pixels
-	}
-	else	//layer fits on physical screen - scrolling not required
-	{
-		this_screen.scroll_flag = 0;	//switch off scrolling
-		this_screen.scroll_offset_x = 0;	//reset scroll offsets
+		// calc max allowed offsets (to prevent scrolling off edge) -
+		// MOVE TO NEW_SCREEN in GTM_CORE.C !!
+		// NB. min scroll offsets are both zero
+		this_screen.max_scroll_offset_x = screen_head->width-screenWide;
+		// 'screenDeep' includes the menu's, so take away 80 pixels
+		this_screen.max_scroll_offset_y = screen_head->height - (screenDeep - (RDMENU_MENUDEEP * 2));
+	} else {
+		// layer fits on physical screen - scrolling not required
+		this_screen.scroll_flag = 0;		// switch off scrolling
+		this_screen.scroll_offset_x = 0;	// reset scroll offsets
 		this_screen.scroll_offset_y = 0;
 	}
 
-	ResetRenderEngine();	//no inter-cycle scrol between new screens (see setScrollTarget in build display)
+	// no inter-cycle scroll between new screens (see setScrollTarget in
+	// build display)
+	ResetRenderEngine();
 
 	// these are the physical screen coords where the system
 	// will try to maintain George's actual feet coords
-	this_screen.feet_x=320;
-	this_screen.feet_y=340;
+	this_screen.feet_x = 320;
+	this_screen.feet_y = 340;
 
-
-	//----------------------------------------------------
 	// shading mask
 
 	screenLayerTable = (_multiScreenHeader *) ((uint8 *) file + sizeof(_standardHeader));
 
-	if (screenLayerTable->maskOffset)
-	{
-		spriteInfo.x			= 0;
-		spriteInfo.y			= 0;
-		spriteInfo.w			= screen_head->width;
-		spriteInfo.h			= screen_head->height;
-		spriteInfo.scale		= 0;
-		spriteInfo.scaledWidth	= 0;
-		spriteInfo.scaledHeight	= 0;
-		spriteInfo.type			= 0;
-		spriteInfo.blend		= 0;
-		spriteInfo.data			= FetchShadingMask(file);
-		spriteInfo.colourTable	= 0;
-
-		rv = OpenLightMask( &spriteInfo );
+	if (screenLayerTable->maskOffset) {
+		spriteInfo.x = 0;
+		spriteInfo.y = 0;
+		spriteInfo.w = screen_head->width;
+		spriteInfo.h = screen_head->height;
+		spriteInfo.scale = 0;
+		spriteInfo.scaledWidth = 0;
+		spriteInfo.scaledHeight = 0;
+		spriteInfo.type = 0;
+		spriteInfo.blend = 0;
+		spriteInfo.data = FetchShadingMask(file);
+		spriteInfo.colourTable = 0;
+
+		rv = OpenLightMask(&spriteInfo);
 		if (rv)
 			ExitWithReport("Driver Error %.8x [%s line %u]", rv, __FILE__, __LINE__);
 
-		this_screen.mask_flag=1;	// so we know to close it later! (see above)
+		// so we know to close it later! (see above)
+		this_screen.mask_flag = 1;
+	} else {
+		// no need to close a mask later
+		this_screen.mask_flag = 0;
 	}
-	else
-		this_screen.mask_flag=0;	// no need to close a mask later
-
-	//----------------------------------------------------
 
-   	res_man.Res_close(this_screen.background_layer_id);	//close the screen file
+	// close the screen file
+   	res_man.Res_close(this_screen.background_layer_id);
 
 	SetUpBackgroundLayers();
 
-
 	Zdebug("end init");
-	return(1);
+	return 1;
 }
-//------------------------------------------------------------------------------------
+
 // called from FN_init_background & also from control panel
 
-void SetUpBackgroundLayers(void)	// James(13jun97)
-{
+void SetUpBackgroundLayers(void) {		// James(13jun97)
 	_multiScreenHeader *screenLayerTable;	// James 06feb97
-	_screenHeader	*screen_head;
-	uint8	*file;
+	_screenHeader *screen_head;
+	uint8 *file;
+	int i;
 
-
-	if (this_screen.background_layer_id)	// if we actually have a screen to initialise (in case called from control panel)
-	{
-		//------------------------------
+	// if we actually have a screen to initialise (in case not called from
+	// control panel)
+	if (this_screen.background_layer_id) {
 		// open resource & set pointers to headers
+		// file points to 1st byte in the layer file
 
-		file = res_man.Res_open(this_screen.background_layer_id);	//file points to 1st byte in the layer file
+		file = res_man.Res_open(this_screen.background_layer_id);
 
 		screen_head = FetchScreenHeader(file);
 
 		screenLayerTable = (_multiScreenHeader *) ((uint8 *) file + sizeof(_standardHeader));
 
-		//------------------------------
-		// first background parallax
-
-		if (screenLayerTable->bg_parallax[0])
-			InitialiseBackgroundLayer(FetchBackgroundParallaxLayer(file,0));
-		else
-			InitialiseBackgroundLayer(NULL);
+		// Background parallax layers
 
-		//------------------------------
-		// second background parallax
-
-		if (screenLayerTable->bg_parallax[1])
-			InitialiseBackgroundLayer(FetchBackgroundParallaxLayer(file,1));
-		else
-			InitialiseBackgroundLayer(NULL);
+		for (i = 0; i < 2; i++) {
+			if (screenLayerTable->bg_parallax[i])
+				InitialiseBackgroundLayer(FetchBackgroundParallaxLayer(file, i));
+			else
+				InitialiseBackgroundLayer(NULL);
+		}
 
-		//------------------------------
-		// normal backround layer
+		// Normal backround layer
 
 		InitialiseBackgroundLayer(FetchBackgroundLayer(file));
 
-		//------------------------------
-		// first foreground parallax
+		// Foreground parallax layers
 
-		if (screenLayerTable->fg_parallax[0])
-			InitialiseBackgroundLayer(FetchForegroundParallaxLayer(file,0));
-		else
-			InitialiseBackgroundLayer(NULL);
-
-		//------------------------------
-		// second foreground parallax
-
-		if (screenLayerTable->fg_parallax[1])
-			InitialiseBackgroundLayer(FetchForegroundParallaxLayer(file,1));
-		else
-			InitialiseBackgroundLayer(NULL);
-
- 		//----------------------------------------------------
-
-		res_man.Res_close(this_screen.background_layer_id);	//close the screen file
+		for (i = 0; i < 2; i++) {
+			if (screenLayerTable->fg_parallax[i])
+				InitialiseBackgroundLayer(FetchForegroundParallaxLayer(file, i));
+			else
+				InitialiseBackgroundLayer(NULL);
+		}
 
-	 	//----------------------------------------------------
-	}
-	else	// no current screen to initialise! (In case called from control panel)
-	{
+		// close the screen file
+		res_man.Res_close(this_screen.background_layer_id);
 	}
 }
-
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
diff --git a/sword2/layers.h b/sword2/layers.h
index 8bc73b7dda..daf15926ce 100644
--- a/sword2/layers.h
+++ b/sword2/layers.h
@@ -20,42 +20,40 @@
 #ifndef	_LAYERS
 #define	_LAYERS
 
-//#include "src\driver96.h"
 #include "memory.h"
 
-
-
-
-
-
-
-
-typedef	struct
-{
-	uint16	scroll_offset_x;		// position x
-	uint16	scroll_offset_y;		// position y
-	uint16	max_scroll_offset_x;	// calc'ed in FN_init_background
-	uint16	max_scroll_offset_y;	//
-	int16	player_feet_x;			// feet coordinates to use - cant just fetch the player compact anymore
-	int16	player_feet_y;
-	int16	feet_x;					// special offset-to-player position - tweek as desired - always set in screen manager object startup
-	int16	feet_y;
-	uint16	screen_wide;			// size of background layer - hense size of back buffer itself (Paul actually malloc's it)
-	uint16	screen_deep;
-	uint32	background_layer_id;	//id of the normal background layer
-	uint16	number_of_layers;		// from the header of the main background layer
-	uint8	new_palette;			// set to non zero to start the palette held within layer file fading up after a build_display
-	uint8	scroll_flag;			// scroll mode 0 off 1 on
-	uint8	mask_flag;				// using shading mask
+typedef	struct {
+	uint16 scroll_offset_x;		// position x
+	uint16 scroll_offset_y;		// position y
+	uint16 max_scroll_offset_x;	// calc'ed in FN_init_background
+	uint16 max_scroll_offset_y;
+	// feet coordinates to use - cant just fetch the player compact anymore
+	int16 player_feet_x;
+	int16 player_feet_y;
+	// special offset-to-player position - tweek as desired - always set
+	// in screen manager object startup
+	int16 feet_x;
+	int16 feet_y;
+	// size of background layer - hence size of back buffer itself (Paul
+	// actually malloc's it)
+	uint16 screen_wide;
+	uint16 screen_deep;
+	uint32 background_layer_id;	// id of the normal background layer
+	// from the header of the main background layer
+	uint16 number_of_layers;
+	// set to non zero to start the palette held within layer file fading
+	// up after a build_display
+	uint8 new_palette;
+	uint8 scroll_flag;		// scroll mode 0 off 1 on
+	uint8 mask_flag;		// using shading mask
 } screen_info;
 
-
-extern	screen_info	this_screen;
-
+extern screen_info this_screen;
 
 int32 FN_init_background(int32 *params);	// Tony11Sept96
-void SetUpBackgroundLayers(void);			// James(13jun97)	called from control panel (as well as inside FN_init_background)
-
 
+// James(13jun97)
+// called from control panel (as well as inside FN_init_background)
+void SetUpBackgroundLayers(void);
 
 #endif
diff --git a/sword2/mem_view.cpp b/sword2/mem_view.cpp
index 3f50b04b9d..ceeee39aef 100644
--- a/sword2/mem_view.cpp
+++ b/sword2/mem_view.cpp
@@ -17,210 +17,159 @@
  * $Header$
  */
 
-//--------------------------------------------------------------------------------------
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-//#include <windows.h>
-
 #include "stdafx.h"
-#include "driver/driver96.h"
 #include "build_display.h"
 #include "console.h"
 #include "debug.h"
-#include "defs.h"
 #include "header.h"
-#include "layers.h"
 #include "mem_view.h"
 #include "memory.h"
 #include "resman.h"
 #include "sword2.h"	// (James11aug97) for CloseGame()
 
-//--------------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------------
-
-char	buf[50];	//has to be global because a local in Fetch_mem_owner is destroyed on exit
-//--------------------------------------------------------------------------------------
-void	Console_mem_display(void)	//Tony13Aug96
-{
-//
-	int	pass,found_end,k,j,free=0;
+// has to be global because a local in Fetch_mem_owner is destroyed on exit
+char buf[50];
+
+void Console_mem_display(void) {	// Tony13Aug96
+	int pass, found_end, k, j, free = 0;
 	_standardHeader	*file_header;
-	int	scrolls=0;
-	char	c;
-
-	char	inf[][20]=
-	{
-		{"M_null  "},
-		{"M_free  "},
-		{"M_locked"},
-		{"M_float "}
+	int scrolls = 0;
+	char c;
+
+	char inf[][20] = {
+		{ "M_null  " },
+		{ "M_free  " },
+		{ "M_locked" },
+		{ "M_float " }
 	};
 
-
-	j=base_mem_block;
-	do
-	{
-
-		if	(mem_list[j].uid<65536)
-		{
+	j = base_mem_block;
+	do {
+		if (mem_list[j].uid < 65536) {
 			file_header = (_standardHeader*) res_man.Res_open(mem_list[j].uid);
-			res_man.Res_close(mem_list[j].uid);	//close immediately so give a true count
+			// close immediately so give a true count
+			res_man.Res_close(mem_list[j].uid);
 
 			Zdebug("view %d", mem_list[j].uid);
 
+			pass = 0;
+			found_end = 0;
 
-			pass=0;
-			found_end=0;
-
-			for	(k=0;k<30;k++)
-			{
-				if (file_header->name[k]==0)
-				{	found_end=1;
+			for (k = 0; k < 30; k++) {
+				if (file_header->name[k] == 0) {
+					found_end = 1;
 					break;
 				}
 
-				if ( (file_header->name[k]<32)||(file_header->name[k]>'z'))
-					pass=1;
-
+				if (file_header->name[k] < ' ' || file_header->name[k] > 'z')
+					pass = 1;
 			}
 
-			if	(file_header->name[0]==0)
-				pass=1;	//also illegal
-
-
-			if	((!pass)&&(found_end)) //&&(file_header->fileType<10))
-				Print_to_console("%d %s, size 0x%.5x (%dk %d%%), res %d %s %s, A%d, C%d", j, 
-					inf[mem_list[j].state],
-					mem_list[j].size, mem_list[j].size/1024, (mem_list[j].size*100)/total_free_memory, mem_list[j].uid,
+			if (file_header->name[0] == 0)
+				pass = 1;	// also illegal
 
+			if (!pass && found_end) { // && file_header->fileType < 10)
+				Print_to_console("%d %s, size 0x%.5x (%dk %d%%), res %d %s %s, A%d, C%d",
+					j, inf[mem_list[j].state],
+					mem_list[j].size,
+					mem_list[j].size / 1024,
+					(mem_list[j].size * 100) / total_free_memory,
+					mem_list[j].uid,
 					res_man.Fetch_cluster(mem_list[j].uid),
 					file_header->name,
 					res_man.Fetch_age(mem_list[j].uid),
 					res_man.Fetch_count(mem_list[j].uid));
-
-			else	Print_to_console(" %d is an illegal resource", mem_list[j].uid);
-
+			} else
+				Print_to_console(" %d is an illegal resource", mem_list[j].uid);
+		} else {
+			Print_to_console("%d %s, size 0x%.5x (%dk %d%%), %s",
+				j, inf[mem_list[j].state], mem_list[j].size,
+				mem_list[j].size / 1024,
+				(mem_list[j].size * 100) / total_free_memory,
+				Fetch_mem_owner(mem_list[j].uid));
 		}
-		else
-			Print_to_console("%d %s, size 0x%.5x (%dk %d%%), %s", j, 
-					inf[mem_list[j].state],
-					mem_list[j].size, mem_list[j].size/1024, (mem_list[j].size*100)/total_free_memory,
-					Fetch_mem_owner(mem_list[j].uid) );
-
-		if	(mem_list[j].state==MEM_free)
-			free+=mem_list[j].size;
 
+		if (mem_list[j].state == MEM_free)
+			free += mem_list[j].size;
 
-		j=mem_list[j].child;
+		j = mem_list[j].child;
 
 		scrolls++;
 
 		Build_display();
 
 
-		if	(scrolls==18)
-		{
+		if (scrolls==18) {
 			Temp_print_to_console("- Press ESC to stop or any other key to continue");
 			Build_display();
 
-			do
-			{
-				// Service windows
+			do {
 				ServiceWindows();
-			}
-			while(!KeyWaiting());
+			} while(!KeyWaiting());
 
 			ReadKey(&c);	//kill the key we just pressed
-			if	(c==27)	//ESC
+			if (c == 27)	//ESC
 				break;
 
-			Clear_console_line();	//clear the Press Esc message ready for the new line
-			scrolls=0;
+			// clear the Press Esc message ready for the new line
+			Clear_console_line();
+			scrolls = 0;
 		}	
-	}
-	while	(j!=-1);
+	} while (j != -1);
 
 	Scroll_console();
-	Print_to_console("(total memory block 0x%.8x %dk %dMB) %d / %d%% free", total_free_memory,
-				total_free_memory/1024,
-				total_free_memory/(1000*1024),
-				free,
-				(free*100)/total_free_memory);
-
-
+	Print_to_console("(total memory block 0x%.8x %dk %dMB) %d / %d%% free",
+		total_free_memory, total_free_memory / 1024,
+		total_free_memory / (1000 * 1024), free,
+		(free * 100) / total_free_memory);
 }
-//--------------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------------
-const char	*Fetch_mem_owner(uint32	uid)	//Tony3June96
-{
 
-	switch(uid)
-	{
-		case	UID_memman:
-			return("MEMMAN");
-			break;
+const char *Fetch_mem_owner(uint32 uid) {	//Tony3June96
+	switch(uid) {
+		case UID_memman:
+			return "MEMMAN";
 
-		case	UID_font:
-			return("font");
-			break;
+		case UID_font:
+			return "font";
 
-		case	UID_temp:
-			return("temp ram allocation");
-			break;
+		case UID_temp:
+			return "temp ram allocation";
 
-		case	UID_decompression_buffer:
-			return("decompression buffer");
-			break;
+		case UID_decompression_buffer:
+			return "decompression buffer";
 
-		case	UID_shrink_buffer:
-			return("shrink buffer");
-			break;
+		case UID_shrink_buffer:
+			return "shrink buffer";
 
-		case	UID_con_sprite:
-			return("console sprite buffer");
-			break;
+		case UID_con_sprite:
+			return "console sprite buffer";
 
-		case	UID_text_sprite:
-			return("text sprite");
-			break;
+		case UID_text_sprite:
+			return "text sprite";
 
-		case	UID_walk_anim:
-			return("walk anim");
-			break;
+		case UID_walk_anim:
+			return "walk anim";
 
-		case	UID_savegame_buffer:
-			return("savegame buffer");
-			break;
+		case UID_savegame_buffer:
+			return "savegame buffer";
 
 		default:
 			sprintf(buf, "<sob> %d?", uid);
-			return(buf);
-			break;
+			return buf;
 	}
 }
 
-//--------------------------------------------------------------------------------------
-void Create_mem_string( char *string )	// James (21oct96 updated 4dec96)
-{
-	int	blockNo = base_mem_block;
-	int blocksUsed=0;
-	int	mem_free=0;
-	int	mem_locked=0;
-	int mem_floating=0;
-	int memUsed=0;
-	int	percent;
-
-
-
-	while (blockNo != -1)
-	{
-		switch (mem_list[blockNo].state)
-		{
+void Create_mem_string(char *string) {	// James (21oct96 updated 4dec96)
+	int blockNo = base_mem_block;
+	int blocksUsed = 0;
+	int mem_free = 0;
+	int mem_locked = 0;
+	int mem_floating = 0;
+	int memUsed = 0;
+	int percent;
+
+	while (blockNo != -1) {
+		switch (mem_list[blockNo].state) {
 			case MEM_free:
 				mem_free++;
 				break;
@@ -242,7 +191,8 @@ void Create_mem_string( char *string )	// James (21oct96 updated 4dec96)
 
 	percent =  (memUsed * 100) / total_free_memory;
 
-	sprintf( string, "locked(%u)+float(%u)+free(%u) = %u/%u blocks (%u%% used)(cur %uk)", mem_locked, mem_floating, mem_free, blocksUsed, MAX_mem_blocks, percent, (res_man.Res_fetch_useage()/1024) );
+	sprintf(string,
+		"locked(%u)+float(%u)+free(%u) = %u/%u blocks (%u%% used)(cur %uk)",
+		mem_locked, mem_floating, mem_free, blocksUsed, MAX_mem_blocks,
+		percent, (res_man.Res_fetch_useage() / 1024));
 }
-//--------------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------------
diff --git a/sword2/mem_view.h b/sword2/mem_view.h
index 84fa5667d4..f8047c7f78 100644
--- a/sword2/mem_view.h
+++ b/sword2/mem_view.h
@@ -20,12 +20,8 @@
 #ifndef	MEMVIEW_H
 #define	MEMVIEW_H
 
-//#include	"src\driver96.h"
-
-
-const char	*Fetch_mem_owner(uint32	uid);
-void	Console_mem_display(void);					// Tony (13Aug96)
-void	Create_mem_string( char *string );			// James (21oct96 updated 4dec96)
-
+const char *Fetch_mem_owner(uint32 uid);
+void Console_mem_display(void);		// Tony (13Aug96)
+void Create_mem_string(char *string);	// James (21oct96 updated 4dec96)
 
 #endif
diff --git a/sword2/memory.cpp b/sword2/memory.cpp
index 8ae7c77989..af581b2e77 100644
--- a/sword2/memory.cpp
+++ b/sword2/memory.cpp
@@ -17,412 +17,488 @@
  * $Header$
  */
 
-//memory manager -	"remember, it's not good to leave memory locked for a moment longer than necessary" Tony
-//					"actually, in a sequential system theoretically you never need to lock any memory!" Chris ;)
+// FIXME: We should investigate which problem all this memory managing stuff
+// is trying to solve. I'm not convinced that it's really needed.
+
+// memory manager
+//   - "remember, it's not good to leave memory locked for a moment longer
+//      than necessary" Tony
+//   - "actually, in a sequential system theoretically you never need to lock
+//      any memory!" Chris ;)
 //
-//					This is a very simple implementation but I see little advantage to being any cleverer
-//					with the coding - i could have put the mem blocks before the defined blocks instead
-//					of in an array and then used pointers to child/parent blocks. But why bother? I've Kept it simple.
-//					When it needs updating or customising it will be accessable to anyone who looks at it.
-//					*doesn't have a purgeable/age consituant yet - if anyone wants this then I'll add it in.
-
-
-//					MemMan v1.1
+// This is a very simple implementation but I see little advantage to being
+// any cleverer with the coding - i could have put the mem blocks before the
+// defined blocks instead of in an array and then used pointers to
+// child/parent blocks. But why bother? I've Kept it simple. When it needs
+// updating or customising it will be accessable to anyone who looks at it.
+//
+// Doesn't have a purgeable/age consituant yet - if anyone wants this then
+// I'll add it in.
 
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
+// MemMan v1.1
 
 #include "stdafx.h"
-#include "driver/driver96.h"
-#include "console.h"
 #include "debug.h"
 #include "memory.h"
 #include "resman.h"
 
+uint32 total_blocks;
+uint32 total_free_memory;
+
+#define MEMORY_POOL (1024 * 12000)
 
-uint32	total_blocks;
-uint32	base_mem_block;
-uint32	total_free_memory;
-uint8	*free_memman;	//address of init malloc to be freed later
+// address of init malloc to be freed later
+uint8 *free_memman;
 
-//#define	MEMDEBUG	1
+// list of defined memory handles - each representing a block of memory.
+mem mem_list[MAX_mem_blocks];
 
-mem	mem_list[MAX_mem_blocks];	//list of defined memory handles - each representing a block of memory.
+uint32 base_mem_block;
 
-int32 VirtualDefrag( uint32 size );	// Used to determine if the required size can be obtained if the defragger is allowed to run.
-int32 suggestedStart = 0;			// Start position of the Defragger as indicated by its sister VirtualDefrag.
+// #define MEMDEBUG 1
 
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
-void	Close_memory_manager(void)	//Tony2Oct96
-{
+// Used to determine if the required size can be obtained if the defragger is
+// allowed to run.
+
+int32 VirtualDefrag(uint32 size);
+
+// Start position of the Defragger as indicated by its sister VirtualDefrag.
+int32 suggestedStart = 0;
+
+void Close_memory_manager(void) {	// Tony2Oct96
 	free(free_memman);
 }
-//------------------------------------------------------------------------------------
-void	Init_memory_manager(void)	//Tony9April96
-{
-	uint32	j;
-	uint8	*memory_base;
 
-	total_free_memory=12000*1024;	//12MB
+void Init_memory_manager(void) {	// Tony9April96
+	uint32 j;
+	uint8 *memory_base;
 
+	total_free_memory = MEMORY_POOL;
 
-	//malloc memory and adjust for long boundaries
-	memory_base = (uint8	*)	malloc(total_free_memory);
+	// malloc memory and adjust for long boundaries
+	memory_base = (uint8 *) malloc(total_free_memory);
 
-	if	(!memory_base)	//could not grab the memory
-	{
+	if (!memory_base) {	//could not grab the memory
 		Zdebug("couldn't malloc %d in Init_memory_manager", total_free_memory);
-		ExitWithReport("Init_memory_manager() couldn't malloc %d bytes [line=%d file=%s]",total_free_memory,__LINE__,__FILE__);
+		ExitWithReport("Init_memory_manager() couldn't malloc %d bytes [line=%d file=%s]", total_free_memory, __LINE__, __FILE__);
 	}
 
-	free_memman = memory_base;	//the original malloc address
-
-//force to long word boundary
-	memory_base+=3;
-	memory_base = (uint8 *)((uint32)memory_base & 0xfffffffc);	// ** was (int)memory_base
-//	total_free_memory-=3;	//play safe
+	// the original malloc address
+	free_memman = memory_base;
 
+#if 0
+	// FIXME: I don't think it's necessary to force alignment here,
+	// because memory_base is the address returned by malloc(), and
+	// according to my C book "every allocated region from malloc must
+	// be aligned for any type".
 
+	// force to long word boundary
+	memory_base += 3;
+	memory_base = (uint8 *) ((uint32) memory_base & 0xfffffffc);	// ** was (int)memory_base
+	// total_free_memory -= 3;	//play safe
+#endif
 
-//set all but first handle to unused
-	for	(j=1;j<MAX_mem_blocks;j++)
-		mem_list[j].state=MEM_null;
+	// set all but first handle to unused
+	for (j = 1; j < MAX_mem_blocks; j++)
+		mem_list[j].state = MEM_null;
 
-
-	total_blocks=1;	//total used (free, locked or floating)
+	// total used (free, locked or floating)
+	total_blocks = 1;
 
 	mem_list[0].ad = memory_base;
-	mem_list[0].state= MEM_free;
-	mem_list[0].age=0;
-	mem_list[0].size=total_free_memory;
-	mem_list[0].parent=-1;	//we are base - for now
-	mem_list[0].child=-1;	//we are the end as well
-	mem_list[0].uid=UID_memman;	//init id
-
-	base_mem_block=0;	//for now
+	mem_list[0].state = MEM_free;
+	mem_list[0].age = 0;
+	mem_list[0].size = total_free_memory;
+	mem_list[0].parent = -1;		// we are base - for now
+	mem_list[0].child = -1;			// we are the end as well
+	mem_list[0].uid = UID_memman;		// init id
+
+	base_mem_block = 0;			// for now
 }
-//------------------------------------------------------------------------------------
-mem	*Talloc(uint32	size,	uint32	type,	uint32	unique_id)	//Tony10Apr96
-{
-//allocate a block of memory - locked or float
-
-//	returns 0 if fails to allocate the memory
-//			or a pointer to a mem structure
 
-	int32	nu_block;
-	uint32	spawn=0;
-	uint32	slack;
+// This is the low-level memory allocator
 
+mem *Talloc(uint32 size, uint32 type, uint32 unique_id) {	// Tony10Apr96
+	// allocate a block of memory - locked or float
 
+	// returns 0 if fails to allocate the memory
+	// or a pointer to a mem structure
 
+	int32 nu_block;
+	uint32 spawn = 0;
+	uint32 slack;
 
+	// we must first round the size UP to a dword, so subsequent blocks
+	// will start dword alligned
 
-//we must first round the size UP to a dword, so subsequent blocks will start dword alligned
-	size+=3;	//move up
-	size &= 0xfffffffc;	//and back down to boundary
+	size += 3;		// move up
+	size &= 0xfffffffc;	// and back down to boundary
 
+	// find a free block large enough
 
+	// the defragger returns when its made a big enough block. This is
+	// a good time to defrag as we're probably not doing anything super
+	// time-critical at the moment
 
-
-//find a free block large enough
-	if	( (nu_block = Defrag_mem(size))==-1)	//the defragger returns when its made a big enough block. This is a good time to defrag as we're probably not
-	{											//doing anything super time-critical at the moment
-		return(0);	//error - couldn't find a big enough space
+	if ((nu_block = Defrag_mem(size)) == -1) {
+		// error - couldn't find a big enough space
+		return 0;
 	}
 
-
-
-//an exact fit?
-	if	(mem_list[nu_block].size==size)	//no new block is required as the fit is perfect
-	{
-		mem_list[nu_block].state=type;	//locked or float
-		mem_list[nu_block].size=size;	//set to the required size
-		mem_list[nu_block].uid=unique_id;	//an identifier
+	// an exact fit?
+	if (mem_list[nu_block].size == size) {
+		// no new block is required as the fit is perfect
+		mem_list[nu_block].state = type;    // locked or float
+		mem_list[nu_block].size = size;	    // set to the required size
+		mem_list[nu_block].uid = unique_id; // an identifier
 
 #ifdef	MEMDEBUG
 		Mem_debug();
-#endif	//MEMDEBUG
-		return(&mem_list[nu_block]);
+#endif
+
+		return &mem_list[nu_block];
 	}
 
+	// nu_block is the free block to split, forming our locked/float block
+	// with a new free block in any remaining space
 
-//	nu_block is the free block to split, forming our locked/float block with a new free block in any remaining space
+	// If our child is free then is can expand downwards to eat up our
+	// chopped space this is good because it doesn't create an extra block
+	// so keeping the block count down.
+	//
+	// Why? Imagine you Talloc 1000k, then free it. Now keep allocating 10
+	// bytes less and freeing again you end up with thousands of new free
+	// mini blocks. This way avoids that as the free child keeps growing
+	// downwards.
 
+	if (mem_list[nu_block].child != -1 && mem_list[mem_list[nu_block].child].state == MEM_free) {
+		// our child is free
+		// the spare memory is the blocks current size minus the
+		// amount we're taking
 
-//if our child is free then is can expand downwards to eat up our chopped space
-//this is good because it doesn't create an extra bloc so keeping the block count down
-//why?
-//imagine you Talloc 1000k, then free it. Now keep allocating 10 bytes less and freeing again
-//you end up with thousands of new free mini blocks. this way avoids that as the free child keeps growing downwards
-	if	((mem_list[nu_block].child != -1) && (mem_list[mem_list[nu_block].child].state==MEM_free))	//our child is free
-	{
-		slack=mem_list[nu_block].size-size;	//the spare memory is the blocks current size minus the amount we're taking
+		slack = mem_list[nu_block].size - size;
 
-		mem_list[nu_block].state=type;	//locked or float
-		mem_list[nu_block].size=size;	//set to the required size
-		mem_list[nu_block].uid=unique_id;	//an identifier
+		mem_list[nu_block].state = type;    // locked or float
+		mem_list[nu_block].size = size;	    // set to the required size
+		mem_list[nu_block].uid = unique_id; // an identifier
 
-		mem_list[mem_list[nu_block].child].ad = mem_list[nu_block].ad+size;	//child starts after us
-		mem_list[mem_list[nu_block].child].size += slack;	//childs size increases
+		// child starts after us
+		mem_list[mem_list[nu_block].child].ad = mem_list[nu_block].ad + size;
+		// child's size increases
+		mem_list[mem_list[nu_block].child].size += slack;
 
-		return(&mem_list[nu_block]);
+		return &mem_list[nu_block];
 	}
 
+	// otherwise we spawn a new block after us and before our child - our
+	// child being a proper block that we cannot change
 
-// otherwise we spawn a new block after us and before our child - our child being a proper block that we cannot change
+	// we remain a child of our parent
+	// we spawn a new child and it inherits our current child
 
-//	we remain a child of our parent
-//	we spawn a new child and it inherits our current child
+	// find a NULL slot for a new block
 
-//find a NULL slot for a new block
-	while((mem_list[spawn].state!=MEM_null)&&(spawn!=MAX_mem_blocks))
+	while (mem_list[spawn].state != MEM_null && spawn!=MAX_mem_blocks)
 		spawn++;
 
-
-	if	(spawn==MAX_mem_blocks)	//run out of blocks - stop the program. this is a major blow up and we need to alert the developer
-	{
-		Mem_debug();	//Lets get a printout of this
-		ExitWithReport("ERROR: ran out of mem blocks in Talloc() [file=%s line=%u]",__FILE__,__LINE__);
+	if (spawn == MAX_mem_blocks) {
+		// run out of blocks - stop the program. this is a major blow
+		// up and we need to alert the developer
+		// Lets get a printout of this
+		Mem_debug();
+		ExitWithReport("ERROR: ran out of mem blocks in Talloc() [file=%s line=%u]", __FILE__, __LINE__);
 	}
 
+	mem_list[spawn].state = MEM_free;	// new block is free
+	mem_list[spawn].uid = UID_memman;	// a memman created bloc
 
+	// size of the existing parent free block minus the size of the new
+	// space Talloc'ed.
 
-	mem_list[spawn].state=MEM_free;	//new block is free
-	mem_list[spawn].uid=UID_memman;	//a memman created bloc
-	mem_list[spawn].size= mem_list[nu_block].size-size;	//size of the existing parent free block minus the size of the new space Talloc'ed.
-														//IOW the remaining memory is given to the new free block
-	mem_list[spawn].ad = mem_list[nu_block].ad+size;	//we start 1 byte after the newly allocated block
-	mem_list[spawn].parent=nu_block;	//the spawned child gets it parent - the newly allocated block
+	mem_list[spawn].size = mem_list[nu_block].size - size;
 
-	mem_list[spawn].child=mem_list[nu_block].child;	//the new child inherits the parents old child (we are its new child "Waaaa")
+	// IOW the remaining memory is given to the new free block
 
+	// we start 1 byte after the newly allocated block
+	mem_list[spawn].ad = mem_list[nu_block].ad + size;
 
+	// the spawned child gets it parent - the newly allocated block
+	mem_list[spawn].parent = nu_block;
 
-	if	(mem_list[spawn].child!=-1)	//is the spawn the end block?
-		mem_list[mem_list[spawn].child].parent= spawn;	//the child of the new free-spawn needs to know its new parent
+	// the new child inherits the parents old child (we are its new
+	// child "Waaaa")
+	mem_list[spawn].child = mem_list[nu_block].child;
 
+	// is the spawn the end block?
+	if (mem_list[spawn].child != -1) {
+		// the child of the new free-spawn needs to know its new parent
+		mem_list[mem_list[spawn].child].parent = spawn;
+	}
 
-	mem_list[nu_block].state=type;	//locked or float
-	mem_list[nu_block].size=size;	//set to the required size
-	mem_list[nu_block].uid=unique_id;	//an identifier
-	mem_list[nu_block].child=spawn;	//the new blocks new child is the newly formed free block
-
+	mem_list[nu_block].state = type;	// locked or float
+	mem_list[nu_block].size = size;		// set to the required size
+	mem_list[nu_block].uid = unique_id;	// an identifier
 
-	total_blocks++;	//we've brought a new block into the world. Ahhh!
+	// the new blocks new child is the newly formed free block
+	mem_list[nu_block].child = spawn;
 
+	//we've brought a new block into the world. Ahhh!
+	total_blocks++;
 
 #ifdef	MEMDEBUG
 	Mem_debug();
-#endif	//MEMDEBUG
+#endif
 
-	return(&mem_list[nu_block]);
+	return &mem_list[nu_block];
 }
-//------------------------------------------------------------------------------------
-void	Free_mem(mem	*block)	//Tony10Apr96
-{
-//kill a block of memory - which was presumably floating or locked
-//once you've done this the memory may be recycled
 
-	block->state=MEM_free;
-	block->uid=UID_memman;	//belongs to the memory manager again
+void Free_mem(mem *block) {	// Tony10Apr96
+	// kill a block of memory - which was presumably floating or locked
+	// once you've done this the memory may be recycled
+
+	block->state = MEM_free;
+	block->uid = UID_memman;	// belongs to the memory manager again
 
 #ifdef	MEMDEBUG
 	Mem_debug();
-#endif	//MEMDEBUG
+#endif
 }
-//------------------------------------------------------------------------------------
-void	Float_mem(mem	*block)	//Tony10Apr96
-{
-//set a block to float
-//wont be trashed but will move around in memory
 
-	block->state=MEM_float;
+void Float_mem(mem *block) {	// Tony10Apr96
+	// set a block to float
+	// wont be trashed but will move around in memory
+
+	block->state = MEM_float;
 
 #ifdef	MEMDEBUG
 	Mem_debug();
-#endif	//MEMDEBUG
+#endif
 }
-//------------------------------------------------------------------------------------
-void	Lock_mem(mem	*block)	//Tony11Apr96
-{
-//set a block to lock
-//wont be moved - don't lock memory for any longer than necessary unless you know the locked memory is at the bottom of the heap
 
-	block->state=MEM_locked;	//can't move now - this block is now crying out to be floated or free'd again
+void Lock_mem(mem *block) {	// Tony11Apr96
+	// set a block to lock
+	// wont be moved - don't lock memory for any longer than necessary
+	// unless you know the locked memory is at the bottom of the heap
+
+	// can't move now - this block is now crying out to be floated or
+	// free'd again
+
+	block->state = MEM_locked;
 
 #ifdef	MEMDEBUG
 	Mem_debug();
-#endif	//MEMDEBUG
+#endif
 }
-//------------------------------------------------------------------------------------
-int32	Defrag_mem(uint32	req_size)	//Tony10Apr96
-{
-//moves floating blocks down and/or merges free blocks until a large enough space is found
-//or there is nothing left to do and a big enough block cannot be found
-//we stop when we find/create a large enough block - this is enough defragging.
 
-	int32	cur_block;	//block 0 remains the parent block
-	int32	original_parent,child, end_child;
-	uint32	j;
-	uint32	*a;
-	uint32	*b;
+int32 Defrag_mem(uint32 req_size) {	// Tony10Apr96
+	// moves floating blocks down and/or merges free blocks until a large
+	// enough space is found or there is nothing left to do and a big
+	// enough block cannot be found we stop when we find/create a large
+	// enough block - this is enough defragging.
 
+	int32 cur_block;	// block 0 remains the parent block
+	int32 original_parent,child, end_child;
+	uint32 j;
+	uint32 *a;
+	uint32 *b;
 
-//	cur_block=base_mem_block;	//the mother of all parents
+	// cur_block = base_mem_block;	//the mother of all parents
 	cur_block = suggestedStart;
 
-
-	do
-	{
-		if	(mem_list[cur_block].state==MEM_free)	//is current block a free block?
-		{
-
-			if	(mem_list[cur_block].size>=req_size)
-			{
-				return(cur_block);	//this block is big enough - return its id
+	do {
+		// is current block a free block?
+		if (mem_list[cur_block].state == MEM_free) {
+			if (mem_list[cur_block].size >= req_size) {
+				// this block is big enough - return its id
+				return cur_block;
 			}
 
-
-			if	(mem_list[cur_block].child==-1)	//the child is the end block - stop if the next block along is the end block
-				return(-1);	//no luck, couldn't find a big enough block
-
-
-//			current free block is too small, but if its child is *also* free then merge the two together
-			if	(mem_list[mem_list[cur_block].child].state==MEM_free)
-			{
-//				ok, we nuke the child and inherit its child
-
-				child=mem_list[cur_block].child;
-
-				mem_list[cur_block].size+= mem_list[child].size;	//our size grows by the size of our child
-				mem_list[cur_block].child = mem_list[child].child;	//our new child is our old childs, child
-
-				if	(mem_list[child].child!=-1)	//not if the chld we're nuking is the end child (it has no child)
-					mem_list[mem_list[child].child].parent=cur_block;	//the (nuked) old childs childs parent is now us
-
-				mem_list[child].state=MEM_null;	//clean up the nuked child, so it can be used again
-
-				total_blocks--;
+			// the child is the end block - stop if the next block
+			// along is the end block
+			if (mem_list[cur_block].child == -1) {
+				// no luck, couldn't find a big enough block
+				return -1;
 			}
 
+			// current free block is too small, but if its child
+			// is *also* free then merge the two together
 
-//			current free block is too small, but if its child is a float then we move the floating memory block down and the free up
-//			but, parent/child relationships must be such that the memory is all continuous between blocks. ie. a childs memory always
-//			begins 1 byte after its parent finishes. However, the positions in the memory list may become truly random, but, any particular
-//			block of locked or floating memory must retain its position within the mem_list - the float stays a float because the handle/pointer has been passed back
-//			what this means is that when the physical memory of the foat moves down (and the free up) the child becomes the parent and the parent the child
-//			but, remember, the parent had a parent and the child another child - these swap over too as the parent/child swap takes place - phew.
-			else	if	(mem_list[mem_list[cur_block].child].state==MEM_float)
-			{
-				child=mem_list[cur_block].child;	//our child is currently floating
-
-			//	memcpy(mem_list[cur_block].ad, mem_list[child].ad, mem_list[child].size);	//move the higher float down over the free block
-
-
-				a=(uint32*) mem_list[cur_block].ad;
-				b=(uint32*) mem_list[child].ad;
-
-				for	(j=0;j<mem_list[child].size/4;j++)
-					*(a++)=*(b++);
+			if (mem_list[mem_list[cur_block].child].state == MEM_free) {
+				// ok, we nuke the child and inherit its child
+				child = mem_list[cur_block].child;
 
+				// our size grows by the size of our child
+				mem_list[cur_block].size += mem_list[child].size;
 
-//				both *ad's change
-				mem_list[child].ad = mem_list[cur_block].ad;	//the float is now where the free was
-				mem_list[cur_block].ad += mem_list[child].size;	//and the free goes up by the size of the float (which has come down)
+				// our new child is our old childs, child
+				mem_list[cur_block].child = mem_list[child].child;
 
-//				the status of the mem_list blocks must remain the same, so...
-				original_parent= mem_list[cur_block].parent;	//our child gets this when we become its child and it our parent
-				mem_list[cur_block].parent=child;	//the free's child becomes its parent
-				mem_list[cur_block].child= mem_list[child].child;	//the new child inherits its previous childs child
+				// not if the chld we're nuking is the end
+				// child (it has no child)
 
-				end_child=mem_list[child].child;	//save this - see next line
+				if (mem_list[child].child != -1) {
+					// the (nuked) old childs childs
+					// parent is now us
+					mem_list[mem_list[child].child].parent = cur_block;
+				}
 
-				mem_list[child].child=cur_block;		//the floats parent becomes its child
-				mem_list[child].parent= original_parent;
+				// clean up the nuked child, so it can be used
+				// again
+				mem_list[child].state = MEM_null;
 
-				if	(end_child!=-1)	//if the child had a child
-					mem_list[end_child].parent=cur_block;	//then its parent is now the new child
-
-				if	(original_parent==-1)	//the base block was the true base parent
-					base_mem_block=child;	//then the child that has moved down becomes the base block as it sits at the lowest possible memory location
-				else
-					mem_list[original_parent].child=child;	//otherwise the parent of the current free block - that is now the child - gets a new child,
-															//that child being previously the child of the child of the original parent
+				total_blocks--;
+			} else if (mem_list[mem_list[cur_block].child].state == MEM_float) {
+				// current free block is too small, but if its
+				// child is a float then we move the floating
+				// memory block down and the free up but,
+				// parent/child relationships must be such
+				// that the memory is all continuous between
+				// blocks. ie. a childs memory always begins 1
+				// byte after its parent finishes. However, the
+				// positions in the memory list may become
+				// truly random, but, any particular block of
+				// locked or floating memory must retain its
+				// position within the mem_list - the float
+				// stays a float because the handle/pointer
+				// has been passed back
+				//
+				// what this means is that when the physical
+				// memory of the foat moves down (and the free
+				// up) the child becomes the parent and the
+				// parent the child but, remember, the parent
+				// had a parent and the child another child -
+				// these swap over too as the parent/child swap
+				// takes place - phew.
+
+				// our child is currently floating
+				child = mem_list[cur_block].child;
+
+				// move the higher float down over the free
+				// block
+				// memcpy(mem_list[cur_block].ad, mem_list[child].ad, mem_list[child].size);
+
+				a = (uint32*) mem_list[cur_block].ad;
+				b = (uint32*) mem_list[child].ad;
+
+				for (j = 0; j < mem_list[child].size / 4; j++)
+					*(a++) = *(b++);
+
+				// both *ad's change
+				// the float is now where the free was and the
+				// free goes up by the size of the float
+				// (which has come down)
+
+				mem_list[child].ad = mem_list[cur_block].ad;
+				mem_list[cur_block].ad += mem_list[child].size;
+
+				// the status of the mem_list blocks must
+				// remain the same, so...
+
+				// our child gets this when we become its
+				// child and it our parent
+				original_parent = mem_list[cur_block].parent;
+
+				// the free's child becomes its parent
+				mem_list[cur_block].parent = child;
+
+				// the new child inherits its previous childs
+				// child
+				mem_list[cur_block].child = mem_list[child].child;
+
+				// save this - see next line
+				end_child = mem_list[child].child;
+
+				// the floats parent becomes its child
+				mem_list[child].child = cur_block;
+				mem_list[child].parent = original_parent;
+
+				// if the child had a child
+				if (end_child != -1) {
+					// then its parent is now the new child
+					mem_list[end_child].parent = cur_block;
+				}
+
+				// if the base block was the true base parent
+				if (original_parent == -1) {
+					// then the child that has moved down
+					// becomes the base block as it sits
+					// at the lowest possible memory
+					// location
+					base_mem_block = child;
+				} else {
+					// otherwise the parent of the current
+					// free block - that is now the child
+					// - gets a new child, that child
+					// being previously the child of the
+					// child of the original parent
+					mem_list[original_parent].child = child;
+				}
+			} else { // if (mem_list[mem_list[cur_block].child].state == MEM_lock)
+				// the child of current is locked - move to it
+				// move to next one along - either locked or
+				// END
+				cur_block=mem_list[cur_block].child;
 			}
-			else	//if	(mem_list[mem_list[cur_block].child].state==MEM_lock)	//the child of current is locked - move to it
-				cur_block=mem_list[cur_block].child;	//move to next one along - either locked or END
-
+		} else {
+			// move to next one along, the current must be
+			// floating, locked, or a NULL slot
+			cur_block = mem_list[cur_block].child;
 		}
-		else
-		{
-			cur_block=mem_list[cur_block].child;	//move to next one along, the current must be floating, locked, or a NULL slot
-		}
-
-	}
-	while(cur_block!=-1);	//while the block we've just done is not the final block
+	} while (cur_block != -1);	// while the block we've just done is not the final block
 
-	return(-1);	//no luck, couldn't find a big enough block
+	return -1;	//no luck, couldn't find a big enough block
 }
-//------------------------------------------------------------------------------------
-void	Mem_debug(void)	//Tony11Apr96
-{
-//gets called with Talloc, Mem_free, Mem_lock & Mem_float if MEMDEBUG has been #defined
-//otherwise can be called at any time anywhere else
-
-	int	j;
-	char	inf[][20]=
-	{
-		{"MEM_null"},
-		{"MEM_free"},
-		{"MEM_locked"},
-		{"MEM_float"}
+
+void Mem_debug(void) {	//Tony11Apr96
+	// gets called with Talloc, Mem_free, Mem_lock & Mem_float if
+	// MEMDEBUG has been #defined otherwise can be called at any time
+	// anywhere else
+
+	int j;
+	char inf[][20] = {
+		{ "MEM_null" },
+		{ "MEM_free" },
+		{ "MEM_locked" },
+		{ "MEM_float" }
 	};
 
 	Zdebug("\nbase %d total %d", base_mem_block, total_blocks);
 
-
-//first in mem list order
-	for	(j=0;j<MAX_mem_blocks;j++)
-	{
-		if	(mem_list[j].state==MEM_null)
+	// first in mem list order
+	for (j = 0; j < MAX_mem_blocks; j++) {
+		if (mem_list[j].state == MEM_null)
 			Zdebug("%d- NULL", j);
 		else
-			Zdebug("%d- state %s, ad %d, size %d, p %d, c %d, id %d", j, 
-				inf[mem_list[j].state],
-				 mem_list[j].ad, mem_list[j].size, mem_list[j].parent, mem_list[j].child, mem_list[j].uid);
+			Zdebug("%d- state %s, ad %d, size %d, p %d, c %d, id %d",
+				j, inf[mem_list[j].state], mem_list[j].ad,
+				mem_list[j].size, mem_list[j].parent,
+				mem_list[j].child, mem_list[j].uid);
 	}
 
-
-//now in child/parent order
-	j=base_mem_block;
-	do
-	{
+	// now in child/parent order
+	j = base_mem_block;
+	do {
 		Zdebug(" %d- state %s, ad %d, size %d, p %d, c %d", j, 
-			inf[mem_list[j].state],
-			 mem_list[j].ad, mem_list[j].size, mem_list[j].parent, mem_list[j].child, mem_list[j].uid);
+			inf[mem_list[j].state], mem_list[j].ad,
+			mem_list[j].size, mem_list[j].parent,
+			mem_list[j].child, mem_list[j].uid);
 
-		j=mem_list[j].child;
-	}
-	while	(j!=-1);
+		j = mem_list[j].child;
+	} while (j != -1);
 }
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
-mem	*Twalloc(uint32	size,	uint32	type,	uint32	unique_id)	//tony12Feb97
-{
-//the high level Talloc
-//can ask the resman to remove old resources to make space - will either do it or halt the system
-
-	mem	*membloc;
-	int	j;
-	uint32	free=0;
-
-	while( VirtualDefrag(size) )
-	{
-		if	(!res_man.Help_the_aged_out())	//trash the oldest closed resource
-		{
+
+mem *Twalloc(uint32 size, uint32 type, uint32 unique_id) {	// tony12Feb97
+	// the high level Talloc
+	// can ask the resman to remove old resources to make space - will
+	// either do it or halt the system
+
+	mem *membloc;
+	int j;
+	uint32 free = 0;
+
+	while (VirtualDefrag(size)) {
+		// trash the oldest closed resource
+		if (!res_man.Help_the_aged_out()) {
 			Zdebug("Twalloc ran out of memory! %d %d %d\n", size, type, unique_id);
 			ExitWithReport("Twalloc ran out of memory!");
 		}
@@ -430,59 +506,57 @@ mem	*Twalloc(uint32	size,	uint32	type,	uint32	unique_id)	//tony12Feb97
 
 	membloc = Talloc(size, type, unique_id);
 
-	if (membloc == 0)
-	{
+	if (membloc == 0) {
 		Zdebug("Talloc failed to get memory VirtualDefrag said was there");
 		ExitWithReport("Talloc failed to get memory VirtualDefrag said was there");
 	}
 
-	j=base_mem_block;
-	do
-	{
+	j = base_mem_block;
+	do {
 
-		if	(mem_list[j].state==MEM_free)
-			free+=mem_list[j].size;
+		if (mem_list[j].state == MEM_free)
+			free += mem_list[j].size;
 
-		j=mem_list[j].child;
-	}
-	while	(j!=-1);
+		j = mem_list[j].child;
+	} while (j != -1);
 
-	return(membloc);	//return the pointer to the memory
+	// return the pointer to the memory
+	return membloc;
 }
 
+// Maximum allowed wasted memory.
+#define MAX_WASTAGE 51200
 
-#define MAX_WASTAGE	51200			// Maximum allowed wasted memory.
-
-int32 VirtualDefrag( uint32 size )	// Chris - 07 April '97
-{
-	//
-	//	Virutually defrags memory...
+int32 VirtualDefrag(uint32 size) {	// Chris - 07 April '97
+	// Virutually defrags memory...
 	//
-	//	Used to determine if there is potentially are large enough free block available is the
-	//	real defragger was allowed to run.
+	// Used to determine if there is potentially are large enough free
+	// block available is the real defragger was allowed to run.
 	//
-	//	The idea being that Twalloc will call this and help_the_aged_out until we indicate that
-	//	it is possible to obtain a large enough free block. This way the defragger need only 
-	//	run once to yield the required block size.
+	// The idea being that Twalloc will call this and help_the_aged_out
+	// until we indicate that it is possible to obtain a large enough
+	// free block. This way the defragger need only run once to yield the
+	// required block size.
 	//
-	//	The reason for its current slowness is that the defragger is potentially called several
-	//	times, each time shifting upto 20Megs around, to obtain the required free block.
-	//
-	int32	cur_block;	
-	uint32	currentBubbleSize = 0;
+	// The reason for its current slowness is that the defragger is
+	// potentially called several times, each time shifting upto 20Megs
+	// around, to obtain the required free block.
+
+	int32 cur_block;	
+	uint32 currentBubbleSize = 0;
 
-	cur_block=base_mem_block;
+	cur_block = base_mem_block;
 	suggestedStart = base_mem_block;
 
-	do
-	{
-		if	(mem_list[cur_block].state == MEM_free)
-		{
-			// Add a little intelligence. At the start the oldest resources are at the bottom of the
-			// tube. However there will be some air at the top. Thus bubbles will be 
-			// created at the bottom and float to the top. If we ignore the top gap
-			// then a large enough bubble will form lower down the tube. Thus less memory
-			// will need to be shifted.
+	do {
+		if (mem_list[cur_block].state == MEM_free) {
+			// Add a little intelligence. At the start the oldest
+			// resources are at the bottom of the tube. However
+			// there will be some air at the top. Thus bubbles
+			// will be created at the bottom and float to the
+			// top. If we ignore the top gap then a large enough
+			// bubble will form lower down the tube. Thus less
+			// memory will need to be shifted.
 
 			if (mem_list[cur_block].child != -1)
 				currentBubbleSize += mem_list[cur_block].size;
@@ -491,22 +565,15 @@ int32 VirtualDefrag( uint32 size )	// Chris - 07 April '97
 
 			if (currentBubbleSize >= size)
 				return 0;
-		}
-		else if (mem_list[cur_block].state == MEM_locked)
-		{
+		} else if (mem_list[cur_block].state == MEM_locked) {
 			currentBubbleSize = 0;
-			suggestedStart    = mem_list[cur_block].child;	// Any free block of the correct size will be above this locked block.
+			// Any free block of the correct size will be above
+			// this locked block.
+			suggestedStart = mem_list[cur_block].child;
 		}
 
 		cur_block = mem_list[cur_block].child;
-	}
-	while(cur_block != -1);	
+	} while (cur_block != -1);	
 
-	return(1);
+	return 1;
 }
-
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
diff --git a/sword2/memory.h b/sword2/memory.h
index 0ea75a47dc..0effce6043 100644
--- a/sword2/memory.h
+++ b/sword2/memory.h
@@ -21,62 +21,58 @@
 #define	MEMORY_H
 
 #include "common/scummsys.h"
-//#include "src\driver96.h"
 
-
-typedef	struct
-{
-	uint32	state;
-	uint32	age;	// *not used*
-	uint32	size;
-	int32	parent;	//who is before us
-	int32	child;	//who is after us
-	uint32	uid;	//id of a position in the resList or some other unique id - for the visual display only
-	uint8	*ad;
+typedef	struct {
+	uint32 state;
+	uint32 age;	// *not used*
+	uint32 size;
+	int32 parent;	// who is before us
+	int32 child;	// who is after us
+	// id of a position in the resList or some other unique id - for the
+	// visual display only
+	uint32 uid;
+	uint8 *ad;
 } mem;
 
-
-#define	MEM_null	0	//null
-#define	MEM_free	1
-#define	MEM_locked	2
-#define	MEM_float	3
+#define	MEM_null			0	// null
+#define	MEM_free			1
+#define	MEM_locked			2
+#define	MEM_float			3
 
 //---------------------------------------
 // MEMORY BLOCKS
 
-#define	MAX_mem_blocks	999
+#define	MAX_mem_blocks			999
 
 // maintain at a good 50% higher than the
 // highest recorded value from the on-screen info
 //---------------------------------------
 
-#define	UID_memman					0xffffffff
-#define	UID_NULL					0xfffffffe			//FREE
-#define	UID_font					0xfffffffd
-#define	UID_temp					0xfffffffc
+#define	UID_memman			0xffffffff
+#define	UID_NULL			0xfffffffe	// FREE
+#define	UID_font			0xfffffffd
+#define	UID_temp			0xfffffffc
 #define	UID_decompression_buffer	0xfffffffb
-#define	UID_shrink_buffer			0xfffffffa
-#define	UID_con_sprite				0xfffffff9
-#define	UID_text_sprite				0xfffffff8
-#define	UID_walk_anim				0xfffffff7
-#define	UID_savegame_buffer			0xfffffff6
+#define	UID_shrink_buffer		0xfffffffa
+#define	UID_con_sprite			0xfffffff9
+#define	UID_text_sprite			0xfffffff8
+#define	UID_walk_anim			0xfffffff7
+#define	UID_savegame_buffer		0xfffffff6
 #define UID_restoregame_buffer		0xfffffff5
 
-void	Init_memory_manager(void);
-void	Close_memory_manager(void);	//Tony2Oct96
-//mem	*Talloc(uint32	size,	uint32	type,	uint32	unique_id);	//low level
-mem	*Twalloc(uint32	size,	uint32	type,	uint32	unique_id);	//high level
-void	Free_mem(mem	*block);
-void	Float_mem(mem	*block);
-void	Lock_mem(mem	*block);
-void	Mem_debug(void);
-void	Visual_mem_display(void);
-int32	Defrag_mem(uint32	req_size);	//Tony10Apr96
-
+void Init_memory_manager(void);
+void Close_memory_manager(void);				// Tony2Oct96
+mem *Twalloc(uint32 size, uint32 type, uint32 unique_id);	// high level
+void Free_mem(mem *block);
+void Float_mem(mem *block);
+void Lock_mem(mem *block);
+void Mem_debug(void);
+void Visual_mem_display(void);
+int32 Defrag_mem(uint32 req_size);				// Tony10Apr96
 
-extern	uint32	total_blocks;
-extern	uint32	base_mem_block;
-extern	mem	mem_list[MAX_mem_blocks];
-extern	uint32	total_free_memory;
+extern uint32 total_blocks;
+extern uint32 base_mem_block;
+extern mem mem_list[MAX_mem_blocks];
+extern uint32 total_free_memory;
 
 #endif
diff --git a/sword2/sync.cpp b/sword2/sync.cpp
index 6611a80c3a..7d3c6adfd9 100644
--- a/sword2/sync.cpp
+++ b/sword2/sync.cpp
@@ -17,165 +17,111 @@
  * $Header$
  */
 
-//------------------------------------------------------------------------------------
-#include <stdio.h>
-
 #include "stdafx.h"
-//#include "src\driver96.h"
-#include "console.h"
 #include "debug.h"
 #include "defs.h"
 #include "interpreter.h"
-#include "memory.h"
-#include "object.h"
 #include "sync.h"
-//------------------------------------------------------------------------------------
-typedef	struct
-{
-	uint32	id;
-	uint32	sync;
-}	_sync_unit;	//haaaaaaaa
-
-#define	MAX_syncs	10	//there wont be many will there. probably 2 at most i reckon
-
-
-_sync_unit	sync_list[MAX_syncs];
-
-//------------------------------------------------------------------------------------
-void	Init_sync_system(void)	//Tony27Nov96
-{
-//set list to 0's
-
-	uint32	j;
 
+typedef	struct {
+	uint32 id;
+	uint32 sync;
+} _sync_unit;	// haaaaaaaa
 
+// there wont be many will there. probably 2 at most i reckon
+#define	MAX_syncs 10
 
-	for	(j=0;j<MAX_syncs;j++)
-		sync_list[j].id=0;
-
+_sync_unit sync_list[MAX_syncs];
 
+void Init_sync_system(void) {		// Tony27Nov96
+	// set list to 0's
+	for (int j = 0; j < MAX_syncs; j++)
+		sync_list[j].id = 0;
 }
-//------------------------------------------------------------------------------------
-int32	FN_send_sync(int32 *params)	//Tony27Nov96
-{
-//param	0 sync's recipient
-//param	1 sync value
-
-
-	uint32	current_sync=0;
 
+int32 FN_send_sync(int32 *params) {	// Tony27Nov96
+	//param	0 sync's recipient
+	//param	1 sync value
 
-	if	(sync_list[current_sync].id)
-	{
-		do
-			current_sync++;
-		while(sync_list[current_sync].id);	//zip along until we find a free slot
-		
+	for (int i = 0; i < MAX_syncs; i++) {
+		if (sync_list[i].id == 0) {
+			// Zdebug(" %d sending sync %d to %d", ID, params[1], params[0]);
+			sync_list[i].id = params[0];
+			sync_list[i].sync = params[1];
+			return IR_CONT;
+		}
 	}
 
-//	Zdebug(" %d sending sync %d to %d", ID, params[1], params[0]);
-
+	// The original code didn't even check for this condition, so maybe
+	// it should be a fatal error?
 
-	sync_list[current_sync].id=params[0];
-	sync_list[current_sync].sync=params[1];
-
-
-
-	return(IR_CONT);
+	warning("No free sync slot");
+	return IR_CONT;
 }
-//------------------------------------------------------------------------------------
-void	Clear_syncs(uint32	id)	//Tony27Nov96
-{
-//clear any syncs registered for this id
-//call this just after the id has been processed
 
-	uint32	j;
+void Clear_syncs(uint32	id) {		// Tony27Nov96
+	// clear any syncs registered for this id
+	// call this just after the id has been processed
+	// there could in theory be more than one sync waiting for us so
+	// clear the lot
 
-
-//there could in theory be more than one sync waiting for us so clear the lot
-
-	for	(j=0;j<MAX_syncs;j++)
-		if	(sync_list[j].id==id)
-		{	//Zdebug("removing sync %d for %d", j, id);
-			sync_list[j].id=0;
+	for (int i = 0; i < MAX_syncs; i++) {
+		if (sync_list[i].id == id) {
+			// Zdebug("removing sync %d for %d", i, id);
+			sync_list[i].id = 0;
 		}
-
-
+	}
 }
-//------------------------------------------------------------------------------------
-uint32	Get_sync(void)	//Tony27Nov96
-{
-	// check for a sync waiting for this character
-	// - called from system code eg. from inside FN_anim(), to see if animation to be quit
-
-	uint32	j;
-
-
-	for	(j=0;j<MAX_syncs;j++)
-		if	(sync_list[j].id == ID)
-			return(1);	//means sync found	Tony12July97
-
-//			return(sync_list[j].sync);	//return sync value waiting
-
 
+uint32 Get_sync(void) {			// Tony27Nov96
+	// check for a sync waiting for this character
+	// - called from system code eg. from inside FN_anim(), to see if
+	// animation to be quit
 
-	return(0);	//no sync found
+	for (int i = 0; i < MAX_syncs; i++) {
+		if (sync_list[i].id == ID) {
+			// means sync found   Tony12July97
+			return 1;
+		}
+	}
 
+	// no sync found
+	return 0;
 }
-//------------------------------------------------------------------------------------
-int32	FN_get_sync(int32	*params)	//Tony27Nov96
-{
-// check for a sync waiting for this character
-// - called from script
 
-//params	none
-
-
-	uint32	j;
-
-
-	for	(j=0;j<MAX_syncs;j++)
-		if	(sync_list[j].id == ID) {
-			RESULT=sync_list[j].sync;
-			return(IR_CONT);	//return sync value waiting
+int32 FN_get_sync(int32 *params) {	// Tony27Nov96
+	// check for a sync waiting for this character
+	// - called from script
+	// params     none
+
+	for (int i = 0; i < MAX_syncs; i++) {
+		if (sync_list[i].id == ID) {
+			// return sync value waiting
+			RESULT = sync_list[i].sync;
+			return IR_CONT;
 		}
+	}
 
-	RESULT=0;
-
-	// if (params); what is the point of this... khalek
-
-	return(IR_CONT);	//no sync found
-
+	// no sync found
+	RESULT = 0;
+	return IR_CONT;
 }
-//------------------------------------------------------------------------------------
-int32	FN_wait_sync(int32	*params)	//Tony27Nov96
-{
-//keep calling until a sync recieved
-
-//params	none
-
 
-	uint32	j;
+int32 FN_wait_sync(int32 *params) {	// Tony27Nov96
+	// keep calling until a sync recieved
+	// params     none
 
-	j=ID;
+	// Zdebug("%d waits", ID);
 
-
-//	Zdebug("%d waits", ID);
-
-	
-	for (j=0;j<MAX_syncs;j++) {
-		if (sync_list[j].id == ID) {
-			RESULT=sync_list[j].sync;
+	for (int i = 0; i < MAX_syncs; i++) {
+		if (sync_list[i].id == ID) {
+			// return sync value waiting
 			//Zdebug(" go");
-			return(IR_CONT);	//return sync value waiting
+			RESULT = sync_list[i].sync;
+			return IR_CONT;
 		}
 	}
 
-	// if (params); // what is the point of this... - khalek
-
-	return(IR_REPEAT);	//back again next cycle
-
+	// back again next cycle
+	return IR_REPEAT;
 }
-//------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------
-
diff --git a/sword2/sync.h b/sword2/sync.h
index 4db00c4731..13f1b7d45a 100644
--- a/sword2/sync.h
+++ b/sword2/sync.h
@@ -20,13 +20,10 @@
 #ifndef	_SYNC
 #define	_SYNC
 
-//#include "src\driver96.h"
 #include "object.h"
 
-
-void	Init_sync_system(void);	//Tony27Nov96
-void	Clear_syncs(uint32	id);	//Tony27Nov96
-uint32	Get_sync(void);	//Tony27Nov96
-
+void Init_sync_system(void);	// Tony27Nov96
+void Clear_syncs(uint32	id);	// Tony27Nov96
+uint32 Get_sync(void);		// Tony27Nov96
 
 #endif