Removed Watcom Compiler support.

10 files changed, 9 insertions, 1470 deletions

diff --git a/src/win95/d3_func.cpp b/src/win95/d3_func.cpp
index 35de5bd..3495440 100644
--- a/src/win95/d3_func.cpp
+++ b/src/win95/d3_func.cpp
@@ -98,12 +98,6 @@ static unsigned char DefaultD3DTextureFilterMax;
 
 #if SuppressWarnings
 static int* itemptr_tmp;
-
-#ifdef __WATCOMC__
-#pragma warning 389 5
-#pragma message("Note: Disabled Warning W389 'Integral value may be truncated...'")
-#endif
-
 #endif
 
 
diff --git a/src/win95/dxlog.c b/src/win95/dxlog.c
index d95bd51..42d2d03 100644
--- a/src/win95/dxlog.c
+++ b/src/win95/dxlog.c
@@ -278,11 +278,7 @@ D3DAppErrorToString(HRESULT error)
     }
 }
 
-#ifdef __WATCOMC__
-	#define LOGFILE_NAME "dx_error.log"
-#else
-	#define LOGFILE_NAME "dx_errorM.log"
-#endif
+#define LOGFILE_NAME "dx_errorM.log"
 
 static LOGFILE * dxlog = 0;
 static int closed_once = 0;
diff --git a/src/win95/hash_tem.hpp b/src/win95/hash_tem.hpp
index 30df53e..bc25f53 100644
--- a/src/win95/hash_tem.hpp
+++ b/src/win95/hash_tem.hpp
@@ -839,17 +839,8 @@ template <class TYPE> class HashTable;
 #define HT_WATCOM_DEFINE_FOR_SIMPLE_TYPE(TYPE) \
 	class HashTable<TYPE> HT_DEFINITION(TYPE,TYPE,TYPE)
 	
-#ifdef __WATCOMC__
-
-//watcom generartes errors if template<> is added to the start of the line - Richard.
-#define HT_DEFINE_FOR_SIMPLE_TYPE(SIMPLE_TYPE) HT_WATCOM_DEFINE_FOR_SIMPLE_TYPE(SIMPLE_TYPE)
-
-#else
-
 #define HT_DEFINE_FOR_SIMPLE_TYPE(SIMPLE_TYPE) template<> HT_WATCOM_DEFINE_FOR_SIMPLE_TYPE(SIMPLE_TYPE)
 
-#endif
-	
 HT_DEFINE_FOR_SIMPLE_TYPE(unsigned long)
 HT_DEFINE_FOR_SIMPLE_TYPE(signed long)
 HT_DEFINE_FOR_SIMPLE_TYPE(unsigned)
diff --git a/src/win95/inline.h b/src/win95/inline.h
index da000e4..717881d 100644
--- a/src/win95/inline.h
+++ b/src/win95/inline.h
@@ -14,15 +14,6 @@
 #include "mmx_math.h"
 #endif
 
