migration VC6 -> VC2010

bonjour,

Je poss�de un gros projet sous VC6 que je souhaite migrer vers VC 2010.

VC6 et VC2010 n'�tant pas compatibles je ne peux pas r�-ouvrir mon projet directement.
La seule m�thode que j'ai trouv�e c'est de recr�er chaque projet et d'y ajouter les fichier .cpp/.h ainsi que les configurations. Assez contraignant vous en conviendrez :?

J'aimerai savoir s'il existe une m�thode plus simple, ou si quelqu'un aurait une remarque � faire l�-dessus ? Je suis preneur de tout ce qu'il vous passera par la t�te :)

Merci et bonne journ�e

Porter ton projet vers VC7.1, puis VC8, puis VC9 puis VC10 ?

Sachant que de VC6 � VC7.1, c'est surtout ton code que tu risque de devoir adapter, et que de VC9 � VC10, c'est surtout les projets eux-m�mes.

temoignage

j'ai fait la tentative, et c'est pas encore fini.
j'ai pris directement un gros projet sous vc6 et je l'ai ouvert avec vc2010.
la phase d'import et de transformation du programme se fait automatiquement, ca c'est plutot une bonne surprise sur le moment.
mais apr�s il faut revoir le code, et ca depend de ce que tu as utilis� dans ton programme.
perso, je dois bien avoir encore 400/500 warning dus � des deprecated ou conseils de changement de la part du compilo vc2010.
mais d�ja, le plus dur est de faire les corrections necessaires et l'inclusions des biblioth�ques vitales pour au moins arriver � la compilation du projet. apr�s, il faudra encore du temps pour �tre s�r que le portage sera complet.
si ton appli est constitu�e de modules, ca sera plus facile, correction et import module par module. plus s�curitaire aussi.
enfin, bref, c'est pas impossible, mais ca demande du travail dont la masse d�pend directement de la nature et du contenu en code de chaque projet.

Citation:

Envoy� par DJ-sauron

bonjour,

Je poss�de un gros projet sous VC6 que je souhaite migrer vers VC 2010.

VC6 et VC2010 n'�tant pas compatibles je ne peux pas r�-ouvrir mon projet directement.
La seule m�thode que j'ai trouv�e c'est de recr�er chaque projet et d'y ajouter les fichier .cpp/.h ainsi que les configurations. Assez contraignant vous en conviendrez :?

J'aimerai savoir s'il existe une m�thode plus simple, ou si quelqu'un aurait une remarque � faire l�-dessus ? Je suis preneur de tout ce qu'il vous passera par la t�te :)

Merci et bonne journ�e

salut,
Visual 2010 permet la migration d'un projet VC6 , tu as essay� ?

Bonsoir,

J'ai test� le syst�me de migration de VC10 avec mon projet VC06. Le r�sultat est assez d�concertant : pas un seul projet ne se forme bien. Apparemment le probl�me se situe directement dans la phase d'import des projets, il ne trouve tout simplement pas les projets du workspace.

Je vais jeter un oeil � l'id�e JolyLoic, mais je pense que cela demande encore plus de boulot que de modifier directement sous VC10 le projet.

je dois faire la m�me manip .. je dois passer un source de vc++ 6 � visual 2010 studio . j ai install� studio 2005 et 2008 aussi

j ai r�ussi � enlever la plupart des warnings mais l� je bloque sur 4 erreurs

� cause du sdk de 2005

Citation:

e:\program files\microsoft visual studio 2005\vc\platformsdk\include\basetsd.h

error C2632: 'char' followed by 'char' is illegal

error C2059: syntax error : ','

error C2632: 'short' followed by 'short' is illegal

error C2059: syntax error : ','

y a t il des astuces avec le batch build ?

merci

Moi, je pencherais pour des constantes de compilation non d�finies ou mal d�finies.

Pouvez-vous montrer la zone du code source de basetsd.h qui pose probl�me ?

