standalone-ruby 1.4.1 → 1.5.0

data/lib/data/c_compilers/tcc/include/wchar.h

@@ -0,0 +1,318 @@
+/*
+ * wchar.h
+ *
+ * Defines of all functions for supporting wide characters. Actually it
+ * just includes all those headers, which is not a good thing to do from a
+ * processing time point of view, but it does mean that everything will be
+ * in sync.
+ *
+ * This file is part of the Mingw32 package.
+ *
+ *  THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ *  This source code is offered for use in the public domain. You may
+ *  use, modify or distribute it freely.
+ *
+ *  This code is distributed in the hope that it will be useful but
+ *  WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ *  DISCLAIMED. This includes but is not limited to warranties of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * $Revision: 1.2 $
+ * $Author: bellard $
+ * $Date: 2005/04/17 13:14:29 $
+ *
+ */
+
+#ifndef	_WCHAR_H_
+#define	_WCHAR_H_
+
+/* All the headers include this file. */
+#include <_mingw.h>
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <sys/types.h>
+
+#define __need_size_t
+#define __need_wint_t
+#define __need_wchar_t
+#ifndef RC_INVOKED
+#include <stddef.h>
+#endif /* Not RC_INVOKED */
+
+#define WCHAR_MIN	0
+#define WCHAR_MAX	((wchar_t)-1)
+
+#ifndef RC_INVOKED
+
+#ifdef __cplusplus 
+extern "C" {
+#endif
+
+#ifndef	__STRICT_ANSI__
+
+#ifndef	_FSIZE_T_DEFINED
+typedef	unsigned long	_fsize_t;
+#define _FSIZE_T_DEFINED
+#endif
+
+#ifndef _WFINDDATA_T_DEFINED
+struct _wfinddata_t {
+    	unsigned	attrib;
+    	time_t		time_create;	/* -1 for FAT file systems */
+    	time_t		time_access;	/* -1 for FAT file systems */
+    	time_t		time_write;
+    	_fsize_t	size;
+    	wchar_t		name[FILENAME_MAX];	/* may include spaces. */
+};
+struct _wfinddatai64_t {
+    unsigned    attrib;
+    time_t      time_create;
+    time_t      time_access;
+    time_t      time_write;
+    __int64     size;
+    wchar_t     name[FILENAME_MAX];
+};
+#define _WFINDDATA_T_DEFINED
+#endif
+
+/* Wide character versions. Also defined in io.h. */
+/* CHECK: I believe these only exist in MSVCRT, and not in CRTDLL. Also
+   applies to other wide character versions? */
+#if !defined (_WIO_DEFINED)
+#if defined (__MSVCRT__)
+int	 _waccess (const wchar_t*, int);
+int	_wchmod (const wchar_t*, int);
+int	_wcreat (const wchar_t*, int);
+long	_wfindfirst (wchar_t*, struct _wfinddata_t *);
+int	_wfindnext (long, struct _wfinddata_t *);
+int	_wunlink (const wchar_t*);
+int	_wopen (const wchar_t*, int, ...);
+int	_wsopen (const wchar_t*, int, int, ...);
+wchar_t* _wmktemp (wchar_t*);
+long	_wfindfirsti64 (const wchar_t*, struct _wfinddatai64_t*);
+int 	_wfindnexti64 (long, struct _wfinddatai64_t*);
+#endif /* defined (__MSVCRT__) */
+#define _WIO_DEFINED
+#endif /* _WIO_DEFINED */
+
+#ifndef _WSTDIO_DEFINED
+/* also in stdio.h - keep in sync */
+int	fwprintf (FILE*, const wchar_t*, ...);
+int	wprintf (const wchar_t*, ...);
+int	swprintf (wchar_t*, const wchar_t*, ...);
+int	_snwprintf (wchar_t*, size_t, const wchar_t*, ...);
+int	vfwprintf (FILE*, const wchar_t*, va_list);
+int	vwprintf (const wchar_t*, va_list);
+int	vswprintf (wchar_t*, const wchar_t*, va_list);
+int	_vsnwprintf (wchar_t*, size_t, const wchar_t*, va_list);
+int	fwscanf (FILE*, const wchar_t*, ...);
+int	wscanf (const wchar_t*, ...);
+int	swscanf (const wchar_t*, const wchar_t*, ...);
+wint_t	fgetwc (FILE*);
+wint_t	fputwc (wchar_t, FILE*);
+wint_t	ungetwc (wchar_t, FILE*);
+
+#ifndef __NO_ISOCEXT  /* externs in libmingwex.a */
+int snwprintf(wchar_t* s, size_t n, const wchar_t*  format, ...);
+extern inline int vsnwprintf (wchar_t* s, size_t n, const wchar_t* format,
+			   va_list arg)
+  { return _vsnwprintf ( s, n, format, arg); }
+#endif
+
+#ifdef __MSVCRT__ 
+wchar_t* fgetws (wchar_t*, int, FILE*);
+int	fputws (const wchar_t*, FILE*);
+wint_t	getwc (FILE*);
+wint_t  getwchar (void);
+wchar_t* _getws (wchar_t*);
+wint_t	putwc (wint_t, FILE*);
+int	_putws (const wchar_t*);
+wint_t	putwchar (wint_t);
+
+FILE*	_wfopen (const wchar_t*, const wchar_t*);
+FILE*	_wfreopen (const wchar_t*, const wchar_t*, FILE*);
+FILE*   _wfsopen (const wchar_t*, const wchar_t*, int);
+wchar_t* _wtmpnam (wchar_t*);
+wchar_t* _wtempnam (const wchar_t*, const wchar_t*);
+int 	_wrename (const wchar_t*, const wchar_t*);
+int	_wremove (const wchar_t*)
+
+FILE*	  _wpopen (const wchar_t*, const wchar_t*)
+void	  _wperror (const wchar_t*);
+#endif	/* __MSVCRT__ */
+#define _WSTDIO_DEFINED
+#endif /* _WSTDIO_DEFINED */
+
+#ifndef _WDIRECT_DEFINED
+/* Also in direct.h */
+#ifdef __MSVCRT__ 
+int	  _wchdir (const wchar_t*);
+wchar_t*  _wgetcwd (wchar_t*, int);
+wchar_t*  _wgetdcwd (int, wchar_t*, int);
+int	  _wmkdir (const wchar_t*);
+int	  _wrmdir (const wchar_t*);
+#endif	/* __MSVCRT__ */
+#define _WDIRECT_DEFINED
+#endif /* _WDIRECT_DEFINED */
+
+#ifndef _STAT_DEFINED
+/*
+ * The structure manipulated and returned by stat and fstat.
+ *
+ * NOTE: If called on a directory the values in the time fields are not only
+ * invalid, they will cause localtime et. al. to return NULL. And calling
+ * asctime with a NULL pointer causes an Invalid Page Fault. So watch it!
+ */
+struct _stat
+{
+	_dev_t	st_dev;		/* Equivalent to drive number 0=A 1=B ... */
+	_ino_t	st_ino;		/* Always zero ? */
+	_mode_t	st_mode;	/* See above constants */
+	short	st_nlink;	/* Number of links. */
+	short	st_uid;		/* User: Maybe significant on NT ? */
+	short	st_gid;		/* Group: Ditto */
+	_dev_t	st_rdev;	/* Seems useless (not even filled in) */
+	_off_t	st_size;	/* File size in bytes */
+	time_t	st_atime;	/* Accessed date (always 00:00 hrs local
+				 * on FAT) */
+	time_t	st_mtime;	/* Modified time */
+	time_t	st_ctime;	/* Creation time */
+};
+
+struct stat
+{
+	_dev_t	st_dev;		/* Equivalent to drive number 0=A 1=B ... */
+	_ino_t	st_ino;		/* Always zero ? */
+	_mode_t	st_mode;	/* See above constants */
+	short	st_nlink;	/* Number of links. */
+	short	st_uid;		/* User: Maybe significant on NT ? */
+	short	st_gid;		/* Group: Ditto */
+	_dev_t	st_rdev;	/* Seems useless (not even filled in) */
+	_off_t	st_size;	/* File size in bytes */
+	time_t	st_atime;	/* Accessed date (always 00:00 hrs local
+				 * on FAT) */
+	time_t	st_mtime;	/* Modified time */
+	time_t	st_ctime;	/* Creation time */
+};
+#if defined (__MSVCRT__)
+struct _stati64 {
+    _dev_t st_dev;
+    _ino_t st_ino;
+    unsigned short st_mode;
+    short st_nlink;
+    short st_uid;
+    short st_gid;
+    _dev_t st_rdev;
+    __int64 st_size;
+    time_t st_atime;
+    time_t st_mtime;
+    time_t st_ctime;
+    };
+#endif  /* __MSVCRT__ */
+#define _STAT_DEFINED
+#endif /* _STAT_DEFINED */
+
+#if !defined ( _WSTAT_DEFINED)
+/* also declared in sys/stat.h */
+#if defined __MSVCRT__
+int	_wstat (const wchar_t*, struct _stat*);
+int	_wstati64 (const wchar_t*, struct _stati64*);
+#endif  /* __MSVCRT__ */
+#define _WSTAT_DEFINED
+#endif /* ! _WSTAT_DEFIND  */
+
+#ifndef _WTIME_DEFINED
+#ifdef __MSVCRT__
+/* wide function prototypes, also declared in time.h */
+wchar_t*	_wasctime (const struct tm*);
+wchar_t*	_wctime (const time_t*);
+wchar_t*	_wstrdate (wchar_t*);
+wchar_t*	_wstrtime (wchar_t*);
+#endif /* __MSVCRT__ */
+size_t		wcsftime (wchar_t*, size_t, const wchar_t*, const struct tm*);
+#define _WTIME_DEFINED
+#endif /* _WTIME_DEFINED */ 
+
+#ifndef _WLOCALE_DEFINED  /* also declared in locale.h */
+wchar_t* _wsetlocale (int, const wchar_t*);
+#define _WLOCALE_DEFINED
+#endif
+
+#ifndef _WSTDLIB_DEFINED /* also declared in stdlib.h */
+long	wcstol	(const wchar_t*, wchar_t**, int);
+unsigned long	wcstoul (const wchar_t*, wchar_t**, int);
+double	wcstod	(const wchar_t*, wchar_t**);
+#if !defined __NO_ISOCEXT /* extern stub in static libmingwex.a */
+extern __inline__ float wcstof( const wchar_t *nptr, wchar_t **endptr)
+{  return (wcstod(nptr, endptr)); }
+#endif /* __NO_ISOCEXT */
+#define  _WSTDLIB_DEFINED
+#endif
+
+
+#ifndef	_NO_OLDNAMES
+
+/* Wide character versions. Also declared in io.h. */
+/* CHECK: Are these in the oldnames???  NO! */
+#if (0)
+int		waccess (const wchar_t *, int);
+int		wchmod (const wchar_t *, int);
+int		wcreat (const wchar_t *, int);
+long		wfindfirst (wchar_t *, struct _wfinddata_t *);
+int		wfindnext (long, struct _wfinddata_t *);
+int		wunlink (const wchar_t *);
+int		wrename (const wchar_t *, const wchar_t *);
+int		wremove (const wchar_t *);
+int		wopen (const wchar_t *, int, ...);
+int		wsopen (const wchar_t *, int, int, ...);
+wchar_t*	wmktemp (wchar_t *);
+#endif
+#endif /* _NO_OLDNAMES */
+
+#endif /* not __STRICT_ANSI__ */
+
+/* These are resolved by -lmsvcp60 */
+/* If you don't have msvcp60.dll in your windows system directory, you can
+   easily obtain it with a search from your favorite search engine. */
+typedef int mbstate_t;
+typedef wchar_t _Wint_t;
+
+wint_t  btowc(int);
+size_t  mbrlen(const char *, size_t, mbstate_t *);
+size_t  mbrtowc(wchar_t *, const char *, size_t, mbstate_t *);
+size_t  mbsrtowcs(wchar_t *, const char **, size_t, mbstate_t *);
+
+size_t  wcrtomb(char *, wchar_t, mbstate_t *);
+size_t  wcsrtombs(char *, const wchar_t **, size_t, mbstate_t *);
+int  	wctob(wint_t);
+
+#ifndef __NO_ISOCEXT /* these need static lib libmingwex.a */
+extern inline int fwide(FILE* stream, int mode) {return -1;} /* limited to byte orientation */ 
+extern inline int mbsinit(const mbstate_t* ps) {return 1;}
+wchar_t* wmemset(wchar_t* s, wchar_t c, size_t n);
+wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n);
+int wmemcmp(const wchar_t* s1, const wchar_t * s2, size_t n);
+wchar_t* wmemcpy(wchar_t* __restrict__ s1, const wchar_t* __restrict__ s2,
+		 size_t n);
+wchar_t* wmemmove(wchar_t* s1, const wchar_t* s2, size_t n);
+long long wcstoll(const wchar_t* __restrict__ nptr,
+		  wchar_t** __restrict__ endptr, int base);
+unsigned long long wcstoull(const wchar_t* __restrict__ nptr,
+			    wchar_t ** __restrict__ endptr, int base);
+
+#endif /* __NO_ISOCEXT */
+
+
+#ifdef __cplusplus
+}	/* end of extern "C" */
+#endif
+
+#endif /* Not RC_INVOKED */
+
+#endif /* not _WCHAR_H_ */
+