-/*
-
-
- Watcom PC Inline Functions.
-
- Watcom Standard C does not support the C++ "inline" directive, so these
- functions have been written as inline assembler instead.
-
-*/
 
 #ifdef __cplusplus
 extern "C" {
@@ -73,524 +64,7 @@ extern "C" {
 */
 
 
-#ifdef __WATCOMC__ /* inline assember for the Watcom compiler */
-
-/* ADD */
-
-void ADD_LL(LONGLONGCH *a, LONGLONGCH *b, LONGLONGCH *c);
-# pragma aux ADD_LL = \
-"mov	eax,[esi]" \
-"mov	edx,[esi+4]" \
-"add	eax,[edi]" \
-"adc	edx,[edi+4]" \
-"mov	[ebx],eax" \
-"mov	[ebx+4],edx" \
-parm[esi] [edi] [ebx] \
-modify[eax edx];
-
-
-/* ADD ++ */
-
-void ADD_LL_PP(LONGLONGCH *c, LONGLONGCH *a);
-# pragma aux ADD_LL_PP = \
-"mov	eax,[esi]" \
-"mov	edx,[esi+4]" \
-"add	[edi],eax" \
-"adc	[edi+4],edx" \
-parm[edi] [esi] \
-modify[eax edx];
-
-
-/* SUB */
-
-void SUB_LL(LONGLONGCH *a, LONGLONGCH *b, LONGLONGCH *c);
-# pragma aux SUB_LL = \
-"mov	eax,[esi]" \
-"mov	edx,[esi+4]" \
-"sub	eax,[edi]" \
-"sbb	edx,[edi+4]" \
-"mov	[ebx],eax" \
-"mov	[ebx+4],edx" \
-parm[esi] [edi] [ebx] \
-modify[eax edx];
-
-
-
-/* SUB -- */
-
-void SUB_LL_MM(LONGLONGCH *c, LONGLONGCH *a);
-# pragma aux SUB_LL_MM = \
-"mov	eax,[esi]" \
-"mov	edx,[esi+4]" \
-"sub	[edi],eax" \
-"sbb	[edi+4],edx" \
-parm[edi] [esi] \
-modify[eax edx];
-
-
-/*
-
- MUL
-
- This is the multiply we use, the 32 x 32 = 64 widening version
-
-*/
-
-void MUL_I_WIDE(int a, int b, LONGLONGCH *c);
-# pragma aux MUL_I_WIDE = \
-"imul	edx"\
-"mov	[ebx],eax" \
-"mov	[ebx+4],edx" \
-parm[eax] [edx] [ebx] \
-modify[eax edx];
-
-
-
-/*
-
- CMP
-
- This substitutes for ==, >, <, >=, <=
-
-*/
-
-int CMP_LL(LONGLONGCH *a, LONGLONGCH *b);
-# pragma aux CMP_LL = \
-"mov	eax,[ebx]" \
-"mov	edx,[ebx+4]" \
-"sub	eax,[ecx]" \
-"sbb	edx,[ecx+4]" \
-"and	edx,edx" \
-"jne	llnz" \
-"and	eax,eax" \
-"jne	llnz" \
-"xor	eax,eax" \
-"jmp	llgs" \
-"llnz:" \
-"mov	eax,1" \
-"and	edx,edx" \
-"jge	llgs" \
-"neg	eax" \
-"llgs:" \
-parm[ebx] [ecx] \
-value[eax] \
-modify[edx];
-
-
-
-
-/* EQUALS */
-
-void EQUALS_LL(LONGLONGCH *a, LONGLONGCH *b);
-# pragma aux EQUALS_LL = \
-"mov	eax,[esi]" \
-"mov	edx,[esi+4]" \
-"mov	[edi],eax" \
-"mov	[edi+4],edx" \
-parm[edi] [esi] \
-modify[eax edx];
-
-
-/* NEGATE */
-
-void NEG_LL(LONGLONGCH *a);
-# pragma aux NEG_LL = \
-"not	dword ptr[esi]" \
-"not	dword ptr[esi+4]" \
-"add	dword ptr[esi],1" \
-"adc	dword ptr[esi+4],0" \
-parm[esi];
-
-
-/* ASR */
-
-void ASR_LL(LONGLONGCH *a, int shift);
-# pragma aux ASR_LL = \
-"and	eax,eax" \
-"jle	asrdn" \
-"asrlp:" \
-"sar	dword ptr[esi+4],1" \
-"rcr	dword ptr[esi],1" \
-"dec	eax" \
-"jne	asrlp" \
-"asrdn:" \
-parm[esi] [eax];
-
-
-/* Convert int to LONGLONGCH */
-
-void IntToLL(LONGLONGCH *a, int *b);
-# pragma aux IntToLL = \
-"mov	eax,[esi]" \
-"cdq" \
-"mov	[edi],eax" \
-"mov	[edi+4],edx" \
-parm[edi] [esi] \
-modify[eax edx];
-
-
-
-
-
-
-
-
-
-/*
-
- Fixed Point Multiply.
-
-
- 16.16 * 16.16 -> 16.16
- or
- 16.16 * 0.32 -> 0.32
-
- A proper version of this function ought to read
- 16.16 * 16.16 -> 32.16
- but this would require a long long result
-
- Algorithm:
-
- Take the mid 32 bits of the 64 bit result
-
-*/
-
-/*
-	These functions have been checked for suitability for 
-	a Pentium and look as if they would work adequately.
-	Might be worth a more detailed look at optimising
-	them though.
-*/
-
-#if 0
-
-int MUL_FIXED(int a, int b);
-# pragma aux MUL_FIXED = \
-"imul edx" \
-"mov ax,dx" \
-"rol eax,16" \
-parm[eax] [edx] \
-value[eax] \
-modify[edx];
-
-#else
-
-int MUL_FIXED(int a, int b);
-# pragma aux MUL_FIXED = \
-"imul edx" \
-"shrd	eax,edx,16" \
-parm[eax] [edx] \
-value[eax] \
-modify[edx];
-
-#endif
-
-
-/*
-
- Fixed Point Divide - returns a / b
-
-*/
-
-int DIV_FIXED(int a, int b);
-# pragma aux DIV_FIXED = \
-"cdq" \
-"rol eax,16" \
-"mov dx,ax" \
-"xor ax,ax" \
-"idiv ebx" \
-parm[eax] [ebx] \
-value[eax] \
-modify[edx];
-
-
-
-
-/*
-
- Multiply and Divide Functions.
-
-*/
-
-
-/*
-
- 32/32 division
-
- This macro is a function on some other platforms
-
-*/
-
-#define DIV_INT(a, b) ((a) / (b))
-
-
-
-
-/*
-
- A Narrowing 64/32 Division
-
-*/
-
-int NarrowDivide(LONGLONGCH *a, int b);
-# pragma aux NarrowDivide = \
-"mov	eax,[esi]" \
-"mov	edx,[esi+4]" \
-"idiv	ebx" \
-parm[esi] [ebx] \
-value[eax] \
-modify[edx];
-
-
-
-/*
-
- This function performs a Widening Multiply followed by a Narrowing Divide.
-
- a = (a * b) / c
-
-*/
-
-int WideMulNarrowDiv(int a, int b, int c);
-# pragma aux WideMulNarrowDiv = \
-"imul	edx"\
-"idiv	ebx" \
-parm[eax] [edx] [ebx] \
-value[eax];
-
-
-
-/*
-
- Function to rotate a VECTORCH using a MATRIXCH
-
- This is the C function
-
-	x =  MUL_FIXED(m->mat11, v->vx);
-	x += MUL_FIXED(m->mat21, v->vy);
-	x += MUL_FIXED(m->mat31, v->vz);
-
-	y  = MUL_FIXED(m->mat12, v->vx);
-	y += MUL_FIXED(m->mat22, v->vy);
-	y += MUL_FIXED(m->mat32, v->vz);
-
-	z  = MUL_FIXED(m->mat13, v->vx);
-	z += MUL_FIXED(m->mat23, v->vy);
-	z += MUL_FIXED(m->mat33, v->vz);
-
-	v->vx = x;
-	v->vy = y;
-	v->vz = z;
-
- This is the MUL_FIXED inline assembler function
-
-	imul edx
-	shrd eax,edx,16
-
-
-typedef struct matrixch {
-
-	int mat11;	0
-	int mat12;	4
-	int mat13;	8
-
-	int mat21;	12
-	int mat22;	16
-	int mat23;	20
-
-	int mat31;	24
-	int mat32;	28
-	int mat33;	32
-
-} MATRIXCH;
-
-*/
-
-void RotateVector_ASM(VECTORCH *v, MATRIXCH *m);
-# pragma aux RotateVector_ASM = \
-\
-"push	eax" \
-"push	ebx" \
-"push	ecx" \
-"push	edx" \
-"push	ebp" \
-\
-"mov	eax,[edi + 0]" \
-"imul	DWORD PTR [esi + 0]" \
-"shrd	eax,edx,16" \
-"mov	ecx,eax"\
-"mov	eax,[edi + 12]" \
-"imul	DWORD PTR [esi + 4]" \
-"shrd	eax,edx,16" \
-"add	ecx,eax" \
-"mov	eax,[edi + 24]" \
-"imul	DWORD PTR [esi + 8]" \
-"shrd	eax,edx,16" \
-"add	ecx,eax" \
-\
-"mov	eax,[edi + 4]" \
-"imul	DWORD PTR [esi + 0]" \
-"shrd	eax,edx,16" \
-"mov	ebx,eax"\
-"mov	eax,[edi + 16]" \
-"imul	DWORD PTR [esi + 4]" \
-"shrd	eax,edx,16" \
-"add	ebx,eax" \
-"mov	eax,[edi + 28]" \
-"imul	DWORD PTR [esi + 8]" \
-"shrd	eax,edx,16" \
-"add	ebx,eax" \
-\
-"mov	eax,[edi + 8]" \
-"imul	DWORD PTR [esi + 0]" \
-"shrd	eax,edx,16" \
-"mov	ebp,eax"\
-"mov	eax,[edi + 20]" \
-"imul	DWORD PTR [esi + 4]" \
-"shrd	eax,edx,16" \
-"add	ebp,eax" \
-"mov	eax,[edi + 32]" \
-"imul	DWORD PTR [esi + 8]" \
-"shrd	eax,edx,16" \
-"add	ebp,eax" \
-\
-"mov	[esi + 0],ecx" \
-"mov	[esi + 4],ebx" \
-"mov	[esi + 8],ebp" \
-\
-"pop	ebp" \
-"pop	edx" \
-"pop	ecx" \
-"pop	ebx" \
-"pop	eax" \
-\
-parm[esi] [edi];
-
-
-/*
-
- Here is the same function, this time copying the result to a second vector
-
-*/
-
-void RotateAndCopyVector_ASM(VECTORCH *v1, VECTORCH *v2, MATRIXCH *m);
-# pragma aux RotateAndCopyVector_ASM = \
-\
-"push	eax" \
-"push	ebx" \
-"push	ecx" \
-"push	ebp" \
-\
-"push	edx" \
-"mov	eax,[edi + 0]" \
-"imul	DWORD PTR [esi + 0]" \
-"shrd	eax,edx,16" \
-"mov	ecx,eax"\
-"mov	eax,[edi + 12]" \
-"imul	DWORD PTR [esi + 4]" \
-"shrd	eax,edx,16" \
-"add	ecx,eax" \
-"mov	eax,[edi + 24]" \
-"imul	DWORD PTR [esi + 8]" \
-"shrd	eax,edx,16" \
-"add	ecx,eax" \
-\
-"mov	eax,[edi + 4]" \
-"imul	DWORD PTR [esi + 0]" \
-"shrd	eax,edx,16" \
-"mov	ebx,eax"\
-"mov	eax,[edi + 16]" \
-"imul	DWORD PTR [esi + 4]" \
-"shrd	eax,edx,16" \
-"add	ebx,eax" \
-"mov	eax,[edi + 28]" \
-"imul	DWORD PTR [esi + 8]" \
-"shrd	eax,edx,16" \
-"add	ebx,eax" \
-\
-"mov	eax,[edi + 8]" \
-"imul	DWORD PTR [esi + 0]" \
-"shrd	eax,edx,16" \
-"mov	ebp,eax"\
-"mov	eax,[edi + 20]" \
-"imul	DWORD PTR [esi + 4]" \
-"shrd	eax,edx,16" \
-"add	ebp,eax" \
-"mov	eax,[edi + 32]" \
-"imul	DWORD PTR [esi + 8]" \
-"shrd	eax,edx,16" \
-"add	ebp,eax" \
-\
-"pop	edx" \
-"mov	[edx + 0],ecx" \
-"mov	[edx + 4],ebx" \
-"mov	[edx + 8],ebp" \
-\
-"pop	ebp" \
-"pop	ecx" \
-"pop	ebx" \
-"pop	eax" \
-\
-parm[esi] [edx] [edi];
-
-
-
-
-#if (SupportFPMathsFunctions || SupportFPSquareRoot)
-
-/*
-
- Square Root
-
- Returns the Square Root of a 32-bit number
-
-*/
-
-static long temp;
-static long temp2;
-
-int SqRoot32(int A);
-# pragma aux SqRoot32 = \
-"finit" \
-"mov	temp,eax" \
-"fild temp" \
-"fsqrt" \
-"fistp temp2" \
-"fwait" \
-"mov	eax,temp2" \
-parm[eax] \
-value[eax];
-
-#endif
-
-
-/*
-
- This may look ugly (it is) but it is a MUCH faster way to convert "float" into "int" than
- the function call "CHP" used by the WATCOM compiler.
-
-*/
-
-static float fptmp;
-static int itmp;
-
-void FloatToInt(void);
-# pragma aux FloatToInt = \
-"fld fptmp" \
-"fistp itmp";
-
-/*
-
- This macro makes usage of the above function easier and more elegant
-
-*/
-
-#define f2i(a, b) { \
-fptmp = (b); \
-FloatToInt(); \
-a = itmp;}
-
-#elif defined(_MSC_VER) && 0 /* inline assember for the Microsoft compiler */
+#if defined(_MSC_VER) && 0 /* inline assember for the Microsoft compiler */
 
 /* ADD */
 
@@ -1111,7 +585,7 @@ a = itmp;}
 
 #else
 
