Remove some more unused code

svn-id: r13653

7 files changed, 31 insertions, 472 deletions

diff --git a/saga/sys_interface.h b/saga/sys_interface.h
index 451e2b64ae..5216fd9e56 100644
--- a/saga/sys_interface.h
+++ b/saga/sys_interface.h
@@ -25,10 +25,6 @@
 
 namespace Saga {
 
-#define BYTE unsigned char
-#define WORD unsigned short
-#define DWORD unsigned int
-
 #define R_CFGFILE_NAME ".reinheritrc"
 
 #define R_DIRECTORY_SEP '/'
diff --git a/saga/xmidi.cpp b/saga/xmidi.cpp
index f29057e1c1..345fa07c3e 100644
--- a/saga/xmidi.cpp
+++ b/saga/xmidi.cpp
@@ -224,11 +224,11 @@ ConvertEventListToSMF(XMIDIEVENT_LIST * event_list,
 	return R_SUCCESS;
 }
 
-int WriteVLQ_DW(char *write_ptr, DWORD value)
+int WriteVLQ_DW(char *write_ptr, uint32 value)
 {
 
 	int vlq_len = 1;
-	DWORD pack = value & 0x7F;
+	uint32 pack = value & 0x7F;
 	uint x;
 
 	while (value >>= 7) {
@@ -236,7 +236,7 @@ int WriteVLQ_DW(char *write_ptr, DWORD value)
 		pack |= ((value & 0x7F) | 0x80);
 		vlq_len++;
 	}
-	for (x = 0; x < sizeof(DWORD); x++) {
+	for (x = 0; x < sizeof(uint32); x++) {
 		*write_ptr++ = ((char *)(&pack))[x];
 	}
 
@@ -472,7 +472,7 @@ XMIDI_ReadEvents(XMIDIEVENT_LIST * event_list,
 	while (event_bytes_left > 0) {
 
 		vlq_len = ReadVLQ2_DW(event_data_ptr,
-							  (DWORD)event_bytes_left, (DWORD *)&new_event_time);
+							  (uint32)event_bytes_left, (uint32 *)&new_event_time);
 
 		event_time += new_event_time;
 		event_data_ptr += vlq_len;
@@ -504,8 +504,8 @@ XMIDI_ReadEvents(XMIDIEVENT_LIST * event_list,
 			    event_time, event, channel, 0, op1, op2, 0, 0);
 
 			vlq_len =
-			    ReadVLQ_DW(event_data_ptr, (DWORD)event_bytes_left,
-						   (DWORD *)&event_len);
+			    ReadVLQ_DW(event_data_ptr, (uint32)event_bytes_left,
+						   (uint32 *)&event_len);
 			AddEventToList(event_list, MIDI_NOTE_OFF_LEN,
 			    event_time + event_len, MIDI_NOTE_OFF, channel, 0,
 			    op1, MIDI_STD_VELOCITY, 0, 0);
@@ -580,7 +580,7 @@ XMIDI_ReadEvents(XMIDIEVENT_LIST * event_list,
 
 		case MIDI_SYSTEMEXCLUSIVE:
 
-			sysex_op = (BYTE) * event_data_ptr++;
+			sysex_op = (byte) * event_data_ptr++;
 			event_bytes_left--;
 
 			if (data_byte == MIDI_NONMIDI) {
@@ -600,9 +600,9 @@ XMIDI_ReadEvents(XMIDIEVENT_LIST * event_list,
 				case MIDI_SYSEX_TEMPO:
 					event_data_ptr++;	/*(skip length VLQ) (always 3) */
 
-					op1 = (BYTE) * event_data_ptr++;
-					op2 = (BYTE) * event_data_ptr++;
-					op3 = (BYTE) * event_data_ptr++;
+					op1 = (byte) * event_data_ptr++;
+					op2 = (byte) * event_data_ptr++;
+					op3 = (byte) * event_data_ptr++;
 					AddEventToList(event_list,
 					    MIDI_SYSEX_TEMPO_LEN, event_time,
 					    event, channel, sysex_op, op1, op2,
@@ -616,10 +616,10 @@ XMIDI_ReadEvents(XMIDIEVENT_LIST * event_list,
 				case MIDI_SYSEX_TIMESIG:
 					event_data_ptr++;	/*(skip length VLQ) (always 4) */
 
-					op1 = (BYTE) * event_data_ptr++;
-					op2 = (BYTE) * event_data_ptr++;
-					op3 = (BYTE) * event_data_ptr++;
-					op4 = (BYTE) * event_data_ptr++;
+					op1 = (byte) * event_data_ptr++;
+					op2 = (byte) * event_data_ptr++;
+					op3 = (byte) * event_data_ptr++;
+					op4 = (byte) * event_data_ptr++;
 					AddEventToList(event_list,
 					    MIDI_SYSEX_TIMESIG_LEN, event_time,
 					    event, channel, sysex_op, op1, op2,
@@ -664,7 +664,7 @@ XMIDI_ReadEvents(XMIDIEVENT_LIST * event_list,
 	return R_SUCCESS;
 }
 
-int GetLengthAsVLQ(DWORD data)
+int GetLengthAsVLQ(uint32 data)
 {
 
 	int len = 1;
@@ -675,10 +675,10 @@ int GetLengthAsVLQ(DWORD data)
 
 }
 
-DWORD ReadVLQ_DW(const uchar *data, DWORD bytes_left, DWORD * value)
+uint32 ReadVLQ_DW(const uchar *data, uint32 bytes_left, uint32 * value)
 {
-	BYTE byte;
-	DWORD vlq_len = 0;
+	byte byte;
+	uint32 vlq_len = 0;
 	*value = 0;
 
 	do {
@@ -693,11 +693,11 @@ DWORD ReadVLQ_DW(const uchar *data, DWORD bytes_left, DWORD * value)
 	return vlq_len;
 }
 
-DWORD ReadVLQ2_DW(const uchar *data, DWORD bytes_left, DWORD * value)
+uint32 ReadVLQ2_DW(const uchar *data, uint32 bytes_left, uint32 * value)
 {
 
-	BYTE byte;
-	DWORD vlq_len = 0;
+	byte byte;
+	uint32 vlq_len = 0;
 	*value = 0;
 
 	while (!((byte = *data++) & 0x80)) {
@@ -768,12 +768,12 @@ AddEventToList(XMIDIEVENT_LIST * event_list, int smf_size, int time, int event,
 	new_event->delta_time = time;
 
 	new_event->sysex_op = sysex_op;
-	new_event->event = (BYTE) event;
-	new_event->channel = (BYTE) channel;
-	new_event->op1 = (BYTE) op1;
-	new_event->op2 = (BYTE) op2;
-	new_event->op3 = (BYTE) op3;
-	new_event->op4 = (BYTE) op4;
+	new_event->event = (byte) event;
+	new_event->channel = (byte) channel;
+	new_event->op1 = (byte) op1;
+	new_event->op2 = (byte) op2;
+	new_event->op3 = (byte) op3;
+	new_event->op4 = (byte) op4;
 
 #ifdef XMIPLAY_VERBOSE
 	R_printf(R_STDOUT,
diff --git a/saga/xmidi.h b/saga/xmidi.h
index f40ae21b44..81b9f69fac 100644
--- a/saga/xmidi.h
+++ b/saga/xmidi.h
@@ -104,10 +104,10 @@ int ReadIFF_IDChunk(IFF_ID_CHUNK *chunk, const uchar *read_p, const uchar **read
 int Print4CC(char *fourcc);
 int XMIDI_ReadEvents(XMIDIEVENT_LIST *event_list, const uchar *event_data, 
 					 size_t event_data_len, uint n_tracks);
-int WriteVLQ_DW(char *write_ptr, DWORD value);
-DWORD ReadVLQ_DW(const uchar *data, DWORD bytes_left, DWORD *value);
-DWORD ReadVLQ2_DW(const uchar *data, DWORD bytes_left, DWORD *value);
-int GetLengthAsVLQ(DWORD data);
+int WriteVLQ_DW(char *write_ptr, uint32 value);
+uint32 ReadVLQ_DW(const uchar *data, uint32 bytes_left, uint32 *value);
+uint32 ReadVLQ2_DW(const uchar *data, uint32 bytes_left, uint32 *value);
+int GetLengthAsVLQ(uint32 data);
 int AddEventToList(XMIDIEVENT_LIST *event_list, int smf_size, int time,
 	    int event, int channel, int sysex_op, int op1, int op2, int op3, int op4);
 int ProcessEventList(XMIDIEVENT_LIST *event_list);
diff --git a/saga/ys_binread.cpp b/saga/ys_binread.cpp
index 3712b28011..ddc028a43a 100644
--- a/saga/ys_binread.cpp
+++ b/saga/ys_binread.cpp
@@ -168,24 +168,6 @@ int ys_read_s16_le(const unsigned char *data_p, const unsigned char **data_pp)
 }
 
 unsigned long
-ys_read_u24_be(const unsigned char *data_p, const unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Reads an unsigned 24 bit integer in big-endian format from the array of 
- * bytes pointed to by 'data_p'. If 'data_pp' is not null, it will set
- * '*data_pp' to point past the integer read. 
-\*---------------------------------------------------------------------------*/
-{
-	unsigned long u24_be = ((unsigned long)data_p[0] << 16) |
-	    ((unsigned long)data_p[1] << 8) | data_p[2];
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 3;
-	}
-
-	return u24_be;
-}
-
-unsigned long
 ys_read_u24_le(const unsigned char *data_p, const unsigned char **data_pp)
 /*---------------------------------------------------------------------------*\
  * Reads an unsigned 24 bit integer in big-endian format from the array of 
@@ -203,58 +185,6 @@ ys_read_u24_le(const unsigned char *data_p, const unsigned char **data_pp)
 	return u24_le;
 }
 
-long ys_read_s24_be(const unsigned char *data_p, const unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Reads a signed 24 bit integer in big-endian, 2's complement format from
- *  the array of bytes pointed to by 'data_p'. 
- * If 'data_pp' is not null, it will set '*data_pp' to point past the integer
- *  read.
-\*---------------------------------------------------------------------------*/
-{
-	unsigned long u24_be = ((unsigned long)data_p[0] << 16) |
-	    ((unsigned long)data_p[1] << 8) | data_p[2];
-	long s24_be;
-
-#ifndef YS_ASSUME_2S_COMP
-	if (u24_be & 0x800000UL) {
-		s24_be = (long)(u24_be - 0x800000UL) - 0x800000;
-	} else
-#endif
-		s24_be = u24_be;
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 3;
-	}
-
-	return s24_be;
-}
-
-long ys_read_s24_le(const unsigned char *data_p, const unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Reads a signed 24 bit integer in little-endian, 2's complement format from
- *  the array of bytes pointed to by 'data_p'. 
- * If 'data_pp' is not null, it will set '*data_pp' to point past the integer
- *  read.
-\*---------------------------------------------------------------------------*/
-{
-	unsigned long u24_be = ((unsigned long)data_p[2] << 16) |
-	    ((unsigned long)data_p[1] << 8) | data_p[0];
-	long s24_be;
-
-#ifndef YS_ASSUME_2S_COMP
-	if (u24_be & 0x800000UL) {
-		s24_be = (long)(u24_be - 0x800000UL) - 0x800000;
-	} else
-#endif
-		s24_be = u24_be;
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 3;
-	}
-
-	return s24_be;
-}
-
 unsigned long
 ys_read_u32_be(const unsigned char *data_p, const unsigned char **data_pp)
 /*---------------------------------------------------------------------------*\
@@ -293,58 +223,4 @@ ys_read_u32_le(const unsigned char *data_p, const unsigned char **data_pp)
 	return u32_le;
 }
 
-long ys_read_s32_be(const unsigned char *data_p, const unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Reads a signed 32 bit integer in big-endian, 2's complement format from
- *  the array of bytes pointed to by 'data_p'. 
- * If 'data_pp' is not null, it will set '*data_pp' to point past the integer
- *  read.
-\*---------------------------------------------------------------------------*/
-{
-	unsigned long u32_be = ((unsigned long)data_p[0] << 24) |
-	    ((unsigned long)data_p[1] << 16) |
-	    ((unsigned long)data_p[2] << 8) | data_p[3];
-	long s32_be;
-
-#ifndef YS_ASSUME_2S_COMP
-	if (u32_be & 0x80000000UL) {
-		s32_be = (long)(u32_be - 0x80000000UL) - 0x7FFFFFFF - 1;
-	} else
-#endif
-		s32_be = u32_be;
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 4;
-	}
-
-	return s32_be;
-}
-
-long ys_read_s32_le(const unsigned char *data_p, const unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Reads a signed 32 bit integer in little-endian, 2's complement format from
- *  the array of bytes pointed to by 'data_p'. 
- * If 'data_pp' is not null, it will set '*data_pp' to point past the integer
- *  read.
-\*---------------------------------------------------------------------------*/
-{
-	unsigned long u32_le = ((unsigned long)data_p[3] << 24) |
-	    ((unsigned long)data_p[2] << 16) |
-	    ((unsigned long)data_p[1] << 8) | data_p[0];
-	long s32_le;
-
-#ifndef YS_ASSUME_2S_COMP
-	if (u32_le & 0x80000000UL) {
-		s32_le = (long)(u32_le - 0x80000000UL) - 0x7FFFFFFF - 1;
-	} else
-#endif
-		s32_le = u32_le;
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 4;
-	}
-
-	return s32_le;
-}
-
 } // End of namespace Saga
diff --git a/saga/ys_binwrite.cpp b/saga/ys_binwrite.cpp
index ae10e364a2..2b01dc5017 100644
--- a/saga/ys_binwrite.cpp
+++ b/saga/ys_binwrite.cpp
@@ -23,17 +23,6 @@
 #include <stddef.h>
 
 namespace Saga {
-void
-ys_write_u8(unsigned int u8, unsigned char *data_p, unsigned char **data_pp)
-{
-	*data_p = (unsigned char)(u8 & 0xFFU);
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 1;
-	}
-
-	return;
-}
 
 void
 ys_write_u16_be(unsigned int u16_be,
@@ -56,154 +45,6 @@ ys_write_u16_be(unsigned int u16_be,
 }
 
 void
-ys_write_u16_le(unsigned int u16_le,
-    unsigned char *data_p, unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Writes an unsigned 16 bit integer in little-endian format to the buffer
- *  pointed to by 'data_p'.
- * If 'data_pp' is not null, the function will set it to point just beyond
- *  the integer written. 
-\*---------------------------------------------------------------------------*/
-{
-	data_p[0] = (unsigned char)(u16_le & 0xFFU);
-	data_p[1] = (unsigned char)((u16_le >> 8) & 0xFFU);
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 2;
-	}
-
-	return;
-}
-
-void
-ys_write_s16_be(int s16_be, unsigned char *data_p, unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Writes an signed 16 bit integer in big-endian format and two's
- *  complement representation to the buffer pointed to by 'data_p'.
- * If 'data_pp' is not null, the function will set it to point just beyond
- *  the integer written. 
-\*---------------------------------------------------------------------------*/
-{
-	unsigned int u16_be = s16_be;
-
-	data_p[0] = (unsigned char)((u16_be >> 8) & 0xFFU);
-	data_p[1] = (unsigned char)(u16_be & 0xFFU);
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 2;
-	}
-
-	return;
-}
-
-void
-ys_write_s16_le(int s16_le, unsigned char *data_p, unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Writes an signed 16 bit integer in little-endian format and two's
- *  complement representation to the buffer pointed to by 'data_p'.
- * If 'data_pp' is not null, the function will set it to point just beyond
- *  the integer written. 
-\*---------------------------------------------------------------------------*/
-{
-	unsigned int u16_le = s16_le;
-
-	data_p[0] = (unsigned char)(u16_le & 0xFFU);
-	data_p[1] = (unsigned char)((u16_le >> 8) & 0xFFU);
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 2;
-	}
-
-	return;
-}
-
-void
-ys_write_u24_be(unsigned long u24_be,
-    unsigned char *data_p, unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Writes an unsigned 24 bit integer in big-endian format to the buffer
- *  pointed to by 'data_p'.
- * If 'data_pp' is not null, the function will set it to point just beyond
- *  the integer written. 
-\*---------------------------------------------------------------------------*/
-{
-	data_p[0] = (unsigned char)((u24_be >> 16) & 0xFFU);
-	data_p[1] = (unsigned char)((u24_be >> 8) & 0xFFU);
-	data_p[2] = (unsigned char)(u24_be & 0xFFU);
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 3;
-	}
-
-	return;
-}
-
-void
-ys_write_u24_le(unsigned long u24_le,
-    unsigned char *data_p, unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Writes an unsigned 24 bit integer in little-endian format to the buffer
- *  pointed to by 'data_p'.
- * If 'data_pp' is not null, the function will set it to point just beyond
- *  the integer written. 
-\*---------------------------------------------------------------------------*/
-{
-	data_p[0] = (unsigned char)(u24_le & 0xFFU);
-	data_p[1] = (unsigned char)((u24_le >> 8) & 0xFFU);
-	data_p[2] = (unsigned char)((u24_le >> 16) & 0xFFU);
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 3;
-	}
-
-	return;
-}
-
-void
-ys_write_s24_be(long s24_be, unsigned char *data_p, unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Writes an signed 24 bit integer in big-endian format and two's
- *  complement representation to the buffer pointed to by 'data_p'.
- * If 'data_pp' is not null, the function will set it to point just beyond
- *  the integer written. 
-\*---------------------------------------------------------------------------*/
-{
-	unsigned long u24_be = s24_be;
-
-	data_p[0] = (unsigned char)((u24_be >> 16) & 0xFFU);
-	data_p[1] = (unsigned char)((u24_be >> 8) & 0xFFU);
-	data_p[2] = (unsigned char)(u24_be & 0xFFU);
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 3;
-	}
-
-	return;
-}
-
-void
-ys_write_s24_le(long s24_le, unsigned char *data_p, unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Writes an signed 24 bit integer in little-endian format and two's
- *  complement representation to the buffer pointed to by 'data_p'.
- * If 'data_pp' is not null, the function will set it to point just beyond
- *  the integer written. 
-\*---------------------------------------------------------------------------*/
-{
-	unsigned long u24_le = s24_le;
-
-	data_p[0] = (unsigned char)(u24_le & 0xFFU);
-	data_p[1] = (unsigned char)((u24_le >> 8) & 0xFFU);
-	data_p[2] = (unsigned char)((u24_le >> 16) & 0xFFU);
-
-	if (data_pp != NULL) {
-		*data_pp = (unsigned char *)(data_p + 3);
-	}
-
-	return;
-}
-
-void
 ys_write_u32_be(unsigned long u32_be,
     unsigned char *data_p, unsigned char **data_pp)
 /*---------------------------------------------------------------------------*\
@@ -225,72 +66,4 @@ ys_write_u32_be(unsigned long u32_be,
 	return;
 }
 
-void
-ys_write_u32_le(unsigned long u32_le,
-    unsigned char *data_p, unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Writes an unsigned 32 bit integer in little-endian format to the buffer
- *  pointed to by 'data_p'.
- * If 'data_pp' is not null, the function will set it to point just beyond
- *  the integer written. 
-\*---------------------------------------------------------------------------*/
-{
-	data_p[0] = (unsigned char)(u32_le & 0xFFU);
-	data_p[1] = (unsigned char)((u32_le >> 8) & 0xFFU);
-	data_p[2] = (unsigned char)((u32_le >> 16) & 0xFFU);
-	data_p[3] = (unsigned char)((u32_le >> 24) & 0xFFU);
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 4;
-	}
-
-	return;
-}
-
-void
-ys_write_s32_be(long s32_be, unsigned char *data_p, unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Writes an signed 32 bit integer in big-endian format and two's
- *  complement representation to the buffer pointed to by 'data_p'.
- * If 'data_pp' is not null, the function will set it to point just beyond
- *  the integer written. 
-\*---------------------------------------------------------------------------*/
-{
-	unsigned long u32_be = s32_be;
-
-	data_p[0] = (unsigned char)((u32_be >> 24) & 0xFFU);
-	data_p[1] = (unsigned char)((u32_be >> 16) & 0xFFU);
-	data_p[2] = (unsigned char)((u32_be >> 8) & 0xFFU);
-	data_p[3] = (unsigned char)(u32_be & 0xFFU);
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 4;
-	}
-
-	return;
-}
-
-void
-ys_write_s32_le(long s32_le, unsigned char *data_p, unsigned char **data_pp)
-/*---------------------------------------------------------------------------*\
- * Writes an signed 32 bit integer in little-endian format and two's
- *  complement representation to the buffer pointed to by 'data_p'.
- * If 'data_pp' is not null, the function will set it to point just beyond
- *  the integer written. 
-\*---------------------------------------------------------------------------*/
-{
-	unsigned long u32_le = s32_le;
-
-	data_p[0] = (unsigned char)(u32_le & 0xFFU);
-	data_p[1] = (unsigned char)((u32_le >> 8) & 0xFFU);
-	data_p[2] = (unsigned char)((u32_le >> 16) & 0xFFU);
-	data_p[3] = (unsigned char)((u32_le >> 24) & 0xFFU);
-
-	if (data_pp != NULL) {
-		*data_pp = data_p + 4;
-	}
-
-	return;
-}
-
 } // End of namespace Saga
diff --git a/saga/ys_dl_list.cpp b/saga/ys_dl_list.cpp
index 116f52e8ea..f07f5491f5 100644
--- a/saga/ys_dl_list.cpp
+++ b/saga/ys_dl_list.cpp
@@ -271,40 +271,4 @@ ys_dll_reorder_down(YS_DL_NODE * list,
 	return YS_E_SUCCESS;
 }
 
-int
-ys_dll_foreach(YS_DL_NODE * list,
-    int direction,
-    void *param,
-    int (*ys_dll_proc) (void *data, void *param), YS_DL_NODE ** t_node)
-{
-	YS_DL_NODE *walk_p;
-
-	/* Only walk bakcward if explicitly requested to */
-	if (direction == YS_WALK_BACKWARD) {
-		for (walk_p = list->prev; walk_p != list;
-		    walk_p = walk_p->prev) {
-
-			if (ys_dll_proc(walk_p->data, param) == 0) {
-				break;
-			}
-
-		}
-	} else {
-		/* Default behavior is to walk forwards */
-		for (walk_p = list->next; walk_p != list;
-		    walk_p = walk_p->next) {
-
-			if (ys_dll_proc(walk_p->data, param) == 0) {
-				break;
-			}
-		}
-	}
-
-	if (t_node) {
-		*t_node = (walk_p != list) ? walk_p : NULL;
-	}
-
-	return YS_E_SUCCESS;
-}
-
 } // End of namespace Saga
diff --git a/saga/yslib.h b/saga/yslib.h
index ca1e4926fa..25d19c0e60 100644
--- a/saga/yslib.h
+++ b/saga/yslib.h
@@ -76,71 +76,24 @@ int ys_read_s16_be(const unsigned char *, const unsigned char **);
 /* Read 16 bit signed integer, 2's complement, little-endian */
 int ys_read_s16_le(const unsigned char *, const unsigned char **);
 
-/* Read 24 bit unsigned integer, big-endian */
-unsigned long ys_read_u24_be(const unsigned char *, const unsigned char **);
-
 /* Read 24 bit unsigned integer, little-endian */
 unsigned long ys_read_u24_le(const unsigned char *, const unsigned char **);
 
-/* Read 24 bit signed integer, 2's complement, big-endian */
-long ys_read_s24_be(const unsigned char *, const unsigned char **);
-
-/* Read 24 bit signed integer, 2's complement, little-endian */
-long ys_read_s24_le(const unsigned char *, const unsigned char **);
-
 /* Read 32 bit unsigned integer, big-endian */
 unsigned long ys_read_u32_be(const unsigned char *, const unsigned char **);
 
 /* Read 32 bit unsigned integer, little-endian */
 unsigned long ys_read_u32_le(const unsigned char *, const unsigned char **);
 
-/* Read 32 bit signed integer, 2's complement, big-endian */
-long ys_read_s32_be(const unsigned char *, const unsigned char **);
-
-/* Read 32 bit signed integer, 2's complement, little-endian */
-long ys_read_s32_le(const unsigned char *, const unsigned char **);
-
 /* ys_binwrite.c : Binary output functions ( buffer oriented ) 
 \*------------------------------------------------------------------*/
 
-void ys_write_u8(unsigned int, unsigned char *, unsigned char **);
-
 /* Write 16 bit unsigned integer, big-endian */
 void ys_write_u16_be(unsigned int, unsigned char *, unsigned char **);
 
-/* Write 16 bit unsigned integer, little-endian */
-void ys_write_u16_le(unsigned int, unsigned char *, unsigned char **);
-
-/* Write 16 bit signed integer, 2's complement, big-endian */
-void ys_write_s16_be(int, unsigned char *, unsigned char **);
-
-/* Write 16 bit signed integer, 2's complement, little-endian */
-void ys_write_s16_le(int, unsigned char *, unsigned char **);
-
-/* Write 24 bit unsigned integer, big-endian */
-void ys_write_u24_be(unsigned long, unsigned char *, unsigned char **);
-
-/* Write 24 bit unsigned integer, little-endian */
-void ys_write_u24_le(unsigned long, unsigned char *, unsigned char **);
-
-/* Write 24 bit signed integer, 2's complement, big-endian */
-void ys_write_s24_be(long, unsigned char *, unsigned char **);
-
-/* Write 24 bit signed integer, 2's complement, little-endian */
-void ys_write_s24_le(long, unsigned char *, unsigned char **);
-
 /* Write 32 bit unsigned integer, big-endian */
 void ys_write_u32_be(unsigned long, unsigned char *, unsigned char **);
 
-/* Write 32 bit unsigned integer, little-endian */
-void ys_write_u32_le(unsigned long, unsigned char *, unsigned char **);
-
-/* Write 32 bit signed integer, 2's complement, big-endian */
-void ys_write_s32_be(long, unsigned char *, unsigned char **);
-
-/* Write 32 bit signed integer, 2's complement, little-endian */
-void ys_write_s32_le(long, unsigned char *, unsigned char **);
-
 
 /* Shared declarations for list modules
 \*------------------------------------------------------------------*/
@@ -185,9 +138,6 @@ YS_DL_NODE *ys_dll_replace(YS_DL_NODE *, void *, size_t);
 int ys_dll_reorder_up(YS_DL_LIST *, YS_DL_NODE *, YS_COMPARE_FUNC *);
 int ys_dll_reorder_down(YS_DL_LIST *, YS_DL_NODE *, YS_COMPARE_FUNC *);
 
-int ys_dll_foreach(YS_DL_LIST *,
-    int, void *, int (*)(void *, void *), YS_DL_NODE **);
-
 
 } // End of namespace Saga