data/lib/data/c_compilers/tcc/include/wctype.h

@@ -0,0 +1,127 @@
+/* 
+ * wctype.h
+ *
+ * Functions for testing wide character types and converting characters.
+ *
+ * This file is part of the Mingw32 package.
+ *
+ * Contributors:
+ *  Created by Mumit Khan <khan@xraylith.wisc.edu>
+ *
+ *  THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ *  This source code is offered for use in the public domain. You may
+ *  use, modify or distribute it freely.
+ *
+ *  This code is distributed in the hope that it will be useful but
+ *  WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ *  DISCLAIMED. This includes but is not limited to warranties of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#ifndef _WCTYPE_H_
+#define _WCTYPE_H_
+
+/* All the headers include this file. */
+#include <_mingw.h>
+
+#define	__need_wchar_t
+#define	__need_wint_t
+#ifndef RC_INVOKED
+#include <stddef.h>
+#endif	/* Not RC_INVOKED */
+
+/*
+ * The following flags are used to tell iswctype and _isctype what character
+ * types you are looking for.
+ */
+#define	_UPPER		0x0001
+#define	_LOWER		0x0002
+#define	_DIGIT		0x0004
+#define	_SPACE		0x0008
+#define	_PUNCT		0x0010
+#define	_CONTROL	0x0020
+#define	_BLANK		0x0040
+#define	_HEX		0x0080
+#define	_LEADBYTE	0x8000
+
+#define	_ALPHA		0x0103
+
+#ifndef RC_INVOKED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef WEOF
+#define	WEOF	(wchar_t)(0xFFFF)
+#endif
+
+#ifndef _WCTYPE_T_DEFINED
+typedef wchar_t wctype_t;
+#define _WCTYPE_T_DEFINED
+#endif
+
+/* Wide character equivalents - also in ctype.h */
+int	iswalnum(wint_t);
+int	iswalpha(wint_t);
+int	iswascii(wint_t);
+int	iswcntrl(wint_t);
+int	iswctype(wint_t, wctype_t);
+int	is_wctype(wint_t, wctype_t);	/* Obsolete! */
+int	iswdigit(wint_t);
+int	iswgraph(wint_t);
+int	iswlower(wint_t);
+int	iswprint(wint_t);
+int	iswpunct(wint_t);
+int	iswspace(wint_t);
+int	iswupper(wint_t);
+int	iswxdigit(wint_t);
+
+wchar_t	towlower(wchar_t);
+wchar_t	towupper(wchar_t);
+
+int	isleadbyte (int);
+
+/* Also in ctype.h */
+
+__MINGW_IMPORT unsigned short _ctype[];
+#ifdef __MSVCRT__
+__MINGW_IMPORT unsigned short* _pctype;
+#else
+__MINGW_IMPORT unsigned short* _pctype_dll;
+#define  _pctype _pctype_dll
+#endif
+
+#if !(defined(__NO_CTYPE_INLINES) || defined(__WCTYPE_INLINES_DEFINED))
+#define __WCTYPE_INLINES_DEFINED
+extern inline int iswalnum(wint_t wc) {return (iswctype(wc,_ALPHA|_DIGIT));}
+extern inline int iswalpha(wint_t wc) {return (iswctype(wc,_ALPHA));}
+extern inline int iswascii(wint_t wc) {return (((unsigned)wc & 0x7F) ==0);}
+extern inline int iswcntrl(wint_t wc) {return (iswctype(wc,_CONTROL));}
+extern inline int iswdigit(wint_t wc) {return (iswctype(wc,_DIGIT));}
+extern inline int iswgraph(wint_t wc) {return (iswctype(wc,_PUNCT|_ALPHA|_DIGIT));}
+extern inline int iswlower(wint_t wc) {return (iswctype(wc,_LOWER));}
+extern inline int iswprint(wint_t wc) {return (iswctype(wc,_BLANK|_PUNCT|_ALPHA|_DIGIT));}
+extern inline int iswpunct(wint_t wc) {return (iswctype(wc,_PUNCT));}
+extern inline int iswspace(wint_t wc) {return (iswctype(wc,_SPACE));}
+extern inline int iswupper(wint_t wc) {return (iswctype(wc,_UPPER));}
+extern inline int iswxdigit(wint_t wc) {return (iswctype(wc,_HEX));}
+extern inline int isleadbyte(int c) {return (_pctype[(unsigned char)(c)] & _LEADBYTE);}
+#endif /* !(defined(__NO_CTYPE_INLINES) || defined(__WCTYPE_INLINES_DEFINED)) */
+
+
+typedef wchar_t wctrans_t;
+wint_t 		towctrans(wint_t, wctrans_t);
+wctrans_t	wctrans(const char*);
+wctype_t	wctype(const char*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* Not RC_INVOKED */
+
+#endif	/* Not _WCTYPE_H_ */
+

data/lib/data/c_compilers/tcc/include/winapi/basetsd.h

@@ -0,0 +1,119 @@
+#ifndef _BASETSD_H
+#define _BASETSD_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifdef __GNUC__
+#ifndef __int64
+#define __int64 long long
+#endif
+#endif
+
+#if defined(_WIN64)
+#define __int3264   __int64
+#define ADDRESS_TAG_BIT 0x40000000000UI64
+#else /*  !_WIN64 */
+#define __int3264   __int32
+#define ADDRESS_TAG_BIT 0x80000000UL
+#define HandleToUlong( h ) ((ULONG)(ULONG_PTR)(h) )
+#define HandleToLong( h ) ((LONG)(LONG_PTR) (h) )
+#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))
+#endif /* !_WIN64 */
+
+#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)
+
+#ifndef RC_INVOKED
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int LONG32, *PLONG32;
+#ifndef XFree86Server
+typedef int INT32, *PINT32;
+#endif /* ndef XFree86Server */
+typedef unsigned int ULONG32, *PULONG32;
+typedef unsigned int DWORD32, *PDWORD32;
+typedef unsigned int UINT32, *PUINT32;
+
+#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;
+typedef unsigned __int64 HANDLE_PTR;
+typedef unsigned int UHALF_PTR, *PUHALF_PTR;
+typedef int HALF_PTR, *PHALF_PTR;
+
+#if 0 /* TODO when WIN64 is here */
+inline unsigned long HandleToUlong(const void* h )
+    { return((unsigned long) h ); }
+inline long HandleToLong( const void* h )
+    { return((long) h ); }
+inline void* LongToHandle( const long h )
+    { return((void*) (INT_PTR) h ); }
+inline unsigned long PtrToUlong( const void* p)
+    { return((unsigned long) p ); }
+inline unsigned int PtrToUint( const void* p )
+    { return((unsigned int) p ); }
+inline unsigned short PtrToUshort( const void* p )
+    { return((unsigned short) p ); }
+inline long PtrToLong( const void* p )
+    { return((long) p ); }
+inline int PtrToInt( const void* p )
+    { return((int) p ); }
+inline short PtrToShort( const void* p )
+    { return((short) p ); }
+inline void* IntToPtr( const int i )
+    { return( (void*)(INT_PTR)i ); }
+inline void* UIntToPtr(const unsigned int ui)
+    { return( (void*)(UINT_PTR)ui ); }
+inline void* LongToPtr( const long l )
+    { return( (void*)(LONG_PTR)l ); }
+inline void* ULongToPtr( const unsigned long ul )
+    { return( (void*)(ULONG_PTR)ul ); }
+#endif /* 0_ */
+
+#else /*  !_WIN64 */
+typedef  int INT_PTR, *PINT_PTR;
+typedef  unsigned int UINT_PTR, *PUINT_PTR;
+typedef  long LONG_PTR, *PLONG_PTR;
+typedef  unsigned long ULONG_PTR, *PULONG_PTR;
+typedef unsigned short UHALF_PTR, *PUHALF_PTR;
+typedef short HALF_PTR, *PHALF_PTR;
+typedef unsigned long HANDLE_PTR;
+#endif /* !_WIN64 */
+
+typedef ULONG_PTR SIZE_T, *PSIZE_T;
+typedef LONG_PTR SSIZE_T, *PSSIZE_T;
+typedef ULONG_PTR DWORD_PTR, *PDWORD_PTR;
+typedef __int64 LONG64, *PLONG64;
+typedef __int64 INT64,  *PINT64;
+typedef unsigned __int64 ULONG64, *PULONG64;
+typedef unsigned __int64 DWORD64, *PDWORD64;
+typedef unsigned __int64 UINT64,  *PUINT64;
+#ifdef __cplusplus
+}
+#endif
+#endif /* !RC_INVOKED */
+
+#endif /* _BASETSD_H */