-#if 1 /* GCC! */
+/* inline assembly has been moved to mathline.c */
 void ADD_LL(LONGLONGCH *a, LONGLONGCH *b, LONGLONGCH *c);
 void ADD_LL_PP(LONGLONGCH *c, LONGLONGCH *a);
 void SUB_LL(LONGLONGCH *a, LONGLONGCH *b, LONGLONGCH *c);
@@ -1147,752 +621,6 @@ fti_fptmp = (b); \
 FloatToInt(); \
 a = fti_itmp;}
 
-#else /* inline stuff */
-
-/* ADD */
-
-
-static __inline__ void ADD_LL(LONGLONGCH *a, LONGLONGCH *b, LONGLONGCH *c)
-{
-/*
-	_asm
-	{
-		mov esi,a
-		mov edi,b
-		mov ebx,c
-		mov	eax,[esi]
-		mov	edx,[esi+4]
-		add	eax,[edi]
-		adc	edx,[edi+4]
-		mov	[ebx],eax
-		mov	[ebx+4],edx
-	}
-*/
-
-__asm__("movl	0(%%esi), %%eax		\n\t"
-	"movl	4(%%esi), %%edx		\n\t"
-	"addl	0(%%edi), %%eax		\n\t"
-	"adcl	4(%%edi), %%edx		\n\t"
-	"movl	%%eax, 0(%%ebx)		\n\t"
-	"movl	%%edx, 4(%%ebx)		\n\t"
-	: 
-	: "S" (a), "D" (b), "b" (c)
-	: "%eax", "%edx", "memory", "cc"
-	);
-
-/*
-__asm__("movl	0(%%esi), %%eax		\n\t"
-	"movl	4(%%esi), %%edx		\n\t"
-	"addl	0(%%edi), %%eax		\n\t"
-	"adcl	4(%%edi), %%edx		\n\t"
-	: "=a" (c->lo32), "=d" (c->hi32)
-	: "S" (a), "D" (b)
-	);
-*/
-}
-
-/* ADD ++ */
-
-static __inline__ void ADD_LL_PP(LONGLONGCH *c, LONGLONGCH *a)
-{
-/*
-	_asm
-	{
-		mov edi,c
-		mov esi,a
-		mov	eax,[esi]
-		mov	edx,[esi+4]
-		add	[edi],eax
-		adc	[edi+4],edx
-	}
-*/
-__asm__("movl	0(%%esi), %%eax		\n\t"
-	"movl	4(%%esi), %%edx		\n\t"
-	"addl	%%eax, 0(%%edi)		\n\t"
-	"adcl	%%edx, 4(%%edi)		\n\t"
-	:
-	: "D" (c), "S" (a)
-	: "%eax", "%edx", "memory", "cc"
-	);
-}
-
-/* SUB */
-
-static __inline__ void SUB_LL(LONGLONGCH *a, LONGLONGCH *b, LONGLONGCH *c)
-{
-/*
-	_asm
-	{
-		mov esi,a
-		mov edi,b
-		mov ebx,c
-		mov	eax,[esi]
-		mov	edx,[esi+4]
-		sub	eax,[edi]
-		sbb	edx,[edi+4]
-		mov	[ebx],eax
-		mov	[ebx+4],edx
-	}
-*/
-__asm__("movl	0(%%esi), %%eax		\n\t"
-	"movl	4(%%esi), %%edx		\n\t"
-	"subl	0(%%edi), %%eax		\n\t"
-	"sbbl	4(%%edi), %%edx		\n\t"
-	"movl	%%eax, 0(%%ebx)		\n\t"
-	"movl	%%edx, 4(%%ebx)		\n\t"
-	:
-	: "S" (a), "D" (b), "b" (c)
-	: "%eax", "%edx", "memory", "cc"
-	);
-}
-
-/* SUB -- */
-
-static __inline__ void SUB_LL_MM(LONGLONGCH *c, LONGLONGCH *a)
-{
-/*
-	_asm
-	{
-		mov edi,c
-		mov esi,a
-		mov	eax,[esi]
-		mov	edx,[esi+4]
-		sub	[edi],eax
-		sbb	[edi+4],edx
-	}
-*/
-__asm__("movl	0(%%esi), %%eax		\n\t"
-	"movl	4(%%esi), %%edx		\n\t"
-	"subl	%%eax, 0(%%edi)		\n\t"
-	"sbbl	%%edx, 4(%%edi)		\n\t"
-	:
-	: "D" (c), "S" (a)
-	: "%eax", "%edx", "memory", "cc"
-	);
-}
-
-/*
-
- MUL
-
- This is the multiply we use, the 32 x 32 = 64 widening version
-
-*/
-
-static __inline__ void MUL_I_WIDE(int a, int b, LONGLONGCH *c)
-{
-/*
-	_asm
-	{
-		mov eax,a
-		mov ebx,c
-		imul b
-		mov	[ebx],eax
-		mov	[ebx+4],edx
-	}
-*/
-__asm__("imull	%2			\n\t"
-	"movl	%%eax, 0(%%ebx)		\n\t"
-	"movl	%%edx, 4(%%ebx)		\n\t"
-	:
-	: "a" (a), "b" (c), "q" (b)
-	: "%edx", "memory", "cc"
-	);
-}
-
-/*
-
- CMP
-
- This substitutes for ==, >, <, >=, <=
-
-*/
-
-static __inline__ int CMP_LL(LONGLONGCH *a, LONGLONGCH *b)
-{
-	int retval;
-/*
-	_asm
-	{
-		mov ebx,a
-		mov ecx,b
-		mov	eax,[ebx]
-		mov	edx,[ebx+4]
-		sub	eax,[ecx]
-		sbb	edx,[ecx+4]
-		and	edx,edx
-		jne	llnz
-		and	eax,eax
-		je	llgs
-		llnz:
-		mov	retval,1
-		and	edx,edx
-		jge	llgs
-		neg	retval
-		llgs:
-	}
-*/
-/* TODO */
-__asm__("movl	0(%%ebx), %%eax		\n\t"
-	"movl	4(%%ebx), %%edx		\n\t"
-	"subl	0(%%ecx), %%eax		\n\t"
-	"sbbl	4(%%ecx), %%edx		\n\t"
-	"xorl	%0, %0                  \n\t" /* hopefully it doesn't pick %eax or %edx */
-	"andl	%%edx, %%edx		\n\t"
-	"jne	0			\n\t" /* llnz */
-	"andl	%%eax, %%eax		\n\t"
-	"je	1			\n"   /* llgs */
-"0:					\n\t" /* llnz */
-	"movl	$1, %0			\n\t"
-	"andl	%%edx, %%edx		\n\t"
-	"jge	1			\n\t" /* llgs */
-	"negl	%0			\n"
-"1:					\n\t" /* llgs */
-	: "=r" (retval)
-	: "b" (a), "c" (b)
-	: "%eax", "%edx", "memory", "cc"
-	);
-	
-	return retval;
-}
-
-/* EQUALS */
-
-static __inline__ void EQUALS_LL(LONGLONGCH *a, LONGLONGCH *b)
-{
-/*
-	_asm
-	{
-		mov edi,a
-		mov esi,b
-		mov	eax,[esi]
-		mov	edx,[esi+4]
-		mov	[edi],eax
-		mov	[edi+4],edx
-	}
-*/
-__asm__("movl	0(%%esi), %%eax		\n\t"
-	"movl	4(%%esi), %%edx		\n\t"
-	"movl	%%eax, 0(%%edi)		\n\t"
-	"movl	%%edx, 4(%%edi)		\n\t"
-	:
-	: "D" (a), "S" (b)
-	: "%eax", "%edx", "memory"
-	);
-}
-
-/* NEGATE */
-
-static __inline__ void NEG_LL(LONGLONGCH *a)
-{
-/*
-	_asm
-	{
-		mov esi,a
-		not	dword ptr[esi]
-		not	dword ptr[esi+4]
-		add	dword ptr[esi],1
-		adc	dword ptr[esi+4],0
-	}
-*/
-__asm__("notl	0(%%esi)		\n\t"
-	"notl	4(%%esi)		\n\t"
-	"addl	$1, 0(%%esi)		\n\t"
-	"adcl	$0, 4(%%esi)		\n\t"
-	:
-	: "S" (a)
-	: "memory", "cc"
-	);
-}
-
-/* ASR */
-
-static __inline__ void ASR_LL(LONGLONGCH *a, int shift)
-{
-/*
-	_asm
-	{
-		mov esi,a
-		mov eax,shift
-		and	eax,eax
-		jle	asrdn
-		asrlp:
-		sar	dword ptr[esi+4],1
-		rcr	dword ptr[esi],1
-		dec	eax
-		jne	asrlp
-		asrdn:
-	}
-*/
-__asm__("andl	%%eax, %%eax		\n\t"
-	"jle	0			\n" /* asrdn */
-"1:					\n\t" /* asrlp */
-	"sarl	$1, 4(%%esi)		\n\t"
-	"rcrl	$1, 0(%%esi)		\n\t"
-	"decl	%%eax			\n\t"
-	"jne	1			\n"
-"0:					\n\t"
-	:
-	: "S" (a), "a" (shift)
-	: "memory", "cc"
-	);
-	
-}
-
-/* Convert int to LONGLONGCH */
-
-static __inline__ void IntToLL(LONGLONGCH *a, int *b)
-{
-/*
-	_asm
-	{
-		mov esi,b
-		mov edi,a
-		mov	eax,[esi]
-		cdq
-		mov	[edi],eax
-		mov	[edi+4],edx
-	}
-*/
-__asm__("movl	0(%%esi), %%eax		\n\t"
-	"cdq				\n\t"
-	"movl	%%eax, 0(%%edi)		\n\t"
-	"movl	%%edx, 4(%%edi)		\n\t"
-	:
-	: "S" (b), "D" (a)
-	: "%eax", "%edx", "memory", "cc"
-	);
-
-}
-
-/*
-
- Fixed Point Multiply.
-
-
- 16.16 * 16.16 -> 16.16
- or
- 16.16 * 0.32 -> 0.32
-
- A proper version of this function ought to read
- 16.16 * 16.16 -> 32.16
- but this would require a long long result
-
- Algorithm:
-
- Take the mid 32 bits of the 64 bit result
-
-*/
-
-/*
-	These functions have been checked for suitability for 
-	a Pentium and look as if they would work adequately.
-	Might be worth a more detailed look at optimising
-	them though.
-*/
-
-static __inline__ int MUL_FIXED(int a, int b)
-{
-	int retval;
-/*
-	_asm
-	{
-		mov eax,a
-		imul b
-		shrd eax,edx,16
-		mov retval,eax
-	}
-*/
-/* TODO */
-__asm__("imull	%2			\n\t"
-	"shrdl	$16, %%edx, %%eax	\n\t"
-	: "=a" (retval)
-	: "a" (a), "q" (b)
-	: "%edx", "cc"
-	);
-	return retval;
-}
-
-/*
-
- Fixed Point Divide - returns a / b
-
-*/
-
-static __inline__ int DIV_FIXED(int a, int b)
-{
-	int retval;
-/*
-	_asm
-	{
-		mov eax,a
-		cdq
-		rol eax,16
-		mov dx,ax
-		xor ax,ax
-		idiv b
-		mov retval,eax
-	}
-*/
-/* TODO */
-__asm__("cdq				\n\t"
-	"roll	$16, %%eax		\n\t"
-	"mov	%%ax, %%dx		\n\t"
-	"xor	%%ax, %%ax		\n\t"
-	"idivl	%2			\n\t"
-	: "=a" (retval)
-	: "a" (a), "q" (b)
-	: "%edx", "cc"
-	);
-	return retval;
-}
-
-/*
-
- Multiply and Divide Functions.
-
-*/
-
-
-/*
-
- 32/32 division
-
- This macro is a function on some other platforms
-
-*/
-
-#define DIV_INT(a, b) ((a) / (b))
-
-/*
-
- A Narrowing 64/32 Division
-
-*/
-
-static __inline__ int NarrowDivide(LONGLONGCH *a, int b)
-{
-	int retval;
-/*
-	_asm
-	{
-		mov esi,a
-		mov	eax,[esi]
-		mov	edx,[esi+4]
-		idiv	b
-		mov retval,eax
-	}
-*/
-__asm__("movl	0(%%esi), %%eax		\n\t"
-	"movl	4(%%esi), %%edx		\n\t"
-	"idivl	%2			\n\t"
-	: "=a" (retval)
-	: "S" (a), "q" (b)
-	: "%edx", "cc"
-	);
-	return retval;
-}
-
-/*
-
- This function performs a Widening Multiply followed by a Narrowing Divide.
-
- a = (a * b) / c
-
-*/
-
-static __inline__ int WideMulNarrowDiv(int a, int b, int c)
-{
-#if 0 /* TODO: broken? */
-	int retval;
-/*
-	_asm
-	{
-		mov eax,a
-		imul b
-		idiv c
-		mov retval,eax
-	}
-*/
-/* TODO */
-__asm__("imull	%2			\n\t"
-	"idivl	%3			\n\t"
-	: "=a" (retval)
-	: "a" (a), "q" (b), "q" (c)
-	: "cc"
-	);	
-	return retval;
-#endif
-	return (a * b) / c;	
-}
-
-/*
-
- Function to rotate a VECTORCH using a MATRIXCH
-
- This is the C function
-
-	x =  MUL_FIXED(m->mat11, v->vx);
-	x += MUL_FIXED(m->mat21, v->vy);
-	x += MUL_FIXED(m->mat31, v->vz);
-
-	y  = MUL_FIXED(m->mat12, v->vx);
-	y += MUL_FIXED(m->mat22, v->vy);
-	y += MUL_FIXED(m->mat32, v->vz);
-
-	z  = MUL_FIXED(m->mat13, v->vx);
-	z += MUL_FIXED(m->mat23, v->vy);
-	z += MUL_FIXED(m->mat33, v->vz);
-
-	v->vx = x;
-	v->vy = y;
-	v->vz = z;
-
- This is the MUL_FIXED inline assembler function
-
-	imul edx
-	shrd eax,edx,16
-
-
-typedef struct matrixch {
-
-	int mat11;	0
-	int mat12;	4
-	int mat13;	8
-
-	int mat21;	12
-	int mat22;	16
-	int mat23;	20
-
-	int mat31;	24
-	int mat32;	28
-	int mat33;	32
-
-} MATRIXCH;
-
-*/
-
-#if 0 /* TODO if these are needed */
-static void RotateVector_ASM(VECTORCH *v, MATRIXCH *m)
-{
-	_asm
-	{
-		mov esi,v
-		mov edi,m
-
-		mov	eax,[edi + 0]
-		imul	DWORD PTR [esi + 0]
-		shrd	eax,edx,16
-		mov	ecx,eax
-		mov	eax,[edi + 12]
-		imul	DWORD PTR [esi + 4]
-		shrd	eax,edx,16
-		add	ecx,eax
-		mov	eax,[edi + 24]
-		imul	DWORD PTR [esi + 8]
-		shrd	eax,edx,16
-		add	ecx,eax
-
-		mov	eax,[edi + 4]
-		imul	DWORD PTR [esi + 0]
-		shrd	eax,edx,16
-		mov	ebx,eax
-		mov	eax,[edi + 16]
-		imul	DWORD PTR [esi + 4]
-		shrd	eax,edx,16
-		add	ebx,eax
-		mov	eax,[edi + 28]
-		imul	DWORD PTR [esi + 8]
-		shrd	eax,edx,16
-		add	ebx,eax
-
-		mov	eax,[edi + 8]
-		imul	DWORD PTR [esi + 0]
-		shrd	eax,edx,16
-		mov	ebp,eax
-		mov	eax,[edi + 20]
-		imul	DWORD PTR [esi + 4]
-		shrd	eax,edx,16
-		add	ebp,eax
-		mov	eax,[edi + 32]
-		imul	DWORD PTR [esi + 8]
-		shrd	eax,edx,16
-		add	ebp,eax
-
-		mov	[esi + 0],ecx
-		mov	[esi + 4],ebx
-		mov	[esi + 8],ebp
-	}
-}
-
-/*
-
- Here is the same function, this time copying the result to a second vector
-
-*/
-
-static void RotateAndCopyVector_ASM(VECTORCH *v1, VECTORCH *v2, MATRIXCH *m)
-{
-	_asm
-	{
-		mov esi,v1
-		mov edi,m
-
-		mov	eax,[edi + 0]
-		imul	DWORD PTR [esi + 0]
-		shrd	eax,edx,16
-		mov	ecx,eax
-		mov	eax,[edi + 12]
-		imul	DWORD PTR [esi + 4]
-		shrd	eax,edx,16
-		add	ecx,eax
-		mov	eax,[edi + 24]
-		imul	DWORD PTR [esi + 8]
-		shrd	eax,edx,16
-		add	ecx,eax
-
-		mov	eax,[edi + 4]
-		imul	DWORD PTR [esi + 0]
-		shrd	eax,edx,16
-		mov	ebx,eax
-		mov	eax,[edi + 16]
-		imul	DWORD PTR [esi + 4]
-		shrd	eax,edx,16
-		add	ebx,eax
-		mov	eax,[edi + 28]
-		imul	DWORD PTR [esi + 8]
-		shrd	eax,edx,16
-		add	ebx,eax
-
-		mov	eax,[edi + 8]
-		imul	DWORD PTR [esi + 0]
-		shrd	eax,edx,16
-		mov	ebp,eax
-		mov	eax,[edi + 20]
-		imul	DWORD PTR [esi + 4]
-		shrd	eax,edx,16
-		add	ebp,eax
-		mov	eax,[edi + 32]
-		imul	DWORD PTR [esi + 8]
-		shrd	eax,edx,16
-		add	ebp,eax
-
-		mov edx,v2
-		mov	[edx + 0],ecx
-		mov	[edx + 4],ebx
-		mov	[edx + 8],ebp
-	}
-}
-#endif
-
-#if (SupportFPMathsFunctions || SupportFPSquareRoot)
-
-/*
-
- Square Root
-
- Returns the Square Root of a 32-bit number
-
-*/
-
-extern int sqrt_temp1;
-extern int sqrt_temp2;
-
-#include <math.h>
-static __inline__ int SqRoot32(int A)
-{
-#if 0
-	sqrt_temp1 = A;
-/*
-	_asm
-	{
-		finit
-		fild A
-		fsqrt
-		fistp temp2
-		fwait
-	}
-*/
-
-__asm__("finit				\n\t"
-	"fild	sqrt_temp1		\n\t"
-	"fsqrt				\n\t"
-	"fistp	sqrt_temp2		\n\t"
-	"fwait				\n\t"
-	:
-	:
-	: "memory", "cc"
-	);
-	
-	return sqrt_temp2;
-#endif
-{ /* TODO: clean this please */
-	double x = A;
-	double retvald = sqrt(x);
-	int retval = retvald;
-	return retval;
-}
-}
-
-#endif
-
-
-/*
-
- This may look ugly (it is) but it is a MUCH faster way to convert "float" into "int" than
- the function call "CHP" used by the WATCOM compiler.
-
-*/
-
-extern float fti_fptmp;
-extern int fti_itmp;
-
-static __inline__ int FloatToInt(float fptmp)
-{
-#if 0
-	fti_fptmp = fptmp;
-/*
-	_asm
-	{
-		fld fptmp
-		fistp itmp
-	}
-*/
-__asm__("fld	fti_fptmp		\n\t"
-	"fistp	fti_itmp		\n\t"
-	:
-	:
-	: "memory", "cc"
-	);
-
-	return fti_itmp;
-#endif	
-
-	return fptmp;
-}
-
-/*
-
- This macro makes usage of the above function easier and more elegant
-
-*/
-
-#define f2i(a, b) { \
-a = FloatToInt(b); \
-}
-
-
-#if 0
-int SqRoot32(int A);
-void FloatToInt();
-#define f2i(a, b) { \
-fti_fptmp = (b); \
-FloatToInt(); \
-a = fti_itmp;}
-#endif
-
-#endif 
-
 #endif
 
 int WideMul2NarrowDiv(int a, int b, int c, int d, int e);
