Index: shogun/classifier/KNN.cpp
===================================================================
--- shogun/classifier/KNN.cpp	(revision 9330)
+++ shogun/classifier/KNN.cpp	(working copy)
@@ -114,12 +114,20 @@
 	int32_t* train_lab=SG_MALLOC(int32_t, train_labels.vlen);
 
 	SG_INFO( "%d test examples\n", num_lab);
+#ifndef WIN32
 	CSignal::clear_cancel();
-
+#endif //WIN32
+	
 	///histogram of classes and returned output
 	float64_t* classes=SG_MALLOC(float64_t, num_classes);
 
-	for (int32_t i=0; i<num_lab && (!CSignal::cancel_computations()); i++)
+	for (int32_t i=0; i<num_lab && 
+#ifndef WIN32
+		(!CSignal::cancel_computations())
+#else
+		1
+#endif // WIN32
+		; i++)
 	{
 		SG_PROGRESS(i, 0, num_lab);
 
@@ -190,10 +198,19 @@
 	float64_t* distances = SG_MALLOC(float64_t, train_labels.vlen);
 
 	SG_INFO("%d test examples\n", num_lab);
+#ifndef WIN32
 	CSignal::clear_cancel();
+#endif // WIN32
 
 	// for each test example
-	for (int32_t i=0; i<num_lab && (!CSignal::cancel_computations()); i++)
+	for (int32_t i=0; i<num_lab && 
+#ifndef WIN32
+		(!CSignal::cancel_computations())
+#else
+		1
+#endif // WIN32
+		; i++)
+
 	{
 		SG_PROGRESS(i,0,num_lab);
 
@@ -242,9 +259,17 @@
 	int32_t* classes=SG_MALLOC(int32_t, num_classes);
 
 	SG_INFO( "%d test examples\n", num_lab);
+#ifndef WIN32
 	CSignal::clear_cancel();
-
-	for (int32_t i=0; i<num_lab && (!CSignal::cancel_computations()); i++)
+#endif // WIN32
+	
+	for (int32_t i=0; i<num_lab && 
+#ifndef WIN32
+		(!CSignal::cancel_computations())
+#else
+		1
+#endif // WIN32
+		; i++)
 	{
 		SG_PROGRESS(i, 0, num_lab);
 
Index: shogun/classifier/mkl/MKL.cpp
===================================================================
--- shogun/classifier/mkl/MKL.cpp	(revision 9330)
+++ shogun/classifier/mkl/MKL.cpp	(working copy)
@@ -281,8 +281,10 @@
 #endif
 
 	mkl_iterations = 0;
+#ifndef WIN32
 	CSignal::clear_cancel();
-
+#endif //WIN32
+	
 	training_time_clock.start();
 
 	if (interleaved_optimization)
@@ -336,7 +338,13 @@
 
 
 			mkl_iterations++;
-			if (perform_mkl_step(sumw, suma) || CSignal::cancel_computations())
+			if (perform_mkl_step(sumw, suma) || 
+#ifndef WIN32
+				CSignal::cancel_computations()
+#else
+				0
+#endif //WIN32
+				)
 				break;
 		}
 
Index: shogun/classifier/svm/gpdtsolve.cpp
===================================================================
--- shogun/classifier/svm/gpdtsolve.cpp	(revision 9330)
+++ shogun/classifier/svm/gpdtsolve.cpp	(working copy)
@@ -1310,7 +1310,13 @@
     }
     Cache->Iteration();
     nit = nit+1;
-  } while (!optimal() && !(CSignal::cancel_computations()));
+  } while (!optimal() && 
+#ifndef WIN32
+	!(CSignal::cancel_computations())
+#else
+	1
+#endif //WIN32
+	);
   /* End of the problem resolution loop                                      */
   /***************************************************************************/
 