data/lib/data/c_compilers/tcc/include/winapi/basetyps.h

@@ -0,0 +1,144 @@
+#ifndef _BASETYPS_H
+#define _BASETYPS_H
+#if __GNUC__ >=3
+#pragma GCC system_header
+#endif
+
+#ifndef __OBJC__
+#ifdef __cplusplus
+#define EXTERN_C extern "C"
+#else
+#define EXTERN_C extern
+#endif  /* __cplusplus */ 
+#define STDMETHODCALLTYPE	__stdcall
+#define STDMETHODVCALLTYPE	__cdecl
+#define STDAPICALLTYPE	__stdcall
+#define STDAPIVCALLTYPE	__cdecl
+#define STDAPI	EXTERN_C HRESULT STDAPICALLTYPE
+#define STDAPI_(t)	EXTERN_C t STDAPICALLTYPE
+#define STDMETHODIMP	HRESULT STDMETHODCALLTYPE
+#define STDMETHODIMP_(t)	t STDMETHODCALLTYPE
+#define STDAPIV	EXTERN_C HRESULT STDAPIVCALLTYPE
+#define STDAPIV_(t)	EXTERN_C t STDAPIVCALLTYPE
+#define STDMETHODIMPV	HRESULT STDMETHODVCALLTYPE
+#define STDMETHODIMPV_(t)	t STDMETHODVCALLTYPE
+#define interface	struct
+#if defined(__cplusplus) && !defined(CINTERFACE)
+#define STDMETHOD(m)	virtual HRESULT STDMETHODCALLTYPE m
+#define STDMETHOD_(t,m)	virtual t STDMETHODCALLTYPE m
+#define PURE	=0
+#define THIS_
+#define THIS	void
+/*
+ __attribute__((com_interface)) is obsolete in __GNUC__ >= 3
+ g++ vtables are now COM-compatible by default
+*/
+#if defined(__GNUC__) &&  __GNUC__ < 3 && !defined(NOCOMATTRIBUTE)
+#define DECLARE_INTERFACE(i) interface __attribute__((com_interface)) i
+#define DECLARE_INTERFACE_(i,b) interface __attribute__((com_interface)) i : public b
+#else
+#define DECLARE_INTERFACE(i) interface i
+#define DECLARE_INTERFACE_(i,b) interface i : public b
+#endif
+#else
+#define STDMETHOD(m)	HRESULT(STDMETHODCALLTYPE *m)
+#define STDMETHOD_(t,m)	t(STDMETHODCALLTYPE *m)
+#define PURE
+#define THIS_	INTERFACE *,
+#define THIS	INTERFACE *
+#ifndef CONST_VTABLE
+#define CONST_VTABLE
+#endif
+#define DECLARE_INTERFACE(i) \
+typedef interface i { CONST_VTABLE struct i##Vtbl *lpVtbl; } i; \
+typedef CONST_VTABLE struct i##Vtbl i##Vtbl; \
+CONST_VTABLE struct i##Vtbl
+#define DECLARE_INTERFACE_(i,b) DECLARE_INTERFACE(i)
+#endif
+#define BEGIN_INTERFACE
+#define END_INTERFACE
+
+#define FWD_DECL(i) typedef interface i i
+#if defined(__cplusplus) && !defined(CINTERFACE)
+#define IENUM_THIS(T)
+#define IENUM_THIS_(T)
+#else
+#define IENUM_THIS(T) T*
+#define IENUM_THIS_(T) T*,
+#endif
+#define DECLARE_ENUMERATOR_(I,T) \
+DECLARE_INTERFACE_(I,IUnknown) \
+{ \
+	STDMETHOD(QueryInterface)(IENUM_THIS_(I) REFIID,PVOID*) PURE; \
+	STDMETHOD_(ULONG,AddRef)(IENUM_THIS(I)) PURE; \
+	STDMETHOD_(ULONG,Release)(IENUM_THIS(I)) PURE; \
+	STDMETHOD(Next)(IENUM_THIS_(I) ULONG,T*,ULONG*) PURE; \
+	STDMETHOD(Skip)(IENUM_THIS_(I) ULONG) PURE; \
+	STDMETHOD(Reset)(IENUM_THIS(I)) PURE; \
+	STDMETHOD(Clone)(IENUM_THIS_(I) I**) PURE; \
+}
+#define DECLARE_ENUMERATOR(T) DECLARE_ENUMERATOR_(IEnum##T,T)
+
+#endif /* __OBJC__ */
+
+#ifndef _GUID_DEFINED /* also defined in winnt.h */
+#define _GUID_DEFINED
+typedef struct _GUID
+{
+    unsigned long Data1;
+    unsigned short Data2;
+    unsigned short Data3;
+    unsigned char Data4[8];
+} GUID,*REFGUID,*LPGUID;
+#endif /* _GUID_DEFINED */
+#ifndef UUID_DEFINED
+#define UUID_DEFINED
+typedef GUID UUID;
+#endif /* UUID_DEFINED */
+typedef GUID IID;
+typedef GUID CLSID;
+typedef CLSID *LPCLSID;
+typedef IID *LPIID;
+typedef IID *REFIID;
+typedef CLSID *REFCLSID;
+typedef GUID FMTID;
+typedef FMTID *REFFMTID;
+typedef unsigned long error_status_t;
+#define uuid_t UUID
+typedef unsigned long PROPID;
+
+#ifndef _REFGUID_DEFINED
+#if defined (__cplusplus) && !defined (CINTERFACE)
+#define REFGUID const GUID&
+#define REFIID const IID&
+#define REFCLSID const CLSID&
+#else
+#define REFGUID const GUID* const
+#define REFIID const IID* const
+#define REFCLSID const CLSID* const
+#endif
+#define _REFGUID_DEFINED
+#define _REFGIID_DEFINED
+#define _REFCLSID_DEFINED
+#endif
+#ifndef GUID_SECTION
+#define GUID_SECTION ".text"
+#endif
+#ifdef __GNUC__
+#define GUID_SECT __attribute__ ((section (GUID_SECTION)))
+#else
+#define GUID_SECT
+#endif
+#if !defined(INITGUID) || (defined(INITGUID) && defined(__cplusplus))
+#define GUID_EXT EXTERN_C
+#else
+#define GUID_EXT
+#endif
+#ifdef INITGUID
+#define DEFINE_GUID(n,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) GUID_EXT const GUID n GUID_SECT = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}
+#define DEFINE_OLEGUID(n,l,w1,w2) DEFINE_GUID(n,l,w1,w2,0xC0,0,0,0,0,0,0,0x46)
+#else
+#define DEFINE_GUID(n,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) GUID_EXT const GUID n
+#define DEFINE_OLEGUID(n,l,w1,w2) DEFINE_GUID(n,l,w1,w2,0xC0,0,0,0,0,0,0,0x46)
+#endif
+#endif