diff --git a/src/win95/list_tem.hpp b/src/win95/list_tem.hpp
index 5f72558..bab4f30 100644
--- a/src/win95/list_tem.hpp
+++ b/src/win95/list_tem.hpp
@@ -100,24 +100,16 @@ struct List_Member_Base
 	union
 	{
 		List_Member_Base<T> *prev;
-		#ifndef __WATCOMC__
 	   	List_Member<T> *prev_debug; // encourage the debugger to display the list members data
-		#endif                      // hopefully casting from base to derived class would not
+		                            // hopefully casting from base to derived class would not
 		                            // cause the actual value of the ptr to change, so the debugger
 		                            // will display the information correctly, and this union
 		                            // won't cause any kind of performance hit
-
-									//watcom doesn't appear to like this, unfortunately.
-
-									
-		
 	};
 	union
 	{
 		List_Member_Base<T> *next;
-		#ifndef __WATCOMC__
 		List_Member<T> *next_debug;
-		#endif
 	};
 	virtual ~List_Member_Base() {}
 };
diff --git a/src/win95/media.hpp b/src/win95/media.hpp
index a7f5a2f..916e5e6 100644
--- a/src/win95/media.hpp
+++ b/src/win95/media.hpp
@@ -1,12 +1,6 @@
 #ifndef _INCLUDED_MEDIA_HPP_
 #define _INCLUDED_MEDIA_HPP_
 