Index: shogun/classifier/svm/LaRank.cpp
===================================================================
--- shogun/classifier/svm/LaRank.cpp	(revision 9330)
+++ shogun/classifier/svm/LaRank.cpp	(working copy)
@@ -608,7 +608,9 @@
 	ASSERT(kernel);
 	ASSERT(labels && labels->get_num_labels());
 
+#ifndef WIN32
 	CSignal::clear_cancel();
+#endif //WIN32
 
 	if (data)
 	{
@@ -629,7 +631,13 @@
 	float64_t gap = DBL_MAX;
 
 	SG_INFO("Training on %d examples\n", nb_train);
-	while (gap > C1 && (!CSignal::cancel_computations()))      // stopping criteria
+	while (gap > C1 && 
+#ifndef WIN32	
+		(!CSignal::cancel_computations())
+#else
+		1
+#endif //WIN32
+		)      // stopping criteria
 	{
 		float64_t tr_err = 0;
 		int32_t ind = step;
Index: shogun/classifier/svm/OnlineSVMSGD.cpp
===================================================================
--- shogun/classifier/svm/OnlineSVMSGD.cpp	(revision 9330)
+++ shogun/classifier/svm/OnlineSVMSGD.cpp	(working copy)
@@ -100,15 +100,23 @@
 	if (features->is_seekable())
 		features->reset_stream();
 
+#ifndef WIN32
 	CSignal::clear_cancel();
-
+#endif //WIN32
+	
 	ELossType loss_type = loss->get_loss_type();
 	bool is_log_loss = false;
 	if ((loss_type == L_LOGLOSS) || (loss_type == L_LOGLOSSMARGIN))
 		is_log_loss = true;
 
 	int32_t vec_count;
-	for(int32_t e=0; e<epochs && (!CSignal::cancel_computations()); e++)
+	for(int32_t e=0; e<epochs && 
+#ifndef WIN32
+		(!CSignal::cancel_computations())
+#else 
+		1
+#endif //WIN32
+		; e++)
 	{
 		vec_count=0;
 		count = skip;
Index: shogun/classifier/svm/SGDQN.cpp
===================================================================
--- shogun/classifier/svm/SGDQN.cpp	(revision 9330)
+++ shogun/classifier/svm/SGDQN.cpp	(working copy)
@@ -140,14 +140,22 @@
 	calibrate();
 
 	SG_INFO("Training on %d vectors\n", num_vec);
+#ifndef WIN32
 	CSignal::clear_cancel();
-
+#endif //WIN32
+	
 	ELossType loss_type = loss->get_loss_type();
 	bool is_log_loss = false;
 	if ((loss_type == L_LOGLOSS) || (loss_type == L_LOGLOSSMARGIN))
 		is_log_loss = true;
 
-	for(int32_t e=0; e<epochs && (!CSignal::cancel_computations()); e++)
+	for(int32_t e=0; e<epochs && 
+#ifndef WIN32
+		(!CSignal::cancel_computations())
+#else 
+		1
+#endif //WIN32
+		; e++)
 	{
 		count = skip;
 		bool updateB=false;
Index: shogun/classifier/svm/SubGradientSVM.cpp
===================================================================
--- shogun/classifier/svm/SubGradientSVM.cpp	(revision 9330)
+++ shogun/classifier/svm/SubGradientSVM.cpp	(working copy)
@@ -567,7 +567,13 @@
 #ifdef DEBUG_SUBGRADIENTSVM
 	float64_t loop_time=0;
 #endif
-	while (!(CSignal::cancel_computations()))
+	while (
+#ifndef WIN32
+			!(CSignal::cancel_computations())
+#else
+			1
+#endif //WIN32
+		)
 	{
 		CTime t;
 		delta_active=find_active(num_feat, num_vec, num_active, num_bound);
Index: shogun/classifier/svm/SVM_libsvm.cpp
===================================================================
--- shogun/classifier/svm/SVM_libsvm.cpp	(revision 9330)
+++ shogun/classifier/svm/SVM_libsvm.cpp	(working copy)
@@ -525,7 +525,9 @@
 	}
 
 	// initialize gradient
+#ifndef WIN32
 	CSignal::clear_cancel();
+#endif //WIN32	
 	CTime start_time;
 	{
 		G = SG_MALLOC(float64_t, l);
@@ -538,7 +540,11 @@
 		}
 		SG_SINFO("Computing gradient for initial set of non-zero alphas\n");
 		//CMath::display_vector(alpha, l, "alphas");
-		for(i=0;i<l && !CSignal::cancel_computations(); i++)
+		for(i=0;i<l 
+#ifndef WIN32
+			&& !CSignal::cancel_computations()
+#endif //WIN32
+			; i++)
 		{
 			if(!is_lower_bound(i))
 			{
@@ -561,7 +567,14 @@
 	int32_t iter = 0;
 	int32_t counter = CMath::min(l,1000)+1;
 
-	while (!CSignal::cancel_computations())
+	while (
+#ifndef WIN32
+			!CSignal::cancel_computations()
+#else
+			1
+#endif //WIN32
+		)
+		
 	{
 		if (Q->max_train_time > 0 && start_time.cur_time_diff() > Q->max_train_time)
 		  break;
Index: shogun/classifier/svm/SVMSGD.cpp
===================================================================
--- shogun/classifier/svm/SVMSGD.cpp	(revision 9330)
+++ shogun/classifier/svm/SVMSGD.cpp	(working copy)
@@ -110,14 +110,22 @@
 	calibrate();
 
 	SG_INFO("Training on %d vectors\n", num_vec);
+#ifndef WIN32
 	CSignal::clear_cancel();
+#endif
 
 	ELossType loss_type = loss->get_loss_type();
 	bool is_log_loss = false;
 	if ((loss_type == L_LOGLOSS) || (loss_type == L_LOGLOSSMARGIN))
 		is_log_loss = true;
 	
-	for(int32_t e=0; e<epochs && (!CSignal::cancel_computations()); e++)
+	for(int32_t e=0; e<epochs && 
+#ifndef WIN32
+		(!CSignal::cancel_computations())
+#else
+		1
+#endif //WIN32
+		; e++)
 	{
 		count = skip;
 		for (int32_t i=0; i<num_vec; i++)
Index: shogun/classifier/vw/VwRegressor.cpp
===================================================================
--- shogun/classifier/vw/VwRegressor.cpp	(revision 9331)
+++ shogun/classifier/vw/VwRegressor.cpp	(working copy)
@@ -65,7 +65,7 @@
 		if (env->random_weights)
 		{
 			for (vw_size_t j = 0; j < length/num_threads; j++)
-				weight_vectors[i][j] = /* BAW  !!!   drand48() */ - 0.5;
+				weight_vectors[i][j] = double( rand() ) / double( RAND_MAX ) - 0.5;
 		}
 
 		if (env->initial_weight != 0.)
Index: shogun/distributions/HMM.cpp
===================================================================
--- shogun/distributions/HMM.cpp	(revision 9330)
+++ shogun/distributions/HMM.cpp	(working copy)
@@ -5545,7 +5545,11 @@
 	float64_t prob_train=CMath::ALMOST_NEG_INFTY;
 	iteration_count=iterations;
 
-	while (!converged(prob, prob_train) && (!CSignal::cancel_computations()))
+	while (!converged(prob, prob_train) 
+#ifndef WIN32	
+			&& (!CSignal::cancel_computations())
+#endif //WIN32
+		)
 	{
 		CMath::swap(working, estimate);
 		prob=prob_train;
Index: shogun/features/DotFeatures.cpp
===================================================================
--- shogun/features/DotFeatures.cpp	(revision 9330)
+++ shogun/features/DotFeatures.cpp	(working copy)
@@ -75,8 +75,10 @@
 	int32_t num_threads=parallel->get_num_threads();
 	ASSERT(num_threads>0);
 
+#ifndef WIN32
 	CSignal::clear_cancel();
-
+#endif //WIN32
+	
 #ifdef HAVE_PTHREAD
 	if (num_threads < 2)
 	{
@@ -153,8 +155,10 @@
 	int32_t num_threads=parallel->get_num_threads();
 	ASSERT(num_threads>0);
 
+#ifndef WIN32
 	CSignal::clear_cancel();
-
+#endif //WIN32
+	
 #ifdef HAVE_PTHREAD
 	if (num_threads < 2)
 	{
@@ -240,7 +244,7 @@
 	if (sub_index)
 	{
 #ifdef WIN32
-		for (int32_t i=start; i<stop i++)
+		for (int32_t i=start; i<stop; i++)
 #else
 		for (int32_t i=start; i<stop &&
 				!CSignal::cancel_computations(); i++)
@@ -258,7 +262,7 @@
 	else
 	{
 #ifdef WIN32
-		for (int32_t i=start; i<stop i++)
+		for (int32_t i=start; i<stop; i++)
 #else
 		for (int32_t i=start; i<stop &&
 				!CSignal::cancel_computations(); i++)
Index: shogun/features/HashedWDFeaturesTransposed.cpp
===================================================================
--- shogun/features/HashedWDFeaturesTransposed.cpp	(revision 9330)
+++ shogun/features/HashedWDFeaturesTransposed.cpp	(working copy)
@@ -208,8 +208,10 @@
 	int32_t num_threads=parallel->get_num_threads();
 	ASSERT(num_threads>0);
 
+#ifndef WIN32
 	CSignal::clear_cancel();
-
+#endif //WIN32
+	
 	if (dim != w_dim)
 		SG_ERROR("Dimensions don't match, vec_len=%d, w_dim=%d\n", dim, w_dim);
 
@@ -292,8 +294,10 @@
 	int32_t num_threads=parallel->get_num_threads();
 	ASSERT(num_threads>0);
 
+#ifndef WIN32
 	CSignal::clear_cancel();
-
+#endif //WIN32
+	
 	if (dim != w_dim)
 		SG_ERROR("Dimensions don't match, vec_len=%d, w_dim=%d\n", dim, w_dim);
 
Index: shogun/features/StringFeatures.cpp
===================================================================
--- shogun/features/StringFeatures.cpp	(revision 9330)
+++ shogun/features/StringFeatures.cpp	(working copy)
@@ -766,6 +766,7 @@
 
 template<class ST> bool CStringFeatures<ST>::load_from_directory(char* dirname)
 {
+#ifndef WIN32
 	remove_subset();
 
 	struct dirent **namelist;
@@ -831,6 +832,9 @@
 			return true;
 		}
 	}
+#else 
+	SG_ERROR("StringFeatures::load_from_directory not implemented on WIN32\n");
+#endif //WIN32
 	return false;
 }
 
Index: shogun/io/AsciiFile.cpp
===================================================================
--- shogun/io/AsciiFile.cpp	(revision 9330)
+++ shogun/io/AsciiFile.cpp	(working copy)
@@ -1077,12 +1077,12 @@
 #else
 ssize_t CAsciiFile::getdelim(char **lineptr, size_t *n, char delimiter, FILE *stream)
 {
-	return ::getdelim(lineptr, n, delimiter, stream);
+	return getdelim(lineptr, n, delimiter, stream);
 }
 
 ssize_t CAsciiFile::getline(char **lineptr, size_t *n, FILE *stream)
 {
-	return ::getline(lineptr, n, stream);
+	return getline(lineptr, n, stream);
 }
 #endif
 
Index: shogun/io/IOBuffer.cpp
===================================================================
--- shogun/io/IOBuffer.cpp	(revision 9330)
+++ shogun/io/IOBuffer.cpp	(working copy)
@@ -16,6 +16,18 @@
 #include <string.h>
 #include <shogun/io/IOBuffer.h>
 
+#ifdef WIN32
+#ifdef __MINGW32__
+
+#include <windows.h>
+ int fsync (int fd)
+ {
+	return (FlushFileBuffers ((HANDLE) _get_osfhandle (fd))) ? 0 : -1;
+ }
+
+ #endif
+#endif //WIN32
+
 using namespace shogun;
 
 CIOBuffer::CIOBuffer()
Index: shogun/io/MemoryMappedFile.h
===================================================================
--- shogun/io/MemoryMappedFile.h	(revision 9330)
+++ shogun/io/MemoryMappedFile.h	(working copy)
@@ -11,16 +11,23 @@
 #ifndef __MEMORYMAPPEDFILE_H__
 #define __MEMORYMAPPEDFILE_H__
 
+#ifdef WIN32
+#warning "MemoryMappedFile not implemented for WIN32"
+#endif //WIN32
+
 #include <shogun/io/SGIO.h>
 #include <shogun/base/SGObject.h>
 
 #include <stdio.h>
 #include <string.h>
+
+#ifndef WIN32
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <unistd.h>
+#endif //WIN32
 
 namespace shogun
 {
@@ -66,7 +73,7 @@
 			int open_flags;
 			int mmap_prot;
 			int mmap_flags;
-
+#ifndef WIN32
 			if (rw=='w')
 			{
 				open_flags=O_RDWR | O_CREAT;
@@ -82,6 +89,7 @@
 			else
 				SG_ERROR("Unknown flags\n");
 
+			
 			fd = open(fname, open_flags, S_IRWXU | S_IRWXG | S_IRWXO);
 			if (fd == -1)
 				SG_ERROR("Error opening file\n");
@@ -101,11 +109,15 @@
 			address = mmap(NULL, length, mmap_prot, mmap_flags, fd, 0);
 			if (address == MAP_FAILED)
 				SG_ERROR("Error mapping file");
+#else
+			SG_ERROR("MemoryMappedFile not implemented on WIN32\n");
+#endif //WIN32
 		}
 
 		/** destructor */
 		virtual ~CMemoryMappedFile()
 		{
+#ifndef WIN32		
 			munmap(address, length);
 			if (rw=='w' && last_written_byte && ftruncate(fd, last_written_byte) == -1)
 
@@ -114,6 +126,7 @@
 				SG_ERROR("Error Truncating file to %ld bytes\n", last_written_byte);
 			}
 			close(fd);
+#endif //WIN32
 		}
 
 		/** get the mapping address
@@ -276,4 +289,6 @@
 		uint64_t last_written_byte;
 };
 }
+
+
 #endif
Index: shogun/io/SerializableAsciiReader00.cpp
===================================================================
--- shogun/io/SerializableAsciiReader00.cpp	(revision 9330)
+++ shogun/io/SerializableAsciiReader00.cpp	(working copy)
@@ -10,6 +10,24 @@
 
 #include <shogun/io/SerializableAsciiReader00.h>
 
+#ifdef WIN32
+
+// workaround for missing declarations in inttypes.h
+#ifndef SCNd8
+  #define SCNd8 "hhd"
+#endif
+#ifndef SCNu8
+  #define SCNu8 "hhu"
+#endif
+#ifndef SCNi8
+  #define SCNi8 "hhi"
+#endif
+#ifndef SCNo8
+  #define SCNo8 "hho"
+#endif
+
+#endif // WIN32
+
 using namespace shogun;
 
 SerializableAsciiReader00::SerializableAsciiReader00(
Index: shogun/io/SimpleFile.h
===================================================================
--- shogun/io/SimpleFile.h	(revision 9330)
+++ shogun/io/SimpleFile.h	(working copy)
@@ -16,7 +16,9 @@
 
 #include <stdio.h>
 #include <string.h>
+#ifndef WIN32
 #include <sys/mman.h>
+#endif //WIN32
 
 namespace shogun
 {
Index: shogun/kernel/Kernel.h
===================================================================
--- shogun/kernel/Kernel.h	(revision 9330)
+++ shogun/kernel/Kernel.h	(working copy)
@@ -857,10 +857,11 @@
 
 						if (total%100 == 0)
 							k->SG_PROGRESS(total, total_start, total_end);
-
+#ifndef WIN32
 						if (CSignal::cancel_computations())
 							break;
-					}
+#endif //WIN32
+							}
 				}
 
 			}
Index: shogun/kernel/WeightedDegreePositionStringKernel.cpp
===================================================================
--- shogun/kernel/WeightedDegreePositionStringKernel.cpp	(revision 9330)
+++ shogun/kernel/WeightedDegreePositionStringKernel.cpp	(working copy)
@@ -1281,8 +1281,14 @@
 	else
 	{
 
+#ifndef WIN32
 		CSignal::clear_cancel();
-		for (int32_t j=0; j<num_feat && !CSignal::cancel_computations(); j++)
+#endif //WIN32
+		for (int32_t j=0; j<num_feat 
+#ifndef WIN32
+			&& !CSignal::cancel_computations()
+#endif //WIN32
+			; j++)
 		{
 			init_optimization(num_suppvec, IDX, alphas, j);
 			pthread_t* threads = SG_MALLOC(pthread_t, num_threads-1);
Index: shogun/lib/Signal.h
===================================================================
--- shogun/lib/Signal.h	(revision 9330)
+++ shogun/lib/Signal.h	(working copy)
@@ -26,6 +26,7 @@
 #ifndef WIN32
 #include <signal.h>
 #define NUMTRAPPEDSIGS 2
+#endif //WIN32
 
 namespace shogun
 {
@@ -46,11 +47,15 @@
  */
 class CSignal : public CSGObject
 {
+// keep stub of CSignal for inclusion in class_list
+#ifndef WIN32 		
+
 	public:
+
 		/** default constructor */
 		CSignal();
 		virtual ~CSignal();
-
+		
 		/** handler
 		 *
 		 * @param signal signal number
@@ -94,9 +99,11 @@
 			return cancel_computation;
 		}
 
+#endif // WIN32		
 		/** @return object name */
 		inline virtual const char* get_name() const { return "Signal"; }
 
+#ifndef WIN32
 	protected:
 		/** signals; handling external lib  */
 		static int signals[NUMTRAPPEDSIGS];
@@ -112,7 +119,8 @@
 
 		/** if shogun should return ASAP */
 		static bool cancel_immediately;
+#endif // WIN32
 };
-#endif // WIN32
 }
+
 #endif // __SIGNAL__H_
Index: shogun/lib/v_array.h
===================================================================
--- shogun/lib/v_array.h	(revision 9330)
+++ shogun/lib/v_array.h	(working copy)
@@ -190,8 +190,12 @@
 	size_t old_length = end_array-begin;
 	begin = SG_REALLOC(T, begin, length);
 	if (old_length < length)
+#ifndef WIN32	
 		bzero(begin + old_length, (length - old_length)*sizeof(T));
-
+#else 
+		memset(begin + old_length, 0, (length - old_length)*sizeof(T));
+#endif
+		
 	end = begin;
 	end_array = begin + length;
 }
Index: shogun/machine/KernelMachine.cpp
===================================================================
--- shogun/machine/KernelMachine.cpp	(revision 9330)
+++ shogun/machine/KernelMachine.cpp	(working copy)
@@ -94,8 +94,10 @@
 		lab=new CLabels(num_vectors);
 		SG_DEBUG( "computing output on %d test examples\n", num_vectors);
 
+#ifndef WIN32
 		CSignal::clear_cancel();
-
+#endif //WIN32
+		
 		if (io->get_show_progress())
 			io->enable_progress();
 		else
Index: shogun/mathematics/Math.cpp
===================================================================
--- shogun/mathematics/Math.cpp	(revision 9330)
+++ shogun/mathematics/Math.cpp	(working copy)
@@ -250,7 +250,11 @@
 	for (int32_t i=0; i<3*2; i++)
 	{
 		log_denom+=CMath::lgammal((floatmax_t) table.matrix[i]+1);
+#ifndef WIN32
 		log_denomf+=gamma(table.matrix[i]+1);
+#else
+		log_denomf+=tgamma(table.matrix[i]+1);
+#endif
 	}
 
 	floatmax_t prob_table_log=log_nom - log_denom;
Index: shogun/ui/GUIClassifier.h
===================================================================
--- shogun/ui/GUIClassifier.h	(revision 9330)
+++ shogun/ui/GUIClassifier.h	(working copy)
@@ -16,6 +16,11 @@
 #include <shogun/machine/Machine.h>
 #include <shogun/classifier/svm/SVM.h>
 
+#ifdef interface
+#warning "macro interface is defined - undefining"
+#undef interface 
+#endif
+
 namespace shogun
 {
 class CSGInterface;
Index: shogun/ui/GUIDistance.h
===================================================================
--- shogun/ui/GUIDistance.h	(revision 9330)
+++ shogun/ui/GUIDistance.h	(working copy)
@@ -17,6 +17,11 @@
 #include <shogun/distance/Distance.h>
 #include <shogun/features/Features.h>
 
+#ifdef interface
+#warning "macro interface is defined - undefining"
+#undef interface 
+#endif
+
 namespace shogun
 {
 class CSGInterface;
Index: shogun/ui/GUIFeatures.h
===================================================================
--- shogun/ui/GUIFeatures.h	(revision 9330)
+++ shogun/ui/GUIFeatures.h	(working copy)
@@ -28,6 +28,11 @@
 #include <shogun/features/ExplicitSpecFeatures.h>
 #include <shogun/features/ImplicitWeightedSpecFeatures.h>
 
+#ifdef interface
+#warning "macro interface is defined - undefining"
+#undef interface 
+#endif
+
 namespace shogun
 {
 class CSGInterface;
Index: shogun/ui/GUIHMM.h
===================================================================
--- shogun/ui/GUIHMM.h	(revision 9330)
+++ shogun/ui/GUIHMM.h	(working copy)
@@ -17,6 +17,11 @@
 #include <shogun/distributions/HMM.h>
 #include <shogun/features/Labels.h>
 
+#ifdef interface
+#warning "macro interface is defined - undefining"
+#undef interface 
+#endif
+
 namespace shogun
 {
 class CSGInterface;
Index: shogun/ui/GUILabels.h
===================================================================
--- shogun/ui/GUILabels.h	(revision 9330)
+++ shogun/ui/GUILabels.h	(working copy)
@@ -16,6 +16,11 @@
 #include <shogun/base/SGObject.h>
 #include <shogun/features/Labels.h>
 
+#ifdef interface
+#warning "macro interface is defined - undefining"
+#undef interface 
+#endif
+
 namespace shogun
 {
 class CSGInterface;
Index: shogun/ui/GUIMath.h
===================================================================
--- shogun/ui/GUIMath.h	(revision 9330)
+++ shogun/ui/GUIMath.h	(working copy)
@@ -14,6 +14,11 @@
 #include <shogun/lib/config.h>
 #include <shogun/base/SGObject.h>
 
+#ifdef interface
+#warning "macro interface is defined - undefining"
+#undef interface 
+#endif
+
 namespace shogun
 {
 class CSGInterface;
Index: shogun/ui/GUIPreprocessor.h
===================================================================
--- shogun/ui/GUIPreprocessor.h	(revision 9330)
+++ shogun/ui/GUIPreprocessor.h	(working copy)
@@ -17,6 +17,11 @@
 #include <shogun/base/SGObject.h>
 #include <shogun/preprocessor/Preprocessor.h>
 
+#ifdef interface
+#warning "macro interface is defined - undefining"
+#undef interface 
+#endif
+
 namespace shogun
 {
 class CSGInterface;