En oubliant pas d'y inclure les #ifdef et #endif les plus proches bien s�r. :aie:

re

merci pour ta r�ponse.

depuis je pense avoir trouv� une des causes de ce probl�me .

dans mon projet sous vc++ 6 (que du C ) j ai un dossier external dependencies qui contient un basetsd.h qui n est pas import� dans visual 2005 .

fichier basethd.h de vc6

____________________________________________________________

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
/*++
 
Copyright (c) 1997-1998  Microsoft Corporation
 
Module Name:
 
    basetsd.h
 
Abstract:
 
    Type definitions for the basic sized types.
 
Author:
 
    Jeff Havens (jhavens)   23-Oct-1997
 
Revision History:
 
--*/
 
#ifndef _BASETSD_H_
#define _BASETSD_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
//
// The following types are guaranteed to be signed and 32 bits wide.
//
 
typedef int LONG32, *PLONG32;
typedef int INT32, *PINT32;
 
//
// The following types are guaranteed to be unsigned and 32 bits wide.
//
 
typedef unsigned int ULONG32, *PULONG32;
typedef unsigned int DWORD32, *PDWORD32;
typedef unsigned int UINT32, *PUINT32;
 
//
// The INT_PTR is guaranteed to be the same size as a pointer.  Its
// size with change with pointer size (32/64).  It should be used
// anywhere that a pointer is cast to an integer type. UINT_PTR is
// the unsigned variation.
//
// HALF_PTR is half the size of a pointer it intended for use with
// within strcuture which contain a pointer and two small fields.
// UHALF_PTR is the unsigned variation.
//
 
#ifdef _WIN64
 
typedef __int64 INT_PTR, *PINT_PTR;
typedef unsigned __int64 UINT_PTR, *PUINT_PTR;
 
#define MAXINT_PTR (0x7fffffffffffffffI64)
#define MININT_PTR (0x8000000000000000I64)
#define MAXUINT_PTR (0xffffffffffffffffUI64)
 
typedef unsigned int UHALF_PTR, *PUHALF_PTR;
typedef int HALF_PTR, *PHALF_PTR;
 
#define MAXUHALF_PTR (0xffffffffUL)
#define MAXHALF_PTR (0x7fffffffL)
#define MINHALF_PTR (0x80000000L)
 
#pragma warning(disable:4311)   // type cast truncation
 
#if !defined(__midl)
__inline
unsigned long
HandleToUlong(
    void *h
    )
{
    return((unsigned long) h );
}
 
__inline
unsigned long
PtrToUlong(
    void  *p
    )
{
    return((unsigned long) p );
}
 
__inline
unsigned short
PtrToUshort(
    void  *p
    )
{
    return((unsigned short) p );
}
 
__inline
long
PtrToLong(
    void  *p
    )
{
    return((long) p );
}
 
__inline
short
PtrToShort(
    void  *p
    )
{
    return((short) p );
}
#endif
#pragma warning(3:4311)   // type cast truncation
 
#else
 
 
typedef long INT_PTR, *PINT_PTR;
typedef unsigned long UINT_PTR, *PUINT_PTR;
 
#define MAXINT_PTR (0x7fffffffL)
#define MININT_PTR (0x80000000L)
#define MAXUINT_PTR (0xffffffffUL)
 
typedef unsigned short UHALF_PTR, *PUHALF_PTR;
typedef short HALF_PTR, *PHALF_PTR;
 
#define MAXUHALF_PTR 0xffff
#define MAXHALF_PTR 0x7fff
#define MINHALF_PTR 0x8000
 
#define HandleToUlong( h ) ((ULONG) (h) )
#define PtrToUlong( p ) ((ULONG) (p) )
#define PtrToLong( p ) ((LONG) (p) )
#define PtrToUshort( p ) ((unsigned short) (p) )
#define PtrToShort( p ) ((short) (p) )
 