-//#if defined(_WIN32) || defined(WIN32) || defined(WINDOWS) || defined(_WINDOWS)
-//	#define _MEDIA_WIN_TARGET
-//	#include <windows.h>
-//#endif // WIN32 || _WIN32 || WINDOWS || _WINDOWS
-
-
 #include <stdio.h>
 #include <limits.h>
 #include <string.h>
@@ -29,10 +23,6 @@ void MediaRead(MediaMedium * pThis, TYPE * p);
 template <class TYPE>
 void MediaWrite(MediaMedium * pThis, TYPE d);
 
-#ifdef __WATCOMC__
-template <class TYPE> class _Media_CompilerHack;
-#endif
-
 class MediaMedium
 {
 	protected:
@@ -284,15 +274,10 @@ class MediaMedium
 	friend class _Media_CompilerHack;
 };
 
-#ifdef __WATCOMC__
-template <class TYPE>
-#endif
 class _Media_CompilerHack
 {
 	public:
-		#ifndef __WATCOMC__
 		template <class TYPE>
-		#endif
 		static inline void MediaRead(MediaMedium * pThis, TYPE * p)
 		{
 			if (pThis->m_nReadBufPos + sizeof(TYPE) <= pThis->m_nBufSize)
@@ -317,9 +302,7 @@ class _Media_CompilerHack
 			}
 		}
 	