#endif
 
//
// SIZE_T used for counts or ranges which need to span the range of
// of a pointer.  SSIZE_T is the signed variation.
//
 
typedef UINT_PTR SIZE_T, *PSIZE_T;
typedef INT_PTR SSIZE_T, *PSSIZE_T;
 
//
// The following types are guaranteed to be signed and 64 bits wide.
//
 
typedef __int64 LONG64, *PLONG64;
typedef __int64 INT64, *PINT64;
 
 
//
// The following types are guaranteed to be unsigned and 64 bits wide.
//
 
typedef unsigned __int64 ULONG64, *PULONG64;
typedef unsigned __int64 DWORD64, *PDWORD64;
typedef unsigned __int64 UINT64, *PUINT64;
 
#ifdef __cplusplus
}
#endif
 
#endif // _BASETSD_H_

___________________________________________________________

sous visual 2005

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
#ifndef _BASETSD_H_
#define _BASETSD_H_
 
#if !defined(_MAC) && (defined(_M_MRX000) || defined(_M_AMD64) || defined(_M_IA64)) && (_MSC_VER >= 1100) && !(defined(MIDL_PASS) || defined(RC_INVOKED))
#define POINTER_64 __ptr64
typedef unsigned __int64 POINTER_64_INT;
#if defined(_WIN64)
#define POINTER_32 __ptr32
#else
#define POINTER_32
#endif
#else
#if defined(_MAC) && defined(_MAC_INT_64)
#define POINTER_64 __ptr64
typedef unsigned __int64 POINTER_64_INT;
#else
#if (_MSC_VER >= 1300) && !(defined(MIDL_PASS) || defined(RC_INVOKED))
#define POINTER_64 __ptr64
#else
#define POINTER_64
#endif
typedef unsigned long POINTER_64_INT;
#endif
#define POINTER_32
#endif
 
#if defined(_IA64_) || defined(_AMD64_)
#define FIRMWARE_PTR
#else
#define FIRMWARE_PTR POINTER_32
#endif
 
 
#if _MSC_VER > 1000
#pragma once
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef signed char         INT8, *PINT8;
typedef signed short        INT16, *PINT16;
typedef signed int          INT32, *PINT32;
typedef signed __int64      INT64, *PINT64;
typedef unsigned char       UINT8, *PUINT8;
typedef unsigned short      UINT16, *PUINT16;
typedef unsigned int        UINT32, *PUINT32;
typedef unsigned __int64    UINT64, *PUINT64;
 
//
// The following types are guaranteed to be signed and 32 bits wide.
//
 
typedef signed int LONG32, *PLONG32;
 
//
// The following types are guaranteed to be unsigned and 32 bits wide.
//
 
typedef unsigned int ULONG32, *PULONG32;
typedef unsigned int DWORD32, *PDWORD32;
 
#if !defined(_W64)
#if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
#define _W64 __w64
#else
#define _W64
#endif
#endif
 
//
// The INT_PTR is guaranteed to be the same size as a pointer.  Its
// size with change with pointer size (32/64).  It should be used
// anywhere that a pointer is cast to an integer type. UINT_PTR is
// the unsigned variation.
//
// __int3264 is intrinsic to 64b MIDL but not to old MIDL or to C compiler.
//
#if ( 501 < __midl )
 
    typedef [public] __int3264 INT_PTR, *PINT_PTR;
    typedef [public] unsigned __int3264 UINT_PTR, *PUINT_PTR;
 
    typedef [public] __int3264 LONG_PTR, *PLONG_PTR;
    typedef [public] unsigned __int3264 ULONG_PTR, *PULONG_PTR;
 
#else  // midl64
// old midl and C++ compiler
 
#if defined(_WIN64)
    typedef __int64 INT_PTR, *PINT_PTR;
    typedef unsigned __int64 UINT_PTR, *PUINT_PTR;
 
    typedef __int64 LONG_PTR, *PLONG_PTR;
    typedef unsigned __int64 ULONG_PTR, *PULONG_PTR;
 
    #define __int3264   __int64
 
#else
    typedef _W64 int INT_PTR, *PINT_PTR;
    typedef _W64 unsigned int UINT_PTR, *PUINT_PTR;
 
    typedef _W64 long LONG_PTR, *PLONG_PTR;
    typedef _W64 unsigned long ULONG_PTR, *PULONG_PTR;
 
    #define __int3264   __int32
 
#endif
#endif // midl64
 
//
// HALF_PTR is half the size of a pointer it intended for use with
// within structures which contain a pointer and two small fields.
// UHALF_PTR is the unsigned variation.
//
 
#ifdef _WIN64
 
#define ADDRESS_TAG_BIT 0x40000000000UI64
 
typedef __int64 SHANDLE_PTR;
typedef unsigned __int64 HANDLE_PTR;
typedef unsigned int UHALF_PTR, *PUHALF_PTR;
typedef int HALF_PTR, *PHALF_PTR;
 
#if !defined(__midl)
__inline
unsigned long
HandleToULong(
    const void *h
    )
{
    return((unsigned long) (ULONG_PTR) h );
}
 
__inline
long
HandleToLong(
    const void *h
    )
{
    return((long) (LONG_PTR) h );
}
 
__inline
void *
ULongToHandle(
    const unsigned long h
    )
{
    return((void *) (UINT_PTR) h );
}
 
 
__inline
void *
LongToHandle(
    const long h
    )
{
    return((void *) (INT_PTR) h );
}
 
 
__inline
unsigned long
PtrToUlong(
    const void  *p
    )
{
    return((unsigned long) (ULONG_PTR) p );
}
 
__inline
unsigned int
PtrToUint(
    const void  *p
    )
{
    return((unsigned int) (UINT_PTR) p );
}
 
__inline
unsigned short
PtrToUshort(
    const void  *p
    )
{
    return((unsigned short) (unsigned long) (ULONG_PTR) p );
}
 
__inline
long
PtrToLong(
    const void  *p
    )
{
    return((long) (LONG_PTR) p );
}
 
__inline
int
PtrToInt(
    const void  *p
    )
{
    return((int) (INT_PTR) p );
}
 
__inline
short
PtrToShort(
    const void  *p
    )
{
    return((short) (long) (LONG_PTR) p );
}
 
__inline
void *
IntToPtr(
    const int i
    )
// Caution: IntToPtr() sign-extends the int value.
{
    return( (void *)(INT_PTR)i );
}
 
__inline
void *
UIntToPtr(
    const unsigned int ui
    )
// Caution: UIntToPtr() zero-extends the unsigned int value.
{
    return( (void *)(UINT_PTR)ui );
}
 
__inline
void *
LongToPtr(
    const long l
    )
// Caution: LongToPtr() sign-extends the long value.
{
    return( (void *)(LONG_PTR)l );
}
 
__inline
void *
ULongToPtr(
    const unsigned long ul
    )
// Caution: ULongToPtr() zero-extends the unsigned long value.
{
    return( (void *)(ULONG_PTR)ul );
}
 
#define PtrToPtr64( p )         ((void * POINTER_64) p)
#define Ptr64ToPtr( p )         ((void *) p)
#define HandleToHandle64( h )   (PtrToPtr64( h ))
#define Handle64ToHandle( h )   (Ptr64ToPtr( h ))
 
__inline
void *
Ptr32ToPtr(
    const void * POINTER_32 p
    )
{
    return((void *) (ULONG_PTR) (unsigned long) p);
}
 
__inline
void *
Handle32ToHandle(
    const void * POINTER_32 h
    )
{
    return((void *) h);
}
 
__inline
void * POINTER_32
PtrToPtr32(
    const void *p
    )
{
    return((void * POINTER_32) (unsigned long) (ULONG_PTR) p);
}
 