-		#ifndef __WATCOMC__
 		template <class TYPE>
-		#endif
 		static inline void MediaWrite(MediaMedium * pThis, TYPE d)
 		{
 			if (pThis->m_nWriteBufPos + sizeof(TYPE) <= pThis->m_nBufSize)
@@ -353,11 +336,7 @@ class _Media_CompilerHack
 template <class TYPE>
 inline void MediaRead(MediaMedium * pThis, TYPE * p)
 {
-	_Media_CompilerHack
-		#ifdef __WATCOMC__
-		<TYPE>
-		#endif
-		::MediaRead(pThis,p);
+	_Media_CompilerHack::MediaRead(pThis,p);
 }
 
 // use this to write simple data types
@@ -368,11 +347,7 @@ inline void MediaRead(MediaMedium * pThis, TYPE * p)
 template <class TYPE>
 inline void MediaWrite(MediaMedium * pThis, TYPE d)
 {
-	_Media_CompilerHack
-		#ifdef __WATCOMC__
-		<TYPE>
-		#endif
-		::MediaWrite(pThis,d);
+	_Media_CompilerHack::MediaWrite(pThis,d);
 }
 
 #ifdef _MEDIA_WIN_TARGET
diff --git a/src/win95/mmx_math.h b/src/win95/mmx_math.h
index fecc15c..5424ac1 100644
--- a/src/win95/mmx_math.h
+++ b/src/win95/mmx_math.h
@@ -87,16 +87,7 @@ extern void MMXAsm_VectorDot(void);
 extern void MMXAsm_VectorDot16(void);
 
 /* inline calls to MMX functions with correct parameters set */
-#ifdef __WATCOMC__
-
-#pragma aux MMX_VectorTransform = "call MMXAsm_VectorTransform" parm [eax] [edx];
-#pragma aux MMX_VectorTransformed = "call MMXAsm_VectorTransformed" parm [eax] [edx] [ecx];
-#pragma aux MMX_VectorTransformAndAdd = "call MMXAsm_VectorTransformAndAdd" parm [eax] [edx] [ecx];
-#pragma aux MMX_VectorTransformedAndAdd = "call MMXAsm_VectorTransformedAndAdd" parm [eax] [edx] [ecx] [ebx];
-#pragma aux MMX_VectorDot = "call MMXAsm_VectorDot" parm [eax] [edx] value [eax];
-#pragma aux MMX_VectorDot16 = "call MMXAsm_VectorDot16" parm [eax] [edx] value [eax];
-
-#elif defined(_MSC_VER)
+#if defined(_MSC_VER)
 
 _asmcall void MMX_VectorTransform(struct vectorch * vector, struct matrixch const * matrix)
 {
@@ -187,119 +178,7 @@ extern int use_mmx_math;
 extern const __int64 mmx_sign_mask;
 extern const __int64 mmx_one_fixed_h;
 
-#ifdef __WATCOMC__
-
-#pragma aux MMXInline_VectorDot = \
-\
-"	movq mm0,[edx]" \
-\
-"	movd mm2,[edx+08h]" \
-"	movq mm4,mm0" \
-\
-"	pand mm4,mmx_sign_mask" \
-"	movq mm6,mm2" \
-\
-"	movq mm1,[eax]" \
-"	paddd mm4,mm4" \
-\
-"	movd mm3,[eax+08h]" \
-"	movq mm5,mm1" \
-\
-"	pand mm6,mmx_sign_mask" \
-"	movq mm7,mm3" \
-\
-"	pand mm5,mmx_sign_mask" \
-"	paddd mm6,mm6" \
-\
-"	pand mm7,mmx_sign_mask" \
-"	paddd mm5,mm5" \
-\
-"	paddd mm0,mm4" \
-"	paddd mm2,mm6" \
-\
-"	paddd mm7,mm7" \
-"	movq mm4,mm2" \
-\
-"	punpcklwd mm4,mm0" \
-"	paddd mm1,mm5" \
-\
-"	punpckhwd mm2,mm0" \
-"	paddd mm3,mm7" \
-\
-"	movq mm5,mm3" \
-"	punpckhwd mm3,mm1" \
-\
-"	punpcklwd mm5,mm1" \
-"	movq mm0,mm2" \
-\
-"	movq mm1,mm4" \
-"	pmaddwd mm0,mm3" \
-\
-"	movq mm6,mm3" \
-"	psrlq mm3,32" \
-\
-"	movq mm7,mm5" \
-"	punpckldq mm3,mm6" \
-\
-"	pmaddwd mm1,mm5" \
-"	psrlq mm5,32" \
-\
-"	punpckldq mm5,mm7" \
-"	pmaddwd mm2,mm3" \
-\
-"	pmaddwd mm4,mm5" \
-"	movq mm3,mm0" \
-\
-"	punpckldq mm0,mm1" \
-\
-"	psubd mm0,mmx_one_fixed_h" \
-"	punpckhdq mm1,mm3" \
-\
-"	psrad mm0,16" \
-"	paddd mm2,mm4" \
-\
-"	pslld mm1,16" \
-"	paddd mm2,mm0" \
-\
-"	paddd mm2,mm1" \
-\
-"	movq mm1,mm2" \
-"	psrlq mm2,32" \
-\
-"	paddd mm1,mm2" \
-\
-"	movd eax,mm1" \
-\
-"	emms" \
-\
-"	inc eax" \
-\
-parm [eax] [edx] value [eax];
-
-#pragma aux MMXInline_VectorDot16 = \
-\
-"	movd mm0,[edx+08h]" \
-\
-"	packssdw mm0,[edx]" \
-\
-"	movd mm1,[eax+08h]" \
-\
-"	packssdw mm1,[eax]" \
-\
-"	pmaddwd mm0,mm1" \
-\
-"	movq mm1,mm0" \
-"	psrlq mm0,32" \
-\
-"	paddd mm0,mm1" \
-\
-"	movd eax,mm0" \
-\
-"	emms" \
-\
-parm [eax] [edx] value [eax];
-
-#elif defined(_MSC_VER)
+#if defined(_MSC_VER)
 
 _asminline signed MMXInline_VectorDot(struct vectorch const * v1, struct vectorch const * v2)
 {
diff --git a/src/win95/plspecfn.c b/src/win95/plspecfn.c
index 217fdd6..0bdd999 100644
--- a/src/win95/plspecfn.c
+++ b/src/win95/plspecfn.c
@@ -486,8 +486,6 @@ void ShapePointsInstr(SHAPEINSTR *shapeinstrptr)
  together, divides the summed product with another integer and then returns
  the result of that divide, which is also an integer.
 
- It is not inlined for Watcom C, although the functions it calls ARE.
-
 */
 
 int WideMul2NarrowDiv(int a, int b, int c, int d, int e)
@@ -1109,9 +1107,6 @@ void MaxLONGLONGCH(LONGLONGCH *llarrayptr, int llarraysize, LONGLONGCH *llmax)
 
  Some operators derived from the 64-bit CMP function.
 
- These were first defined for pcwatcom\plspecfn.h and transferred as and
- when needed to other platforms.
-
 */
 
 
diff --git a/src/win95/string.hpp b/src/win95/string.hpp
index 9994a67..bb0a56a 100644
--- a/src/win95/string.hpp
+++ b/src/win95/string.hpp
@@ -1,10 +1,6 @@
 #ifndef _included_string_hpp_
 #define _included_string_hpp_
 
-#ifdef __WATCOMC__
-#include <string.hpp>
-#else
-
 #ifndef __cplusplus
 #error "string.hpp requires C++ compilation"
 #endif
@@ -179,5 +175,3 @@ inline int valid(String const & str)
 }
 
 #endif
-
-#endif
diff --git a/src/win95/win_func.cpp b/src/win95/win_func.cpp
index 6be299e..76297a6 100644
--- a/src/win95/win_func.cpp
+++ b/src/win95/win_func.cpp
@@ -253,12 +253,7 @@ BOOL WaitForRasterThread()
   mssetup api
 */
 
-#ifdef __WATCOMC__
-
-unsigned int GetCPUId(void);
-#pragma aux GetCPUId = "mov eax,1" "cpuid" value [edx] modify [eax ebx ecx];
-
-#elif defined(_MSC_VER)
+#if defined(_MSC_VER)
 
 static unsigned int GetCPUId(void)
 {