#define HandleToHandle32( h )       (PtrToPtr32( h ))
 
#endif // !_midl
 
#else  // !_WIN64
 
#define ADDRESS_TAG_BIT 0x80000000UL
 
typedef unsigned short UHALF_PTR, *PUHALF_PTR;
typedef short HALF_PTR, *PHALF_PTR;
typedef _W64 long SHANDLE_PTR;
typedef _W64 unsigned long HANDLE_PTR;
 
#define HandleToULong( h ) ((ULONG)(ULONG_PTR)(h) )
#define HandleToLong( h )  ((LONG)(LONG_PTR) (h) )
#define ULongToHandle( ul ) ((HANDLE)(ULONG_PTR) (ul) )
#define LongToHandle( h )   ((HANDLE)(LONG_PTR) (h) )
#define PtrToUlong( p ) ((ULONG)(ULONG_PTR) (p) )
#define PtrToLong( p )  ((LONG)(LONG_PTR) (p) )
#define PtrToUint( p ) ((UINT)(UINT_PTR) (p) )
#define PtrToInt( p )  ((INT)(INT_PTR) (p) )
#define PtrToUshort( p ) ((unsigned short)(ULONG_PTR)(p) )
#define PtrToShort( p )  ((short)(LONG_PTR)(p) )
#define IntToPtr( i )    ((VOID *)(INT_PTR)((int)i))
#define UIntToPtr( ui )  ((VOID *)(UINT_PTR)((unsigned int)ui))
#define LongToPtr( l )   ((VOID *)(LONG_PTR)((long)l))
#define ULongToPtr( ul ) ((VOID *)(ULONG_PTR)((unsigned long)ul))
 
#if !defined(__midl)
__inline
void * POINTER_64
PtrToPtr64(
    const void *p
    )
{
    return((void * POINTER_64) (unsigned __int64) (ULONG_PTR)p );
}
 
__inline
void *
Ptr64ToPtr(
    const void * POINTER_64 p
    )
{
    return((void *) (ULONG_PTR) (unsigned __int64) p);
}
 
__inline
void * POINTER_64
HandleToHandle64(
    const void *h
    )
{
    return((void * POINTER_64) h );
}
 
__inline
void *
Handle64ToHandle(
    const void * POINTER_64 h
    )
{
    return((void *) (ULONG_PTR) (unsigned __int64) h );
}
#endif
 
#define Ptr32ToPtr( p )         ((void *) p)
#define Handle32ToHandle( h )   (Ptr32ToPtr( h ))
#define PtrToPtr32( p )         ((void * POINTER_32) p)
#define HandleToHandle32( h )   (PtrToPtr32( h ))
 
#endif // !_WIN64
 
#define HandleToUlong(h)  HandleToULong(h)
#define UlongToHandle(ul) ULongToHandle(ul)
#define UlongToPtr(ul) ULongToPtr(ul)
#define UintToPtr(ui)  UIntToPtr(ui)
 
#define MAXUINT_PTR  (~((UINT_PTR)0))
#define MAXINT_PTR   ((INT_PTR)(MAXUINT_PTR >> 1))
#define MININT_PTR   (~MAXINT_PTR)
 
#define MAXULONG_PTR (~((ULONG_PTR)0))
#define MAXLONG_PTR  ((LONG_PTR)(MAXULONG_PTR >> 1))
#define MINLONG_PTR  (~MAXLONG_PTR)
 
#define MAXUHALF_PTR ((UHALF_PTR)~0)
#define MAXHALF_PTR  ((HALF_PTR)(MAXUHALF_PTR >> 1))
#define MINHALF_PTR  (~MAXHALF_PTR)
 
//
// SIZE_T used for counts or ranges which need to span the range of
// of a pointer.  SSIZE_T is the signed variation.
//
 
typedef ULONG_PTR SIZE_T, *PSIZE_T;
typedef LONG_PTR SSIZE_T, *PSSIZE_T;
 
//
// Add Windows flavor DWORD_PTR types
//
 
typedef ULONG_PTR DWORD_PTR, *PDWORD_PTR;
 
//
// The following types are guaranteed to be signed and 64 bits wide.
//
 
typedef __int64 LONG64, *PLONG64;
 
 
//
// The following types are guaranteed to be unsigned and 64 bits wide.
//
 
typedef unsigned __int64 ULONG64, *PULONG64;
typedef unsigned __int64 DWORD64, *PDWORD64;
 
//
// Thread affinity.
//
 
typedef ULONG_PTR KAFFINITY;
typedef KAFFINITY *PKAFFINITY;
 
#ifdef __cplusplus
}
#endif
 
#endif // _BASETSD_H_

______________________________________________

la zone qui pose pb

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifdef __cplusplus
extern "C" {
#endif

typedef signed char         INT8, *PINT8;
typedef signed short        INT16, *PINT16;

typedef signed int          INT32, *PINT32;
typedef signed __int64      INT64, *PINT64;
typedef unsigned char       UINT8, *PUINT8;
typedef unsigned short      UINT16, *PUINT16;
typedef unsigned int        UINT32, *PUINT32;
typedef unsigned __int64    UINT64, *PUINT64;

_____________________________________________________

dans un de mes sources

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifdef WIN32
#define INT2 __int8
#define INT8 __int8
#define INT16 __int16
#define INT_32 __int32
#define INT_64 __int64
#else
#define INT2 char
#define INT8 char
#define INT16 short
#define INT_32 long
#define INT_64 long long int  // This may not be 64 bit on some compilers
#endif

__________________________________________

� un autre endroit j ai

Code:

1
2
unsigned  INT8      // ce qui fait unsigned signed char 
unsigned  INT16    //               unsigned  signed char

peut �tre l� ..

sinon il y aurait peut �tre la solution d exclure le basetsd.h du sdk de vc 2005 mais l� je ne sais pas le faire avec tools --> options --> projects and solutions --> VC++ DIRECTORIES

Primo, il faut toujours inclure en premier les includes Windows, et si possible dans un StdAfx.h.
En faisant cela, vos red�finitions n'influenceront pas l'interpr�tation/expansion en ligne des includes syst�mes.

Secondo, si le message d'erreur est bien
Citation:
Code:

1 2 3 error C2632: 'char' followed by 'char' is illegal error C2059: syntax error : ','
alors, vous �tes pass� dans la section non Win32 de ces d�finitions :
Citation:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #ifdef WIN32 #define INT2 __int8 #define INT8 __int8 #define INT16 __int16 #define INT_32 __int32 #define INT_64 __int64 #else #define INT2 char #define INT8 char #define INT16 short #define INT_32 long #define INT_64 long long int // This may not be 64 bit on some compilers #endif
V�rifiez vos constantes de compilation ou la d�finition de __int8.
Si vous �tes paum� dans les includes et les defines, utilisez /P dans les options de compilation.
http://msdn.microsoft.com/fr-fr/libr...v=VS.100).aspx

Tertio, il est simple de changer les priorit�s de recherche d'includes dans VS pour utiliser de vieilles versions des includes (et des lib, � fortiori).
Clic droit sur le projet dans l'explorateur de solution->Propri�t�s->Configuration Properties->VC++ Directories->Includes Diextories
Dans cette liste, le pr�-processeur va chercher les .h dans l'ordre d'apparitions dans cette liste.
Mais vous allez rester ad vitam aeternam sur une version plus support�e des includes C++. Faites le bon, maintenant avant qu'il ne soit trop tard.

Donc abandonnez votre "#define INT8 __int8" qui est en collision avec les d�finitions dans les includes Windows, qui deviennent des d�finitions "standard de fait".