spawnrys/aegnux
1
0
Fork 0
mirror of https://github.com/relativemodder/aegnux.git synced 2025-12-10 13:39:43 +05:00
Code Issues Packages Projects Releases Wiki Activity

cleanup from wine headers and some UI changes

Browse Source
This commit is contained in:
Andrew
2025-10-30 18:46:17 +03:00
parent 0675b4a305
commit 54181b5bbc
1400 changed files with 31 additions and 1423008 deletions
Download Patch File Download Diff File Expand all files Collapse all files

559
assets/wine/include/wine/debug.h
View File

@@ -1,559 +0,0 @@
/*
* Wine debugging interface
*
* Copyright 1999 Patrik Stridvall
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#if 0
#pragma makedep install
#endif
#ifndef __WINE_WINE_DEBUG_H
#define __WINE_WINE_DEBUG_H
#include <stdarg.h>
#include <stdio.h>
#include <windef.h>
#include <winbase.h>
#ifndef GUID_DEFINED
#include <guiddef.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
struct _GUID;
/*
* Internal definitions (do not use these directly)
*/
enum __wine_debug_class
{
__WINE_DBCL_FIXME,
__WINE_DBCL_ERR,
__WINE_DBCL_WARN,
__WINE_DBCL_TRACE,
__WINE_DBCL_INIT = 7 /* lazy init flag */
};
struct __wine_debug_channel
{
unsigned char flags;
char name[15];
};
#ifndef WINE_NO_TRACE_MSGS
# define __WINE_GET_DEBUGGING_TRACE(dbch) ((dbch)->flags & (1 << __WINE_DBCL_TRACE))
#else
# define __WINE_GET_DEBUGGING_TRACE(dbch) 0
#endif
#ifndef WINE_NO_DEBUG_MSGS
# define __WINE_GET_DEBUGGING_WARN(dbch) ((dbch)->flags & (1 << __WINE_DBCL_WARN))
# define __WINE_GET_DEBUGGING_FIXME(dbch) ((dbch)->flags & (1 << __WINE_DBCL_FIXME))
#else
# define __WINE_GET_DEBUGGING_WARN(dbch) 0
# define __WINE_GET_DEBUGGING_FIXME(dbch) 0
#endif
/* define error macro regardless of what is configured */
#define __WINE_GET_DEBUGGING_ERR(dbch) ((dbch)->flags & (1 << __WINE_DBCL_ERR))
#define __WINE_GET_DEBUGGING(dbcl,dbch) __WINE_GET_DEBUGGING##dbcl(dbch)
#define __WINE_IS_DEBUG_ON(dbcl,dbch) \
(__WINE_GET_DEBUGGING##dbcl(dbch) && (__wine_dbg_get_channel_flags(dbch) & (1 << __WINE_DBCL##dbcl)))
#define __WINE_DPRINTF(dbcl,dbch) \
do { if(__WINE_GET_DEBUGGING(dbcl,(dbch))) { \
struct __wine_debug_channel * const __dbch = (dbch); \
const enum __wine_debug_class __dbcl = __WINE_DBCL##dbcl; \
__WINE_DBG_LOG
#define __WINE_DBG_LOG(...) \
wine_dbg_log( __dbcl, __dbch, __func__, __VA_ARGS__); } } while(0)
#if (defined(__GNUC__) || defined(__clang__)) && (defined(__MINGW32__) || defined (_MSC_VER) || !defined(__WINE_USE_MSVCRT))
#define __WINE_PRINTF_ATTR(fmt,args) __attribute__((format (printf,fmt,args)))
#else
#define __WINE_PRINTF_ATTR(fmt,args)
#endif
#ifdef WINE_NO_TRACE_MSGS
#define WINE_TRACE(...) do { } while(0)
#define WINE_TRACE_(ch) WINE_TRACE
#endif
#ifdef WINE_NO_DEBUG_MSGS
#define WINE_WARN(...) do { } while(0)
#define WINE_WARN_(ch) WINE_WARN
#define WINE_FIXME(...) do { } while(0)
#define WINE_FIXME_(ch) WINE_FIXME
#endif
NTSYSAPI int WINAPI __wine_dbg_write( const char *str, unsigned int len );
extern DECLSPEC_EXPORT unsigned char __cdecl __wine_dbg_get_channel_flags( struct __wine_debug_channel *channel );
extern DECLSPEC_EXPORT const char * __cdecl __wine_dbg_strdup( const char *str );
extern DECLSPEC_EXPORT int __cdecl __wine_dbg_output( const char *str );
extern DECLSPEC_EXPORT int __cdecl __wine_dbg_header( enum __wine_debug_class cls, struct __wine_debug_channel *channel,
const char *function );
/*
* Exported definitions and macros
*/
/* These functions return a printable version of a string, including
quotes. The string will be valid for some time, but not indefinitely
as strings are re-used. */
#if defined(__x86_64__) && defined(__GNUC__) && defined(__WINE_USE_MSVCRT)
# define __wine_dbg_cdecl __cdecl
#else
# define __wine_dbg_cdecl
#endif
static const char * __wine_dbg_cdecl wine_dbg_vsprintf( const char *format, va_list args ) __WINE_PRINTF_ATTR(1,0);
static inline const char * __wine_dbg_cdecl wine_dbg_vsprintf( const char *format, va_list args )
{
char buffer[200];
vsnprintf( buffer, sizeof(buffer), format, args );
buffer[sizeof(buffer) - 1] = 0;
return __wine_dbg_strdup( buffer );
}
static const char * __wine_dbg_cdecl wine_dbg_sprintf( const char *format, ... ) __WINE_PRINTF_ATTR(1,2);
static inline const char * __wine_dbg_cdecl wine_dbg_sprintf( const char *format, ... )
{
const char *ret;
va_list args;
va_start( args, format );
ret = wine_dbg_vsprintf( format, args );
va_end( args );
return ret;
}
static int __wine_dbg_cdecl wine_dbg_vprintf( const char *format, va_list args ) __WINE_PRINTF_ATTR(1,0);
static inline int __wine_dbg_cdecl wine_dbg_vprintf( const char *format, va_list args )
{
char buffer[1024];
vsnprintf( buffer, sizeof(buffer), format, args );
buffer[sizeof(buffer) - 1] = 0;
return __wine_dbg_output( buffer );
}
static int __wine_dbg_cdecl wine_dbg_printf( const char *format, ... ) __WINE_PRINTF_ATTR(1,2);
static inline int __wine_dbg_cdecl wine_dbg_printf( const char *format, ... )
{
int ret;
va_list args;
va_start( args, format );
ret = wine_dbg_vprintf( format, args );
va_end( args );
return ret;
}
static int __wine_dbg_cdecl wine_dbg_vlog( enum __wine_debug_class cls,
struct __wine_debug_channel *channel, const char *func,
const char *format, va_list args ) __WINE_PRINTF_ATTR(4,0);
static inline int __wine_dbg_cdecl wine_dbg_vlog( enum __wine_debug_class cls,
struct __wine_debug_channel *channel,
const char *function, const char *format, va_list args )
{
int ret;
if (*format == '\1') /* special magic to avoid standard prefix */
{
format++;
function = NULL;
}
if ((ret = __wine_dbg_header( cls, channel, function )) != -1) ret += wine_dbg_vprintf( format, args );
return ret;
}
static int __wine_dbg_cdecl wine_dbg_log( enum __wine_debug_class cls,
struct __wine_debug_channel *channel, const char *func,
const char *format, ... ) __WINE_PRINTF_ATTR(4,5);
static inline int __wine_dbg_cdecl wine_dbg_log( enum __wine_debug_class cls,
struct __wine_debug_channel *channel,
const char *function, const char *format, ... )
{
va_list args;
int ret;
va_start( args, format );
ret = wine_dbg_vlog( cls, channel, function, format, args );
va_end( args );
return ret;
}
static inline const char *wine_dbgstr_an( const char *str, int n )
{
static const char hex[16] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
char buffer[300], *dst = buffer;
if (!str) return "(null)";
if (!((ULONG_PTR)str >> 16)) return wine_dbg_sprintf( "#%04x", LOWORD(str) );
#ifndef WINE_UNIX_LIB
if (IsBadStringPtrA( str, n )) return "(invalid)";
#endif
if (n == -1) for (n = 0; str[n]; n++) ;
*dst++ = '"';
while (n-- > 0 && dst <= buffer + sizeof(buffer) - 9)
{
unsigned char c = *str++;
switch (c)
{
case '\n': *dst++ = '\\'; *dst++ = 'n'; break;
case '\r': *dst++ = '\\'; *dst++ = 'r'; break;
case '\t': *dst++ = '\\'; *dst++ = 't'; break;
case '"': *dst++ = '\\'; *dst++ = '"'; break;
case '\\': *dst++ = '\\'; *dst++ = '\\'; break;
default:
if (c < ' ' || c >= 127)
{
*dst++ = '\\';
*dst++ = 'x';
*dst++ = hex[(c >> 4) & 0x0f];
*dst++ = hex[c & 0x0f];
}
else *dst++ = c;
}
}
*dst++ = '"';
if (n > 0)
{
*dst++ = '.';
*dst++ = '.';
*dst++ = '.';
}
*dst = 0;
return __wine_dbg_strdup( buffer );
}
static inline const char *wine_dbgstr_wn( const WCHAR *str, int n )
{
static const char hex[16] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
char buffer[300], *dst = buffer;
if (!str) return "(null)";
if (!((ULONG_PTR)str >> 16)) return wine_dbg_sprintf( "#%04x", LOWORD(str) );
#ifndef WINE_UNIX_LIB
if (IsBadStringPtrW( str, n )) return "(invalid)";
#endif
if (n == -1) for (n = 0; str[n]; n++) ;
*dst++ = 'L';
*dst++ = '"';
while (n-- > 0 && dst <= buffer + sizeof(buffer) - 10)
{
WCHAR c = *str++;
switch (c)
{
case '\n': *dst++ = '\\'; *dst++ = 'n'; break;
case '\r': *dst++ = '\\'; *dst++ = 'r'; break;
case '\t': *dst++ = '\\'; *dst++ = 't'; break;
case '"': *dst++ = '\\'; *dst++ = '"'; break;
case '\\': *dst++ = '\\'; *dst++ = '\\'; break;
default:
if (c < ' ' || c >= 127)
{
*dst++ = '\\';
*dst++ = hex[(c >> 12) & 0x0f];
*dst++ = hex[(c >> 8) & 0x0f];
*dst++ = hex[(c >> 4) & 0x0f];
*dst++ = hex[c & 0x0f];
}
else *dst++ = (char)c;
}
}
*dst++ = '"';
if (n > 0)
{
*dst++ = '.';
*dst++ = '.';
*dst++ = '.';
}
*dst = 0;
return __wine_dbg_strdup( buffer );
}
static inline const char *wine_dbgstr_a( const char *s )
{
return wine_dbgstr_an( s, -1 );
}
static inline const char *wine_dbgstr_w( const WCHAR *s )
{
return wine_dbgstr_wn( s, -1 );
}
#if defined(__hstring_h__) && defined(__WINSTRING_H_)
static inline const char *wine_dbgstr_hstring( HSTRING hstr )
{
UINT32 len;
const WCHAR *str = WindowsGetStringRawBuffer( hstr, &len );
return wine_dbgstr_wn( str, len );
}
#endif
static inline const char *wine_dbgstr_guid( const GUID *id )
{
if (!id) return "(null)";
if (!((ULONG_PTR)id >> 16)) return wine_dbg_sprintf( "<guid-0x%04hx>", (WORD)(ULONG_PTR)id );
return wine_dbg_sprintf( "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
(unsigned int)id->Data1, id->Data2, id->Data3,
id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] );
}
static inline const char *wine_dbgstr_fourcc( unsigned int fourcc )
{
char str[4] = { (char)fourcc, (char)(fourcc >> 8), (char)(fourcc >> 16), (char)(fourcc >> 24) };
if (!fourcc)
return "''";
if (isprint( str[0] ) && isprint( str[1] ) && isprint( str[2] ) && isprint( str[3] ))
return wine_dbg_sprintf( "'%.4s'", str );
return wine_dbg_sprintf( "0x%08x", fourcc );
}
static inline const char *wine_dbgstr_point( const POINT *pt )
{
if (!pt) return "(null)";
return wine_dbg_sprintf( "(%d,%d)", (int)pt->x, (int)pt->y );
}
static inline const char *wine_dbgstr_rect( const RECT *rect )
{
if (!rect) return "(null)";
return wine_dbg_sprintf( "(%d,%d)-(%d,%d)", (int)rect->left, (int)rect->top,
(int)rect->right, (int)rect->bottom );
}
static inline const char *wine_dbgstr_longlong( ULONGLONG ll )
{
if (sizeof(ll) > sizeof(unsigned long) && ll >> 32)
return wine_dbg_sprintf( "%lx%08lx", (unsigned long)(ll >> 32), (unsigned long)ll );
else return wine_dbg_sprintf( "%lx", (unsigned long)ll );
}
#if defined(__oaidl_h__) && defined(V_VT)
static inline const char *wine_dbgstr_vt( VARTYPE vt )
{
static const char *const variant_types[] =
{
"VT_EMPTY","VT_NULL","VT_I2","VT_I4","VT_R4","VT_R8","VT_CY","VT_DATE",
"VT_BSTR","VT_DISPATCH","VT_ERROR","VT_BOOL","VT_VARIANT","VT_UNKNOWN",
"VT_DECIMAL","15","VT_I1","VT_UI1","VT_UI2","VT_UI4","VT_I8","VT_UI8",
"VT_INT","VT_UINT","VT_VOID","VT_HRESULT","VT_PTR","VT_SAFEARRAY",
"VT_CARRAY","VT_USERDEFINED","VT_LPSTR","VT_LPWSTR","32","33","34","35",
"VT_RECORD","VT_INT_PTR","VT_UINT_PTR","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","VT_FILETIME","VT_BLOB","VT_STREAM","VT_STORAGE",
"VT_STREAMED_OBJECT","VT_STORED_OBJECT","VT_BLOB_OBJECT","VT_CF","VT_CLSID",
"VT_VERSIONED_STREAM"
};
static const char *const variant_flags[16] =
{
"",
"|VT_VECTOR",
"|VT_ARRAY",
"|VT_VECTOR|VT_ARRAY",
"|VT_BYREF",
"|VT_VECTOR|VT_BYREF",
"|VT_ARRAY|VT_BYREF",
"|VT_VECTOR|VT_ARRAY|VT_BYREF",
"|VT_RESERVED",
"|VT_VECTOR|VT_RESERVED",
"|VT_ARRAY|VT_RESERVED",
"|VT_VECTOR|VT_ARRAY|VT_RESERVED",
"|VT_BYREF|VT_RESERVED",
"|VT_VECTOR|VT_BYREF|VT_RESERVED",
"|VT_ARRAY|VT_BYREF|VT_RESERVED",
"|VT_VECTOR|VT_ARRAY|VT_BYREF|VT_RESERVED",
};
if (vt & ~VT_TYPEMASK)
return wine_dbg_sprintf( "%s%s", wine_dbgstr_vt(vt&VT_TYPEMASK), variant_flags[vt>>12] );
if (vt < sizeof(variant_types)/sizeof(*variant_types))
return variant_types[vt];
if (vt == VT_BSTR_BLOB)
return "VT_BSTR_BLOB";
return wine_dbg_sprintf( "vt(invalid %x)", vt );
}
static inline const char *wine_dbgstr_variant( const VARIANT *v )
{
if (!v)
return "(null)";
if (V_VT(v) & VT_BYREF) {
if (V_VT(v) == (VT_VARIANT|VT_BYREF))
return wine_dbg_sprintf( "%p {VT_VARIANT|VT_BYREF: %s}", v, wine_dbgstr_variant(V_VARIANTREF(v)) );
if (V_VT(v) == (VT_BSTR|VT_BYREF))
return wine_dbg_sprintf( "%p {VT_BSTR|VT_BYREF: %s}", v, V_BSTRREF(v) ? wine_dbgstr_w(*V_BSTRREF(v)) : "(none)" );
return wine_dbg_sprintf( "%p {%s %p}", v, wine_dbgstr_vt(V_VT(v)), V_BYREF(v) );
}
if (V_ISARRAY(v) || V_ISVECTOR(v))
return wine_dbg_sprintf( "%p {%s %p}", v, wine_dbgstr_vt(V_VT(v)), V_ARRAY(v) );
switch(V_VT(v)) {
case VT_EMPTY:
return wine_dbg_sprintf( "%p {VT_EMPTY}", v );
case VT_NULL:
return wine_dbg_sprintf( "%p {VT_NULL}", v );
case VT_I2:
return wine_dbg_sprintf( "%p {VT_I2: %d}", v, V_I2(v) );
case VT_I4:
return wine_dbg_sprintf( "%p {VT_I4: %d}", v, (int)V_I4(v) );
case VT_R4:
return wine_dbg_sprintf( "%p {VT_R4: %f}", v, V_R4(v) );
case VT_R8:
return wine_dbg_sprintf( "%p {VT_R8: %lf}", v, V_R8(v) );
case VT_CY:
return wine_dbg_sprintf( "%p {VT_CY: %s}", v, wine_dbgstr_longlong(V_CY(v).int64) );
case VT_DATE:
return wine_dbg_sprintf( "%p {VT_DATE: %lf}", v, V_DATE(v) );
case VT_LPSTR:
return wine_dbg_sprintf( "%p {VT_LPSTR: %s}", v, wine_dbgstr_a((const char *)V_BSTR(v)) );
case VT_LPWSTR:
return wine_dbg_sprintf( "%p {VT_LPWSTR: %s}", v, wine_dbgstr_w(V_BSTR(v)) );
case VT_BSTR:
return wine_dbg_sprintf( "%p {VT_BSTR: %s}", v, wine_dbgstr_w(V_BSTR(v)) );
case VT_DISPATCH:
return wine_dbg_sprintf( "%p {VT_DISPATCH: %p}", v, V_DISPATCH(v) );
case VT_ERROR:
return wine_dbg_sprintf( "%p {VT_ERROR: %08x}", v, (int)V_ERROR(v) );
case VT_BOOL:
return wine_dbg_sprintf( "%p {VT_BOOL: %x}", v, V_BOOL(v) );
case VT_UNKNOWN:
return wine_dbg_sprintf( "%p {VT_UNKNOWN: %p}", v, V_UNKNOWN(v) );
case VT_I1:
return wine_dbg_sprintf( "%p {VT_I1: %d}", v, V_I1(v) );
case VT_UI1:
return wine_dbg_sprintf( "%p {VT_UI1: %u}", v, V_UI1(v) );
case VT_UI2:
return wine_dbg_sprintf( "%p {VT_UI2: %u}", v, V_UI2(v) );
case VT_UI4:
return wine_dbg_sprintf( "%p {VT_UI4: %u}", v, (unsigned int)V_UI4(v) );
case VT_I8:
return wine_dbg_sprintf( "%p {VT_I8: %s}", v, wine_dbgstr_longlong(V_I8(v)) );
case VT_UI8:
return wine_dbg_sprintf( "%p {VT_UI8: %s}", v, wine_dbgstr_longlong(V_UI8(v)) );
case VT_INT:
return wine_dbg_sprintf( "%p {VT_INT: %d}", v, V_INT(v) );
case VT_UINT:
return wine_dbg_sprintf( "%p {VT_UINT: %u}", v, V_UINT(v) );
case VT_VOID:
return wine_dbg_sprintf( "%p {VT_VOID}", v );
case VT_RECORD:
return wine_dbg_sprintf( "%p {VT_RECORD: %p %p}", v, V_RECORD(v), V_RECORDINFO(v) );
default:
return wine_dbg_sprintf( "%p {vt %s}", v, wine_dbgstr_vt(V_VT(v)) );
}
}
#endif /* defined(__oaidl_h__) && defined(V_VT) */
#ifndef WINE_TRACE
#define WINE_TRACE __WINE_DPRINTF(_TRACE,__wine_dbch___default)
#define WINE_TRACE_(ch) __WINE_DPRINTF(_TRACE,&__wine_dbch_##ch)
#endif
#define WINE_TRACE_ON(ch) __WINE_IS_DEBUG_ON(_TRACE,&__wine_dbch_##ch)
#ifndef WINE_WARN
#define WINE_WARN __WINE_DPRINTF(_WARN,__wine_dbch___default)
#define WINE_WARN_(ch) __WINE_DPRINTF(_WARN,&__wine_dbch_##ch)
#endif
#define WINE_WARN_ON(ch) __WINE_IS_DEBUG_ON(_WARN,&__wine_dbch_##ch)
#ifndef WINE_FIXME
#define WINE_FIXME __WINE_DPRINTF(_FIXME,__wine_dbch___default)
#define WINE_FIXME_(ch) __WINE_DPRINTF(_FIXME,&__wine_dbch_##ch)
#endif
#define WINE_FIXME_ON(ch) __WINE_IS_DEBUG_ON(_FIXME,&__wine_dbch_##ch)
#define WINE_ERR __WINE_DPRINTF(_ERR,__wine_dbch___default)
#define WINE_ERR_(ch) __WINE_DPRINTF(_ERR,&__wine_dbch_##ch)
#define WINE_ERR_ON(ch) __WINE_IS_DEBUG_ON(_ERR,&__wine_dbch_##ch)
#define WINE_DECLARE_DEBUG_CHANNEL(ch) \
static struct __wine_debug_channel __wine_dbch_##ch = { 0xff, #ch }; \
C_ASSERT(sizeof(#ch) <= sizeof(__wine_dbch_##ch.name))
#define WINE_DEFAULT_DEBUG_CHANNEL(ch) \
static struct __wine_debug_channel __wine_dbch_##ch = { 0xff, #ch }; \
C_ASSERT(sizeof(#ch) <= sizeof(__wine_dbch_##ch.name)); \
static struct __wine_debug_channel * const __wine_dbch___default = &__wine_dbch_##ch
#define WINE_MESSAGE wine_dbg_printf
#ifdef __WINESRC__
/* Wine uses shorter names that are very likely to conflict with other software */
static inline const char *debugstr_an( const char * s, int n ) { return wine_dbgstr_an( s, n ); }
static inline const char *debugstr_wn( const WCHAR *s, int n ) { return wine_dbgstr_wn( s, n ); }
static inline const char *debugstr_guid( const struct _GUID *id ) { return wine_dbgstr_guid(id); }
static inline const char *debugstr_fourcc( unsigned int cc ) { return wine_dbgstr_fourcc( cc ); }
static inline const char *debugstr_a( const char *s ) { return wine_dbgstr_an( s, -1 ); }
static inline const char *debugstr_w( const WCHAR *s ) { return wine_dbgstr_wn( s, -1 ); }
#if defined(__hstring_h__) && defined(__WINSTRING_H_)
static inline const char *debugstr_hstring( struct HSTRING__ *s ) { return wine_dbgstr_hstring( s ); }
#endif
#if defined(__oaidl_h__) && defined(V_VT)
static inline const char *debugstr_vt( VARTYPE vt ) { return wine_dbgstr_vt( vt ); }
static inline const char *debugstr_variant( const VARIANT *v ) { return wine_dbgstr_variant( v ); }
#endif
#define TRACE WINE_TRACE
#define TRACE_(ch) WINE_TRACE_(ch)
#define TRACE_ON(ch) WINE_TRACE_ON(ch)
#define WARN WINE_WARN
#define WARN_(ch) WINE_WARN_(ch)
#define WARN_ON(ch) WINE_WARN_ON(ch)
#define FIXME WINE_FIXME
#define FIXME_(ch) WINE_FIXME_(ch)
#define FIXME_ON(ch) WINE_FIXME_ON(ch)
#undef ERR /* Solaris got an 'ERR' define in <sys/reg.h> */
#define ERR WINE_ERR
#define ERR_(ch) WINE_ERR_(ch)
#define ERR_ON(ch) WINE_ERR_ON(ch)
#define MESSAGE WINE_MESSAGE
#endif /* __WINESRC__ */
#ifdef __cplusplus
}
#endif
#endif /* __WINE_WINE_DEBUG_H */

299
assets/wine/include/wine/exception.h
View File

@@ -1,299 +0,0 @@
/*
* Wine exception handling
*
* Copyright (c) 1999 Alexandre Julliard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#if 0
#pragma makedep install
#endif
#ifndef __WINE_WINE_EXCEPTION_H
#define __WINE_WINE_EXCEPTION_H
#include <windef.h>
#include <winternl.h>
#include <rtlsupportapi.h>
#include <excpt.h>
#ifdef __cplusplus
extern "C" {
#endif
/* The following definitions allow using exceptions in Wine and Winelib code
*
* They should be used like this:
*
* __TRY
* {
* do some stuff that can raise an exception
* }
* __EXCEPT(filter_func)
* {
* handle the exception here
* }
* __ENDTRY
*
* or
*
* __TRY
* {
* do some stuff that can raise an exception
* }
* __FINALLY(finally_func)
*
* The filter_func and finally_func functions must be defined like this:
*
* LONG CALLBACK filter_func( PEXCEPTION_POINTERS __eptr ) { ... }
*
* void CALLBACK finally_func( BOOL __normal ) { ... }
*
* The filter function must return one of the EXCEPTION_* code; it can
* use GetExceptionInformation() and GetExceptionCode() to retrieve the
* exception info.
*
* Warning: Inside a __TRY or __EXCEPT block, 'break' or 'continue' statements
* break out of the current block, but avoid using them because they
* won't work when compiling with native exceptions. You cannot use
* 'return', 'goto', or 'longjmp' to leave a __TRY block either, as
* this will surely crash. You can use 'return', 'goto', or 'longjmp'
* to leave an __EXCEPT block though.
*
* -- AJ
*/
#if !defined(__GNUC__) && !defined(__clang__)
#define __attribute__(x) /* nothing */
#endif
/* Define this if you want to use your compiler built-in __try/__except support.
* This is only useful when compiling to a native Windows binary, as the built-in
* compiler exceptions will most certainly not work under Winelib.
*/
#ifdef USE_COMPILER_EXCEPTIONS
#define __TRY __try
#define __EXCEPT(func) __except((func)(GetExceptionInformation()))
#define __EXCEPT_CTX(func, ctx) __except((func)(GetExceptionInformation(), ctx))
#define __FINALLY(func) __finally { (func)(!AbnormalTermination()); }
#define __FINALLY_CTX(func, ctx) __finally { (func)(!AbnormalTermination(), ctx); }
#define __ENDTRY /*nothing*/
#define __EXCEPT_PAGE_FAULT __except(GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION)
#define __EXCEPT_ALL __except(EXCEPTION_EXECUTE_HANDLER)
#else /* USE_COMPILER_EXCEPTIONS */
#ifdef __i386__
typedef struct { int reg[16]; } __wine_jmp_buf;
#elif defined(__x86_64__)
typedef struct { DECLSPEC_ALIGN(16) struct { unsigned __int64 Part[2]; } reg[16]; } __wine_jmp_buf;
#elif defined(__arm__)
typedef struct { int reg[28]; } __wine_jmp_buf;
#elif defined(__aarch64__)
typedef struct { __int64 reg[24]; } __wine_jmp_buf;
#else
typedef struct { int reg; } __wine_jmp_buf;
#endif
extern int __cdecl __attribute__ ((__nothrow__,__returns_twice__)) __wine_setjmpex( __wine_jmp_buf *buf,
EXCEPTION_REGISTRATION_RECORD *frame );
extern void DECLSPEC_NORETURN __cdecl __wine_longjmp( __wine_jmp_buf *buf, int retval );
extern void DECLSPEC_NORETURN __cdecl __wine_rtl_unwind( EXCEPTION_REGISTRATION_RECORD* frame, EXCEPTION_RECORD *record,
void (*target)(void) );
extern DWORD __cdecl __wine_exception_handler( EXCEPTION_RECORD *record,
EXCEPTION_REGISTRATION_RECORD *frame,
CONTEXT *context,
EXCEPTION_REGISTRATION_RECORD **pdispatcher );
extern DWORD __cdecl __wine_exception_ctx_handler( EXCEPTION_RECORD *record,
EXCEPTION_REGISTRATION_RECORD *frame,
CONTEXT *context,
EXCEPTION_REGISTRATION_RECORD **pdispatcher );
extern DWORD __cdecl __wine_exception_handler_page_fault( EXCEPTION_RECORD *record,
EXCEPTION_REGISTRATION_RECORD *frame,
CONTEXT *context,
EXCEPTION_REGISTRATION_RECORD **pdispatcher );
extern DWORD __cdecl __wine_exception_handler_all( EXCEPTION_RECORD *record,
EXCEPTION_REGISTRATION_RECORD *frame,
CONTEXT *context,
EXCEPTION_REGISTRATION_RECORD **pdispatcher );
extern DWORD __cdecl __wine_finally_handler( EXCEPTION_RECORD *record,
EXCEPTION_REGISTRATION_RECORD *frame,
CONTEXT *context,
EXCEPTION_REGISTRATION_RECORD **pdispatcher );
extern DWORD __cdecl __wine_finally_ctx_handler( EXCEPTION_RECORD *record,
EXCEPTION_REGISTRATION_RECORD *frame,
CONTEXT *context,
EXCEPTION_REGISTRATION_RECORD **pdispatcher );
#define __TRY \
do { __WINE_FRAME __f; \
int __first = 1; \
for (;;) if (!__first) \
{ \
do {
#define __EXCEPT(func) \
} while(0); \
__wine_pop_frame( &__f.frame ); \
break; \
} else { \
__f.frame.Handler = __wine_exception_handler; \
__f.u.filter = (func); \
if (__wine_setjmpex( &__f.jmp, &__f.frame )) { \
const __WINE_FRAME * const __eptr __attribute__((unused)) = &__f; \
do {
#define __EXCEPT_CTX(func, context) \
} while(0); \
__wine_pop_frame( &__f.frame ); \
break; \
} else { \
__f.frame.Handler = __wine_exception_ctx_handler; \
__f.u.filter_ctx = (func); \
__f.ctx = context; \
if (__wine_setjmpex( &__f.jmp, &__f.frame )) { \
const __WINE_FRAME * const __eptr __attribute__((unused)) = &__f; \
do {
#define __EXCEPT_HANDLER(handler) \
} while(0); \
__wine_pop_frame( &__f.frame ); \
break; \
} else { \
__f.frame.Handler = (handler); \
if (__wine_setjmpex( &__f.jmp, &__f.frame )) { \
const __WINE_FRAME * const __eptr __attribute__((unused)) = &__f; \
do {
#define __EXCEPT_PAGE_FAULT __EXCEPT_HANDLER(__wine_exception_handler_page_fault)
#define __EXCEPT_ALL __EXCEPT_HANDLER(__wine_exception_handler_all)
#define __ENDTRY \
} while (0); \
break; \
} \
__wine_push_frame( &__f.frame ); \
__first = 0; \
} \
} while (0);
#define __FINALLY(func) \
} while(0); \
__wine_pop_frame( &__f.frame ); \
(func)(1); \
break; \
} else { \
__f.frame.Handler = __wine_finally_handler; \
__f.u.finally_func = (func); \
__wine_push_frame( &__f.frame ); \
__first = 0; \
} \
} while (0);
#define __FINALLY_CTX(func, context) \
} while(0); \
__wine_pop_frame( &__f.frame ); \
(func)(1, context); \
break; \
} else { \
__f.frame.Handler = __wine_finally_ctx_handler; \
__f.u.finally_func_ctx = (func); \
__f.ctx = context; \
__wine_push_frame( &__f.frame ); \
__first = 0; \
} \
} while (0);
typedef LONG (CALLBACK *__WINE_FILTER)(PEXCEPTION_POINTERS);
typedef LONG (CALLBACK *__WINE_FILTER_CTX)(PEXCEPTION_POINTERS, void*);
typedef void (CALLBACK *__WINE_FINALLY)(BOOL);
typedef void (CALLBACK *__WINE_FINALLY_CTX)(BOOL, void*);
#define GetExceptionInformation() (__eptr)
#define GetExceptionCode() (__eptr->ExceptionRecord->ExceptionCode)
#define AbnormalTermination() (!__normal)
typedef struct __tagWINE_FRAME
{
EXCEPTION_REGISTRATION_RECORD frame;
union
{
/* exception data */
__WINE_FILTER filter;
__WINE_FILTER_CTX filter_ctx;
/* finally data */
__WINE_FINALLY finally_func;
__WINE_FINALLY_CTX finally_func_ctx;
} u;
void *ctx;
__wine_jmp_buf jmp;
/* hack to make GetExceptionCode() work in handler */
DWORD ExceptionCode;
const struct __tagWINE_FRAME *ExceptionRecord;
} __WINE_FRAME;
#endif /* USE_COMPILER_EXCEPTIONS */
static inline EXCEPTION_REGISTRATION_RECORD *__wine_push_frame( EXCEPTION_REGISTRATION_RECORD *frame )
{
#if (defined(__GNUC__) || defined(__clang__)) && defined(__i386__)
EXCEPTION_REGISTRATION_RECORD *prev;
__asm__ __volatile__("movl %%fs:0,%0"
"\n\tmovl %0,(%1)"
"\n\tmovl %1,%%fs:0"
: "=&r" (prev) : "r" (frame) : "memory" );
return prev;
#else
NT_TIB *teb = (NT_TIB *)NtCurrentTeb();
frame->Prev = teb->ExceptionList;
teb->ExceptionList = frame;
return frame->Prev;
#endif
}
static inline EXCEPTION_REGISTRATION_RECORD *__wine_pop_frame( EXCEPTION_REGISTRATION_RECORD *frame )
{
#if (defined(__GNUC__) || defined(__clang__)) && defined(__i386__)
__asm__ __volatile__("movl %0,%%fs:0"
: : "r" (frame->Prev) : "memory" );
return frame->Prev;
#else
NT_TIB *teb = (NT_TIB *)NtCurrentTeb();
teb->ExceptionList = frame->Prev;
return frame->Prev;
#endif
}
static inline EXCEPTION_REGISTRATION_RECORD *__wine_get_frame(void)
{
#if (defined(__GNUC__) || defined(__clang__)) && defined(__i386__)
EXCEPTION_REGISTRATION_RECORD *ret;
__asm__ __volatile__("movl %%fs:0,%0" : "=r" (ret) );
return ret;
#else
NT_TIB *teb = (NT_TIB *)NtCurrentTeb();
return teb->ExceptionList;
#endif
}
#ifdef __cplusplus
}
#endif
#endif /* __WINE_WINE_EXCEPTION_H */

4845
assets/wine/include/wine/iaccessible2.h
View File

File diff suppressed because it is too large Load Diff

5477
assets/wine/include/wine/iaccessible2.idl
View File

File diff suppressed because it is too large Load Diff

279
assets/wine/include/wine/itss.h
View File

@@ -1,279 +0,0 @@
/*** Autogenerated by WIDL 10.17 from /home/runner/build_wine/wine/include/wine/itss.idl - Do not edit ***/
#ifdef _WIN32
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include <rpc.h>
#include <rpcndr.h>
#endif
#ifndef COM_NO_WINDOWS_H
#include <windows.h>
#include <ole2.h>
#endif
#ifndef __itss_h__
#define __itss_h__
/* Forward declarations */
#ifndef __IITStorage_FWD_DEFINED__
#define __IITStorage_FWD_DEFINED__
typedef interface IITStorage IITStorage;
#ifdef __cplusplus
interface IITStorage;
#endif /* __cplusplus */
#endif
/* Headers for imported files */
#include <oaidl.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _ITS_Control_Data {
UINT cdwControlData;
UINT adwControlData[1];
} ITS_Control_Data;
typedef struct _ITS_Control_Data *PITS_Control_Data;
typedef enum ECompactionLev {
COMPACT_DATA = 0,
COMPACT_DATA_AND_PATH = 1
} ECompactionLev;
/*****************************************************************************
* IITStorage interface
*/
#ifndef __IITStorage_INTERFACE_DEFINED__
#define __IITStorage_INTERFACE_DEFINED__
DEFINE_GUID(IID_IITStorage, 0x88cc31de, 0x27ab, 0x11d0, 0x9d,0xf9, 0x00,0xa0,0xc9,0x22,0xe6,0xec);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("88cc31de-27ab-11d0-9df9-00a0c922e6ec")
IITStorage : public IUnknown
{
virtual HRESULT STDMETHODCALLTYPE StgCreateDocfile(
const WCHAR *pwcsName,
DWORD grfMode,
DWORD reserved,
IStorage **ppstgOpen) = 0;
virtual HRESULT STDMETHODCALLTYPE StgCreateDocfileOnILockBytes(
ILockBytes *plkbyt,
DWORD grfMode,
DWORD reserved,
IStorage **ppstgOpen) = 0;
virtual HRESULT STDMETHODCALLTYPE StgIsStorageFile(
const WCHAR *pwcsName) = 0;
virtual HRESULT STDMETHODCALLTYPE StgIsStorageILockBytes(
ILockBytes *plkbyt) = 0;
virtual HRESULT STDMETHODCALLTYPE StgOpenStorage(
const WCHAR *pwcsName,
IStorage *pstgPriority,
DWORD grfMode,
SNB snbExclude,
DWORD reserved,
IStorage **ppstgOpen) = 0;
virtual HRESULT STDMETHODCALLTYPE StgOpenStorageOnILockBytes(
ILockBytes *plkbyt,
IStorage *pStgPriority,
DWORD grfMode,
SNB snbExclude,
DWORD reserved,
IStorage **ppstgOpen) = 0;
virtual HRESULT STDMETHODCALLTYPE StgSetTimes(
const WCHAR *lpszName,
const FILETIME *pctime,
const FILETIME *patime,
const FILETIME *pmtime) = 0;
virtual HRESULT STDMETHODCALLTYPE SetControlData(
PITS_Control_Data pControlData) = 0;
virtual HRESULT STDMETHODCALLTYPE DefaultControlData(
PITS_Control_Data *ppControlData) = 0;
virtual HRESULT STDMETHODCALLTYPE Compact(
const WCHAR *pwcsName,
ECompactionLev iLev) = 0;
};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IITStorage, 0x88cc31de, 0x27ab, 0x11d0, 0x9d,0xf9, 0x00,0xa0,0xc9,0x22,0xe6,0xec)
#endif
#else
typedef struct IITStorageVtbl {
BEGIN_INTERFACE
/*** IUnknown methods ***/
HRESULT (STDMETHODCALLTYPE *QueryInterface)(
IITStorage *This,
REFIID riid,
void **ppvObject);
ULONG (STDMETHODCALLTYPE *AddRef)(
IITStorage *This);
ULONG (STDMETHODCALLTYPE *Release)(
IITStorage *This);
/*** IITStorage methods ***/
HRESULT (STDMETHODCALLTYPE *StgCreateDocfile)(
IITStorage *This,
const WCHAR *pwcsName,
DWORD grfMode,
DWORD reserved,
IStorage **ppstgOpen);
HRESULT (STDMETHODCALLTYPE *StgCreateDocfileOnILockBytes)(
IITStorage *This,
ILockBytes *plkbyt,
DWORD grfMode,
DWORD reserved,
IStorage **ppstgOpen);
HRESULT (STDMETHODCALLTYPE *StgIsStorageFile)(
IITStorage *This,
const WCHAR *pwcsName);
HRESULT (STDMETHODCALLTYPE *StgIsStorageILockBytes)(
IITStorage *This,
ILockBytes *plkbyt);
HRESULT (STDMETHODCALLTYPE *StgOpenStorage)(
IITStorage *This,
const WCHAR *pwcsName,
IStorage *pstgPriority,
DWORD grfMode,
SNB snbExclude,
DWORD reserved,
IStorage **ppstgOpen);
HRESULT (STDMETHODCALLTYPE *StgOpenStorageOnILockBytes)(
IITStorage *This,
ILockBytes *plkbyt,
IStorage *pStgPriority,
DWORD grfMode,
SNB snbExclude,
DWORD reserved,
IStorage **ppstgOpen);
HRESULT (STDMETHODCALLTYPE *StgSetTimes)(
IITStorage *This,
const WCHAR *lpszName,
const FILETIME *pctime,
const FILETIME *patime,
const FILETIME *pmtime);
HRESULT (STDMETHODCALLTYPE *SetControlData)(
IITStorage *This,
PITS_Control_Data pControlData);
HRESULT (STDMETHODCALLTYPE *DefaultControlData)(
IITStorage *This,
PITS_Control_Data *ppControlData);
HRESULT (STDMETHODCALLTYPE *Compact)(
IITStorage *This,
const WCHAR *pwcsName,
ECompactionLev iLev);
END_INTERFACE
} IITStorageVtbl;
interface IITStorage {
CONST_VTBL IITStorageVtbl* lpVtbl;
};
#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IITStorage_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IITStorage_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IITStorage_Release(This) (This)->lpVtbl->Release(This)
/*** IITStorage methods ***/
#define IITStorage_StgCreateDocfile(This,pwcsName,grfMode,reserved,ppstgOpen) (This)->lpVtbl->StgCreateDocfile(This,pwcsName,grfMode,reserved,ppstgOpen)
#define IITStorage_StgCreateDocfileOnILockBytes(This,plkbyt,grfMode,reserved,ppstgOpen) (This)->lpVtbl->StgCreateDocfileOnILockBytes(This,plkbyt,grfMode,reserved,ppstgOpen)
#define IITStorage_StgIsStorageFile(This,pwcsName) (This)->lpVtbl->StgIsStorageFile(This,pwcsName)
#define IITStorage_StgIsStorageILockBytes(This,plkbyt) (This)->lpVtbl->StgIsStorageILockBytes(This,plkbyt)
#define IITStorage_StgOpenStorage(This,pwcsName,pstgPriority,grfMode,snbExclude,reserved,ppstgOpen) (This)->lpVtbl->StgOpenStorage(This,pwcsName,pstgPriority,grfMode,snbExclude,reserved,ppstgOpen)
#define IITStorage_StgOpenStorageOnILockBytes(This,plkbyt,pStgPriority,grfMode,snbExclude,reserved,ppstgOpen) (This)->lpVtbl->StgOpenStorageOnILockBytes(This,plkbyt,pStgPriority,grfMode,snbExclude,reserved,ppstgOpen)
#define IITStorage_StgSetTimes(This,lpszName,pctime,patime,pmtime) (This)->lpVtbl->StgSetTimes(This,lpszName,pctime,patime,pmtime)
#define IITStorage_SetControlData(This,pControlData) (This)->lpVtbl->SetControlData(This,pControlData)
#define IITStorage_DefaultControlData(This,ppControlData) (This)->lpVtbl->DefaultControlData(This,ppControlData)
#define IITStorage_Compact(This,pwcsName,iLev) (This)->lpVtbl->Compact(This,pwcsName,iLev)
#else
/*** IUnknown methods ***/
static inline HRESULT IITStorage_QueryInterface(IITStorage* This,REFIID riid,void **ppvObject) {
return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static inline ULONG IITStorage_AddRef(IITStorage* This) {
return This->lpVtbl->AddRef(This);
}
static inline ULONG IITStorage_Release(IITStorage* This) {
return This->lpVtbl->Release(This);
}
/*** IITStorage methods ***/
static inline HRESULT IITStorage_StgCreateDocfile(IITStorage* This,const WCHAR *pwcsName,DWORD grfMode,DWORD reserved,IStorage **ppstgOpen) {
return This->lpVtbl->StgCreateDocfile(This,pwcsName,grfMode,reserved,ppstgOpen);
}
static inline HRESULT IITStorage_StgCreateDocfileOnILockBytes(IITStorage* This,ILockBytes *plkbyt,DWORD grfMode,DWORD reserved,IStorage **ppstgOpen) {
return This->lpVtbl->StgCreateDocfileOnILockBytes(This,plkbyt,grfMode,reserved,ppstgOpen);
}
static inline HRESULT IITStorage_StgIsStorageFile(IITStorage* This,const WCHAR *pwcsName) {
return This->lpVtbl->StgIsStorageFile(This,pwcsName);
}
static inline HRESULT IITStorage_StgIsStorageILockBytes(IITStorage* This,ILockBytes *plkbyt) {
return This->lpVtbl->StgIsStorageILockBytes(This,plkbyt);
}
static inline HRESULT IITStorage_StgOpenStorage(IITStorage* This,const WCHAR *pwcsName,IStorage *pstgPriority,DWORD grfMode,SNB snbExclude,DWORD reserved,IStorage **ppstgOpen) {
return This->lpVtbl->StgOpenStorage(This,pwcsName,pstgPriority,grfMode,snbExclude,reserved,ppstgOpen);
}
static inline HRESULT IITStorage_StgOpenStorageOnILockBytes(IITStorage* This,ILockBytes *plkbyt,IStorage *pStgPriority,DWORD grfMode,SNB snbExclude,DWORD reserved,IStorage **ppstgOpen) {
return This->lpVtbl->StgOpenStorageOnILockBytes(This,plkbyt,pStgPriority,grfMode,snbExclude,reserved,ppstgOpen);
}
static inline HRESULT IITStorage_StgSetTimes(IITStorage* This,const WCHAR *lpszName,const FILETIME *pctime,const FILETIME *patime,const FILETIME *pmtime) {
return This->lpVtbl->StgSetTimes(This,lpszName,pctime,patime,pmtime);
}
static inline HRESULT IITStorage_SetControlData(IITStorage* This,PITS_Control_Data pControlData) {
return This->lpVtbl->SetControlData(This,pControlData);
}
static inline HRESULT IITStorage_DefaultControlData(IITStorage* This,PITS_Control_Data *ppControlData) {
return This->lpVtbl->DefaultControlData(This,ppControlData);
}
static inline HRESULT IITStorage_Compact(IITStorage* This,const WCHAR *pwcsName,ECompactionLev iLev) {
return This->lpVtbl->Compact(This,pwcsName,iLev);
}
#endif
#endif
#endif
#endif /* __IITStorage_INTERFACE_DEFINED__ */
DEFINE_GUID(CLSID_ITStorage,0x5d02926a,0x212e,0x11d0,0x9d,0xf9,0x00,0xa0,0xc9,0x22,0xe6,0xec);
DEFINE_GUID(CLSID_MSFSStore,0xd54eee56,0xaaab,0x11d0,0x9e,0x1d,0x00,0xa0,0xc9,0x22,0xe6,0xec);
DEFINE_GUID(CLSID_MSITStore,0x9d148290,0xb9c8,0x11d0,0xa4,0xcc,0x00,0x00,0xf8,0x01,0x49,0xf6);
DEFINE_GUID(CLSID_ITSProtocol,0x9d148291,0xb9c8,0x11d0,0xa4,0xcc,0x00,0x00,0xf8,0x01,0x49,0xf6);
/* Begin additional prototypes for all interfaces */
ULONG __RPC_USER SNB_UserSize (ULONG *, ULONG, SNB *);
unsigned char * __RPC_USER SNB_UserMarshal (ULONG *, unsigned char *, SNB *);
unsigned char * __RPC_USER SNB_UserUnmarshal(ULONG *, unsigned char *, SNB *);
void __RPC_USER SNB_UserFree (ULONG *, SNB *);
/* End additional prototypes */
#ifdef __cplusplus
}
#endif
#endif /* __itss_h__ */

99
assets/wine/include/wine/itss.idl
View File

@@ -1,99 +0,0 @@
/*
* Copyright (C) 2004 Mike McCormack
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#if 0
#pragma makedep header install
#endif
import "oaidl.idl";
typedef struct _ITS_Control_Data
{
UINT cdwControlData;
UINT adwControlData[1];
} ITS_Control_Data, *PITS_Control_Data;
typedef enum ECompactionLev {
COMPACT_DATA = 0,
COMPACT_DATA_AND_PATH
} ECompactionLev;
[
object,
uuid(88cc31de-27ab-11d0-9df9-00a0c922e6ec),
pointer_default(unique)
]
interface IITStorage : IUnknown
{
HRESULT StgCreateDocfile(
[in] const WCHAR * pwcsName,
[in] DWORD grfMode,
[in] DWORD reserved,
[out] IStorage ** ppstgOpen);
HRESULT StgCreateDocfileOnILockBytes(
[in] ILockBytes * plkbyt,
[in] DWORD grfMode,
[in] DWORD reserved,
[out] IStorage ** ppstgOpen);
HRESULT StgIsStorageFile(
[in] const WCHAR * pwcsName);
HRESULT StgIsStorageILockBytes(
[in] ILockBytes * plkbyt);
HRESULT StgOpenStorage(
[in] const WCHAR * pwcsName,
[in] IStorage * pstgPriority,
[in] DWORD grfMode,
[in] SNB snbExclude,
[in] DWORD reserved,
[out] IStorage ** ppstgOpen);
HRESULT StgOpenStorageOnILockBytes(
[in] ILockBytes * plkbyt,
[in] IStorage * pStgPriority,
[in] DWORD grfMode,
[in] SNB snbExclude,
[in] DWORD reserved,
[out] IStorage ** ppstgOpen);
HRESULT StgSetTimes(
[in] WCHAR const * lpszName,
[in] FILETIME const * pctime,
[in] FILETIME const * patime,
[in] FILETIME const * pmtime);
HRESULT SetControlData(
[in] PITS_Control_Data pControlData);
HRESULT DefaultControlData(
[out] PITS_Control_Data * ppControlData);
HRESULT Compact(
[in] const WCHAR * pwcsName,
[in] ECompactionLev iLev);
}
cpp_quote("DEFINE_GUID(CLSID_ITStorage,0x5d02926a,0x212e,0x11d0,0x9d,0xf9,0x00,0xa0,0xc9,0x22,0xe6,0xec);")
cpp_quote("DEFINE_GUID(CLSID_MSFSStore,0xd54eee56,0xaaab,0x11d0,0x9e,0x1d,0x00,0xa0,0xc9,0x22,0xe6,0xec);")
cpp_quote("DEFINE_GUID(CLSID_MSITStore,0x9d148290,0xb9c8,0x11d0,0xa4,0xcc,0x00,0x00,0xf8,0x01,0x49,0xf6);")
cpp_quote("DEFINE_GUID(CLSID_ITSProtocol,0x9d148291,0xb9c8,0x11d0,0xa4,0xcc,0x00,0x00,0xf8,0x01,0x49,0xf6);")

174
assets/wine/include/wine/mfinternal.h
View File

@@ -1,174 +0,0 @@
/*** Autogenerated by WIDL 10.17 from /home/runner/build_wine/wine/include/wine/mfinternal.idl - Do not edit ***/
#ifdef _WIN32
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include <rpc.h>
#include <rpcndr.h>
#endif
#ifndef COM_NO_WINDOWS_H
#include <windows.h>
#include <ole2.h>
#endif
#ifndef __mfinternal_h__
#define __mfinternal_h__
/* Forward declarations */
#ifndef __IMFSinkClassFactory_FWD_DEFINED__
#define __IMFSinkClassFactory_FWD_DEFINED__
typedef interface IMFSinkClassFactory IMFSinkClassFactory;
#ifdef __cplusplus
interface IMFSinkClassFactory;
#endif /* __cplusplus */
#endif
/* Headers for imported files */
#include <unknwn.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __IMFByteStream_FWD_DEFINED__
#define __IMFByteStream_FWD_DEFINED__
typedef interface IMFByteStream IMFByteStream;
#ifdef __cplusplus
interface IMFByteStream;
#endif /* __cplusplus */
#endif
#ifndef __IMFMediaSink_FWD_DEFINED__
#define __IMFMediaSink_FWD_DEFINED__
typedef interface IMFMediaSink IMFMediaSink;
#ifdef __cplusplus
interface IMFMediaSink;
#endif /* __cplusplus */
#endif
#ifndef __IMFMediaType_FWD_DEFINED__
#define __IMFMediaType_FWD_DEFINED__
typedef interface IMFMediaType IMFMediaType;
#ifdef __cplusplus
interface IMFMediaType;
#endif /* __cplusplus */
#endif
#ifndef __IMFAsyncCallback_FWD_DEFINED__
#define __IMFAsyncCallback_FWD_DEFINED__
typedef interface IMFAsyncCallback IMFAsyncCallback;
#ifdef __cplusplus
interface IMFAsyncCallback;
#endif /* __cplusplus */
#endif
/*****************************************************************************
* IMFSinkClassFactory interface
*/
#ifndef __IMFSinkClassFactory_INTERFACE_DEFINED__
#define __IMFSinkClassFactory_INTERFACE_DEFINED__
DEFINE_GUID(IID_IMFSinkClassFactory, 0x37aa1c3b, 0x620f, 0x477e, 0xbe,0xf9, 0xac,0x4a,0xa8,0x5b,0xe9,0x5d);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("37aa1c3b-620f-477e-bef9-ac4aa85be95d")
IMFSinkClassFactory : public IUnknown
{
virtual HRESULT STDMETHODCALLTYPE CreateMediaSink(
IMFByteStream *stream,
IMFMediaType *video_type,
IMFMediaType *audio_type,
IMFMediaSink **sink) = 0;
};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFSinkClassFactory, 0x37aa1c3b, 0x620f, 0x477e, 0xbe,0xf9, 0xac,0x4a,0xa8,0x5b,0xe9,0x5d)
#endif
#else
typedef struct IMFSinkClassFactoryVtbl {
BEGIN_INTERFACE
/*** IUnknown methods ***/
HRESULT (STDMETHODCALLTYPE *QueryInterface)(
IMFSinkClassFactory *This,
REFIID riid,
void **ppvObject);
ULONG (STDMETHODCALLTYPE *AddRef)(
IMFSinkClassFactory *This);
ULONG (STDMETHODCALLTYPE *Release)(
IMFSinkClassFactory *This);
/*** IMFSinkClassFactory methods ***/
HRESULT (STDMETHODCALLTYPE *CreateMediaSink)(
IMFSinkClassFactory *This,
IMFByteStream *stream,
IMFMediaType *video_type,
IMFMediaType *audio_type,
IMFMediaSink **sink);
END_INTERFACE
} IMFSinkClassFactoryVtbl;
interface IMFSinkClassFactory {
CONST_VTBL IMFSinkClassFactoryVtbl* lpVtbl;
};
#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFSinkClassFactory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFSinkClassFactory_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFSinkClassFactory_Release(This) (This)->lpVtbl->Release(This)
/*** IMFSinkClassFactory methods ***/
#define IMFSinkClassFactory_CreateMediaSink(This,stream,video_type,audio_type,sink) (This)->lpVtbl->CreateMediaSink(This,stream,video_type,audio_type,sink)
#else
/*** IUnknown methods ***/
static inline HRESULT IMFSinkClassFactory_QueryInterface(IMFSinkClassFactory* This,REFIID riid,void **ppvObject) {
return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static inline ULONG IMFSinkClassFactory_AddRef(IMFSinkClassFactory* This) {
return This->lpVtbl->AddRef(This);
}
static inline ULONG IMFSinkClassFactory_Release(IMFSinkClassFactory* This) {
return This->lpVtbl->Release(This);
}
/*** IMFSinkClassFactory methods ***/
static inline HRESULT IMFSinkClassFactory_CreateMediaSink(IMFSinkClassFactory* This,IMFByteStream *stream,IMFMediaType *video_type,IMFMediaType *audio_type,IMFMediaSink **sink) {
return This->lpVtbl->CreateMediaSink(This,stream,video_type,audio_type,sink);
}
#endif
#endif
#endif
#endif /* __IMFSinkClassFactory_INTERFACE_DEFINED__ */
DEFINE_GUID(CLSID_MF3GPSinkClassFactory, 0xe54cdfaf, 0x2381, 0x4cad, 0xab, 0x99, 0xf3, 0x85, 0x17, 0x12, 0x7d, 0x5c);
DEFINE_GUID(CLSID_MFAC3SinkClassFactory, 0x255a6fda, 0x6f93, 0x4e8a, 0x96, 0x11, 0xde, 0xd1, 0x16, 0x9e, 0xef, 0xb4);
DEFINE_GUID(CLSID_MFADTSSinkClassFactory, 0xd7ca55ab, 0x5022, 0x4db3, 0xa5, 0x99, 0xab, 0xaf, 0xa3, 0x58, 0xe6, 0xf3);
DEFINE_GUID(CLSID_MFAVISinkClassFactory, 0xaf4b1274, 0xb78a, 0x4979, 0xae, 0xf5, 0x20, 0xe7, 0x8f, 0xee, 0x10, 0x2e);
DEFINE_GUID(CLSID_MFFMPEG4SinkClassFactory, 0x60f9f51e, 0x4613, 0x4b35, 0xae, 0x88, 0x33, 0x25, 0x42, 0xb5, 0x67, 0xb8);
DEFINE_GUID(CLSID_MFMP3SinkClassFactory, 0x11275a82, 0x5e5a, 0x47fd, 0xa0, 0x1c, 0x36, 0x83, 0xc1, 0x2f, 0xb1, 0x96);
DEFINE_GUID(CLSID_MFMPEG4SinkClassFactory, 0xa22c4fc7, 0x6e91, 0x4e1d, 0x89, 0xe9, 0x53, 0xb2, 0x66, 0x7b, 0x72, 0xba);
DEFINE_GUID(CLSID_MFWAVESinkClassFactory, 0x36f99745, 0x23c9, 0x4c9c, 0x8d, 0xd5, 0xcc, 0x31, 0xce, 0x96, 0x43, 0x90);
DEFINE_GUID(CLSID_AsfByteStreamPlugin, 0x41457294, 0x644c, 0x4298, 0xa2, 0x8a, 0xbd, 0x69, 0xf2, 0xc0, 0xcf, 0x3b);
DEFINE_GUID(CLSID_AVIByteStreamPlugin, 0x7afa253e, 0xf823, 0x42f6, 0xa5, 0xd9, 0x71, 0x4b, 0xde, 0x46, 0x74, 0x12);
DEFINE_GUID(CLSID_MPEG4ByteStreamHandlerPlugin, 0x271c3902, 0x6095, 0x4c45, 0xa2, 0x2f, 0x20, 0x09, 0x18, 0x16, 0xee, 0x9e);
DEFINE_GUID(CLSID_WAVByteStreamPlugin, 0x42c9b9f5, 0x16fc, 0x47ef, 0xaf, 0x22, 0xda, 0x05, 0xf7, 0xc8, 0x42, 0xe3);
DEFINE_GUID(CLSID_MP3ByteStreamPlugin, 0xa82e50ba, 0x8e92, 0x41eb, 0x9d, 0xf2, 0x43, 0x3f, 0x50, 0xec, 0x29, 0x93);
/* Begin additional prototypes for all interfaces */
/* End additional prototypes */
#ifdef __cplusplus
}
#endif
#endif /* __mfinternal_h__ */

61
assets/wine/include/wine/mfinternal.idl
View File

@@ -1,61 +0,0 @@
/*
* Copyright 2022 Nikolay Sivov for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#if 0
#pragma makedep header install
#endif
import "unknwn.idl";
interface IMFByteStream;
interface IMFMediaSink;
interface IMFMediaType;
interface IMFAsyncCallback;
/* Internal interface used to instantiate registered sinks. It should be compatible,
except for used method names. */
[
uuid(37aa1c3b-620f-477e-bef9-ac4aa85be95d),
object,
local
]
interface IMFSinkClassFactory : IUnknown
{
HRESULT CreateMediaSink(
[in] IMFByteStream *stream,
[in] IMFMediaType *video_type,
[in] IMFMediaType *audio_type,
[out] IMFMediaSink **sink
);
}
cpp_quote("DEFINE_GUID(CLSID_MF3GPSinkClassFactory, 0xe54cdfaf, 0x2381, 0x4cad, 0xab, 0x99, 0xf3, 0x85, 0x17, 0x12, 0x7d, 0x5c);")
cpp_quote("DEFINE_GUID(CLSID_MFAC3SinkClassFactory, 0x255a6fda, 0x6f93, 0x4e8a, 0x96, 0x11, 0xde, 0xd1, 0x16, 0x9e, 0xef, 0xb4);")
cpp_quote("DEFINE_GUID(CLSID_MFADTSSinkClassFactory, 0xd7ca55ab, 0x5022, 0x4db3, 0xa5, 0x99, 0xab, 0xaf, 0xa3, 0x58, 0xe6, 0xf3);")
cpp_quote("DEFINE_GUID(CLSID_MFAVISinkClassFactory, 0xaf4b1274, 0xb78a, 0x4979, 0xae, 0xf5, 0x20, 0xe7, 0x8f, 0xee, 0x10, 0x2e);")
cpp_quote("DEFINE_GUID(CLSID_MFFMPEG4SinkClassFactory, 0x60f9f51e, 0x4613, 0x4b35, 0xae, 0x88, 0x33, 0x25, 0x42, 0xb5, 0x67, 0xb8);")
cpp_quote("DEFINE_GUID(CLSID_MFMP3SinkClassFactory, 0x11275a82, 0x5e5a, 0x47fd, 0xa0, 0x1c, 0x36, 0x83, 0xc1, 0x2f, 0xb1, 0x96);")
cpp_quote("DEFINE_GUID(CLSID_MFMPEG4SinkClassFactory, 0xa22c4fc7, 0x6e91, 0x4e1d, 0x89, 0xe9, 0x53, 0xb2, 0x66, 0x7b, 0x72, 0xba);")
cpp_quote("DEFINE_GUID(CLSID_MFWAVESinkClassFactory, 0x36f99745, 0x23c9, 0x4c9c, 0x8d, 0xd5, 0xcc, 0x31, 0xce, 0x96, 0x43, 0x90);")
cpp_quote("DEFINE_GUID(CLSID_AsfByteStreamPlugin, 0x41457294, 0x644c, 0x4298, 0xa2, 0x8a, 0xbd, 0x69, 0xf2, 0xc0, 0xcf, 0x3b);")
cpp_quote("DEFINE_GUID(CLSID_AVIByteStreamPlugin, 0x7afa253e, 0xf823, 0x42f6, 0xa5, 0xd9, 0x71, 0x4b, 0xde, 0x46, 0x74, 0x12);")
cpp_quote("DEFINE_GUID(CLSID_MPEG4ByteStreamHandlerPlugin, 0x271c3902, 0x6095, 0x4c45, 0xa2, 0x2f, 0x20, 0x09, 0x18, 0x16, 0xee, 0x9e);")
cpp_quote("DEFINE_GUID(CLSID_WAVByteStreamPlugin, 0x42c9b9f5, 0x16fc, 0x47ef, 0xaf, 0x22, 0xda, 0x05, 0xf7, 0xc8, 0x42, 0xe3);")
cpp_quote("DEFINE_GUID(CLSID_MP3ByteStreamPlugin, 0xa82e50ba, 0x8e92, 0x41eb, 0x9d, 0xf2, 0x43, 0x3f, 0x50, 0xec, 0x29, 0x93);")

37
assets/wine/include/wine/msvcrt/assert.h
View File

@@ -1,37 +0,0 @@
/*
* Assert support
*
* Copyright 2011 Alexandre Julliard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <corecrt.h>
#ifdef __cplusplus
extern "C" {
#endif
#undef assert
#ifdef NDEBUG
#define assert(_expr) ((void)0)
#else
_ACRTIMP DECLSPEC_NORETURN void __cdecl _assert(const char *, const char *, unsigned int);
#define assert(_expr) (void)((!!(_expr)) || (_assert(#_expr, __FILE__, __LINE__), 0))
#endif
#ifdef __cplusplus
}
#endif

58
assets/wine/include/wine/msvcrt/complex.h
View File

@@ -1,58 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
*/
#ifndef _COMPLEX_H_DEFINED
#define _COMPLEX_H_DEFINED
#include <corecrt.h>
#ifndef _C_COMPLEX_T
#define _C_COMPLEX_T
typedef struct _C_double_complex
{
double _Val[2];
} _C_double_complex;
typedef struct _C_float_complex
{
float _Val[2];
} _C_float_complex;
#endif
typedef _C_double_complex _Dcomplex;
typedef _C_float_complex _Fcomplex;
_ACRTIMP _Dcomplex __cdecl _Cbuild(double, double);
_ACRTIMP _Dcomplex __cdecl cexp(_Dcomplex);
_ACRTIMP double __cdecl carg(_Dcomplex);
_ACRTIMP double __cdecl cimag(_Dcomplex);
_ACRTIMP double __cdecl creal(_Dcomplex);
#if defined(__i386__) && !defined(__MINGW32__) && !defined(_MSC_VER)
/* Note: this should return a _Fcomplex, but calling convention for returning
* structures is different between Windows and gcc on i386. */
_ACRTIMP unsigned __int64 __cdecl _FCbuild(float, float);
static inline _Fcomplex __cdecl __wine__FCbuild(float r, float i)
{
union {
_Fcomplex c;
unsigned __int64 ull;
} u;
u.ull = _FCbuild(r, i);
return u.c;
}
#define _FCbuild(r, i) __wine__FCbuild(r, i)
#else
_ACRTIMP _Fcomplex __cdecl _FCbuild(float, float);
#endif
_ACRTIMP float __cdecl cargf(_Fcomplex);
_ACRTIMP float __cdecl cimagf(_Fcomplex);
_ACRTIMP float __cdecl crealf(_Fcomplex);
#endif /* _COMPLEX_H_DEFINED */

63
assets/wine/include/wine/msvcrt/conio.h
View File

@@ -1,63 +0,0 @@
/*
* Console I/O definitions
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Jon Griffiths and Francois Gouget.
* This file is in the public domain.
*/
#ifndef __WINE_CONIO_H
#define __WINE_CONIO_H
#include <corecrt.h>
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP char* __cdecl _cgets(char*);
_ACRTIMP int __cdecl _cprintf(const char*,...);
_ACRTIMP int __cdecl _cputs(const char*);
_ACRTIMP int __cdecl _cscanf(const char*,...);
_ACRTIMP int __cdecl _getch(void);
_ACRTIMP int __cdecl _getche(void);
_ACRTIMP int __cdecl _kbhit(void);
_ACRTIMP int __cdecl _putch(int);
_ACRTIMP int __cdecl _ungetch(int);
#ifdef _M_IX86
_ACRTIMP int __cdecl _inp(unsigned short);
_ACRTIMP __msvcrt_ulong __cdecl _inpd(unsigned short);
_ACRTIMP unsigned short __cdecl _inpw(unsigned short);
_ACRTIMP int __cdecl _outp(unsigned short, int);
_ACRTIMP __msvcrt_ulong __cdecl _outpd(unsigned short, __msvcrt_ulong);
_ACRTIMP unsigned short __cdecl _outpw(unsigned short, unsigned short);
#endif
#ifdef __cplusplus
}
#endif
static inline char* cgets(char* str) { return _cgets(str); }
static inline int cputs(const char* str) { return _cputs(str); }
static inline int getch(void) { return _getch(); }
static inline int getche(void) { return _getche(); }
static inline int kbhit(void) { return _kbhit(); }
static inline int putch(int c) { return _putch(c); }
static inline int ungetch(int c) { return _ungetch(c); }
#ifdef _M_IX86
static inline int inp(unsigned short i) { return _inp(i); }
static inline unsigned short inpw(unsigned short i) { return _inpw(i); }
static inline int outp(unsigned short i, int j) { return _outp(i, j); }
static inline unsigned short outpw(unsigned short i, unsigned short j) { return _outpw(i, j); }
#endif
#if defined(__GNUC__) && (__GNUC__ < 4)
_ACRTIMP int __cdecl cprintf(const char*,...) __attribute__((alias("_cprintf"),format(printf,1,2)));
_ACRTIMP int __cdecl cscanf(const char*,...) __attribute__((alias("_cscanf"),format(scanf,1,2)));
#else
#define cprintf _cprintf
#define cscanf _cscanf
#endif /* __GNUC__ */
#endif /* __WINE_CONIO_H */

354
assets/wine/include/wine/msvcrt/corecrt.h
View File

@@ -1,354 +0,0 @@
/*
* CRT definitions
*
* Copyright 2000 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_CORECRT_H
#define __WINE_CORECRT_H
#ifndef __WINE_USE_MSVCRT
#define __WINE_USE_MSVCRT
#endif
#ifdef __WINE_CONFIG_H
# error You cannot use config.h with msvcrt
#endif
#ifdef WINE_UNIX_LIB
# error msvcrt headers cannot be used in Unix code
#endif
#ifndef _WIN32
# define _WIN32
#endif
#ifndef WIN32
# define WIN32
#endif
#if (defined(__x86_64__) || defined(__powerpc64__) || defined(__aarch64__)) && !defined(_WIN64)
#define _WIN64
#endif
#ifndef _MSVCR_VER
# define _MSVCR_VER 140
#endif
#if !defined(_UCRT) && _MSVCR_VER >= 140
# define _UCRT
#endif
#include <sal.h>
#ifndef _MSC_VER
# ifndef __int8
# define __int8 char
# endif
# ifndef __int16
# define __int16 short
# endif
# ifndef __int32
# define __int32 int
# endif
# ifndef __int64
# if defined(_WIN64) && !defined(__MINGW64__)
# define __int64 long
# else
# define __int64 long long
# endif
# endif
#endif
#ifndef NULL
#ifdef __cplusplus
#ifndef _WIN64
#define NULL 0
#else
#define NULL 0LL
#endif
#else
#define NULL ((void *)0)
#endif
#endif
#ifndef __has_attribute
#define __has_attribute(x) 0
#endif
#ifndef __has_declspec_attribute
# if defined(_MSC_VER)
# define __has_declspec_attribute(x) 1
# else
# define __has_declspec_attribute(x) 0
# endif
#endif
#if !defined(_MSC_VER) && !defined(__MINGW32__)
# undef __stdcall
# undef __cdecl
# if defined(__i386__) && defined(__GNUC__)
# if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 2)) || defined(__APPLE__)
# define __stdcall __attribute__((__stdcall__)) __attribute__((__force_align_arg_pointer__))
# define __cdecl __attribute__((__cdecl__)) __attribute__((__force_align_arg_pointer__))
# else
# define __stdcall __attribute__((__stdcall__))
# define __cdecl __attribute__((__cdecl__))
# endif
# elif defined(__x86_64__) && defined(__GNUC__)
# if __has_attribute(__force_align_arg_pointer__)
# define __stdcall __attribute__((ms_abi)) __attribute__((__force_align_arg_pointer__))
# else
# define __stdcall __attribute__((ms_abi))
# endif
# define __cdecl __stdcall
# else
# define __stdcall
# define __cdecl
# endif
#endif /* _MSC_VER || __MINGW32__ */
#ifndef DECLSPEC_NORETURN
# ifdef __GNUC__
# define DECLSPEC_NORETURN __attribute__((noreturn))
# elif __has_declspec_attribute(noreturn) && !defined(MIDL_PASS)
# define DECLSPEC_NORETURN __declspec(noreturn)
# else
# define DECLSPEC_NORETURN
# endif
#endif
#ifndef DECLSPEC_ALIGN
# ifdef __GNUC__
# define DECLSPEC_ALIGN(x) __attribute__((aligned(x)))
# elif __has_declspec_attribute(align) && !defined(MIDL_PASS)
# define DECLSPEC_ALIGN(x) __declspec(align(x))
# else
# define DECLSPEC_ALIGN(x)
# endif
#endif
#ifndef _ACRTIMP
# ifdef _CRTIMP
# define _ACRTIMP _CRTIMP
# elif __has_declspec_attribute(dllimport)
# define _ACRTIMP __declspec(dllimport)
# elif defined(__MINGW32__) || defined(__CYGWIN__)
# define _ACRTIMP __attribute__((dllimport))
# else
# define _ACRTIMP
# endif
#endif
#define _ARGMAX 100
#define _CRT_INT_MAX 0x7fffffff
#ifndef _MSVCRT_LONG_DEFINED
#define _MSVCRT_LONG_DEFINED
/* we need 32-bit longs even on 64-bit */
#ifdef __LP64__
typedef int __msvcrt_long;
typedef unsigned int __msvcrt_ulong;
#else
typedef long __msvcrt_long;
typedef unsigned long __msvcrt_ulong;
#endif
#endif
#ifndef _INTPTR_T_DEFINED
#ifdef _WIN64
typedef __int64 intptr_t;
#else
typedef int intptr_t;
#endif
#define _INTPTR_T_DEFINED
#endif
#ifndef _UINTPTR_T_DEFINED
#ifdef _WIN64
typedef unsigned __int64 uintptr_t;
#else
typedef unsigned int uintptr_t;
#endif
#define _UINTPTR_T_DEFINED
#endif
#ifndef _PTRDIFF_T_DEFINED
#ifdef _WIN64
typedef __int64 ptrdiff_t;
#else
typedef int ptrdiff_t;
#endif
#define _PTRDIFF_T_DEFINED
#endif
#ifndef _SIZE_T_DEFINED
#ifdef _WIN64
typedef unsigned __int64 size_t;
#else
typedef unsigned int size_t;
#endif
#define _SIZE_T_DEFINED
#endif
typedef size_t rsize_t;
#ifndef _TIME32_T_DEFINED
typedef __msvcrt_long __time32_t;
#define _TIME32_T_DEFINED
#endif
#ifndef _TIME64_T_DEFINED
typedef __int64 DECLSPEC_ALIGN(8) __time64_t;
#define _TIME64_T_DEFINED
#endif
#ifdef _USE_32BIT_TIME_T
# ifdef _WIN64
# error You cannot use 32-bit time_t in Win64
# endif
#elif !defined(_WIN64)
# define _USE_32BIT_TIME_T
#endif
#ifndef _TIME_T_DEFINED
#ifdef _USE_32BIT_TIME_T
typedef __time32_t time_t;
#else
typedef __time64_t time_t;
#endif
#define _TIME_T_DEFINED
#endif
#ifndef _WCHAR_T_DEFINED
#ifndef __cplusplus
typedef unsigned short wchar_t;
#endif
#define _WCHAR_T_DEFINED
#endif
#ifndef _WCTYPE_T_DEFINED
typedef unsigned short wint_t;
typedef unsigned short wctype_t;
#define _WCTYPE_T_DEFINED
#endif
#ifndef _ERRNO_T_DEFINED
typedef int errno_t;
#define _ERRNO_T_DEFINED
#endif
#ifndef _CONST_RETURN
# ifdef __cplusplus
# define _CONST_RETURN const
# define _CRT_CONST_CORRECT_OVERLOADS
# else
# define _CONST_RETURN
# endif
#endif
struct threadlocaleinfostruct;
struct threadmbcinfostruct;
typedef struct threadlocaleinfostruct *pthreadlocinfo;
typedef struct threadmbcinfostruct *pthreadmbcinfo;
typedef struct localeinfo_struct
{
pthreadlocinfo locinfo;
pthreadmbcinfo mbcinfo;
} _locale_tstruct, *_locale_t;
#ifndef _TAGLC_ID_DEFINED
typedef struct tagLC_ID {
unsigned short wLanguage;
unsigned short wCountry;
unsigned short wCodePage;
} LC_ID, *LPLC_ID;
#define _TAGLC_ID_DEFINED
#endif
#ifndef _THREADLOCALEINFO
typedef struct threadlocaleinfostruct {
#if _MSVCR_VER >= 140
unsigned short *pctype;
int mb_cur_max;
unsigned int lc_codepage;
#endif
int refcount;
#if _MSVCR_VER < 140
unsigned int lc_codepage;
#endif
unsigned int lc_collate_cp;
__msvcrt_ulong lc_handle[6];
LC_ID lc_id[6];
struct {
char *locale;
wchar_t *wlocale;
int *refcount;
int *wrefcount;
} lc_category[6];
int lc_clike;
#if _MSVCR_VER < 140
int mb_cur_max;
#endif
int *lconv_intl_refcount;
int *lconv_num_refcount;
int *lconv_mon_refcount;
struct lconv *lconv;
int *ctype1_refcount;
unsigned short *ctype1;
#if _MSVCR_VER < 140
unsigned short *pctype;
#endif
const unsigned char *pclmap;
const unsigned char *pcumap;
struct __lc_time_data *lc_time_curr;
#if _MSVCR_VER >= 110
wchar_t *lc_name[6];
#endif
} threadlocinfo;
#define _THREADLOCALEINFO
#endif
#if defined(__MINGW32__) || (defined(_MSC_VER) && defined(__clang__))
#define __WINE_CRT_PRINTF_ATTR(fmt,args) __attribute__((format (printf,fmt,args)))
#define __WINE_CRT_SCANF_ATTR(fmt,args) __attribute__((format (scanf,fmt,args)))
#else
#define __WINE_CRT_PRINTF_ATTR(fmt,args)
#define __WINE_CRT_SCANF_ATTR(fmt,args)
#endif
#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)))
#define __WINE_ALLOC_SIZE(...) __attribute__((__alloc_size__(__VA_ARGS__)))
#else
#define __WINE_ALLOC_SIZE(...)
#endif
#if defined(__GNUC__) && (__GNUC__ > 10)
#define __WINE_DEALLOC(...) __attribute__((malloc (__VA_ARGS__)))
#else
#define __WINE_DEALLOC(...)
#endif
#if defined(__GNUC__) && (__GNUC__ > 2)
#define __WINE_MALLOC __attribute__((malloc))
#else
#define __WINE_MALLOC
#endif
#endif /* __WINE_CORECRT_H */

155
assets/wine/include/wine/msvcrt/corecrt_io.h
View File

@@ -1,155 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
*/
#ifndef _IO_DEFINED
#define _IO_DEFINED
#include <corecrt_wio.h>
#pragma pack(push,8)
#if defined(_USE_32BIT_TIME_T)
# define _finddata_t _finddata32_t
# define _finddatai64_t _finddata32i64_t
#else
# define _finddata_t _finddata64i32_t
# define _finddatai64_t _finddata64_t
#endif
struct _finddata32_t {
unsigned attrib;
__time32_t time_create;
__time32_t time_access;
__time32_t time_write;
_fsize_t size;
char name[260];
};
struct _finddata32i64_t {
unsigned attrib;
__time32_t time_create;
__time32_t time_access;
__time32_t time_write;
__int64 DECLSPEC_ALIGN(8) size;
char name[260];
};
struct _finddata64i32_t {
unsigned attrib;
__time64_t time_create;
__time64_t time_access;
__time64_t time_write;
_fsize_t size;
char name[260];
};
struct _finddata64_t {
unsigned attrib;
__time64_t time_create;
__time64_t time_access;
__time64_t time_write;
__int64 DECLSPEC_ALIGN(8) size;
char name[260];
};
/* The following are also defined in dos.h */
#define _A_NORMAL 0x00000000
#define _A_RDONLY 0x00000001
#define _A_HIDDEN 0x00000002
#define _A_SYSTEM 0x00000004
#define _A_VOLID 0x00000008
#define _A_SUBDIR 0x00000010
#define _A_ARCH 0x00000020
#ifdef _UCRT
# ifdef _USE_32BIT_TIME_T
# define _findfirst _findfirst32
# define _findfirsti64 _findfirst32i64
# define _findnext _findnext32
# define _findnexti64 _findnext32i64
# else
# define _findfirst _findfirst64i32
# define _findfirsti64 _findfirst64
# define _findnext _findnext64i32
# define _findnexti64 _findnext64
# endif
#else /* _UCRT */
# ifdef _USE_32BIT_TIME_T
# define _findfirst32 _findfirst
# define _findfirst32i64 _findfirsti64
# define _findnext32 _findnext
# define _findnext32i64 _findnexti64
# else
# define _findfirst64i32 _findfirst
# define _findfirst64 _findfirsti64
# define _findnext64i32 _findnext
# define _findnext64 _findnexti64
# endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP int __cdecl _access(const char*,int);
_ACRTIMP errno_t __cdecl _access_s(const char*,int);
_ACRTIMP int __cdecl _chmod(const char*,int);
_ACRTIMP int __cdecl _chsize(int,__msvcrt_long);
_ACRTIMP int __cdecl _chsize_s(int,__int64);
_ACRTIMP int __cdecl _close(int);
_ACRTIMP int __cdecl _creat(const char*,int);
_ACRTIMP int __cdecl _dup(int);
_ACRTIMP int __cdecl _dup2(int,int);
_ACRTIMP int __cdecl _eof(int);
_ACRTIMP __int64 __cdecl _filelengthi64(int);
_ACRTIMP __msvcrt_long __cdecl _filelength(int);
_ACRTIMP int __cdecl _findclose(intptr_t);
#ifdef _UCRT
_ACRTIMP intptr_t __cdecl _findfirst32(const char*,struct _finddata32_t*);
_ACRTIMP intptr_t __cdecl _findfirst32i64(const char*, struct _finddata32i64_t*);
_ACRTIMP intptr_t __cdecl _findfirst64(const char*,struct _finddata64_t*);
_ACRTIMP intptr_t __cdecl _findfirst64i32(const char*, struct _finddata64i32_t*);
_ACRTIMP int __cdecl _findnext32(intptr_t,struct _finddata32_t*);
_ACRTIMP int __cdecl _findnext32i64(intptr_t,struct _finddata32i64_t*);
_ACRTIMP int __cdecl _findnext64(intptr_t,struct _finddata64_t*);
_ACRTIMP int __cdecl _findnext64i32(intptr_t,struct _finddata64i32_t*);
#else
_ACRTIMP intptr_t __cdecl _findfirst(const char*,struct _finddata_t*);
_ACRTIMP intptr_t __cdecl _findfirsti64(const char*, struct _finddatai64_t*);
_ACRTIMP intptr_t __cdecl _findfirst64(const char*, struct _finddata64_t*);
_ACRTIMP int __cdecl _findnext(intptr_t,struct _finddata_t*);
_ACRTIMP int __cdecl _findnexti64(intptr_t, struct _finddatai64_t*);
_ACRTIMP int __cdecl _findnext64(intptr_t, struct _finddata64_t*);
#endif
_ACRTIMP intptr_t __cdecl _get_osfhandle(int);
_ACRTIMP int __cdecl _isatty(int);
_ACRTIMP int __cdecl _locking(int,int,__msvcrt_long);
_ACRTIMP __msvcrt_long __cdecl _lseek(int,__msvcrt_long,int);
_ACRTIMP __int64 __cdecl _lseeki64(int,__int64,int);
_ACRTIMP char* __cdecl _mktemp(char*);
_ACRTIMP int __cdecl _mktemp_s(char*,size_t);
_ACRTIMP int __cdecl _open(const char*,int,...);
_ACRTIMP int __cdecl _open_osfhandle(intptr_t,int);
_ACRTIMP int __cdecl _pipe(int*,unsigned int,int);
_ACRTIMP int __cdecl _read(int,void*,unsigned int);
_ACRTIMP int __cdecl _setmode(int,int);
_ACRTIMP int __cdecl _sopen(const char*,int,int,...);
_ACRTIMP errno_t __cdecl _sopen_dispatch(const char*,int,int,int,int*,int);
_ACRTIMP errno_t __cdecl _sopen_s(int*,const char*,int,int,int);
_ACRTIMP __msvcrt_long __cdecl _tell(int);
_ACRTIMP __int64 __cdecl _telli64(int);
_ACRTIMP int __cdecl _umask(int);
_ACRTIMP int __cdecl _unlink(const char*);
_ACRTIMP int __cdecl _write(int,const void*,unsigned int);
_ACRTIMP int __cdecl remove(const char*);
_ACRTIMP int __cdecl rename(const char*,const char*);
#ifdef __cplusplus
}
#endif
#pragma pack(pop)
#endif /* _IO_DEFINED */

50
assets/wine/include/wine/msvcrt/corecrt_malloc.h
View File

@@ -1,50 +0,0 @@
/*
* Heap definitions
*
* Copyright 2001 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_CORECRT_MALLOC_H
#define __WINE_CORECRT_MALLOC_H
#include <corecrt.h>
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP void* __cdecl calloc(size_t,size_t);
_ACRTIMP void __cdecl free(void*);
_ACRTIMP void* __cdecl malloc(size_t);
_ACRTIMP void* __cdecl realloc(void*,size_t);
_ACRTIMP void* __cdecl _recalloc(void*,size_t,size_t) __WINE_ALLOC_SIZE(2,3) __WINE_DEALLOC(free);
_ACRTIMP int __cdecl _callnewh(size_t);
_ACRTIMP void* __cdecl _expand(void*,size_t);
_ACRTIMP size_t __cdecl _msize(void*);
_ACRTIMP void __cdecl _aligned_free(void*);
_ACRTIMP void* __cdecl _aligned_malloc(size_t,size_t) __WINE_ALLOC_SIZE(1) __WINE_DEALLOC(_aligned_free) __WINE_MALLOC;
_ACRTIMP size_t __cdecl _aligned_msize(void*,size_t,size_t);
_ACRTIMP void* __cdecl _aligned_offset_malloc(size_t,size_t,size_t) __WINE_ALLOC_SIZE(1) __WINE_DEALLOC(_aligned_free) __WINE_MALLOC;
_ACRTIMP void* __cdecl _aligned_realloc(void*,size_t,size_t) __WINE_ALLOC_SIZE(2) __WINE_DEALLOC(_aligned_free);
_ACRTIMP void* __cdecl _aligned_offset_realloc(void*,size_t,size_t,size_t) __WINE_ALLOC_SIZE(2) __WINE_DEALLOC(_aligned_free);
#ifdef __cplusplus
}
#endif
#endif /* __WINE_CORECRT_MALLOC_H */

75
assets/wine/include/wine/msvcrt/corecrt_startup.h
View File

@@ -1,75 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
*/
#ifndef _INC_CORECRT_STARTUP
#define _INC_CORECRT_STARTUP
#include <corecrt.h>
typedef enum _crt_argv_mode
{
_crt_argv_no_arguments,
_crt_argv_unexpanded_arguments,
_crt_argv_expanded_arguments
} _crt_argv_mode;
typedef enum _crt_app_type
{
_crt_unknown_app,
_crt_console_app,
_crt_gui_app
} _crt_app_type;
typedef void (__cdecl *_PVFV)(void);
typedef int (__cdecl *_PIFV)(void);
typedef void (__cdecl *_PVFI)(int);
_ACRTIMP int __cdecl _initterm_e(_PIFV *, _PIFV *);
typedef struct _onexit_table_t {
_PVFV *_first;
_PVFV *_last;
_PVFV *_end;
} _onexit_table_t;
#ifndef _CRT_ONEXIT_T_DEFINED
#define _CRT_ONEXIT_T_DEFINED
typedef int (__cdecl *_onexit_t)(void);
#endif
struct _exception;
typedef int (__cdecl *_UserMathErrorFunctionPointer)(struct _exception *);
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _UCRT
_ACRTIMP void __cdecl __getmainargs(int *, char ***, char ***, int, int *);
_ACRTIMP void __cdecl __wgetmainargs(int *, wchar_t ***, wchar_t ***, int, int *);
#define _set_app_type __set_app_type
#endif /* _UCRT */
_ACRTIMP void __cdecl __setusermatherr(_UserMathErrorFunctionPointer);
_ACRTIMP errno_t __cdecl _configure_narrow_argv(_crt_argv_mode);
_ACRTIMP errno_t __cdecl _configure_wide_argv(_crt_argv_mode);
_ACRTIMP int __cdecl _crt_at_quick_exit(_PVFV);
_ACRTIMP int __cdecl _crt_atexit(_PVFV);
_ACRTIMP int __cdecl _execute_onexit_table(_onexit_table_t*);
_ACRTIMP char **__cdecl _get_initial_narrow_environment(void);
_ACRTIMP wchar_t **__cdecl _get_initial_wide_environment(void);
_ACRTIMP char* __cdecl _get_narrow_winmain_command_line(void);
_ACRTIMP wchar_t* __cdecl _get_wide_winmain_command_line(void);
_ACRTIMP int __cdecl _initialize_narrow_environment(void);
_ACRTIMP int __cdecl _initialize_onexit_table(_onexit_table_t*);
_ACRTIMP int __cdecl _initialize_wide_environment(void);
_ACRTIMP int __cdecl _register_onexit_function(_onexit_table_t*,_onexit_t);
_ACRTIMP void __cdecl _set_app_type(_crt_app_type);
#ifdef __cplusplus
}
#endif
#endif /* _INC_CORECRT_STARTUP */

31
assets/wine/include/wine/msvcrt/corecrt_stdio_config.h
View File

@@ -1,31 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#ifndef _STDIO_CONFIG_DEFINED
#define _STDIO_CONFIG_DEFINED
#include <corecrt.h>
#define _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION 0x0001ULL
#define _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR 0x0002ULL
#define _CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS 0x0004ULL
#define _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY 0x0008ULL
#define _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS 0x0010ULL
#define _CRT_INTERNAL_PRINTF_STANDARD_ROUNDING 0x0020ULL
#define _CRT_INTERNAL_SCANF_SECURECRT 0x0001ULL
#define _CRT_INTERNAL_SCANF_LEGACY_WIDE_SPECIFIERS 0x0002ULL
#define _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY 0x0004ULL
#ifndef _CRT_INTERNAL_LOCAL_PRINTF_OPTIONS
#define _CRT_INTERNAL_LOCAL_PRINTF_OPTIONS _CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS
#endif
#ifndef _CRT_INTERNAL_LOCAL_SCANF_OPTIONS
#define _CRT_INTERNAL_LOCAL_SCANF_OPTIONS _CRT_INTERNAL_SCANF_LEGACY_WIDE_SPECIFIERS
#endif
#endif /* _STDIO_CONFIG_DEFINED */

67
assets/wine/include/wine/msvcrt/corecrt_wctype.h
View File

@@ -1,67 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
*/
#ifndef _WCTYPE_DEFINED
#define _WCTYPE_DEFINED
#include <corecrt.h>
#ifdef __cplusplus
extern "C" {
#endif
/* ASCII char classification table - binary compatible */
#define _UPPER 0x0001 /* C1_UPPER */
#define _LOWER 0x0002 /* C1_LOWER */
#define _DIGIT 0x0004 /* C1_DIGIT */
#define _SPACE 0x0008 /* C1_SPACE */
#define _PUNCT 0x0010 /* C1_PUNCT */
#define _CONTROL 0x0020 /* C1_CNTRL */
#define _BLANK 0x0040 /* C1_BLANK */
#define _HEX 0x0080 /* C1_XDIGIT */
#define _LEADBYTE 0x8000
#define _ALPHA (0x0100|_UPPER|_LOWER) /* (C1_ALPHA|_UPPER|_LOWER) */
_ACRTIMP const unsigned short* __cdecl __pctype_func(void);
_ACRTIMP int __cdecl _isleadbyte_l(int,_locale_t);
_ACRTIMP int __cdecl _iswalnum_l(wint_t,_locale_t);
_ACRTIMP int __cdecl _iswalpha_l(wint_t,_locale_t);
_ACRTIMP int __cdecl _iswblank_l(wint_t,_locale_t);
_ACRTIMP int __cdecl _iswcntrl_l(wint_t,_locale_t);
_ACRTIMP int __cdecl _iswctype_l(wint_t,wctype_t,_locale_t);
_ACRTIMP int __cdecl _iswdigit_l(wint_t,_locale_t);
_ACRTIMP int __cdecl _iswgraph_l(wint_t,_locale_t);
_ACRTIMP int __cdecl _iswlower_l(wint_t,_locale_t);
_ACRTIMP int __cdecl _iswprint_l(wint_t,_locale_t);
_ACRTIMP int __cdecl _iswpunct_l(wint_t,_locale_t);
_ACRTIMP int __cdecl _iswspace_l(wint_t,_locale_t);
_ACRTIMP int __cdecl _iswupper_l(wint_t,_locale_t);
_ACRTIMP int __cdecl _iswxdigit_l(wint_t,_locale_t);
_ACRTIMP wint_t __cdecl _towlower_l(wint_t,_locale_t);
_ACRTIMP wint_t __cdecl _towupper_l(wint_t,_locale_t);
_ACRTIMP int __cdecl is_wctype(wint_t,wctype_t);
_ACRTIMP int __cdecl isleadbyte(int);
_ACRTIMP int __cdecl iswalnum(wint_t);
_ACRTIMP int __cdecl iswalpha(wint_t);
_ACRTIMP int __cdecl iswascii(wint_t);
_ACRTIMP int __cdecl iswblank(wint_t);
_ACRTIMP int __cdecl iswcntrl(wint_t);
_ACRTIMP int __cdecl iswctype(wint_t,wctype_t);
_ACRTIMP int __cdecl iswdigit(wint_t);
_ACRTIMP int __cdecl iswgraph(wint_t);
_ACRTIMP int __cdecl iswlower(wint_t);
_ACRTIMP int __cdecl iswprint(wint_t);
_ACRTIMP int __cdecl iswpunct(wint_t);
_ACRTIMP int __cdecl iswspace(wint_t);
_ACRTIMP int __cdecl iswupper(wint_t);
_ACRTIMP int __cdecl iswxdigit(wint_t);
_ACRTIMP wint_t __cdecl towlower(wint_t);
_ACRTIMP wint_t __cdecl towupper(wint_t);
#ifdef __cplusplus
}
#endif
#endif /* _WCTYPE_DEFINED */

25
assets/wine/include/wine/msvcrt/corecrt_wdirect.h
View File

@@ -1,25 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
*/
#ifndef _WDIRECT_DEFINED
#define _WDIRECT_DEFINED
#include <corecrt.h>
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP int __cdecl _wchdir(const wchar_t*);
_ACRTIMP wchar_t* __cdecl _wgetcwd(wchar_t*,int);
_ACRTIMP wchar_t* __cdecl _wgetdcwd(int,wchar_t*,int);
_ACRTIMP int __cdecl _wmkdir(const wchar_t*);
_ACRTIMP int __cdecl _wrmdir(const wchar_t*);
#ifdef __cplusplus
}
#endif
#endif /* _WDIRECT_DEFINED */

113
assets/wine/include/wine/msvcrt/corecrt_wio.h
View File

@@ -1,113 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
*/
#ifndef _WIO_DEFINED
#define _WIO_DEFINED
#include <corecrt.h>
#pragma pack(push,8)
typedef __msvcrt_ulong _fsize_t;
#if defined(_USE_32BIT_TIME_T)
# define _wfinddata_t _wfinddata32_t
# define _wfinddatai64_t _wfinddata32i64_t
#else
# define _wfinddata_t _wfinddata64i32_t
# define _wfinddatai64_t _wfinddata64_t
#endif
struct _wfinddata32_t {
unsigned attrib;
__time32_t time_create;
__time32_t time_access;
__time32_t time_write;
_fsize_t size;
wchar_t name[260];
};
struct _wfinddata32i64_t {
unsigned attrib;
__time32_t time_create;
__time32_t time_access;
__time32_t time_write;
__int64 DECLSPEC_ALIGN(8) size;
wchar_t name[260];
};
struct _wfinddata64i32_t {
unsigned attrib;
__time64_t time_create;
__time64_t time_access;
__time64_t time_write;
_fsize_t size;
wchar_t name[260];
};
struct _wfinddata64_t {
unsigned attrib;
__time64_t time_create;
__time64_t time_access;
__time64_t time_write;
__int64 DECLSPEC_ALIGN(8) size;
wchar_t name[260];
};
#ifdef _UCRT
# ifdef _USE_32BIT_TIME_T
# define _wfindfirst _wfindfirst32
# define _wfindfirsti64 _wfindfirst32i64
# define _wfindnext _wfindnext32
# define _wfindnexti64 _wfindnext32i64
# else
# define _wfindfirst _wfindfirst64i32
# define _wfindfirsti64 _wfindfirst64
# define _wfindnext _wfindnext64i32
# define _wfindnexti64 _wfindnext64
# endif
#else /* _UCRT */
# ifdef _USE_32BIT_TIME_T
# define _wfindfirst32 _wfindfirst
# define _wfindfirst32i64 _wfindfirsti64
# define _wfindnext32 _wfindnext
# define _wfindnext32i64 _wfindnexti64
# else
# define _wfindfirst64i32 _wfindfirst
# define _wfindfirst64 _wfindfirsti64
# define _wfindnext64i32 _wfindnext
# define _wfindnext64 _wfindnexti64
# endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP int __cdecl _waccess(const wchar_t*,int);
_ACRTIMP int __cdecl _wchmod(const wchar_t*,int);
_ACRTIMP int __cdecl _wcreat(const wchar_t*,int);
_ACRTIMP intptr_t __cdecl _wfindfirst32(const wchar_t*,struct _wfinddata32_t*);
_ACRTIMP intptr_t __cdecl _wfindfirst32i64(const wchar_t*, struct _wfinddata32i64_t*);
_ACRTIMP intptr_t __cdecl _wfindfirst64(const wchar_t*,struct _wfinddata64_t*);
_ACRTIMP intptr_t __cdecl _wfindfirst64i32(const wchar_t*, struct _wfinddata64i32_t*);
_ACRTIMP int __cdecl _wfindnext32(intptr_t,struct _wfinddata32_t*);
_ACRTIMP int __cdecl _wfindnext32i64(intptr_t,struct _wfinddata32i64_t*);
_ACRTIMP int __cdecl _wfindnext64(intptr_t,struct _wfinddata64_t*);
_ACRTIMP int __cdecl _wfindnext64i32(intptr_t,struct _wfinddata64i32_t*);
_ACRTIMP wchar_t* __cdecl _wmktemp(wchar_t*);
_ACRTIMP int __cdecl _wopen(const wchar_t*,int,...);
_ACRTIMP int __cdecl _wrename(const wchar_t*,const wchar_t*);
_ACRTIMP int __cdecl _wsopen(const wchar_t*,int,int,...);
_ACRTIMP errno_t __cdecl _wsopen_s(int*,const wchar_t*,int,int,int);
_ACRTIMP int __cdecl _wunlink(const wchar_t*);
#ifdef __cplusplus
}
#endif
#pragma pack(pop)
#endif /* _WIO_DEFINED */

37
assets/wine/include/wine/msvcrt/corecrt_wprocess.h
View File

@@ -1,37 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
*/
#ifndef _WPROCESS_DEFINED
#define _WPROCESS_DEFINED
#include <corecrt.h>
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP intptr_t __cdecl _wexecl(const wchar_t*,const wchar_t*,...);
_ACRTIMP intptr_t __cdecl _wexecle(const wchar_t*,const wchar_t*,...);
_ACRTIMP intptr_t __cdecl _wexeclp(const wchar_t*,const wchar_t*,...);
_ACRTIMP intptr_t __cdecl _wexeclpe(const wchar_t*,const wchar_t*,...);
_ACRTIMP intptr_t __cdecl _wexecv(const wchar_t*,const wchar_t* const *);
_ACRTIMP intptr_t __cdecl _wexecve(const wchar_t*,const wchar_t* const *,const wchar_t* const *);
_ACRTIMP intptr_t __cdecl _wexecvp(const wchar_t*,const wchar_t* const *);
_ACRTIMP intptr_t __cdecl _wexecvpe(const wchar_t*,const wchar_t* const *,const wchar_t* const *);
_ACRTIMP intptr_t __cdecl _wspawnl(int,const wchar_t*,const wchar_t*,...);
_ACRTIMP intptr_t __cdecl _wspawnle(int,const wchar_t*,const wchar_t*,...);
_ACRTIMP intptr_t __cdecl _wspawnlp(int,const wchar_t*,const wchar_t*,...);
_ACRTIMP intptr_t __cdecl _wspawnlpe(int,const wchar_t*,const wchar_t*,...);
_ACRTIMP intptr_t __cdecl _wspawnv(int,const wchar_t*,const wchar_t* const *);
_ACRTIMP intptr_t __cdecl _wspawnve(int,const wchar_t*,const wchar_t* const *,const wchar_t* const *);
_ACRTIMP intptr_t __cdecl _wspawnvp(int,const wchar_t*,const wchar_t* const *);
_ACRTIMP intptr_t __cdecl _wspawnvpe(int,const wchar_t*,const wchar_t* const *,const wchar_t* const *);
_ACRTIMP int __cdecl _wsystem(const wchar_t*);
#ifdef __cplusplus
}
#endif
#endif /* _WPROCESS_DEFINED */

417
assets/wine/include/wine/msvcrt/corecrt_wstdio.h
View File

@@ -1,417 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#ifndef _WSTDIO_DEFINED
#define _WSTDIO_DEFINED
#include <corecrt.h>
#include <corecrt_stdio_config.h>
#ifndef RC_INVOKED
#include <stdarg.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
#pragma pack(push,8)
#ifndef _FILE_DEFINED
#define _FILE_DEFINED
#pragma pack(push,8)
typedef struct _iobuf
{
#ifdef _UCRT
void *_Placeholder;
#else
char* _ptr;
int _cnt;
char* _base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char* _tmpfname;
#endif
} FILE;
#pragma pack(pop)
#endif /* _FILE_DEFINED */
#ifndef WEOF
#define WEOF (wint_t)(0xFFFF)
#endif
_ACRTIMP FILE *__cdecl __acrt_iob_func(unsigned index);
#define stdin (__acrt_iob_func(0))
#define stdout (__acrt_iob_func(1))
#define stderr (__acrt_iob_func(2))
_ACRTIMP wint_t __cdecl _fgetwc_nolock(FILE*);
_ACRTIMP wint_t __cdecl _fgetwchar(void);
_ACRTIMP wint_t __cdecl _fputwc_nolock(wint_t,FILE*);
_ACRTIMP wint_t __cdecl _fputwchar(wint_t);
_ACRTIMP wint_t __cdecl _getwc_nolock(FILE*);
_ACRTIMP wchar_t* __cdecl _getws(wchar_t*);
_ACRTIMP wint_t __cdecl _putwc_nolock(wint_t,FILE*);
_ACRTIMP int __cdecl _putws(const wchar_t*);
_ACRTIMP wint_t __cdecl _ungetwc_nolock(wint_t,FILE*);
_ACRTIMP FILE* __cdecl _wfdopen(int,const wchar_t*);
_ACRTIMP FILE* __cdecl _wfopen(const wchar_t*,const wchar_t*);
_ACRTIMP errno_t __cdecl _wfopen_s(FILE**,const wchar_t*,const wchar_t*);
_ACRTIMP FILE* __cdecl _wfreopen(const wchar_t*,const wchar_t*,FILE*);
_ACRTIMP FILE* __cdecl _wfsopen(const wchar_t*,const wchar_t*,int);
_ACRTIMP void __cdecl _wperror(const wchar_t*);
_ACRTIMP FILE* __cdecl _wpopen(const wchar_t*,const wchar_t*);
_ACRTIMP int __cdecl _wremove(const wchar_t*);
_ACRTIMP wchar_t* __cdecl _wtempnam(const wchar_t*,const wchar_t*);
_ACRTIMP wchar_t* __cdecl _wtmpnam(wchar_t*);
_ACRTIMP wint_t __cdecl fgetwc(FILE*);
_ACRTIMP wchar_t* __cdecl fgetws(wchar_t*,int,FILE*);
_ACRTIMP wint_t __cdecl fputwc(wint_t,FILE*);
_ACRTIMP int __cdecl fputws(const wchar_t*,FILE*);
_ACRTIMP int __cdecl fputws(const wchar_t*,FILE*);
_ACRTIMP wint_t __cdecl getwc(FILE*);
_ACRTIMP wint_t __cdecl getwchar(void);
_ACRTIMP wchar_t* __cdecl getws(wchar_t*);
_ACRTIMP wint_t __cdecl putwc(wint_t,FILE*);
_ACRTIMP wint_t __cdecl putwchar(wint_t);
_ACRTIMP int __cdecl putws(const wchar_t*);
_ACRTIMP wint_t __cdecl ungetwc(wint_t,FILE*);
#ifdef _UCRT
_ACRTIMP int __cdecl __stdio_common_vfwprintf(unsigned __int64,FILE*,const wchar_t*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vfwprintf_s(unsigned __int64,FILE*,const wchar_t*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vsnwprintf_s(unsigned __int64,wchar_t*,size_t,size_t,const wchar_t*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vswprintf(unsigned __int64,wchar_t*,size_t,const wchar_t*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vswprintf_p(unsigned __int64,wchar_t*,size_t,const wchar_t*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vswprintf_s(unsigned __int64,wchar_t*,size_t,const wchar_t*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vfwscanf(unsigned __int64,FILE*,const wchar_t*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vswscanf(unsigned __int64,const wchar_t*,size_t,const wchar_t*,_locale_t,va_list);
#endif /* _UCRT */
#if defined(_UCRT) && !defined(_NO_CRT_STDIO_INLINE)
static inline int __cdecl _vsnwprintf(wchar_t *buffer, size_t size, const wchar_t *format, va_list args)
{
int ret = __stdio_common_vswprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, format, NULL, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl _snwprintf(wchar_t *buffer, size_t size, const wchar_t* format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vswprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl _vsnwprintf_s(wchar_t *buffer, size_t size, size_t count, const wchar_t *format, va_list args)
{
int ret = __stdio_common_vsnwprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, count, format, NULL, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl _snwprintf_s(wchar_t *buffer, size_t size, size_t count, const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vsnwprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, count, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl vswprintf(wchar_t *buffer, size_t size, const wchar_t *format, va_list args)
{
int ret = __stdio_common_vswprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, format, NULL, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl swprintf(wchar_t *buffer, size_t size, const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vswprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl _vswprintf(wchar_t *buffer, const wchar_t *format, va_list args)
{
int ret = __stdio_common_vswprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, -1, format, NULL, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl _swprintf(wchar_t *buffer, const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vswprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, -1, format, NULL, args);
va_end(args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl vswprintf_s(wchar_t *buffer, size_t size, const wchar_t *format, va_list args)
{
int ret = __stdio_common_vswprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, format, NULL, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl swprintf_s(wchar_t *buffer, size_t size, const wchar_t* format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vswprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl _swprintf_l(wchar_t *buffer, size_t size, const wchar_t* format, _locale_t locale, ...)
{
int ret;
va_list args;
va_start(args, locale);
ret = __stdio_common_vswprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, format, locale, args);
va_end(args);
return ret;
}
static inline int __cdecl _vscwprintf(const wchar_t *format, va_list args)
{
int ret = __stdio_common_vswprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR,
NULL, 0, format, NULL, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl _vswprintf_p_l(wchar_t *buffer, size_t size, const wchar_t *format, _locale_t locale, va_list args)
{
int ret = __stdio_common_vswprintf_p(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, format, locale, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl _vscwprintf_p_l(const wchar_t *format, _locale_t locale, va_list args)
{
int ret = __stdio_common_vswprintf_p(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR,
NULL, 0, format, locale, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl _scwprintf(const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vswprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR,
NULL, 0, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl vfwprintf(FILE *file, const wchar_t *format, va_list args)
{
return __stdio_common_vfwprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, file, format, NULL, args);
}
static inline int __cdecl fwprintf(FILE *file, const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfwprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, file, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl vfwprintf_s(FILE *file, const wchar_t *format, va_list args)
{
return __stdio_common_vfwprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, file, format, NULL, args);
}
static inline int __cdecl fwprintf_s(FILE *file, const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = vfwprintf_s(file, format, args);
va_end(args);
return ret;
}
static inline int __cdecl vwprintf(const wchar_t *format, va_list args)
{
return __stdio_common_vfwprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, stdout, format, NULL, args);
}
static inline int __cdecl wprintf(const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfwprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, stdout, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl vwprintf_s(const wchar_t *format, va_list args)
{
return __stdio_common_vfwprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, stdout, format, NULL, args);
}
static inline int __cdecl wprintf_s(const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = vfwprintf_s(stdout, format, args);
va_end(args);
return ret;
}
static inline int __cdecl swscanf(const wchar_t *buffer, const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vswscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS, buffer, -1, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl swscanf_s(const wchar_t *buffer, const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vswscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS | _CRT_INTERNAL_SCANF_SECURECRT, buffer, -1, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl fwscanf(FILE *file, const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfwscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS, file, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl fwscanf_s(FILE *file, const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfwscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS | _CRT_INTERNAL_SCANF_SECURECRT, file, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl wscanf(FILE *file, const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfwscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS, stdin, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl wscanf_s(FILE *file, const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfwscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS | _CRT_INTERNAL_SCANF_SECURECRT, stdin, format, NULL, args);
va_end(args);
return ret;
}
#else /* _UCRT && !_NO_CRT_STDIO_INLINE */
_ACRTIMP int __cdecl _scwprintf(const wchar_t*,...);
_ACRTIMP int __cdecl _snwprintf(wchar_t*,size_t,const wchar_t*,...);
_ACRTIMP int __cdecl _snwprintf_s(wchar_t*,size_t,size_t,const wchar_t*,...);
_ACRTIMP int __cdecl _vscwprintf(const wchar_t*,va_list);
_ACRTIMP int __cdecl _vscwprintf_p_l(const wchar_t*,_locale_t,va_list);
_ACRTIMP int __cdecl _vsnwprintf(wchar_t*,size_t,const wchar_t*,va_list);
_ACRTIMP int __cdecl _vsnwprintf_s(wchar_t*,size_t,size_t,const wchar_t*,va_list);
_ACRTIMP int __cdecl _vswprintf_p_l(wchar_t*,size_t,const wchar_t*,_locale_t,va_list);
_ACRTIMP int __cdecl fwprintf(FILE*,const wchar_t*,...);
_ACRTIMP int __cdecl fwprintf_s(FILE*,const wchar_t*,...);
_ACRTIMP int __cdecl swprintf_s(wchar_t*,size_t,const wchar_t*,...);
_ACRTIMP int __cdecl vfwprintf(FILE*,const wchar_t*,va_list);
_ACRTIMP int __cdecl vfwprintf_s(FILE*,const wchar_t*,va_list);
_ACRTIMP int __cdecl vswprintf_s(wchar_t*,size_t,const wchar_t*,va_list);
_ACRTIMP int __cdecl vwprintf(const wchar_t*,va_list);
_ACRTIMP int __cdecl vwprintf_s(const wchar_t*,va_list);
_ACRTIMP int __cdecl wprintf(const wchar_t*,...);
_ACRTIMP int __cdecl wprintf_s(const wchar_t*,...);
#ifdef _CRT_NON_CONFORMING_SWPRINTFS
_ACRTIMP int __cdecl swprintf(wchar_t*,const wchar_t*,...);
_ACRTIMP int __cdecl vswprintf(wchar_t*,const wchar_t*,va_list);
#elif !defined(_NO_CRT_STDIO_INLINE)
static inline int __cdecl vswprintf(wchar_t *buffer, size_t size, const wchar_t *format, va_list args) { return _vsnwprintf(buffer,size,format,args); }
static inline int __cdecl swprintf(wchar_t *buffer, size_t size, const wchar_t *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = _vsnwprintf(buffer, size, format, args);
va_end(args);
return ret;
}
#else
_ACRTIMP int __cdecl vswprintf(wchar_t*,size_t,const wchar_t*,va_list);
_ACRTIMP int __cdecl swprintf(wchar_t*,size_t,const wchar_t*,...);
#endif /* _CRT_NON_CONFORMING_SWPRINTFS */
_ACRTIMP int __cdecl fwscanf(FILE*,const wchar_t*,...);
_ACRTIMP int __cdecl fwscanf_s(FILE*,const wchar_t*,...);
_ACRTIMP int __cdecl swscanf(const wchar_t*,const wchar_t*,...);
_ACRTIMP int __cdecl swscanf_s(const wchar_t*,const wchar_t*,...);
_ACRTIMP int __cdecl wscanf(const wchar_t*,...);
_ACRTIMP int __cdecl wscanf_s(const wchar_t*,...);
#endif /* _UCRT && !_NO_CRT_STDIO_INLINE */
#ifdef __cplusplus
}
#endif
#pragma pack(pop)
#endif /* _WSTDIO_DEFINED */

91
assets/wine/include/wine/msvcrt/corecrt_wstdlib.h
View File

@@ -1,91 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
*/
#ifndef _WSTDLIB_DEFINED
#define _WSTDLIB_DEFINED
#include <corecrt.h>
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP wchar_t* __cdecl _itow(int,wchar_t*,int);
_ACRTIMP errno_t __cdecl _itow_s(int,wchar_t*,size_t, int);
_ACRTIMP wchar_t* __cdecl _i64tow(__int64,wchar_t*,int);
_ACRTIMP errno_t __cdecl _i64tow_s(__int64, wchar_t*, size_t, int);
_ACRTIMP wchar_t* __cdecl _ltow(__msvcrt_long,wchar_t*,int);
_ACRTIMP errno_t __cdecl _ltow_s(__msvcrt_long,wchar_t*,size_t,int);
_ACRTIMP wchar_t* __cdecl _ui64tow(unsigned __int64,wchar_t*,int);
_ACRTIMP errno_t __cdecl _ui64tow_s(unsigned __int64, wchar_t*, size_t, int);
_ACRTIMP wchar_t* __cdecl _ultow(__msvcrt_ulong,wchar_t*,int);
_ACRTIMP errno_t __cdecl _ultow_s(__msvcrt_ulong, wchar_t*, size_t, int);
_ACRTIMP errno_t __cdecl _wdupenv_s(wchar_t**,size_t*,const wchar_t*);
_ACRTIMP wchar_t* __cdecl _wfullpath(wchar_t*,const wchar_t*,size_t);
_ACRTIMP wchar_t* __cdecl _wgetenv(const wchar_t*);
_ACRTIMP errno_t __cdecl _wgetenv_s(size_t *,wchar_t *,size_t,const wchar_t *);
_ACRTIMP void __cdecl _wmakepath(wchar_t*,const wchar_t*,const wchar_t*,const wchar_t*,const wchar_t*);
_ACRTIMP int __cdecl _wmakepath_s(wchar_t*,size_t,const wchar_t*,const wchar_t*,const wchar_t*,const wchar_t*);
_ACRTIMP void __cdecl _wperror(const wchar_t*);
_ACRTIMP int __cdecl _wputenv(const wchar_t*);
_ACRTIMP void __cdecl _wsearchenv(const wchar_t*,const wchar_t*,wchar_t*);
_ACRTIMP void __cdecl _wsplitpath(const wchar_t*,wchar_t*,wchar_t*,wchar_t*,wchar_t*);
_ACRTIMP errno_t __cdecl _wsplitpath_s(const wchar_t*,wchar_t*,size_t,wchar_t*,size_t,
wchar_t*,size_t,wchar_t*,size_t);
_ACRTIMP int __cdecl _wsystem(const wchar_t*);
_ACRTIMP double __cdecl _wtof(const wchar_t*);
_ACRTIMP int __cdecl _wtoi(const wchar_t*);
_ACRTIMP __int64 __cdecl _wtoi64(const wchar_t*);
_ACRTIMP __msvcrt_long __cdecl _wtol(const wchar_t*);
_ACRTIMP size_t __cdecl mbstowcs(wchar_t*,const char*,size_t);
_ACRTIMP size_t __cdecl _mbstowcs_l(wchar_t*,const char*,size_t,_locale_t);
_ACRTIMP errno_t __cdecl mbstowcs_s(size_t*,wchar_t*,size_t,const char*,size_t);
_ACRTIMP errno_t __cdecl _mbstowcs_s_l(size_t*,wchar_t*,size_t,const char*,size_t,_locale_t);
_ACRTIMP int __cdecl mbtowc(wchar_t*,const char*,size_t);
_ACRTIMP int __cdecl _mbtowc_l(wchar_t*,const char*,size_t,_locale_t);
_ACRTIMP double __cdecl wcstod(const wchar_t*,wchar_t**);
_ACRTIMP double __cdecl _wcstod_l(const wchar_t*,wchar_t**,_locale_t);
_ACRTIMP float __cdecl wcstof(const wchar_t*,wchar_t**);
_ACRTIMP float __cdecl _wcstof_l(const wchar_t*,wchar_t**,_locale_t);
_ACRTIMP __msvcrt_long __cdecl wcstol(const wchar_t*,wchar_t**,int);
_ACRTIMP __msvcrt_long __cdecl _wcstol_l(const wchar_t*,wchar_t**,int,_locale_t);
_ACRTIMP size_t __cdecl wcstombs(char*,const wchar_t*,size_t);
_ACRTIMP size_t __cdecl _wcstombs_l(char*,const wchar_t*,size_t,_locale_t);
_ACRTIMP errno_t __cdecl wcstombs_s(size_t*,char*,size_t,const wchar_t*,size_t);
_ACRTIMP errno_t __cdecl _wcstombs_s_l(size_t*,char*,size_t,const wchar_t*,size_t,_locale_t);
_ACRTIMP __msvcrt_ulong __cdecl wcstoul(const wchar_t*,wchar_t**,int);
_ACRTIMP __msvcrt_ulong __cdecl _wcstoul_l(const wchar_t*,wchar_t**,int,_locale_t);
_ACRTIMP int __cdecl wctomb(char*,wchar_t);
_ACRTIMP int __cdecl _wctomb_l(char*,wchar_t,_locale_t);
_ACRTIMP __int64 __cdecl _wcstoi64(const wchar_t*,wchar_t**,int);
_ACRTIMP __int64 __cdecl _wcstoi64_l(const wchar_t*,wchar_t**,int,_locale_t);
_ACRTIMP unsigned __int64 __cdecl _wcstoui64(const wchar_t*,wchar_t**,int);
_ACRTIMP unsigned __int64 __cdecl _wcstoui64_l(const wchar_t*,wchar_t**,int,_locale_t);
_ACRTIMP __int64 __cdecl wcstoll(const wchar_t*,wchar_t**,int);
_ACRTIMP __int64 __cdecl _wcstoll_l(const wchar_t*,wchar_t**,int,_locale_t);
_ACRTIMP unsigned __int64 __cdecl wcstoull(const wchar_t*,wchar_t**,int);
_ACRTIMP unsigned __int64 __cdecl _wcstoull_l(const wchar_t*,wchar_t**,int,_locale_t);
#ifdef _UCRT
_ACRTIMP double __cdecl _wcstold_l(const wchar_t*,wchar_t**,_locale_t);
static inline long double wcstold(const wchar_t *string, wchar_t **endptr) { return _wcstold_l(string, endptr, NULL); }
#endif /* _UCRT */
#ifdef __cplusplus
extern "C++" {
template <size_t size>
inline errno_t _wgetenv_s(size_t *ret, wchar_t (&buf)[size], const wchar_t *var)
{
return _wgetenv_s(ret, buf, size, var);
}
} /* extern "C++" */
}
#endif
#endif /* _WSTDLIB_DEFINED */

100
assets/wine/include/wine/msvcrt/corecrt_wstring.h
View File

@@ -1,100 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
*/
#ifndef _WSTRING_DEFINED
#define _WSTRING_DEFINED
#include <corecrt.h>
#include <corecrt_malloc.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _CRT_MEMORY_DEFINED
#define _CRT_MEMORY_DEFINED
_ACRTIMP void* __cdecl memchr(const void*,int,size_t);
_ACRTIMP int __cdecl memcmp(const void*,const void*,size_t);
_ACRTIMP void* __cdecl memcpy(void*,const void*,size_t);
_ACRTIMP errno_t __cdecl memcpy_s(void*,size_t,const void*,size_t);
_ACRTIMP void* __cdecl memset(void*,int,size_t);
_ACRTIMP void* __cdecl _memccpy(void*,const void*,int,size_t);
_ACRTIMP int __cdecl _memicmp(const void*,const void*,size_t);
_ACRTIMP int __cdecl _memicmp_l(const void*,const void*,size_t,_locale_t);
static inline int memicmp(const void* s1, const void* s2, size_t len) { return _memicmp(s1, s2, len); }
static inline void* memccpy(void *s1, const void *s2, int c, size_t n) { return _memccpy(s1, s2, c, n); }
#endif /* _CRT_MEMORY_DEFINED */
_ACRTIMP void* __cdecl memmove(void*,const void*,size_t);
_ACRTIMP wchar_t* __cdecl _wcsdup(const wchar_t*) __WINE_DEALLOC(free) __WINE_MALLOC;
_ACRTIMP wchar_t* __cdecl _wcserror(int);
_ACRTIMP int __cdecl _wcsicmp(const wchar_t*,const wchar_t*);
_ACRTIMP int __cdecl _wcsicmp_l(const wchar_t*,const wchar_t*, _locale_t);
_ACRTIMP int __cdecl _wcsicoll(const wchar_t*,const wchar_t*);
_ACRTIMP int __cdecl _wcsicoll_l(const wchar_t*, const wchar_t*, _locale_t);
_ACRTIMP wchar_t* __cdecl _wcslwr(wchar_t*);
_ACRTIMP errno_t __cdecl _wcslwr_s(wchar_t*, size_t);
_ACRTIMP int __cdecl _wcscoll_l(const wchar_t*, const wchar_t*, _locale_t);
_ACRTIMP int __cdecl _wcsncoll(const wchar_t*, const wchar_t*, size_t);
_ACRTIMP int __cdecl _wcsncoll_l(const wchar_t*, const wchar_t*, size_t, _locale_t);
_ACRTIMP int __cdecl _wcsnicmp(const wchar_t*,const wchar_t*,size_t);
_ACRTIMP int __cdecl _wcsnicoll(const wchar_t*,const wchar_t*,size_t);
_ACRTIMP int __cdecl _wcsnicoll_l(const wchar_t*, const wchar_t*, size_t, _locale_t);
_ACRTIMP size_t __cdecl _wcsnlen(const wchar_t*,size_t);
_ACRTIMP wchar_t* __cdecl _wcsnset(wchar_t*,wchar_t,size_t);
_ACRTIMP wchar_t* __cdecl _wcsrev(wchar_t*);
_ACRTIMP wchar_t* __cdecl _wcsset(wchar_t*,wchar_t);
_ACRTIMP wchar_t* __cdecl _wcsupr(wchar_t*);
_ACRTIMP errno_t __cdecl _wcsupr_s(wchar_t*, size_t);
_ACRTIMP size_t __cdecl _wcsxfrm_l(wchar_t*,const wchar_t*,size_t,_locale_t);
_ACRTIMP wchar_t* __cdecl wcscat(wchar_t*,const wchar_t*);
_ACRTIMP errno_t __cdecl wcscat_s(wchar_t*,size_t,const wchar_t*);
_ACRTIMP wchar_t* __cdecl wcschr(const wchar_t*,wchar_t);
_ACRTIMP int __cdecl wcscmp(const wchar_t*,const wchar_t*);
_ACRTIMP int __cdecl wcscoll(const wchar_t*,const wchar_t*);
_ACRTIMP wchar_t* __cdecl wcscpy(wchar_t*,const wchar_t*);
_ACRTIMP errno_t __cdecl wcscpy_s(wchar_t*,size_t,const wchar_t*);
_ACRTIMP size_t __cdecl wcscspn(const wchar_t*,const wchar_t*);
_ACRTIMP size_t __cdecl wcslen(const wchar_t*);
_ACRTIMP wchar_t* __cdecl wcsncat(wchar_t*,const wchar_t*,size_t);
_ACRTIMP errno_t __cdecl wcsncat_s(wchar_t*,size_t,const wchar_t*,size_t);
_ACRTIMP int __cdecl wcsncmp(const wchar_t*,const wchar_t*,size_t);
_ACRTIMP wchar_t* __cdecl wcsncpy(wchar_t*,const wchar_t*,size_t);
_ACRTIMP errno_t __cdecl wcsncpy_s(wchar_t*,size_t,const wchar_t*,size_t);
_ACRTIMP size_t __cdecl wcsnlen(const wchar_t*,size_t);
_ACRTIMP wchar_t* __cdecl wcspbrk(const wchar_t*,const wchar_t*);
_ACRTIMP wchar_t* __cdecl wcsrchr(const wchar_t*,wchar_t wcFor);
_ACRTIMP size_t __cdecl wcsspn(const wchar_t*,const wchar_t*);
_ACRTIMP wchar_t* __cdecl wcsstr(const wchar_t*,const wchar_t*);
_ACRTIMP wchar_t* __cdecl wcstok_s(wchar_t*,const wchar_t*,wchar_t**);
_ACRTIMP size_t __cdecl wcsxfrm(wchar_t*,const wchar_t*,size_t);
#ifdef _UCRT
_ACRTIMP wchar_t* __cdecl wcstok(wchar_t*,const wchar_t*,wchar_t**);
static inline wchar_t* _wcstok(wchar_t* str, const wchar_t *delim) { return wcstok(str, delim, NULL); }
# ifdef __cplusplus
extern "C++" inline wchar_t* wcstok(wchar_t* str, const wchar_t *delim) { return wcstok(str, delim, NULL); }
# elif defined(_CRT_NON_CONFORMING_WCSTOK)
# define wcstok _wcstok
# endif
#else /* _UCRT */
_ACRTIMP wchar_t* __cdecl wcstok(wchar_t*,const wchar_t*);
# define _wcstok wcstok
#endif /* _UCRT */
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
extern "C++" {
template <size_t S> inline errno_t wcscat_s(wchar_t (&dst)[S], const wchar_t *arg) throw() { return wcscat_s(dst, S, arg); }
} /* extern "C++" */
#endif /* __cplusplus */
#endif /* _WSTRING_DEFINED */

51
assets/wine/include/wine/msvcrt/corecrt_wtime.h
View File

@@ -1,51 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
*/
#ifndef _WTIME_DEFINED
#define _WTIME_DEFINED
#include <corecrt.h>
struct tm {
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
};
#if defined(_USE_32BIT_TIME_T) && !defined(_UCRT)
#define _wctime32 _wctime
#endif
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP wchar_t* __cdecl _wasctime(const struct tm*);
_ACRTIMP size_t __cdecl wcsftime(wchar_t*,size_t,const wchar_t*,const struct tm*);
_ACRTIMP size_t __cdecl _wcsftime_l(wchar_t*,size_t,const wchar_t*,const struct tm*,_locale_t);
_ACRTIMP wchar_t* __cdecl _wctime32(const __time32_t*);
_ACRTIMP wchar_t* __cdecl _wctime64(const __time64_t*);
_ACRTIMP wchar_t* __cdecl _wstrdate(wchar_t*);
_ACRTIMP errno_t __cdecl _wstrdate_s(wchar_t*,size_t);
_ACRTIMP wchar_t* __cdecl _wstrtime(wchar_t*);
_ACRTIMP errno_t __cdecl _wstrtime_s(wchar_t*,size_t);
#ifndef _USE_32BIT_TIME_T
static inline wchar_t* _wctime(const time_t *t) { return _wctime64(t); }
#elif defined(_UCRT)
static inline wchar_t* _wctime(const time_t *t) { return _wctime32(t); }
#endif
#ifdef __cplusplus
}
#endif
#endif /* _WTIME_DEFINED */

132
assets/wine/include/wine/msvcrt/crtdbg.h
View File

@@ -1,132 +0,0 @@
/*
* Debug API
*
* Copyright 2001 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_CRTDBG_H_
#define __WINE_CRTDBG_H_
#include <corecrt.h>
/* The debug API is not implemented in Winelib.
* Redirect everything to the regular APIs.
*/
#define _CRT_WARN 0
#define _CRT_ERROR 1
#define _CRT_ASSERT 2
#define _CRT_ERRCNT 3
#define _FREE_BLOCK 0
#define _NORMAL_BLOCK 1
#define _CRT_BLOCK 2
#define _IGNORE_BLOCK 3
#define _CLIENT_BLOCK 4
#define _MAX_BLOCKS 5
#define _BLOCK_TYPE(block) (block & 0xFFFF)
#define _BLOCK_SUBTYPE(block) (block >> 16 & 0xFFFF)
typedef struct _CrtMemState
{
struct _CrtMemBlockHeader* pBlockHeader;
__msvcrt_ulong lCounts[_MAX_BLOCKS];
__msvcrt_ulong lSizes[_MAX_BLOCKS];
__msvcrt_ulong lHighWaterCount;
__msvcrt_ulong lTotalCount;
} _CrtMemState;
#ifndef _DEBUG
#define _ASSERT(expr) ((void)0)
#define _ASSERTE(expr) ((void)0)
#define _CrtDbgBreak() ((void)0)
#define _CrtCheckMemory() ((int)1)
#define _CrtDbgReport(...) ((int)0)
#define _CrtDumpMemoryLeaks() ((int)0)
#define _CrtSetBreakAlloc(a) ((__msvcrt_long)0)
#define _CrtSetDbgFlag(f) ((int)0)
#define _CrtSetDumpClient(f) ((void)0)
#define _CrtSetReportMode(t,m) ((int)0)
#else /* _DEBUG */
#include <assert.h>
#define _ASSERT(expr) assert(expr)
#define _ASSERTE(expr) assert(expr)
#if defined(_MSC_VER)
#define _CrtDbgBreak() __debugbreak()
#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
#define _CrtDbgBreak() __asm__ ("\tint $0x3\n")
#else
#define _CrtDbgBreak() ((void)0)
#endif
#ifdef __cplusplus
extern "C" {
#endif
extern int _crtAssertBusy;
extern int _crtBreakAlloc;
extern int _crtDbgFlag;
_ACRTIMP int __cdecl _CrtCheckMemory(void);
_ACRTIMP int __cdecl _CrtDbgReport(int reportType, const char *filename, int linenumber,
const char *moduleName, const char *format, ...) __WINE_CRT_PRINTF_ATTR(5, 6);
_ACRTIMP int __cdecl _CrtDumpMemoryLeaks(void);
_ACRTIMP int __cdecl _CrtSetBreakAlloc(int);
_ACRTIMP int __cdecl _CrtSetDbgFlag(int);
_ACRTIMP void *__cdecl _CrtSetDumpClient(void *dumpClient);
_ACRTIMP int __cdecl _CrtSetReportMode(int reportType, int reportMode);
#ifdef __cplusplus
}
#endif
#endif /* _DEBUG */
#define _CrtDoForAllClientObjects(f,c) ((void)0)
#define _CrtIsMemoryBlock(p,s,r,f,l) ((int)1)
#define _CrtIsValidHeapPointer(p) ((int)1)
#define _CrtIsValidPointer(p,s,a) ((int)1)
#define _CrtMemCheckpoint(s) ((void)0)
#define _CrtMemDifference(s1,s2,s3) ((int)0)
#define _CrtMemDumpAllObjectsSince(s) ((void)0)
#define _CrtMemDumpStatistics(s) ((void)0)
#define _CrtSetAllocHook(f) ((void)0)
#define _RPT0(t,m)
#define _RPT1(t,m,p1)
#define _RPT2(t,m,p1,p2)
#define _RPT3(t,m,p1,p2,p3)
#define _RPT4(t,m,p1,p2,p3,p4)
#define _RPTF0(t,m)
#define _RPTF1(t,m,p1)
#define _RPTF2(t,m,p1,p2)
#define _RPTF3(t,m,p1,p2,p3)
#define _RPTF4(t,m,p1,p2,p3,p4)
#define _malloc_dbg(s,t,f,l) malloc(s)
#define _calloc_dbg(c,s,t,f,l) calloc(c,s)
#define _expand_dbg(p,s,t,f,l) _expand(p,s)
#define _free_dbg(p,t) free(p)
#define _realloc_dbg(p,s,t,f,l) realloc(p,s)
#endif /* __WINE_CRTDBG_H */

26
assets/wine/include/wine/msvcrt/crtdefs.h
View File

@@ -1,26 +0,0 @@
/*
* CRT definitions
*
* Copyright 2000 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_CRTDEFS_H
#define __WINE_CRTDEFS_H
#include <corecrt.h>
#endif /* __WINE_CRTDEFS_H */

70
assets/wine/include/wine/msvcrt/ctype.h
View File

@@ -1,70 +0,0 @@
/*
* Character type definitions
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Jon Griffiths and Francois Gouget.
* This file is in the public domain.
*/
#ifndef __WINE_CTYPE_H
#define __WINE_CTYPE_H
#include <corecrt_wctype.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef WEOF
#define WEOF (wint_t)(0xFFFF)
#endif
_ACRTIMP int __cdecl __isascii(int);
_ACRTIMP int __cdecl __iscsym(int);
_ACRTIMP int __cdecl __iscsymf(int);
_ACRTIMP int __cdecl __toascii(int);
_ACRTIMP int __cdecl _isblank_l(int,_locale_t);
_ACRTIMP int __cdecl _isctype(int,int);
_ACRTIMP int __cdecl _isctype_l(int,int,_locale_t);
_ACRTIMP int __cdecl _islower_l(int,_locale_t);
_ACRTIMP int __cdecl _isupper_l(int,_locale_t);
_ACRTIMP int __cdecl _isdigit_l(int,_locale_t);
_ACRTIMP int __cdecl _isxdigit_l(int,_locale_t);
_ACRTIMP int __cdecl _tolower(int);
_ACRTIMP int __cdecl _tolower_l(int,_locale_t);
_ACRTIMP int __cdecl _toupper(int);
_ACRTIMP int __cdecl _toupper_l(int,_locale_t);
_ACRTIMP int __cdecl isalnum(int);
_ACRTIMP int __cdecl isalpha(int);
_ACRTIMP int __cdecl isblank(int);
_ACRTIMP int __cdecl iscntrl(int);
_ACRTIMP int __cdecl isdigit(int);
_ACRTIMP int __cdecl isgraph(int);
_ACRTIMP int __cdecl islower(int);
_ACRTIMP int __cdecl isprint(int);
_ACRTIMP int __cdecl _isprint_l(int,_locale_t);
_ACRTIMP int __cdecl ispunct(int);
_ACRTIMP int __cdecl isspace(int);
_ACRTIMP int __cdecl _isspace_l(int,_locale_t);
_ACRTIMP int __cdecl isupper(int);
_ACRTIMP int __cdecl isxdigit(int);
_ACRTIMP int __cdecl tolower(int);
_ACRTIMP int __cdecl toupper(int);
#ifndef MB_CUR_MAX
_ACRTIMP int __cdecl ___mb_cur_max_func(void);
_ACRTIMP int __cdecl ___mb_cur_max_l_func(_locale_t);
#define __mb_cur_max ___mb_cur_max_func()
#define MB_CUR_MAX ___mb_cur_max_func()
#endif /* MB_CUR_MAX */
#ifdef __cplusplus
}
#endif
static inline int isascii(int c) { return __isascii(c); }
static inline int iscsym(int c) { return __iscsym(c); }
static inline int iscsymf(int c) { return __iscsymf(c); }
static inline int toascii(int c) { return __toascii(c); }
#endif /* __WINE_CTYPE_H */

50
assets/wine/include/wine/msvcrt/direct.h
View File

@@ -1,50 +0,0 @@
/*
* Path and directory definitions
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Jon Griffiths and Francois Gouget.
* This file is in the public domain.
*/
#ifndef __WINE_DIRECT_H
#define __WINE_DIRECT_H
#include <corecrt_wdirect.h>
#pragma pack(push,8)
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _DISKFREE_T_DEFINED
#define _DISKFREE_T_DEFINED
struct _diskfree_t {
unsigned int total_clusters;
unsigned int avail_clusters;
unsigned int sectors_per_cluster;
unsigned int bytes_per_sector;
};
#endif /* _DISKFREE_T_DEFINED */
_ACRTIMP int __cdecl _chdir(const char*);
_ACRTIMP int __cdecl _chdrive(int);
_ACRTIMP char* __cdecl _getcwd(char*,int);
_ACRTIMP char* __cdecl _getdcwd(int,char*,int);
_ACRTIMP int __cdecl _getdrive(void);
_ACRTIMP __msvcrt_ulong __cdecl _getdrives(void);
_ACRTIMP int __cdecl _mkdir(const char*);
_ACRTIMP int __cdecl _rmdir(const char*);
#ifdef __cplusplus
}
#endif
static inline int chdir(const char* newdir) { return _chdir(newdir); }
static inline char* getcwd(char * buf, int size) { return _getcwd(buf, size); }
static inline int mkdir(const char* newdir) { return _mkdir(newdir); }
static inline int rmdir(const char* dir) { return _rmdir(dir); }
#pragma pack(pop)
#endif /* __WINE_DIRECT_H */

1
assets/wine/include/wine/msvcrt/dirent.h
View File

@@ -1 +0,0 @@
#include <direct.h>

50
assets/wine/include/wine/msvcrt/dos.h
View File

@@ -1,50 +0,0 @@
/*
* DOS definitions
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Jon Griffiths and Francois Gouget.
* This file is in the public domain.
*/
#ifndef __WINE_DOS_H
#define __WINE_DOS_H
#include <corecrt.h>
#pragma pack(push,8)
/* The following are also defined in io.h */
#define _A_NORMAL 0x00000000
#define _A_RDONLY 0x00000001
#define _A_HIDDEN 0x00000002
#define _A_SYSTEM 0x00000004
#define _A_VOLID 0x00000008
#define _A_SUBDIR 0x00000010
#define _A_ARCH 0x00000020
#ifndef _DISKFREE_T_DEFINED
#define _DISKFREE_T_DEFINED
struct _diskfree_t {
unsigned int total_clusters;
unsigned int avail_clusters;
unsigned int sectors_per_cluster;
unsigned int bytes_per_sector;
};
#endif /* _DISKFREE_T_DEFINED */
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP unsigned int __cdecl _getdiskfree(unsigned int, struct _diskfree_t *);
#ifdef __cplusplus
}
#endif
#define diskfree_t _diskfree_t
#pragma pack(pop)
#endif /* __WINE_DOS_H */

48
assets/wine/include/wine/msvcrt/eh.h
View File

@@ -1,48 +0,0 @@
/*
* C++ exception handling facility
*
* Copyright 2000 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_EH_H
#define __WINE_EH_H
#include <corecrt.h>
#ifndef __cplusplus
#error "eh.h is meant only for C++ applications"
#endif
#pragma pack(push,8)
struct _EXCEPTION_POINTERS;
typedef void (__cdecl *terminate_handler)(void);
typedef void (__cdecl *terminate_function)(void);
typedef void (__cdecl *unexpected_handler)(void);
typedef void (__cdecl *unexpected_function)(void);
typedef void (__cdecl *_se_translator_function)(unsigned int code, struct _EXCEPTION_POINTERS *info);
_ACRTIMP terminate_function __cdecl set_terminate(terminate_function func);
_ACRTIMP unexpected_function __cdecl set_unexpected(unexpected_function func);
_ACRTIMP _se_translator_function __cdecl set_se_translator(_se_translator_function func);
_ACRTIMP DECLSPEC_NORETURN void __cdecl terminate(void);
_ACRTIMP DECLSPEC_NORETURN void __cdecl unexpected(void);
#pragma pack(pop)
#endif /* __WINE_EH_H */

122
assets/wine/include/wine/msvcrt/errno.h
View File

@@ -1,122 +0,0 @@
/*
* Copyright 2001 Jon Griffiths
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_ERRNO_H
#define __WINE_ERRNO_H
#include <corecrt.h>
# define EPERM 1
# define ENOENT 2
# define ESRCH 3
# define EINTR 4
# define EIO 5
# define ENXIO 6
# define E2BIG 7
# define ENOEXEC 8
# define EBADF 9
# define ECHILD 10
# define EAGAIN 11
# define ENOMEM 12
# define EACCES 13
# define EFAULT 14
# define EBUSY 16
# define EEXIST 17
# define EXDEV 18
# define ENODEV 19
# define ENOTDIR 20
# define EISDIR 21
# define EINVAL 22
# define ENFILE 23
# define EMFILE 24
# define ENOTTY 25
# define EFBIG 27
# define ENOSPC 28
# define ESPIPE 29
# define EROFS 30
# define EMLINK 31
# define EPIPE 32
# define EDOM 33
# define ERANGE 34
# define EDEADLK 36
# define EDEADLOCK EDEADLK
# define ENAMETOOLONG 38
# define ENOLCK 39
# define ENOSYS 40
# define ENOTEMPTY 41
# define EILSEQ 42
# define STRUNCATE 80
#ifndef _CRT_NO_POSIX_ERROR_CODES
# define EADDRINUSE 100
# define EADDRNOTAVAIL 101
# define EAFNOSUPPORT 102
# define EALREADY 103
# define EBADMSG 104
# define ECANCELED 105
# define ECONNABORTED 106
# define ECONNREFUSED 107
# define ECONNRESET 108
# define EDESTADDRREQ 109
# define EHOSTUNREACH 110
# define EIDRM 111
# define EINPROGRESS 112
# define EISCONN 113
# define ELOOP 114
# define EMSGSIZE 115
# define ENETDOWN 116
# define ENETRESET 117
# define ENETUNREACH 118
# define ENOBUFS 119
# define ENODATA 120
# define ENOLINK 121
# define ENOMSG 122
# define ENOPROTOOPT 123
# define ENOSR 124
# define ENOSTR 125
# define ENOTCONN 126
# define ENOTRECOVERABLE 127
# define ENOTSOCK 128
# define ENOTSUP 129
# define EOPNOTSUPP 130
# define EOTHER 131
# define EOVERFLOW 132
# define EOWNERDEAD 133
# define EPROTO 134
# define EPROTONOSUPPORT 135
# define EPROTOTYPE 136
# define ETIME 137
# define ETIMEDOUT 138
# define ETXTBSY 139
# define EWOULDBLOCK 140
#endif
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP int* __cdecl _errno(void);
#ifdef __cplusplus
}
#endif
#define errno (*_errno())
#endif /* __WINE_ERRNO_H */

50
assets/wine/include/wine/msvcrt/fcntl.h
View File

@@ -1,50 +0,0 @@
/*
* File definitions
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Jon Griffiths and Francois Gouget.
* This file is in the public domain.
*/
#ifndef __WINE_FCNTL_H
#define __WINE_FCNTL_H
#include <corecrt.h>
#define _O_RDONLY 0
#define _O_WRONLY 1
#define _O_RDWR 2
#define _O_ACCMODE (_O_RDONLY|_O_WRONLY|_O_RDWR)
#define _O_APPEND 0x0008
#define _O_RANDOM 0x0010
#define _O_SEQUENTIAL 0x0020
#define _O_TEMPORARY 0x0040
#define _O_NOINHERIT 0x0080
#define _O_CREAT 0x0100
#define _O_TRUNC 0x0200
#define _O_EXCL 0x0400
#define _O_SHORT_LIVED 0x1000
#define _O_TEXT 0x4000
#define _O_BINARY 0x8000
#define _O_RAW _O_BINARY
#define _O_WTEXT 0x10000
#define _O_U16TEXT 0x20000
#define _O_U8TEXT 0x40000
#define O_RDONLY _O_RDONLY
#define O_WRONLY _O_WRONLY
#define O_RDWR _O_RDWR
#define O_ACCMODE _O_ACCMODE
#define O_APPEND _O_APPEND
#define O_RANDOM _O_RANDOM
#define O_SEQUENTIAL _O_SEQUENTIAL
#define O_TEMPORARY _O_TEMPORARY
#define O_NOINHERIT _O_NOINHERIT
#define O_CREAT _O_CREAT
#define O_TRUNC _O_TRUNC
#define O_EXCL _O_EXCL
#define O_TEXT _O_TEXT
#define O_BINARY _O_BINARY
#define O_RAW _O_BINARY
#endif /* __WINE_FCNTL_H */

51
assets/wine/include/wine/msvcrt/fenv.h
View File

@@ -1,51 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
*/
#ifndef _INC_FENV
#define _INC_FENV
#include <float.h>
#define FE_TONEAREST _RC_NEAR
#define FE_UPWARD _RC_UP
#define FE_DOWNWARD _RC_DOWN
#define FE_TOWARDZERO _RC_CHOP
#define FE_INEXACT _SW_INEXACT
#define FE_UNDERFLOW _SW_UNDERFLOW
#define FE_OVERFLOW _SW_OVERFLOW
#define FE_DIVBYZERO _SW_ZERODIVIDE
#define FE_INVALID _SW_INVALID
#define FE_ALL_EXCEPT (FE_DIVBYZERO | FE_INEXACT | FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW)
#ifdef __cplusplus
extern "C" {
#endif
typedef struct
{
__msvcrt_ulong _Fe_ctl;
__msvcrt_ulong _Fe_stat;
} fenv_t;
typedef __msvcrt_ulong fexcept_t;
_ACRTIMP int __cdecl fegetenv(fenv_t*);
_ACRTIMP int __cdecl fesetenv(const fenv_t*);
_ACRTIMP int __cdecl fegetexceptflag(fexcept_t*, int);
_ACRTIMP int __cdecl fegetround(void);
_ACRTIMP int __cdecl feholdexcept(fenv_t*);
_ACRTIMP int __cdecl fesetround(int);
_ACRTIMP int __cdecl fesetexceptflag(const fexcept_t*, int);
_ACRTIMP int __cdecl feclearexcept(int);
_ACRTIMP int __cdecl fetestexcept(int);
_ACRTIMP int __cdecl feupdateenv(const fenv_t*);
#ifdef __cplusplus
}
#endif
#endif /* _INC_FENV */

166
assets/wine/include/wine/msvcrt/float.h
View File

@@ -1,166 +0,0 @@
/*
* Floating point arithmetic.
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Hans Leidekker.
* This file is in the public domain.
*/
#ifndef __WINE_FLOAT_H
#define __WINE_FLOAT_H
#include <corecrt.h>
#ifdef __cplusplus
extern "C" {
#endif
#define DBL_DIG 15
#define DBL_EPSILON 2.2204460492503131e-016
#define DBL_MANT_DIG 53
#define DBL_MAX 1.7976931348623158e+308
#define DBL_MAX_10_EXP 308
#define DBL_MAX_EXP 1024
#define DBL_MIN 2.2250738585072014e-308
#define DBL_MIN_10_EXP (-307)
#define DBL_MIN_EXP (-1021)
#define _DBL_RADIX 2
#define _DBL_ROUNDS 1
#define DBL_RADIX _DBL_RADIX
#define DBL_ROUNDS _DBL_ROUNDS
#define FLT_DIG 6
#define FLT_EPSILON 1.192092896e-07F
#define FLT_MANT_DIG 24
#define FLT_MAX 3.402823466e+38F
#define FLT_MAX_10_EXP 38
#define FLT_MAX_EXP 128
#define FLT_MIN 1.175494351e-38F
#define FLT_MIN_10_EXP (-37)
#define FLT_MIN_EXP (-125)
#define FLT_RADIX 2
#define FLT_ROUNDS 1
#define LDBL_DIG DBL_DIG
#define LDBL_EPSILON DBL_EPSILON
#define LDBL_MANT_DIG DBL_MANT_DIG
#define LDBL_MAX DBL_MAX
#define LDBL_MAX_10_EXP DBL_MAX_10_EXP
#define LDBL_MAX_EXP DBL_MAX_EXP
#define LDBL_MIN DBL_MIN
#define LDBL_MIN_10_EXP DBL_MIN_10_EXP
#define LDBL_MIN_EXP DBL_MIN_EXP
#define _LDBL_RADIX _DBL_RADIX
#define _LDBL_ROUNDS _DBL_ROUNDS
#define LDBL_RADIX _LDBL_RADIX
#define LDBL_ROUNDS _LDBL_ROUNDS
/* Control word masks for unMask */
#define _MCW_EM 0x0008001f
#define _MCW_IC 0x00040000
#define _MCW_RC 0x00000300
#define _MCW_PC 0x00030000
#define _MCW_DN 0x03000000
/* Control word values for unNew (use with related unMask above) */
#define _EM_INVALID 0x00000010
#define _EM_DENORMAL 0x00080000
#define _EM_ZERODIVIDE 0x00000008
#define _EM_OVERFLOW 0x00000004
#define _EM_UNDERFLOW 0x00000002
#define _EM_INEXACT 0x00000001
#define _IC_AFFINE 0x00040000
#define _IC_PROJECTIVE 0x00000000
#define _RC_CHOP 0x00000300
#define _RC_UP 0x00000200
#define _RC_DOWN 0x00000100
#define _RC_NEAR 0x00000000
#define _PC_24 0x00020000
#define _PC_53 0x00010000
#define _PC_64 0x00000000
#define _DN_SAVE 0x00000000
#define _DN_FLUSH 0x01000000
#define _DN_FLUSH_OPERANDS_SAVE_RESULTS 0x02000000
#define _DN_SAVE_OPERANDS_FLUSH_RESULTS 0x03000000
#define _EM_AMBIGUOUS 0x80000000
/* _statusfp bit flags */
#define _SW_INEXACT 0x00000001 /* inexact (precision) */
#define _SW_UNDERFLOW 0x00000002 /* underflow */
#define _SW_OVERFLOW 0x00000004 /* overflow */
#define _SW_ZERODIVIDE 0x00000008 /* zero divide */
#define _SW_INVALID 0x00000010 /* invalid */
#define _SW_UNEMULATED 0x00000040 /* unemulated instruction */
#define _SW_SQRTNEG 0x00000080 /* square root of a neg number */
#define _SW_STACKOVERFLOW 0x00000200 /* FP stack overflow */
#define _SW_STACKUNDERFLOW 0x00000400 /* FP stack underflow */
#define _SW_DENORMAL 0x00080000 /* denormal status bit */
/* fpclass constants */
#define _FPCLASS_SNAN 0x0001 /* Signaling "Not a Number" */
#define _FPCLASS_QNAN 0x0002 /* Quiet "Not a Number" */
#define _FPCLASS_NINF 0x0004 /* Negative Infinity */
#define _FPCLASS_NN 0x0008 /* Negative Normal */
#define _FPCLASS_ND 0x0010 /* Negative Denormal */
#define _FPCLASS_NZ 0x0020 /* Negative Zero */
#define _FPCLASS_PZ 0x0040 /* Positive Zero */
#define _FPCLASS_PD 0x0080 /* Positive Denormal */
#define _FPCLASS_PN 0x0100 /* Positive Normal */
#define _FPCLASS_PINF 0x0200 /* Positive Infinity */
/* floating point error signals */
#define _FPE_INVALID 0x81
#define _FPE_DENORMAL 0x82
#define _FPE_ZERODIVIDE 0x83
#define _FPE_OVERFLOW 0x84
#define _FPE_UNDERFLOW 0x85
#define _FPE_INEXACT 0x86
#define _FPE_UNEMULATED 0x87
#define _FPE_SQRTNEG 0x88
#define _FPE_STACKOVERFLOW 0x8a
#define _FPE_STACKUNDERFLOW 0x8b
#define _FPE_EXPLICITGEN 0x8c
#if defined(__i386__)
#define _CW_DEFAULT (_RC_NEAR + _PC_53 + _EM_INVALID + _EM_ZERODIVIDE + _EM_OVERFLOW + _EM_UNDERFLOW + _EM_INEXACT + _EM_DENORMAL)
#elif defined(__x86_64__)
#define _CW_DEFAULT (_RC_NEAR + _PC_64 + _EM_INVALID + _EM_ZERODIVIDE + _EM_OVERFLOW + _EM_UNDERFLOW + _EM_INEXACT + _EM_DENORMAL)
#endif
_ACRTIMP unsigned int __cdecl _clearfp(void);
_ACRTIMP void __cdecl _fpreset(void);
_ACRTIMP unsigned int __cdecl _statusfp(void);
_ACRTIMP int __cdecl __fpe_flt_rounds(void);
_ACRTIMP unsigned int __cdecl _control87(unsigned int, unsigned int);
_ACRTIMP unsigned int __cdecl _controlfp(unsigned int, unsigned int);
_ACRTIMP errno_t __cdecl _controlfp_s(unsigned int *, unsigned int, unsigned int);
#ifdef __i386__
_ACRTIMP int __cdecl __control87_2(unsigned int, unsigned int, unsigned int *, unsigned int *);
#endif
_ACRTIMP double __cdecl _copysign (double, double);
_ACRTIMP double __cdecl _chgsign (double);
_ACRTIMP double __cdecl _scalb(double, __msvcrt_long);
_ACRTIMP double __cdecl _logb(double);
_ACRTIMP double __cdecl _nextafter(double, double);
_ACRTIMP int __cdecl _finite(double);
_ACRTIMP int __cdecl _isnan(double);
_ACRTIMP int __cdecl _fpclass(double);
_ACRTIMP int * __cdecl __fpecode(void);
#ifdef __x86_64__
_ACRTIMP float __cdecl _scalbf(float, __msvcrt_long);
#endif
#ifdef __cplusplus
}
#endif
#endif /* __WINE_FLOAT_H */

239
assets/wine/include/wine/msvcrt/fpieee.h
View File

@@ -1,239 +0,0 @@
/**
* Derived from mingw-w64 header.
* This file is in the public domain.
*/
#ifndef __WINE_FPIEEE_H
#define __WINE_FPIEEE_H
#include <corecrt.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
_FpCompareEqual,
_FpCompareGreater,
_FpCompareLess,
_FpCompareUnordered
} _FPIEEE_COMPARE_RESULT;
typedef enum {
_FpFormatFp32,
_FpFormatFp64,
_FpFormatFp80,
_FpFormatFp128,
_FpFormatI16,
_FpFormatI32,
_FpFormatI64,
_FpFormatU16,
_FpFormatU32,
_FpFormatU64,
_FpFormatBcd80,
_FpFormatCompare,
_FpFormatString,
} _FPIEEE_FORMAT;
typedef enum {
_FpCodeUnspecified,
_FpCodeAdd,
_FpCodeSubtract,
_FpCodeMultiply,
_FpCodeDivide,
_FpCodeSquareRoot,
_FpCodeRemainder,
_FpCodeCompare,
_FpCodeConvert,
_FpCodeRound,
_FpCodeTruncate,
_FpCodeFloor,
_FpCodeCeil,
_FpCodeAcos,
_FpCodeAsin,
_FpCodeAtan,
_FpCodeAtan2,
_FpCodeCabs,
_FpCodeCos,
_FpCodeCosh,
_FpCodeExp,
_FpCodeFabs,
_FpCodeFmod,
_FpCodeFrexp,
_FpCodeHypot,
_FpCodeLdexp,
_FpCodeLog,
_FpCodeLog10,
_FpCodeModf,
_FpCodePow,
_FpCodeSin,
_FpCodeSinh,
_FpCodeTan,
_FpCodeTanh,
_FpCodeY0,
_FpCodeY1,
_FpCodeYn,
_FpCodeLogb,
_FpCodeNextafter,
_FpCodeNegate,
_FpCodeFmin,
_FpCodeFmax,
_FpCodeConvertTrunc,
_XMMIAddps,
_XMMIAddss,
_XMMISubps,
_XMMISubss,
_XMMIMulps,
_XMMIMulss,
_XMMIDivps,
_XMMIDivss,
_XMMISqrtps,
_XMMISqrtss,
_XMMIMaxps,
_XMMIMaxss,
_XMMIMinps,
_XMMIMinss,
_XMMICmpps,
_XMMICmpss,
_XMMIComiss,
_XMMIUComiss,
_XMMICvtpi2ps,
_XMMICvtsi2ss,
_XMMICvtps2pi,
_XMMICvtss2si,
_XMMICvttps2pi,
_XMMICvttss2si,
_XMMIAddsubps,
_XMMIHaddps,
_XMMIHsubps,
_XMMI2Addpd,
_XMMI2Addsd,
_XMMI2Subpd,
_XMMI2Subsd,
_XMMI2Mulpd,
_XMMI2Mulsd,
_XMMI2Divpd,
_XMMI2Divsd,
_XMMI2Sqrtpd,
_XMMI2Sqrtsd,
_XMMI2Maxpd,
_XMMI2Maxsd,
_XMMI2Minpd,
_XMMI2Minsd,
_XMMI2Cmppd,
_XMMI2Cmpsd,
_XMMI2Comisd,
_XMMI2UComisd,
_XMMI2Cvtpd2pi,
_XMMI2Cvtsd2si,
_XMMI2Cvttpd2pi,
_XMMI2Cvttsd2si,
_XMMI2Cvtps2pd,
_XMMI2Cvtss2sd,
_XMMI2Cvtpd2ps,
_XMMI2Cvtsd2ss,
_XMMI2Cvtdq2ps,
_XMMI2Cvttps2dq,
_XMMI2Cvtps2dq,
_XMMI2Cvttpd2dq,
_XMMI2Cvtpd2dq,
_XMMI2Addsubpd,
_XMMI2Haddpd,
_XMMI2Hsubpd,
} _FP_OPERATION_CODE;
typedef enum {
_FpRoundNearest,
_FpRoundMinusInfinity,
_FpRoundPlusInfinity,
_FpRoundChopped
} _FPIEEE_ROUNDING_MODE;
typedef enum {
_FpPrecisionFull,
_FpPrecision53,
_FpPrecision24,
} _FPIEEE_PRECISION;
typedef float _FP32;
typedef double _FP64;
typedef short _I16;
typedef int _I32;
typedef unsigned short _U16;
typedef unsigned int _U32;
typedef __int64 _Q64;
typedef struct {
unsigned short W[5];
} _FP80;
typedef struct DECLSPEC_ALIGN(16) {
__msvcrt_ulong W[4];
} _FP128;
typedef struct DECLSPEC_ALIGN(8) {
__msvcrt_ulong W[2];
} _I64;
typedef struct DECLSPEC_ALIGN(8) {
__msvcrt_ulong W[2];
} _U64;
typedef struct {
unsigned short W[5];
} _BCD80;
typedef struct DECLSPEC_ALIGN(16) {
_Q64 W[2];
} _FPQ64;
typedef struct {
union {
_FP32 Fp32Value;
_FP64 Fp64Value;
_FP80 Fp80Value;
_FP128 Fp128Value;
_I16 I16Value;
_I32 I32Value;
_I64 I64Value;
_U16 U16Value;
_U32 U32Value;
_U64 U64Value;
_BCD80 Bcd80Value;
char *StringValue;
int CompareValue;
_Q64 Q64Value;
_FPQ64 Fpq64Value;
} Value;
unsigned int OperandValid : 1;
unsigned int Format : 4;
} _FPIEEE_VALUE;
typedef struct {
unsigned int Inexact : 1;
unsigned int Underflow : 1;
unsigned int Overflow : 1;
unsigned int ZeroDivide : 1;
unsigned int InvalidOperation : 1;
} _FPIEEE_EXCEPTION_FLAGS;
typedef struct {
unsigned int RoundingMode : 2;
unsigned int Precision : 3;
unsigned int Operation :12;
_FPIEEE_EXCEPTION_FLAGS Cause;
_FPIEEE_EXCEPTION_FLAGS Enable;
_FPIEEE_EXCEPTION_FLAGS Status;
_FPIEEE_VALUE Operand1;
_FPIEEE_VALUE Operand2;
_FPIEEE_VALUE Result;
} _FPIEEE_RECORD,*_PFPIEEE_RECORD;
struct _EXCEPTION_POINTERS;
_ACRTIMP int __cdecl _fpieee_flt(__msvcrt_ulong _ExceptionCode,struct _EXCEPTION_POINTERS *_PtExceptionPtr,int (__cdecl *_Handler)(_FPIEEE_RECORD *));
#ifdef __cplusplus
}
#endif
#endif

110
assets/wine/include/wine/msvcrt/intrin.h
View File

@@ -1,110 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the Wine project.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#ifndef _INC_INTRIN
#define _INC_INTRIN
#if defined(__i386__) || (defined(__x86_64__) && !defined(__arm64ec__))
# include <x86intrin.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __has_builtin
# define __has_builtin(x) 0
#endif
#if defined(__i386__) || (defined(__x86_64__) && !defined(__arm64ec__))
#if __has_builtin(__cpuidex) || (defined(_MSC_VER) && !defined(__clang__))
void __cpuidex(int info[4], int ax, int cx);
#pragma intrinsic(__cpuidex)
#else
static inline void __cpuidex(int info[4], int ax, int cx)
{
__asm__ ("cpuid" : "=a"(info[0]), "=b" (info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(ax), "c"(cx));
}
#endif
#if __has_builtin(__cpuid) || (defined(_MSC_VER) && !defined(__clang__))
void __cpuid(int info[4], int ax);
#pragma intrinsic(__cpuid)
#else
static inline void __cpuid(int info[4], int ax)
{
return __cpuidex(info, ax, 0);
}
#endif
#endif
#if defined(__aarch64__) || defined(__arm64ec__)
typedef enum _tag_ARM64INTR_BARRIER_TYPE
{
_ARM64_BARRIER_OSHLD = 0x1,
_ARM64_BARRIER_OSHST = 0x2,
_ARM64_BARRIER_OSH = 0x3,
_ARM64_BARRIER_NSHLD = 0x5,
_ARM64_BARRIER_NSHST = 0x6,
_ARM64_BARRIER_NSH = 0x7,
_ARM64_BARRIER_ISHLD = 0x9,
_ARM64_BARRIER_ISHST = 0xa,
_ARM64_BARRIER_ISH = 0xb,
_ARM64_BARRIER_LD = 0xd,
_ARM64_BARRIER_ST = 0xe,
_ARM64_BARRIER_SY = 0xf
} _ARM64INTR_BARRIER_TYPE;
#endif
#ifdef __arm__
typedef enum _tag_ARMINTR_BARRIER_TYPE
{
_ARM_BARRIER_OSHST = 0x2,
_ARM_BARRIER_OSH = 0x3,
_ARM_BARRIER_NSHST = 0x6,
_ARM_BARRIER_NSH = 0x7,
_ARM_BARRIER_ISHST = 0xa,
_ARM_BARRIER_ISH = 0xb,
_ARM_BARRIER_ST = 0xe,
_ARM_BARRIER_SY = 0xf
} _ARMINTR_BARRIER_TYPE;
#endif
#if defined(_MSC_VER) && (defined(__arm__) || defined(__aarch64__) || defined(__arm64ec__))
void __dmb(unsigned int);
#pragma intrinsic(__dmb)
#endif
#if defined(_MSC_VER) && (defined(__aarch64__) || defined(__arm64ec__))
unsigned __int64 __getReg(int);
#pragma intrinsic(__getReg)
#endif
#if defined(_MSC_VER)
unsigned char _BitScanForward(unsigned long*,unsigned long);
#endif
#if defined(_MSC_VER) && (defined(__x86_64__) || defined(__aarch64__))
unsigned char _BitScanForward64(unsigned long*,unsigned __int64);
#endif
#if defined(_MSC_VER) && defined(__x86_64__)
unsigned __int64 __shiftright128(unsigned __int64, unsigned __int64, unsigned char);
unsigned __int64 _umul128(unsigned __int64, unsigned __int64, unsigned __int64*);
#endif
#ifdef __cplusplus
}
#endif
#endif /* _INC_INTRIN */

246
assets/wine/include/wine/msvcrt/inttypes.h
View File

@@ -1,246 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the mingw-w64 runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
/* 7.8 Format conversion of integer types <inttypes.h> */
#ifndef _INTTYPES_H_
#define _INTTYPES_H_
#include <corecrt.h>
#include <stdint.h>
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
intmax_t quot;
intmax_t rem;
} imaxdiv_t;
/* 7.8.1 Macros for format specifiers */
#define PRId64 "lld"
#define PRIi64 "lli"
#define PRIo64 "llo"
#define PRIu64 "llu"
#define PRIx64 "llx"
#define PRIX64 "llX"
/* fprintf macros for signed types */
#define PRId8 "d"
#define PRId16 "d"
#define PRId32 "d"
#define PRIdLEAST8 "d"
#define PRIdLEAST16 "d"
#define PRIdLEAST32 "d"
#define PRIdLEAST64 PRId64
#define PRIdFAST8 "d"
#define PRIdFAST16 "d"
#define PRIdFAST32 "d"
#define PRIdFAST64 PRId64
#define PRIdMAX PRId64
#define PRIi8 "i"
#define PRIi16 "i"
#define PRIi32 "i"
#define PRIiLEAST8 "i"
#define PRIiLEAST16 "i"
#define PRIiLEAST32 "i"
#define PRIiLEAST64 PRIi64
#define PRIiFAST8 "i"
#define PRIiFAST16 "i"
#define PRIiFAST32 "i"
#define PRIiFAST64 PRIi64
#define PRIiMAX PRIi64
#define PRIo8 "o"
#define PRIo16 "o"
#define PRIo32 "o"
#define PRIoLEAST8 "o"
#define PRIoLEAST16 "o"
#define PRIoLEAST32 "o"
#define PRIoLEAST64 PRIo64
#define PRIoFAST8 "o"
#define PRIoFAST16 "o"
#define PRIoFAST32 "o"
#define PRIoFAST64 PRIo64
#define PRIoMAX PRIo64
/* fprintf macros for unsigned types */
#define PRIu8 "u"
#define PRIu16 "u"
#define PRIu32 "u"
#define PRIuLEAST8 "u"
#define PRIuLEAST16 "u"
#define PRIuLEAST32 "u"
#define PRIuLEAST64 PRIu64
#define PRIuFAST8 "u"
#define PRIuFAST16 "u"
#define PRIuFAST32 "u"
#define PRIuFAST64 PRIu64
#define PRIuMAX PRIu64
#define PRIx8 "x"
#define PRIx16 "x"
#define PRIx32 "x"
#define PRIxLEAST8 "x"
#define PRIxLEAST16 "x"
#define PRIxLEAST32 "x"
#define PRIxLEAST64 PRIx64
#define PRIxFAST8 "x"
#define PRIxFAST16 "x"
#define PRIxFAST32 "x"
#define PRIxFAST64 PRIx64
#define PRIxMAX PRIx64
#define PRIX8 "X"
#define PRIX16 "X"
#define PRIX32 "X"
#define PRIXLEAST8 "X"
#define PRIXLEAST16 "X"
#define PRIXLEAST32 "X"
#define PRIXLEAST64 PRIX64
#define PRIXFAST8 "X"
#define PRIXFAST16 "X"
#define PRIXFAST32 "X"
#define PRIXFAST64 PRIX64
#define PRIXMAX PRIX64
/*
* fscanf macros for signed int types
* NOTE: if 32-bit int is used for int_fast8_t and int_fast16_t
* (see stdint.h, 7.18.1.3), FAST8 and FAST16 should have
* no length identifiers
*/
#define SCNd16 "hd"
#define SCNd32 "d"
#define SCNd64 PRId64
#define SCNdLEAST16 "hd"
#define SCNdLEAST32 "d"
#define SCNdLEAST64 PRId64
#define SCNdFAST16 "hd"
#define SCNdFAST32 "d"
#define SCNdFAST64 PRId64
#define SCNdMAX PRId64
#define SCNi16 "hi"
#define SCNi32 "i"
#define SCNi64 PRIi64
#define SCNiLEAST16 "hi"
#define SCNiLEAST32 "i"
#define SCNiLEAST64 PRIi64
#define SCNiFAST16 "hi"
#define SCNiFAST32 "i"
#define SCNiFAST64 PRIi64
#define SCNiMAX PRIi64
#define SCNo16 "ho"
#define SCNo32 "o"
#define SCNo64 PRIo64
#define SCNoLEAST16 "ho"
#define SCNoLEAST32 "o"
#define SCNoLEAST64 PRIo64
#define SCNoFAST16 "ho"
#define SCNoFAST32 "o"
#define SCNoFAST64 PRIo64
#define SCNoMAX PRIo64
#define SCNx16 "hx"
#define SCNx32 "x"
#define SCNx64 PRIx64
#define SCNxLEAST16 "hx"
#define SCNxLEAST32 "x"
#define SCNxLEAST64 PRIx64
#define SCNxFAST16 "hx"
#define SCNxFAST32 "x"
#define SCNxFAST64 PRIx64
#define SCNxMAX PRIx64
/* fscanf macros for unsigned int types */
#define SCNu16 "hu"
#define SCNu32 "u"
#define SCNu64 PRIu64
#define SCNuLEAST16 "hu"
#define SCNuLEAST32 "u"
#define SCNuLEAST64 PRIu64
#define SCNuFAST16 "hu"
#define SCNuFAST32 "u"
#define SCNuFAST64 PRIu64
#define SCNuMAX PRIu64
#ifdef _WIN64
#define PRIdPTR PRId64
#define PRIiPTR PRIi64
#define PRIoPTR PRIo64
#define PRIuPTR PRIu64
#define PRIxPTR PRIx64
#define PRIXPTR PRIX64
#define SCNdPTR PRId64
#define SCNiPTR PRIi64
#define SCNoPTR PRIo64
#define SCNxPTR PRIx64
#define SCNuPTR PRIu64
#else
#define PRIdPTR "d"
#define PRIiPTR "i"
#define PRIoPTR "o"
#define PRIuPTR "u"
#define PRIxPTR "x"
#define PRIXPTR "X"
#define SCNdPTR "d"
#define SCNiPTR "i"
#define SCNoPTR "o"
#define SCNxPTR "x"
#define SCNuPTR "u"
#endif
_ACRTIMP imaxdiv_t __cdecl imaxdiv(intmax_t, intmax_t);
_ACRTIMP __int64 __cdecl strtoimax(const char*,char**,int);
_ACRTIMP __int64 __cdecl strtoimax_l(const char*,char**,int,_locale_t);
_ACRTIMP unsigned __int64 __cdecl strtoumax(const char*,char**,int);
_ACRTIMP unsigned __int64 __cdecl strtoumax_l(const char*,char**,int,_locale_t);
#ifdef __cplusplus
}
#endif
#endif /* ndef _INTTYPES_H */

48
assets/wine/include/wine/msvcrt/io.h
View File

@@ -1,48 +0,0 @@
/*
* System I/O definitions.
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Jon Griffiths and Francois Gouget.
* This file is in the public domain.
*/
#ifndef __WINE_IO_H
#define __WINE_IO_H
#include <corecrt.h>
#include <corecrt_io.h>
static inline int access(const char* path, int mode) { return _access(path, mode); }
static inline int chmod(const char* path, int mode) { return _chmod(path, mode); }
static inline int chsize(int fd, __msvcrt_long size) { return _chsize(fd, size); }
static inline int close(int fd) { return _close(fd); }
static inline int creat(const char* path, int mode) { return _creat(path, mode); }
static inline int dup(int od) { return _dup(od); }
static inline int dup2(int od, int nd) { return _dup2(od, nd); }
static inline int eof(int fd) { return _eof(fd); }
static inline __msvcrt_long filelength(int fd) { return _filelength(fd); }
static inline int isatty(int fd) { return _isatty(fd); }
static inline int locking(int fd, int mode, __msvcrt_long size) { return _locking(fd, mode, size); }
static inline __msvcrt_long lseek(int fd, __msvcrt_long off, int where) { return _lseek(fd, off, where); }
static inline char* mktemp(char* pat) { return _mktemp(pat); }
static inline int read(int fd, void* buf, unsigned int size) { return _read(fd, buf, size); }
static inline int setmode(int fd, int mode) { return _setmode(fd, mode); }
static inline __msvcrt_long tell(int fd) { return _tell(fd); }
#ifndef _UMASK_DEFINED
static inline int umask(int fd) { return _umask(fd); }
#define _UMASK_DEFINED
#endif
#ifndef _UNLINK_DEFINED
static inline int unlink(const char* path) { return _unlink(path); }
#define _UNLINK_DEFINED
#endif
static inline int write(int fd, const void* buf, unsigned int size) { return _write(fd, buf, size); }
#if defined(__GNUC__) && (__GNUC__ < 4)
_ACRTIMP int __cdecl open(const char*,int,...) __attribute__((alias("_open")));
_ACRTIMP int __cdecl sopen(const char*,int,int,...) __attribute__((alias("_sopen")));
#else
#define open _open
#define sopen _sopen
#endif /* __GNUC__ */
#endif /* __WINE_IO_H */

53
assets/wine/include/wine/msvcrt/limits.h
View File

@@ -1,53 +0,0 @@
#ifndef __WINE_LIMITS_H
#define __WINE_LIMITS_H
#include <corecrt.h>
#define CHAR_BIT 8
#define MB_LEN_MAX 5
#define SCHAR_MIN (-0x80)
#define SCHAR_MAX 0x7f
#define UCHAR_MAX 0xff
#ifdef __CHAR_UNSIGNED__
# define CHAR_MIN 0
# define CHAR_MAX UCHAR_MAX
#else
# define CHAR_MIN SCHAR_MIN
# define CHAR_MAX SCHAR_MAX
#endif
#define SHRT_MIN (-0x8000)
#define SHRT_MAX 0x7fff
#define USHRT_MAX 0xffff
#define INT_MIN (-0x7fffffff - 1)
#define INT_MAX 0x7fffffff
#define UINT_MAX 0xffffffffU
#define LONG_MIN (-0x7fffffffL - 1L)
#define LONG_MAX 0x7fffffffL
#define ULONG_MAX 0xffffffffUL
#define LLONG_MAX 0x7fffffffffffffffLL
#define LLONG_MIN (-LLONG_MAX-1)
#define ULLONG_MAX 0xffffffffffffffffULL
#define _I64_MAX 0x7fffffffffffffffLL
#define _I64_MIN (-_I64_MAX-1)
#define _UI64_MAX 0xffffffffffffffffULL
#define I64_MIN _I64_MIN
#define I64_MAX _I64_MAX
#define UI64_MAX _UI64_MAX
#ifndef SIZE_MAX
# ifdef _WIN64
# define SIZE_MAX UI64_MAX
# else
# define SIZE_MAX UINT_MAX
# endif
#endif
#endif /* __WINE_LIMITS_H */

111
assets/wine/include/wine/msvcrt/locale.h
View File

@@ -1,111 +0,0 @@
/*
* Locale definitions
*
* Copyright 2000 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_LOCALE_H
#define __WINE_LOCALE_H
#include <corecrt.h>
#define LC_ALL 0
#define LC_COLLATE 1
#define LC_CTYPE 2
#define LC_MONETARY 3
#define LC_NUMERIC 4
#define LC_TIME 5
#define LC_MIN LC_ALL
#define LC_MAX LC_TIME
#ifndef _LCONV_DEFINED
#define _LCONV_DEFINED
struct lconv
{
char* decimal_point;
char* thousands_sep;
char* grouping;
char* int_curr_symbol;
char* currency_symbol;
char* mon_decimal_point;
char* mon_thousands_sep;
char* mon_grouping;
char* positive_sign;
char* negative_sign;
char int_frac_digits;
char frac_digits;
char p_cs_precedes;
char p_sep_by_space;
char n_cs_precedes;
char n_sep_by_space;
char p_sign_posn;
char n_sign_posn;
#if _MSVCR_VER >= 100
wchar_t* _W_decimal_point;
wchar_t* _W_thousands_sep;
wchar_t* _W_int_curr_symbol;
wchar_t* _W_currency_symbol;
wchar_t* _W_mon_decimal_point;
wchar_t* _W_mon_thousands_sep;
wchar_t* _W_positive_sign;
wchar_t* _W_negative_sign;
#endif
};
#endif /* _LCONV_DEFINED */
struct tm;
#ifndef _CONFIG_LOCALE_SWT
#define _CONFIG_LOCALE_SWT
#define _ENABLE_PER_THREAD_LOCALE 0x1
#define _DISABLE_PER_THREAD_LOCALE 0x2
#define _ENABLE_PER_THREAD_LOCALE_GLOBAL 0x10
#define _DISABLE_PER_THREAD_LOCALE_GLOBAL 0x20
#define _ENABLE_PER_THREAD_LOCALE_NEW 0x100
#define _DISABLE_PER_THREAD_LOCALE_NEW 0x200
#endif
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP char* __cdecl setlocale(int,const char*);
_ACRTIMP struct lconv* __cdecl localeconv(void);
_ACRTIMP size_t __cdecl _Strftime(char*,size_t,const char*,const struct tm*,void*);
_ACRTIMP int __cdecl _configthreadlocale(int);
_ACRTIMP _locale_t __cdecl _get_current_locale(void);
_ACRTIMP _locale_t __cdecl _create_locale(int, const char*);
_ACRTIMP _locale_t __cdecl _wcreate_locale(int, const wchar_t*);
_ACRTIMP void __cdecl _free_locale(_locale_t);
_ACRTIMP unsigned int __cdecl ___lc_codepage_func(void);
_ACRTIMP wchar_t** __cdecl ___lc_locale_name_func(void);
_ACRTIMP void* __cdecl _Gettnames(void);
_ACRTIMP void* __cdecl _W_Gettnames(void);
#ifndef _WLOCALE_DEFINED
#define _WLOCALE_DEFINED
_ACRTIMP wchar_t* __cdecl _wsetlocale(int,const wchar_t*);
#endif /* _WLOCALE_DEFINED */
#ifdef __cplusplus
}
#endif
#endif /* __WINE_LOCALE_H */

84
assets/wine/include/wine/msvcrt/malloc.h
View File

@@ -1,84 +0,0 @@
/*
* Heap definitions
*
* Copyright 2001 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_MALLOC_H
#define __WINE_MALLOC_H
#include <corecrt.h>
#include <corecrt_malloc.h>
/* heap function constants */
#define _HEAPEMPTY -1
#define _HEAPOK -2
#define _HEAPBADBEGIN -3
#define _HEAPBADNODE -4
#define _HEAPEND -5
#define _HEAPBADPTR -6
#define _FREEENTRY 0
#define _USEDENTRY 1
#ifndef _HEAPINFO_DEFINED
#define _HEAPINFO_DEFINED
typedef struct _heapinfo
{
int* _pentry;
size_t _size;
int _useflag;
} _HEAPINFO;
#endif /* _HEAPINFO_DEFINED */
#ifdef __i386__
_ACRTIMP unsigned int* __cdecl __p__amblksiz(void);
#define _amblksiz (*__p__amblksiz());
#else
extern unsigned int _amblksiz;
#endif
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP int __cdecl _heapadd(void*,size_t);
_ACRTIMP int __cdecl _heapchk(void);
_ACRTIMP int __cdecl _heapmin(void);
_ACRTIMP int __cdecl _heapset(unsigned int);
_ACRTIMP size_t __cdecl _heapused(size_t*,size_t*);
_ACRTIMP int __cdecl _heapwalk(_HEAPINFO*);
_ACRTIMP intptr_t __cdecl _get_heap_handle(void);
_ACRTIMP size_t __cdecl _get_sbh_threshold(void);
_ACRTIMP int __cdecl _set_sbh_threshold(size_t size);
#ifdef _MSC_VER
void *_alloca(size_t size);
#endif
#ifdef __cplusplus
}
#endif
# ifdef __GNUC__
# define _alloca(x) __builtin_alloca((x))
# define alloca(x) __builtin_alloca((x))
# elif defined(_MSC_VER)
# define alloca(x) _alloca((x))
# endif
#endif /* __WINE_MALLOC_H */

436
assets/wine/include/wine/msvcrt/math.h
View File

@@ -1,436 +0,0 @@
/*
* Math functions.
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Hans Leidekker.
* This file is in the public domain.
*/
#ifndef __WINE_MATH_H
#define __WINE_MATH_H
#include <corecrt.h>
#pragma pack(push,8)
#ifdef __cplusplus
extern "C" {
#endif
#define _DOMAIN 1 /* domain error in argument */
#define _SING 2 /* singularity */
#define _OVERFLOW 3 /* range overflow */
#define _UNDERFLOW 4 /* range underflow */
#define _TLOSS 5 /* total loss of precision */
#define _PLOSS 6 /* partial loss of precision */
#ifndef _EXCEPTION_DEFINED
#define _EXCEPTION_DEFINED
struct _exception
{
int type;
char *name;
double arg1;
double arg2;
double retval;
};
#endif /* _EXCEPTION_DEFINED */
#ifndef _COMPLEX_DEFINED
#define _COMPLEX_DEFINED
struct _complex
{
double x; /* Real part */
double y; /* Imaginary part */
};
#endif /* _COMPLEX_DEFINED */
_ACRTIMP double __cdecl sin(double);
_ACRTIMP double __cdecl cos(double);
_ACRTIMP double __cdecl tan(double);
_ACRTIMP double __cdecl sinh(double);
_ACRTIMP double __cdecl cosh(double);
_ACRTIMP double __cdecl tanh(double);
_ACRTIMP double __cdecl asin(double);
_ACRTIMP double __cdecl acos(double);
_ACRTIMP double __cdecl atan(double);
_ACRTIMP double __cdecl atan2(double, double);
_ACRTIMP double __cdecl asinh(double);
_ACRTIMP double __cdecl acosh(double);
_ACRTIMP double __cdecl atanh(double);
_ACRTIMP double __cdecl exp(double);
_ACRTIMP double __cdecl log(double);
_ACRTIMP double __cdecl log10(double);
_ACRTIMP double __cdecl pow(double, double);
_ACRTIMP double __cdecl sqrt(double);
_ACRTIMP double __cdecl ceil(double);
_ACRTIMP double __cdecl floor(double);
_ACRTIMP double __cdecl fabs(double);
_ACRTIMP double __cdecl ldexp(double, int);
_ACRTIMP double __cdecl frexp(double, int*);
_ACRTIMP double __cdecl modf(double, double*);
_ACRTIMP double __cdecl fdim(double, double);
_ACRTIMP double __cdecl fmod(double, double);
_ACRTIMP double __cdecl fmin(double, double);
_ACRTIMP double __cdecl fmax(double, double);
_ACRTIMP double __cdecl erf(double);
_ACRTIMP double __cdecl remainder(double, double);
_ACRTIMP double __cdecl remquo(double, double, int*);
_ACRTIMP float __cdecl remquof(float, float, int*);
_ACRTIMP double __cdecl lgamma(double);
_ACRTIMP double __cdecl tgamma(double);
_ACRTIMP double __cdecl _hypot(double, double);
_ACRTIMP double __cdecl _j0(double);
_ACRTIMP double __cdecl _j1(double);
_ACRTIMP double __cdecl _jn(int, double);
_ACRTIMP double __cdecl _y0(double);
_ACRTIMP double __cdecl _y1(double);
_ACRTIMP double __cdecl _yn(int, double);
_ACRTIMP double __cdecl cbrt(double);
_ACRTIMP double __cdecl exp2(double);
_ACRTIMP double __cdecl expm1(double);
_ACRTIMP double __cdecl log1p(double);
_ACRTIMP double __cdecl log2(double);
_ACRTIMP double __cdecl logb(double);
_ACRTIMP double __cdecl rint(double);
_ACRTIMP double __cdecl round(double);
_ACRTIMP double __cdecl trunc(double);
_ACRTIMP float __cdecl cbrtf(float);
_ACRTIMP float __cdecl exp2f(float);
_ACRTIMP float __cdecl expm1f(float);
_ACRTIMP float __cdecl log1pf(float);
_ACRTIMP float __cdecl log2f(float);
_ACRTIMP float __cdecl logbf(float);
_ACRTIMP float __cdecl rintf(float);
_ACRTIMP float __cdecl roundf(float);
_ACRTIMP float __cdecl truncf(float);
_ACRTIMP int __cdecl ilogb(double);
_ACRTIMP int __cdecl ilogbf(float);
_ACRTIMP float __cdecl fmaf(float x, float y, float z);
_ACRTIMP double __cdecl fma(double x, double y, double z);
_ACRTIMP __int64 __cdecl llrint(double);
_ACRTIMP __int64 __cdecl llrintf(float);
_ACRTIMP __int64 __cdecl llround(double);
_ACRTIMP __int64 __cdecl llroundf(float);
_ACRTIMP __msvcrt_long __cdecl lrint(double);
_ACRTIMP __msvcrt_long __cdecl lrintf(float);
_ACRTIMP __msvcrt_long __cdecl lround(double);
_ACRTIMP __msvcrt_long __cdecl lroundf(float);
_ACRTIMP double __cdecl scalbn(double,int);
_ACRTIMP float __cdecl scalbnf(float,int);
_ACRTIMP double __cdecl scalbln(double,__msvcrt_long);
_ACRTIMP float __cdecl scalblnf(float,__msvcrt_long);
_ACRTIMP double __cdecl _copysign (double, double);
_ACRTIMP double __cdecl _chgsign (double);
_ACRTIMP double __cdecl _scalb(double, __msvcrt_long);
_ACRTIMP double __cdecl _logb(double);
_ACRTIMP double __cdecl _nextafter(double, double);
_ACRTIMP int __cdecl _finite(double);
_ACRTIMP int __cdecl _isnan(double);
_ACRTIMP int __cdecl _fpclass(double);
_ACRTIMP double __cdecl nextafter(double, double);
#if !defined(__i386__) || defined(_NO_CRT_MATH_INLINE)
_ACRTIMP float __cdecl sinf(float);
_ACRTIMP float __cdecl cosf(float);
_ACRTIMP float __cdecl tanf(float);
_ACRTIMP float __cdecl sinhf(float);
_ACRTIMP float __cdecl coshf(float);
_ACRTIMP float __cdecl tanhf(float);
_ACRTIMP float __cdecl asinf(float);
_ACRTIMP float __cdecl acosf(float);
_ACRTIMP float __cdecl atanf(float);
_ACRTIMP float __cdecl atan2f(float, float);
_ACRTIMP float __cdecl atanhf(float);
_ACRTIMP float __cdecl expf(float);
_ACRTIMP float __cdecl logf(float);
_ACRTIMP float __cdecl log10f(float);
_ACRTIMP float __cdecl powf(float, float);
_ACRTIMP float __cdecl sqrtf(float);
_ACRTIMP float __cdecl ceilf(float);
_ACRTIMP float __cdecl floorf(float);
_ACRTIMP float __cdecl modff(float, float*);
_ACRTIMP float __cdecl fmodf(float, float);
_ACRTIMP int __cdecl _finitef(float);
_ACRTIMP int __cdecl _isnanf(float);
_ACRTIMP int __cdecl _fpclassf(float);
#else
static inline float sinf(float x) { return sin(x); }
static inline float cosf(float x) { return cos(x); }
static inline float tanf(float x) { return tan(x); }
static inline float sinhf(float x) { return sinh(x); }
static inline float coshf(float x) { return cosh(x); }
static inline float tanhf(float x) { return tanh(x); }
static inline float asinf(float x) { return asin(x); }
static inline float acosf(float x) { return acos(x); }
static inline float atanf(float x) { return atan(x); }
static inline float atan2f(float x, float y) { return atan2(x, y); }
static inline float expf(float x) { return exp(x); }
static inline float logf(float x) { return log(x); }
static inline float log10f(float x) { return log10(x); }
static inline float powf(float x, float y) { return pow(x, y); }
static inline float sqrtf(float x) { return sqrt(x); }
static inline float ceilf(float x) { return ceil(x); }
static inline float floorf(float x) { return floor(x); }
static inline float modff(float x, float *y) { double yd, ret = modf(x, &yd); *y = yd; return ret; }
static inline float fmodf(float x, float y) { return fmod(x, y); }
static inline int _finitef(float x) { return _finite(x); }
static inline int _isnanf(float x) { return _isnan(x); }
static inline int _fpclassf(float x)
{
unsigned int ix = *(int*)&x;
double d = x;
/* construct denormal double */
if (!(ix >> 23 & 0xff) && (ix << 1))
{
unsigned __int64 id = (((unsigned __int64)ix >> 31) << 63) | 1;
d = *(double*)&id;
}
return _fpclass(d);
}
#endif
#if (defined(__x86_64__) && !defined(_UCRT)) || defined(_NO_CRT_MATH_INLINE)
_ACRTIMP float __cdecl frexpf(float, int*);
#else
static inline float frexpf(float x, int *y) { return frexp(x, y); }
#endif
#if (!defined(__i386__) && !defined(__x86_64__) && (_MSVCR_VER == 0 || _MSVCR_VER >= 110)) || defined(_NO_CRT_MATH_INLINE)
_ACRTIMP float __cdecl fabsf(float);
#else
static inline float fabsf(float x) { return fabs(x); }
#endif
#if !defined(__i386__) || _MSVCR_VER>=120 || defined(_NO_CRT_MATH_INLINE)
_ACRTIMP float __cdecl _chgsignf(float);
_ACRTIMP float __cdecl _copysignf(float, float);
_ACRTIMP float __cdecl _logbf(float);
_ACRTIMP float __cdecl acoshf(float);
_ACRTIMP float __cdecl asinhf(float);
_ACRTIMP float __cdecl atanhf(float);
_ACRTIMP float __cdecl erff(float);
_ACRTIMP float __cdecl fdimf(float, float);
_ACRTIMP float __cdecl fmaxf(float, float);
_ACRTIMP float __cdecl fminf(float, float);
_ACRTIMP float __cdecl lgammaf(float);
_ACRTIMP float __cdecl nextafterf(float, float);
_ACRTIMP float __cdecl remainderf(float, float);
_ACRTIMP float __cdecl tgammaf(float);
#else
static inline float _chgsignf(float x) { return _chgsign(x); }
static inline float _copysignf(float x, float y) { return _copysign(x, y); }
static inline float _logbf(float x) { return _logb(x); }
#endif
static inline float ldexpf(float x, int y) { return ldexp(x, y); }
#ifdef _UCRT
_ACRTIMP double __cdecl copysign(double, double);
_ACRTIMP float __cdecl copysignf(float, float);
#else
#define copysign(x,y) _copysign(x,y)
#define copysignf(x,y) _copysignf(x,y)
#endif
_ACRTIMP double __cdecl nearbyint(double);
_ACRTIMP float __cdecl nearbyintf(float);
_ACRTIMP float __cdecl _hypotf(float, float);
_ACRTIMP int __cdecl _matherr(struct _exception*);
_ACRTIMP double __cdecl _cabs(struct _complex);
#if (defined(__GNUC__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)))) || defined(__clang__)
# define INFINITY __builtin_inff()
# define NAN __builtin_nanf("")
# define HUGE_VAL __builtin_huge_val()
#else
static const union {
unsigned int __i;
float __f;
} __inff = { 0x7f800000 }, __nanf = { 0x7fc00000 };
# define INFINITY (__inff.__f)
# define NAN (__nanf.__f)
# define HUGE_VAL ((double)INFINITY)
#endif
#define FP_INFINITE 1
#define FP_NAN 2
#define FP_NORMAL -1
#define FP_SUBNORMAL -2
#define FP_ZERO 0
#define _C2 1
#define FP_ILOGB0 (-0x7fffffff - _C2)
#define FP_ILOGBNAN 0x7fffffff
_ACRTIMP short __cdecl _dtest(double*);
_ACRTIMP short __cdecl _ldtest(long double*);
_ACRTIMP short __cdecl _fdtest(float*);
_ACRTIMP int __cdecl _dsign(double);
_ACRTIMP int __cdecl _ldsign(long double);
_ACRTIMP int __cdecl _fdsign(float);
#ifdef __cplusplus
extern "C++" {
inline int fpclassify(float x) throw() { return _fdtest(&x); }
inline int fpclassify(double x) throw() { return _dtest(&x); }
inline int fpclassify(long double x) throw() { return _ldtest(&x); }
inline bool signbit(float x) throw() { return _fdsign(x) != 0; }
inline bool signbit(double x) throw() { return _dsign(x) != 0; }
inline bool signbit(long double x) throw() { return _ldsign(x) != 0; }
template <class T> inline bool isfinite(T x) throw() { return fpclassify(x) <= 0; }
template <class T> inline bool isinf(T x) throw() { return fpclassify(x) == FP_INFINITE; }
template <class T> inline bool isnan(T x) throw() { return fpclassify(x) == FP_NAN; }
template <class T> inline bool isnormal(T x) throw() { return fpclassify(x) == FP_NORMAL; }
} /* extern "C++" */
#elif _MSVCR_VER >= 120
_ACRTIMP short __cdecl _dclass(double);
_ACRTIMP short __cdecl _fdclass(float);
#define fpclassify(x) (sizeof(x) == sizeof(float) ? _fdclass(x) : _dclass(x))
#define signbit(x) (sizeof(x) == sizeof(float) ? _fdsign(x) : _dsign(x))
#define isinf(x) (fpclassify(x) == FP_INFINITE)
#define isnan(x) (fpclassify(x) == FP_NAN)
#define isnormal(x) (fpclassify(x) == FP_NORMAL)
#define isfinite(x) (fpclassify(x) <= 0)
_ACRTIMP int __cdecl _dpcomp(double, double);
_ACRTIMP int __cdecl _fdpcomp(float, float);
#define _FP_LT 1
#define _FP_EQ 2
#define _FP_GT 4
#else
static inline int __isnanf(float x)
{
union { float x; unsigned int i; } u = { x };
return (u.i & 0x7fffffff) > 0x7f800000;
}
static inline int __isnan(double x)
{
union { double x; unsigned __int64 i; } u = { x };
return (u.i & ~0ull >> 1) > 0x7ffull << 52;
}
static inline int __isinff(float x)
{
union { float x; unsigned int i; } u = { x };
return (u.i & 0x7fffffff) == 0x7f800000;
}
static inline int __isinf(double x)
{
union { double x; unsigned __int64 i; } u = { x };
return (u.i & ~0ull >> 1) == 0x7ffull << 52;
}
static inline int __isnormalf(float x)
{
union { float x; unsigned int i; } u = { x };
return ((u.i + 0x00800000) & 0x7fffffff) >= 0x01000000;
}
static inline int __isnormal(double x)
{
union { double x; unsigned __int64 i; } u = { x };
return ((u.i + (1ull << 52)) & ~0ull >> 1) >= 1ull << 53;
}
static inline int __signbitf(float x)
{
union { float x; unsigned int i; } u = { x };
return (int)(u.i >> 31);
}
static inline int __signbit(double x)
{
union { double x; unsigned __int64 i; } u = { x };
return (int)(u.i >> 63);
}
#define isinf(x) (sizeof(x) == sizeof(float) ? __isinff(x) : __isinf(x))
#define isnan(x) (sizeof(x) == sizeof(float) ? __isnanf(x) : __isnan(x))
#define isnormal(x) (sizeof(x) == sizeof(float) ? __isnormalf(x) : __isnormal(x))
#define signbit(x) (sizeof(x) == sizeof(float) ? __signbitf(x) : __signbit(x))
#define isfinite(x) (!isinf(x) && !isnan(x))
#endif
#ifdef _UCRT
#if defined(__GNUC__) || defined(__clang__)
# define isgreater(x, y) __builtin_isgreater(x, y)
# define isgreaterequal(x, y) __builtin_isgreaterequal(x, y)
# define isless(x, y) __builtin_isless(x, y)
# define islessequal(x, y) __builtin_islessequal(x, y)
# define islessgreater(x, y) __builtin_islessgreater(x, y)
# define isunordered(x, y) __builtin_isunordered(x, y)
#else
# define __FP_COMPARE(x,y) (sizeof(x) == sizeof(float) && sizeof(y) == sizeof(float) ? _fdpcomp(x,y) : _dpcomp(x,y))
# define isgreater(x, y) ((__FP_COMPARE(x, y) & _FP_GT) != 0)
# define isgreaterequal(x, y) ((__FP_COMPARE(x, y) & (_FP_GT|_FP_EQ)) != 0)
# define isless(x, y) ((__FP_COMPARE(x, y) & _FP_LT) != 0)
# define islessequal(x, y) ((__FP_COMPARE(x, y) & (_FP_LT|_FP_EQ)) != 0)
# define islessgreater(x, y) ((__FP_COMPARE(x, y) & (_FP_LT|_FP_GT)) != 0)
# define isunordered(x, y) (!__FP_COMPARE(x, y))
#endif
#endif /* _UCRT */
#ifdef __cplusplus
}
#endif
#pragma pack(pop)
#if !defined(__STRICT_ANSI__) || defined(_POSIX_C_SOURCE) || defined(_POSIX_SOURCE) || defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE) || defined(_USE_MATH_DEFINES)
#ifndef _MATH_DEFINES_DEFINED
#define _MATH_DEFINES_DEFINED
#define M_E 2.71828182845904523536
#define M_LOG2E 1.44269504088896340736
#define M_LOG10E 0.434294481903251827651
#define M_LN2 0.693147180559945309417
#define M_LN10 2.30258509299404568402
#define M_PI 3.14159265358979323846
#define M_PI_2 1.57079632679489661923
#define M_PI_4 0.785398163397448309616
#define M_1_PI 0.318309886183790671538
#define M_2_PI 0.636619772367581343076
#define M_2_SQRTPI 1.12837916709551257390
#define M_SQRT2 1.41421356237309504880
#define M_SQRT1_2 0.707106781186547524401
#endif /* !_MATH_DEFINES_DEFINED */
#endif /* _USE_MATH_DEFINES */
static inline double hypot( double x, double y ) { return _hypot( x, y ); }
static inline double j0( double x ) { return _j0( x ); }
static inline double j1( double x ) { return _j1( x ); }
static inline double jn( int n, double x ) { return _jn( n, x ); }
static inline double y0( double x ) { return _y0( x ); }
static inline double y1( double x ) { return _y1( x ); }
static inline double yn( int n, double x ) { return _yn( n, x ); }
static inline float hypotf( float x, float y ) { return _hypotf( x, y ); }
static inline long double atan2l( long double x, long double y ) { return atan2( (double)y, (double)x ); }
#endif /* __WINE_MATH_H */

81
assets/wine/include/wine/msvcrt/mbctype.h
View File

@@ -1,81 +0,0 @@
/*
* Multibyte char definitions
*
* Copyright 2001 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_MBCTYPE_H
#define __WINE_MBCTYPE_H
#include <corecrt.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __i386__
_ACRTIMP unsigned char* __cdecl __p__mbctype(void);
#define _mbctype (__p__mbctype())
#else
extern unsigned char MSVCRT_mbctype[];
#endif
#define _MS 0x01
#define _MP 0x02
#define _M1 0x04
#define _M2 0x08
#define _SBUP 0x10
#define _SBLOW 0x20
#define _MBC_SINGLE 0
#define _MBC_LEAD 1
#define _MBC_TRAIL 2
#define _MBC_ILLEGAL -1
#define _KANJI_CP 932
#define _MB_CP_SBCS 0
#define _MB_CP_OEM -2
#define _MB_CP_ANSI -3
#define _MB_CP_LOCALE -4
_ACRTIMP int __cdecl _getmbcp(void);
_ACRTIMP int __cdecl _ismbbalnum(unsigned int);
_ACRTIMP int __cdecl _ismbbalpha(unsigned int);
_ACRTIMP int __cdecl _ismbbgraph(unsigned int);
_ACRTIMP int __cdecl _ismbbkalnum(unsigned int);
_ACRTIMP int __cdecl _ismbbkana(unsigned int);
_ACRTIMP int __cdecl _ismbbkprint(unsigned int);
_ACRTIMP int __cdecl _ismbbkpunct(unsigned int);
_ACRTIMP int __cdecl _ismbbprint(unsigned int);
_ACRTIMP int __cdecl _ismbbpunct(unsigned int);
_ACRTIMP int __cdecl _setmbcp(int);
#ifndef _MBLEADTRAIL_DEFINED
#define _MBLEADTRAIL_DEFINED
_ACRTIMP int __cdecl _ismbblead(unsigned int);
_ACRTIMP int __cdecl _ismbblead_l(unsigned int,_locale_t);
_ACRTIMP int __cdecl _ismbbtrail(unsigned int);
_ACRTIMP int __cdecl _ismbslead(const unsigned char*,const unsigned char*);
_ACRTIMP int __cdecl _ismbstrail(const unsigned char*,const unsigned char*);
#endif /* _MBLEADTRAIL_DEFINED */
#ifdef __cplusplus
}
#endif
#endif /* __WINE_MBCTYPE_H */

132
assets/wine/include/wine/msvcrt/mbstring.h
View File

@@ -1,132 +0,0 @@
/*
* Multibyte string definitions
*
* Copyright 2001 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_MBSTRING_H
#define __WINE_MBSTRING_H
#include <corecrt.h>
#pragma pack(push,8)
#ifndef _NLSCMP_DEFINED
#define _NLSCMPERROR ((unsigned int)0x7fffffff)
#define _NLSCMP_DEFINED
#endif
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP int __cdecl _ismbcalnum(unsigned int);
_ACRTIMP int __cdecl _ismbcalpha(unsigned int);
_ACRTIMP int __cdecl _ismbcdigit(unsigned int);
_ACRTIMP int __cdecl _ismbcgraph(unsigned int);
_ACRTIMP int __cdecl _ismbchira(unsigned int);
_ACRTIMP int __cdecl _ismbckata(unsigned int);
_ACRTIMP int __cdecl _ismbcl0(unsigned int);
_ACRTIMP int __cdecl _ismbcl1(unsigned int);
_ACRTIMP int __cdecl _ismbcl2(unsigned int);
_ACRTIMP int __cdecl _ismbclegal(unsigned int);
_ACRTIMP int __cdecl _ismbclegal_l(unsigned int, _locale_t);
_ACRTIMP int __cdecl _ismbclower(unsigned int);
_ACRTIMP int __cdecl _ismbcprint(unsigned int);
_ACRTIMP int __cdecl _ismbcpunct(unsigned int);
_ACRTIMP int __cdecl _ismbcspace(unsigned int);
_ACRTIMP int __cdecl _ismbcsymbol(unsigned int);
_ACRTIMP int __cdecl _ismbcupper(unsigned int);
_ACRTIMP unsigned int __cdecl _mbbtombc(unsigned int);
_ACRTIMP int __cdecl _mbbtype(unsigned char,int);
_ACRTIMP int __cdecl _mbbtype_l(unsigned char,int,_locale_t);
#define _mbccmp(_cpc1,_cpc2) _mbsncmp((_cpc1),(_cpc2),1)
_ACRTIMP void __cdecl _mbccpy(unsigned char*,const unsigned char*);
_ACRTIMP unsigned int __cdecl _mbcjistojms(unsigned int);
_ACRTIMP unsigned int __cdecl _mbcjmstojis(unsigned int);
_ACRTIMP size_t __cdecl _mbclen(const unsigned char*);
_ACRTIMP unsigned int __cdecl _mbctohira(unsigned int);
_ACRTIMP unsigned int __cdecl _mbctokata(unsigned int);
_ACRTIMP unsigned int __cdecl _mbctolower(unsigned int);
_ACRTIMP unsigned int __cdecl _mbctombb(unsigned int);
_ACRTIMP unsigned int __cdecl _mbctoupper(unsigned int);
_ACRTIMP int __cdecl _mbsbtype(const unsigned char*,size_t);
_ACRTIMP unsigned char* __cdecl _mbscat(unsigned char*,const unsigned char*);
_ACRTIMP unsigned char* __cdecl _mbschr(const unsigned char*,unsigned int);
_ACRTIMP int __cdecl _mbscmp(const unsigned char*,const unsigned char*);
_ACRTIMP int __cdecl _mbscmp_l(const unsigned char*,const unsigned char*,_locale_t);
_ACRTIMP int __cdecl _mbscoll(const unsigned char*,const unsigned char*);
_ACRTIMP unsigned char* __cdecl _mbscpy(unsigned char*,const unsigned char*);
_ACRTIMP size_t __cdecl _mbscspn(const unsigned char*,const unsigned char*);
_ACRTIMP unsigned char* __cdecl _mbsdec(const unsigned char*,const unsigned char*);
_ACRTIMP unsigned char* __cdecl _mbsdup(const unsigned char*);
_ACRTIMP int __cdecl _mbsicmp(const unsigned char*,const unsigned char*);
_ACRTIMP int __cdecl _mbsicoll(const unsigned char*,const unsigned char*);
_ACRTIMP unsigned char* __cdecl _mbsinc(const unsigned char*);
_ACRTIMP size_t __cdecl _mbslen(const unsigned char*);
_ACRTIMP unsigned char* __cdecl _mbslwr(unsigned char*);
_ACRTIMP errno_t __cdecl _mbslwr_s(unsigned char*, size_t);
_ACRTIMP unsigned char* __cdecl _mbsnbcat(unsigned char*,const unsigned char*,size_t);
_ACRTIMP errno_t __cdecl _mbsnbcat_s(unsigned char*,size_t,const unsigned char*,size_t);
_ACRTIMP int __cdecl _mbsnbcmp(const unsigned char*,const unsigned char*,size_t);
_ACRTIMP int __cdecl _mbsnbcoll(const unsigned char*,const unsigned char*,size_t);
_ACRTIMP size_t __cdecl _mbsnbcnt(const unsigned char*,size_t);
_ACRTIMP unsigned char* __cdecl _mbsnbcpy(unsigned char*,const unsigned char*,size_t);
_ACRTIMP int __cdecl _mbsnbicmp(const unsigned char*,const unsigned char*,size_t);
_ACRTIMP int __cdecl _mbsnbicoll(const unsigned char*,const unsigned char*,size_t);
_ACRTIMP unsigned char* __cdecl _mbsnbset(unsigned char*,unsigned int,size_t);
_ACRTIMP unsigned char* __cdecl _mbsncat(unsigned char*,const unsigned char*, size_t);
_ACRTIMP size_t __cdecl _mbsnccnt(const unsigned char*,size_t);
_ACRTIMP int __cdecl _mbsncmp(const unsigned char*,const unsigned char*,size_t);
_ACRTIMP int __cdecl _mbsncoll(const unsigned char*,const unsigned char*,size_t);
_ACRTIMP unsigned char* __cdecl _mbsncpy(unsigned char*,const unsigned char*,size_t);
_ACRTIMP errno_t __cdecl _mbsncpy_s(unsigned char*,size_t,const unsigned char*,size_t);
_ACRTIMP errno_t __cdecl _mbsncpy_s_l(unsigned char*,size_t,const unsigned char*,size_t,_locale_t);
_ACRTIMP unsigned int __cdecl _mbsnextc(const unsigned char*);
_ACRTIMP unsigned int __cdecl _mbsnextc_l(const unsigned char*,_locale_t);
_ACRTIMP int __cdecl _mbsnicmp(const unsigned char*,const unsigned char*,size_t);
_ACRTIMP int __cdecl _mbsnicoll(const unsigned char*,const unsigned char*,size_t);
_ACRTIMP unsigned char* __cdecl _mbsninc(const unsigned char*,size_t);
_ACRTIMP unsigned char* __cdecl _mbsnset(unsigned char*,unsigned int,size_t);
_ACRTIMP unsigned char* __cdecl _mbspbrk(const unsigned char*,const unsigned char*);
_ACRTIMP unsigned char* __cdecl _mbsrchr(const unsigned char*,unsigned int);
_ACRTIMP unsigned char* __cdecl _mbsrev(unsigned char*);
_ACRTIMP unsigned char* __cdecl _mbsset(unsigned char*,unsigned int);
_ACRTIMP size_t __cdecl _mbsspn(const unsigned char*,const unsigned char*);
_ACRTIMP unsigned char* __cdecl _mbsspnp(const unsigned char*,const unsigned char*);
_ACRTIMP unsigned char* __cdecl _mbsstr(const unsigned char*,const unsigned char*);
_ACRTIMP unsigned char* __cdecl _mbstok(unsigned char*,const unsigned char*);
_ACRTIMP unsigned char* __cdecl _mbstok_l(unsigned char*,const unsigned char*,_locale_t);
_ACRTIMP unsigned char* __cdecl _mbstok_s(unsigned char*,const unsigned char*,unsigned char**);
_ACRTIMP unsigned char* __cdecl _mbsupr(unsigned char*);
_ACRTIMP errno_t __cdecl _mbsupr_s(unsigned char*, size_t);
#ifndef _MBLEADTRAIL_DEFINED
#define _MBLEADTRAIL_DEFINED
_ACRTIMP int __cdecl _ismbblead(unsigned int);
_ACRTIMP int __cdecl _ismbblead_l(unsigned int,_locale_t);
_ACRTIMP int __cdecl _ismbbtrail(unsigned int);
_ACRTIMP int __cdecl _ismbslead(const unsigned char*,const unsigned char*);
_ACRTIMP int __cdecl _ismbstrail(const unsigned char*,const unsigned char*);
#endif /* _MBLEADTRAIL_DEFINED */
#ifdef __cplusplus
}
#endif
#pragma pack(pop)
#endif /* __WINE_MBSTRING_H */

38
assets/wine/include/wine/msvcrt/memory.h
View File

@@ -1,38 +0,0 @@
/*
* Memory definitions
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Jon Griffiths and Francois Gouget.
* This file is in the public domain.
*/
#ifndef __WINE_MEMORY_H
#define __WINE_MEMORY_H
#include <corecrt.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _CRT_MEMORY_DEFINED
#define _CRT_MEMORY_DEFINED
_ACRTIMP void* __cdecl memchr(const void*,int,size_t);
_ACRTIMP int __cdecl memcmp(const void*,const void*,size_t);
_ACRTIMP void* __cdecl memcpy(void*,const void*,size_t);
_ACRTIMP errno_t __cdecl memcpy_s(void*,size_t,const void*,size_t);
_ACRTIMP void* __cdecl memset(void*,int,size_t);
_ACRTIMP void* __cdecl _memccpy(void*,const void*,int,size_t);
_ACRTIMP int __cdecl _memicmp(const void*,const void*,size_t);
_ACRTIMP int __cdecl _memicmp_l(const void*,const void*,size_t,_locale_t);
static inline int memicmp(const void* s1, const void* s2, size_t len) { return _memicmp(s1, s2, len); }
static inline void* memccpy(void *s1, const void *s2, int c, size_t n) { return _memccpy(s1, s2, c, n); }
#endif /* _CRT_MEMORY_DEFINED */
#ifdef __cplusplus
}
#endif
#endif /* __WINE_MEMORY_H */

107
assets/wine/include/wine/msvcrt/process.h
View File

@@ -1,107 +0,0 @@
/*
* Process definitions
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Jon Griffiths and Francois Gouget.
* This file is in the public domain.
*/
#ifndef __WINE_PROCESS_H
#define __WINE_PROCESS_H
#include <corecrt_startup.h>
#include <corecrt_wprocess.h>
/* Process creation flags */
#define _P_WAIT 0
#define _P_NOWAIT 1
#define _P_OVERLAY 2
#define _P_NOWAITO 3
#define _P_DETACH 4
#define _WAIT_CHILD 0
#define _WAIT_GRANDCHILD 1
#ifdef __cplusplus
extern "C" {
#endif
typedef void (__cdecl *_beginthread_start_routine_t)(void *);
typedef unsigned int (__stdcall *_beginthreadex_start_routine_t)(void *);
_ACRTIMP uintptr_t __cdecl _beginthread(_beginthread_start_routine_t,unsigned int,void*);
_ACRTIMP uintptr_t __cdecl _beginthreadex(void*,unsigned int,_beginthreadex_start_routine_t,void*,unsigned int,unsigned int*);
_ACRTIMP intptr_t __cdecl _cwait(int*,intptr_t,int);
_ACRTIMP DECLSPEC_NORETURN void __cdecl _endthread(void);
_ACRTIMP DECLSPEC_NORETURN void __cdecl _endthreadex(unsigned int);
_ACRTIMP intptr_t __cdecl _execl(const char*,const char*,...);
_ACRTIMP intptr_t __cdecl _execle(const char*,const char*,...);
_ACRTIMP intptr_t __cdecl _execlp(const char*,const char*,...);
_ACRTIMP intptr_t __cdecl _execlpe(const char*,const char*,...);
_ACRTIMP intptr_t __cdecl _execv(const char*,const char* const *);
_ACRTIMP intptr_t __cdecl _execve(const char*,const char* const *,const char* const *);
_ACRTIMP intptr_t __cdecl _execvp(const char*,const char* const *);
_ACRTIMP intptr_t __cdecl _execvpe(const char*,const char* const *,const char* const *);
_ACRTIMP int __cdecl _getpid(void);
_ACRTIMP intptr_t __cdecl _spawnl(int,const char*,const char*,...);
_ACRTIMP intptr_t __cdecl _spawnle(int,const char*,const char*,...);
_ACRTIMP intptr_t __cdecl _spawnlp(int,const char*,const char*,...);
_ACRTIMP intptr_t __cdecl _spawnlpe(int,const char*,const char*,...);
_ACRTIMP intptr_t __cdecl _spawnv(int,const char*,const char* const *);
_ACRTIMP intptr_t __cdecl _spawnve(int,const char*,const char* const *,const char* const *);
_ACRTIMP intptr_t __cdecl _spawnvp(int,const char*,const char* const *);
_ACRTIMP intptr_t __cdecl _spawnvpe(int,const char*,const char* const *,const char* const *);
_ACRTIMP void __cdecl _c_exit(void);
_ACRTIMP void __cdecl _cexit(void);
_ACRTIMP DECLSPEC_NORETURN void __cdecl _exit(int);
_ACRTIMP DECLSPEC_NORETURN void __cdecl abort(void);
_ACRTIMP DECLSPEC_NORETURN void __cdecl exit(int);
_ACRTIMP DECLSPEC_NORETURN void __cdecl quick_exit(int);
_ACRTIMP int __cdecl system(const char*);
#ifdef __cplusplus
}
#endif
#define P_WAIT _P_WAIT
#define P_NOWAIT _P_NOWAIT
#define P_OVERLAY _P_OVERLAY
#define P_NOWAITO _P_NOWAITO
#define P_DETACH _P_DETACH
#define WAIT_CHILD _WAIT_CHILD
#define WAIT_GRANDCHILD _WAIT_GRANDCHILD
static inline intptr_t cwait(int *status, intptr_t pid, int action) { return _cwait(status, pid, action); }
static inline int getpid(void) { return _getpid(); }
static inline intptr_t spawnv(int flags, const char* name, const char* const* argv) { return _spawnv(flags, name, argv); }
static inline intptr_t spawnve(int flags, const char* name, const char* const* argv, const char* const* envv) { return _spawnve(flags, name, argv, envv); }
static inline intptr_t spawnvp(int flags, const char* name, const char* const* argv) { return _spawnvp(flags, name, argv); }
static inline intptr_t spawnvpe(int flags, const char* name, const char* const* argv, const char* const* envv) { return _spawnvpe(flags, name, argv, envv); }
#define execv _execv
#define execve _execve
#define execvp _execvp
#define execvpe _execvpe
#if defined(__GNUC__) && (__GNUC__ < 4)
_ACRTIMP intptr_t __cdecl execl(const char*,const char*,...) __attribute__((alias("_execl")));
_ACRTIMP intptr_t __cdecl execle(const char*,const char*,...) __attribute__((alias("_execle")));
_ACRTIMP intptr_t __cdecl execlp(const char*,const char*,...) __attribute__((alias("_execlp")));
_ACRTIMP intptr_t __cdecl execlpe(const char*,const char*,...) __attribute__((alias("_execlpe")));
_ACRTIMP intptr_t __cdecl spawnl(int,const char*,const char*,...) __attribute__((alias("_spawnl")));
_ACRTIMP intptr_t __cdecl spawnle(int,const char*,const char*,...) __attribute__((alias("_spawnle")));
_ACRTIMP intptr_t __cdecl spawnlp(int,const char*,const char*,...) __attribute__((alias("_spawnlp")));
_ACRTIMP intptr_t __cdecl spawnlpe(int,const char*,const char*,...) __attribute__((alias("_spawnlpe")));
#else
#define execl _execl
#define execle _execle
#define execlp _execlp
#define execlpe _execlpe
#define spawnl _spawnl
#define spawnle _spawnle
#define spawnlp _spawnlp
#define spawnlpe _spawnlpe
#endif /* __GNUC__ */
#endif /* __WINE_PROCESS_H */

45
assets/wine/include/wine/msvcrt/search.h
View File

@@ -1,45 +0,0 @@
/*
* Heap definitions
*
* Copyright 2001 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_SEARCH_H
#define __WINE_SEARCH_H
#include <corecrt.h>
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP void* __cdecl _lfind(const void*,const void*,unsigned int*,unsigned int,int (__cdecl *)(const void*,const void*));
_ACRTIMP void* __cdecl _lsearch(const void*,void*,unsigned int*,unsigned int,int (__cdecl *)(const void*,const void*));
_ACRTIMP void* __cdecl bsearch(const void*,const void*,size_t,size_t,int (__cdecl *)(const void*,const void*));
_ACRTIMP void* __cdecl bsearch_s(const void*,const void*,rsize_t,rsize_t,int (__cdecl *)(void*,const void*,const void*),void*);
_ACRTIMP void __cdecl qsort(void*,size_t,size_t,int (__cdecl *)(const void*,const void*));
#ifdef __cplusplus
}
#endif
static inline void* lfind(const void* match, const void* start, unsigned int* array_size, unsigned int elem_size, int (__cdecl *cf)(const void*,const void*))
{ return _lfind(match, start, array_size, elem_size, cf); }
static inline void* lsearch(const void* match, void* start, unsigned int* array_size, unsigned int elem_size, int (__cdecl *cf)(const void*,const void*) )
{ return _lsearch(match, start, array_size, elem_size, cf); }
#endif /* __WINE_SEARCH_H */

185
assets/wine/include/wine/msvcrt/setjmp.h
View File

@@ -1,185 +0,0 @@
/*
* Setjmp/Longjmp definitions
*
* Copyright 2001 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_SETJMP_H
#define __WINE_SETJMP_H
#include <corecrt.h>
#pragma pack(push,8)
#ifdef __i386__
typedef struct __JUMP_BUFFER
{
unsigned long Ebp;
unsigned long Ebx;
unsigned long Edi;
unsigned long Esi;
unsigned long Esp;
unsigned long Eip;
unsigned long Registration;
unsigned long TryLevel;
/* Start of new struct members */
unsigned long Cookie;
unsigned long UnwindFunc;
unsigned long UnwindData[6];
} _JUMP_BUFFER;
#define _JBLEN 16
#define _JBTYPE int
#elif defined(__x86_64__)
typedef DECLSPEC_ALIGN(16) struct _SETJMP_FLOAT128
{
unsigned __int64 Part[2];
} SETJMP_FLOAT128;
typedef DECLSPEC_ALIGN(16) struct _JUMP_BUFFER
{
unsigned __int64 Frame;
unsigned __int64 Rbx;
unsigned __int64 Rsp;
unsigned __int64 Rbp;
unsigned __int64 Rsi;
unsigned __int64 Rdi;
unsigned __int64 R12;
unsigned __int64 R13;
unsigned __int64 R14;
unsigned __int64 R15;
unsigned __int64 Rip;
unsigned long MxCsr;
unsigned short FpCsr;
unsigned short Spare;
SETJMP_FLOAT128 Xmm6;
SETJMP_FLOAT128 Xmm7;
SETJMP_FLOAT128 Xmm8;
SETJMP_FLOAT128 Xmm9;
SETJMP_FLOAT128 Xmm10;
SETJMP_FLOAT128 Xmm11;
SETJMP_FLOAT128 Xmm12;
SETJMP_FLOAT128 Xmm13;
SETJMP_FLOAT128 Xmm14;
SETJMP_FLOAT128 Xmm15;
} _JUMP_BUFFER;
#define _JBLEN 16
typedef SETJMP_FLOAT128 _JBTYPE;
#elif defined(__arm__)
typedef struct _JUMP_BUFFER
{
unsigned long Frame;
unsigned long R4;
unsigned long R5;
unsigned long R6;
unsigned long R7;
unsigned long R8;
unsigned long R9;
unsigned long R10;
unsigned long R11;
unsigned long Sp;
unsigned long Pc;
unsigned long Fpscr;
unsigned long long D[8];
} _JUMP_BUFFER;
#define _JBLEN 28
#define _JBTYPE int
#elif defined(__aarch64__)
typedef struct _JUMP_BUFFER
{
unsigned __int64 Frame;
unsigned __int64 Reserved;
unsigned __int64 X19;
unsigned __int64 X20;
unsigned __int64 X21;
unsigned __int64 X22;
unsigned __int64 X23;
unsigned __int64 X24;
unsigned __int64 X25;
unsigned __int64 X26;
unsigned __int64 X27;
unsigned __int64 X28;
unsigned __int64 Fp;
unsigned __int64 Lr;
unsigned __int64 Sp;
unsigned long Fpcr;
unsigned long Fpsr;
double D[8];
} _JUMP_BUFFER;
#define _JBLEN 24
#define _JBTYPE unsigned __int64
#else
#define _JBLEN 1
#define _JBTYPE int
#endif
typedef _JBTYPE jmp_buf[_JBLEN];
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP void __cdecl longjmp(jmp_buf,int);
#ifndef __has_builtin
# define __has_builtin(x) 0
#endif
#ifdef _UCRT
# ifdef __i386__
# define _setjmp __intrinsic_setjmp
# else
# define _setjmpex __intrinsic_setjmpex
# endif
#endif
#ifdef __i386__
_ACRTIMP int __cdecl __attribute__((__nothrow__,__returns_twice__)) _setjmp(jmp_buf);
# define setjmp(buf) _setjmp((buf))
#elif !defined(_setjmpex) && __has_builtin(_setjmpex)
_ACRTIMP int __cdecl __attribute__((__nothrow__,__returns_twice__)) _setjmpex(jmp_buf);
# define setjmp(buf) _setjmpex(buf)
#else
_ACRTIMP int __cdecl __attribute__((__nothrow__,__returns_twice__)) _setjmpex(jmp_buf,void*);
# if __has_builtin(__builtin_sponentry)
# define setjmp(buf) _setjmpex((buf), __builtin_sponentry())
# elif __has_builtin(__builtin_frame_address)
# define setjmp(buf) _setjmpex((buf), __builtin_frame_address(0))
# else
# define setjmp(buf) _setjmpex((buf), NULL)
# endif
#endif /* __i386__ */
#ifdef __cplusplus
}
#endif
#pragma pack(pop)
#endif /* __WINE_SETJMP_H */

44
assets/wine/include/wine/msvcrt/share.h
View File

@@ -1,44 +0,0 @@
/*
* share.h
*
* Constants for file sharing functions.
*
* Derived from the Mingw32 header written by Colin Peters.
* Modified for Wine use by Bill Medland
* This file is in the public domain.
*
* Original header contained the following
*
* 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 __WINE_SHARE_H
#define __WINE_SHARE_H
#ifndef __WINE_USE_MSVCRT
#define __WINE_USE_MSVCRT
#endif
#define SH_COMPAT 0x00 /* Compatibility */
#define SH_DENYRW 0x10 /* Deny read/write */
#define SH_DENYWR 0x20 /* Deny write */
#define SH_DENYRD 0x30 /* Deny read */
#define SH_DENYNO 0x40 /* Deny nothing */
#define SH_SECURE 0x80 /* Share read access if read-only */
#define _SH_COMPAT SH_COMPAT
#define _SH_DENYRW SH_DENYRW
#define _SH_DENYWR SH_DENYWR
#define _SH_DENYRD SH_DENYRD
#define _SH_DENYNO SH_DENYNO
#define _SH_SECURE SH_SECURE
#endif /* __WINE_SHARE_H_ */

53
assets/wine/include/wine/msvcrt/signal.h
View File

@@ -1,53 +0,0 @@
/*
* Signal definitions
*
* Copyright 2005 Juan Lang
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef _WINE_SIGNAL_H
#define _WINE_SIGNAL_H
#include <corecrt.h>
#define SIGINT 2
#define SIGILL 4
#define SIGFPE 8
#define SIGSEGV 11
#define SIGTERM 15
#define SIGBREAK 21
#define SIGABRT 22
#define NSIG (SIGABRT + 1)
#ifdef __cplusplus
extern "C" {
#endif
typedef void (__cdecl *__sighandler_t)(int);
#define SIG_DFL ((__sighandler_t)0)
#define SIG_IGN ((__sighandler_t)1)
#define SIG_ERR ((__sighandler_t)-1)
_ACRTIMP void** __cdecl __pxcptinfoptrs(void);
_ACRTIMP __sighandler_t __cdecl signal(int sig, __sighandler_t func);
_ACRTIMP int __cdecl raise(int sig);
#ifdef __cplusplus
}
#endif
#endif /* _WINE_SIGNAL_H */

31
assets/wine/include/wine/msvcrt/stdarg.h
View File

@@ -1,31 +0,0 @@
/*
* Variable argument definitions
*
* Copyright 2022 Jacek Caban
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef _INC_STDARG
#define _INC_STDARG
#include <vadefs.h>
#define va_start(v,l) _crt_va_start(v,l)
#define va_arg(v,l) _crt_va_arg(v,l)
#define va_end(v) _crt_va_end(v)
#define va_copy(d,s) _crt_va_copy(d,s)
#endif /* _INC_STDARG */

31
assets/wine/include/wine/msvcrt/stdbool.h
View File

@@ -1,31 +0,0 @@
/*
* Copyright 2020 Brendan Shanks for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_STDBOOL_H
#define __WINE_STDBOOL_H
#ifndef __cplusplus
#define bool _Bool
#define true 1
#define false 0
#endif
#define __bool_true_false_are_defined 1
#endif /* __WINE_STDBOOL_H */

45
assets/wine/include/wine/msvcrt/stddef.h
View File

@@ -1,45 +0,0 @@
/*
* Copyright 2000 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_STDDEF_H
#define __WINE_STDDEF_H
#include <corecrt.h>
#if defined(__GNUC__) || defined(__clang__)
#define offsetof(s,m) __builtin_offsetof(s,m)
#elif defined(_WIN64)
#define offsetof(s,m) (size_t)((ptrdiff_t)&(((s*)NULL)->m))
#else
#define offsetof(s,m) (size_t)&(((s*)NULL)->m)
#endif
typedef double max_align_t;
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP __msvcrt_ulong __cdecl __threadid(void);
_ACRTIMP __msvcrt_ulong __cdecl __threadhandle(void);
#define _threadid (__threadid())
#ifdef __cplusplus
}
#endif
#endif /* __WINE_STDDEF_H */

208
assets/wine/include/wine/msvcrt/stdint.h
View File

@@ -1,208 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the mingw-w64 runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
/* ISO C9x 7.18 Integer types <stdint.h>
* Based on ISO/IEC SC22/WG14 9899 Committee draft (SC22 N2794)
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* Contributor: Danny Smith <danny_r_smith_2001@yahoo.co.nz>
*
* 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.
*
* Date: 2000-12-02
*/
#ifndef _STDINT_H
#define _STDINT_H
#include <corecrt.h>
#include <stddef.h>
/* 7.18.1.1 Exact-width integer types */
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef int int32_t;
typedef unsigned uint32_t;
typedef long long int64_t;
typedef unsigned long long uint64_t;
/* 7.18.1.2 Minimum-width integer types */
typedef signed char int_least8_t;
typedef unsigned char uint_least8_t;
typedef short int_least16_t;
typedef unsigned short uint_least16_t;
typedef int int_least32_t;
typedef unsigned uint_least32_t;
typedef long long int_least64_t;
typedef unsigned long long uint_least64_t;
/* 7.18.1.3 Fastest minimum-width integer types
* Not actually guaranteed to be fastest for all purposes
* Here we use the exact-width types for 8 and 16-bit ints.
*/
typedef signed char int_fast8_t;
typedef unsigned char uint_fast8_t;
typedef short int_fast16_t;
typedef unsigned short uint_fast16_t;
typedef int int_fast32_t;
typedef unsigned int uint_fast32_t;
typedef long long int_fast64_t;
typedef unsigned long long uint_fast64_t;
/* 7.18.1.5 Greatest-width integer types */
typedef long long intmax_t;
typedef unsigned long long uintmax_t;
/* 7.18.2 Limits of specified-width integer types */
#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) || \
defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
/* 7.18.2.1 Limits of exact-width integer types */
#define INT8_MIN (-128)
#define INT16_MIN (-32768)
#define INT32_MIN (-2147483647 - 1)
#define INT64_MIN (-9223372036854775807LL - 1)
#define INT8_MAX 127
#define INT16_MAX 32767
#define INT32_MAX 2147483647
#define INT64_MAX 9223372036854775807LL
#define UINT8_MAX 255
#define UINT16_MAX 65535
#define UINT32_MAX 0xffffffffU /* 4294967295U */
#define UINT64_MAX 0xffffffffffffffffULL /* 18446744073709551615ULL */
/* 7.18.2.2 Limits of minimum-width integer types */
#define INT_LEAST8_MIN INT8_MIN
#define INT_LEAST16_MIN INT16_MIN
#define INT_LEAST32_MIN INT32_MIN
#define INT_LEAST64_MIN INT64_MIN
#define INT_LEAST8_MAX INT8_MAX
#define INT_LEAST16_MAX INT16_MAX
#define INT_LEAST32_MAX INT32_MAX
#define INT_LEAST64_MAX INT64_MAX
#define UINT_LEAST8_MAX UINT8_MAX
#define UINT_LEAST16_MAX UINT16_MAX
#define UINT_LEAST32_MAX UINT32_MAX
#define UINT_LEAST64_MAX UINT64_MAX
/* 7.18.2.3 Limits of fastest minimum-width integer types */
#define INT_FAST8_MIN INT8_MIN
#define INT_FAST16_MIN INT16_MIN
#define INT_FAST32_MIN INT32_MIN
#define INT_FAST64_MIN INT64_MIN
#define INT_FAST8_MAX INT8_MAX
#define INT_FAST16_MAX INT16_MAX
#define INT_FAST32_MAX INT32_MAX
#define INT_FAST64_MAX INT64_MAX
#define UINT_FAST8_MAX UINT8_MAX
#define UINT_FAST16_MAX UINT16_MAX
#define UINT_FAST32_MAX UINT32_MAX
#define UINT_FAST64_MAX UINT64_MAX
/* 7.18.2.4 Limits of integer types capable of holding
object pointers */
#ifdef _WIN64
#define INTPTR_MIN INT64_MIN
#define INTPTR_MAX INT64_MAX
#define UINTPTR_MAX UINT64_MAX
#else
#define INTPTR_MIN INT32_MIN
#define INTPTR_MAX INT32_MAX
#define UINTPTR_MAX UINT32_MAX
#endif
/* 7.18.2.5 Limits of greatest-width integer types */
#define INTMAX_MIN INT64_MIN
#define INTMAX_MAX INT64_MAX
#define UINTMAX_MAX UINT64_MAX
/* 7.18.3 Limits of other integer types */
#ifdef _WIN64
#define PTRDIFF_MIN INT64_MIN
#define PTRDIFF_MAX INT64_MAX
#else
#define PTRDIFF_MIN INT32_MIN
#define PTRDIFF_MAX INT32_MAX
#endif
#define SIG_ATOMIC_MIN INT32_MIN
#define SIG_ATOMIC_MAX INT32_MAX
#ifndef SIZE_MAX
#ifdef _WIN64
#define SIZE_MAX UINT64_MAX
#else
#define SIZE_MAX UINT32_MAX
#endif
#endif
#ifndef WCHAR_MIN /* also in wchar.h */
#define WCHAR_MIN 0U
#define WCHAR_MAX 0xffffU
#endif
/*
* wint_t is unsigned short for compatibility with MS runtime
*/
#define WINT_MIN 0U
#define WINT_MAX 0xffffU
#endif /* !defined ( __cplusplus) || defined __STDC_LIMIT_MACROS */
/* 7.18.4 Macros for integer constants */
#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) || \
defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
/* 7.18.4.1 Macros for minimum-width integer constants
According to Douglas Gwyn <gwyn@arl.mil>:
"This spec was changed in ISO/IEC 9899:1999 TC1; in ISO/IEC
9899:1999 as initially published, the expansion was required
to be an integer constant of precisely matching type, which
is impossible to accomplish for the shorter types on most
platforms, because C99 provides no standard way to designate
an integer constant with width less than that of type int.
TC1 changed this to require just an integer constant
*expression* with *promoted* type."
The trick used here is from Clive D W Feather.
*/
#define INT8_C(val) (INT_LEAST8_MAX-INT_LEAST8_MAX+(val))
#define INT16_C(val) (INT_LEAST16_MAX-INT_LEAST16_MAX+(val))
#define INT32_C(val) (INT_LEAST32_MAX-INT_LEAST32_MAX+(val))
/* The 'trick' doesn't work in C89 for long long because, without
suffix, (val) will be evaluated as int, not intmax_t */
#define INT64_C(val) val##LL
#define UINT8_C(val) (val)
#define UINT16_C(val) (val)
#define UINT32_C(val) (val##U)
#define UINT64_C(val) val##ULL
/* 7.18.4.2 Macros for greatest-width integer constants */
#define INTMAX_C(val) val##LL
#define UINTMAX_C(val) val##ULL
#endif /* !defined ( __cplusplus) || defined __STDC_CONSTANT_MACROS */
#endif /* _STDINT_H */

547
assets/wine/include/wine/msvcrt/stdio.h
View File

@@ -1,547 +0,0 @@
/*
* Standard I/O definitions.
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Jon Griffiths and Francois Gouget.
* This file is in the public domain.
*/
#ifndef __WINE_STDIO_H
#define __WINE_STDIO_H
#include <corecrt_wstdio.h>
/* file._flag flags */
#ifndef _UCRT
#define _IOREAD 0x0001
#define _IOWRT 0x0002
#define _IOMYBUF 0x0008
#define _IOEOF 0x0010
#define _IOERR 0x0020
#define _IOSTRG 0x0040
#define _IORW 0x0080
#endif
#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2
/* more file._flag flags, but these conflict with Unix */
#define _IOFBF 0x0000
#define _IONBF 0x0004
#define _IOLBF 0x0040
#define EOF (-1)
#define FILENAME_MAX 260
#define TMP_MAX 0x7fff
#define TMP_MAX_S 0x7fffffff
#define FOPEN_MAX 20
#define L_tmpnam 260
#define BUFSIZ 512
#ifndef SEEK_SET
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
#endif
#ifndef _FPOS_T_DEFINED
typedef __int64 DECLSPEC_ALIGN(8) fpos_t;
#define _FPOS_T_DEFINED
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _STDIO_DEFINED
# ifdef __i386__
_ACRTIMP FILE* __cdecl __p__iob(void);
# define _iob (__p__iob())
# else
_ACRTIMP FILE* __cdecl __iob_func(void);
# define _iob (__iob_func())
# endif
#endif /* _STDIO_DEFINED */
/* return value for _get_output_format */
#define _TWO_DIGIT_EXPONENT 0x1
#ifndef _STDIO_DEFINED
#define _STDIO_DEFINED
_ACRTIMP int __cdecl _fcloseall(void);
_ACRTIMP FILE* __cdecl _fdopen(int,const char*);
_ACRTIMP int __cdecl _fgetchar(void);
_ACRTIMP int __cdecl _filbuf(FILE*);
_ACRTIMP int __cdecl _fileno(FILE*);
_ACRTIMP int __cdecl _flsbuf(int,FILE*);
_ACRTIMP int __cdecl _flushall(void);
_ACRTIMP int __cdecl _fputchar(int);
_ACRTIMP FILE* __cdecl _fsopen(const char*,const char*,int);
_ACRTIMP int __cdecl _get_printf_count_output(void);
_ACRTIMP int __cdecl _getmaxstdio(void);
_ACRTIMP int __cdecl _getw(FILE*);
_ACRTIMP int __cdecl _pclose(FILE*);
_ACRTIMP FILE* __cdecl _popen(const char*,const char*);
_ACRTIMP int __cdecl _putw(int,FILE*);
_ACRTIMP int __cdecl _rmtmp(void);
_ACRTIMP int __cdecl _set_printf_count_output(int);
_ACRTIMP int __cdecl _setmaxstdio(int);
_ACRTIMP char* __cdecl _tempnam(const char*,const char*);
_ACRTIMP int __cdecl _unlink(const char*);
_ACRTIMP void __cdecl _lock_file(FILE*);
_ACRTIMP void __cdecl _unlock_file(FILE*);
_ACRTIMP size_t __cdecl _fread_nolock(void*,size_t,size_t,FILE*);
_ACRTIMP size_t __cdecl _fread_nolock_s(void*,size_t,size_t,size_t,FILE*);
_ACRTIMP size_t __cdecl _fwrite_nolock(const void*,size_t,size_t,FILE*);
_ACRTIMP int __cdecl _fclose_nolock(FILE*);
_ACRTIMP int __cdecl _fflush_nolock(FILE*);
_ACRTIMP int __cdecl _fgetc_nolock(FILE*);
_ACRTIMP int __cdecl _fputc_nolock(int,FILE*);
_ACRTIMP int __cdecl _fseek_nolock(FILE*,__msvcrt_long,int);
_ACRTIMP int __cdecl _fseeki64_nolock(FILE*,__int64,int);
_ACRTIMP __msvcrt_long __cdecl _ftell_nolock(FILE*);
_ACRTIMP __int64 __cdecl _ftelli64_nolock(FILE*);
_ACRTIMP int __cdecl _getc_nolock(FILE*);
_ACRTIMP int __cdecl _putc_nolock(int,FILE*);
_ACRTIMP int __cdecl _ungetc_nolock(int,FILE*);
_ACRTIMP void __cdecl clearerr(FILE*);
_ACRTIMP errno_t __cdecl clearerr_s(FILE*);
_ACRTIMP int __cdecl fclose(FILE*);
_ACRTIMP int __cdecl feof(FILE*);
_ACRTIMP int __cdecl ferror(FILE*);
_ACRTIMP int __cdecl fflush(FILE*);
_ACRTIMP int __cdecl fgetc(FILE*);
_ACRTIMP int __cdecl fgetpos(FILE*,fpos_t*);
_ACRTIMP char* __cdecl fgets(char*,int,FILE*);
_ACRTIMP FILE* __cdecl fopen(const char*,const char*);
_ACRTIMP errno_t __cdecl fopen_s(FILE**,const char*,const char*);
_ACRTIMP int __cdecl fputc(int,FILE*);
_ACRTIMP int __cdecl fputs(const char*,FILE*);
_ACRTIMP size_t __cdecl fread(void*,size_t,size_t,FILE*);
_ACRTIMP size_t __cdecl fread_s(void*,size_t,size_t,size_t,FILE*);
_ACRTIMP FILE* __cdecl freopen(const char*,const char*,FILE*);
_ACRTIMP errno_t __cdecl freopen_s(FILE**,const char*,const char*,FILE*);
_ACRTIMP int __cdecl fseek(FILE*,__msvcrt_long,int);
_ACRTIMP int __cdecl _fseeki64(FILE*,__int64,int);
_ACRTIMP int __cdecl fsetpos(FILE*,fpos_t*);
_ACRTIMP __msvcrt_long __cdecl ftell(FILE*);
_ACRTIMP __int64 __cdecl _ftelli64(FILE*);
_ACRTIMP size_t __cdecl fwrite(const void*,size_t,size_t,FILE*);
_ACRTIMP int __cdecl getc(FILE*);
_ACRTIMP int __cdecl getchar(void);
_ACRTIMP char* __cdecl gets(char*);
_ACRTIMP void __cdecl perror(const char*);
_ACRTIMP int __cdecl putc(int,FILE*);
_ACRTIMP int __cdecl putchar(int);
_ACRTIMP int __cdecl puts(const char*);
_ACRTIMP int __cdecl remove(const char*);
_ACRTIMP int __cdecl rename(const char*,const char*);
_ACRTIMP void __cdecl rewind(FILE*);
_ACRTIMP void __cdecl setbuf(FILE*,char*);
_ACRTIMP int __cdecl setvbuf(FILE*,char*,int,size_t);
_ACRTIMP FILE* __cdecl tmpfile(void);
_ACRTIMP errno_t __cdecl tmpfile_s(FILE**);
_ACRTIMP char* __cdecl tmpnam(char*);
_ACRTIMP int __cdecl ungetc(int,FILE*);
_ACRTIMP unsigned int __cdecl _get_output_format(void);
_ACRTIMP unsigned int __cdecl _set_output_format(unsigned int);
#ifdef _UCRT
_ACRTIMP int __cdecl __stdio_common_vfprintf(unsigned __int64,FILE*,const char*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vfprintf_s(unsigned __int64,FILE*,const char*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vsprintf(unsigned __int64,char*,size_t,const char*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vsprintf_p(unsigned __int64,char*,size_t,const char*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vsprintf_s(unsigned __int64,char*,size_t,const char*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vsnprintf_s(unsigned __int64,char*,size_t,size_t,const char*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vfscanf(unsigned __int64,FILE*,const char*,_locale_t,va_list);
_ACRTIMP int __cdecl __stdio_common_vsscanf(unsigned __int64,char const*,size_t,const char*,_locale_t,va_list);
#endif /* _UCRT */
#if defined(_UCRT) && !defined(_NO_CRT_STDIO_INLINE)
static inline int __cdecl vsnprintf(char *buffer, size_t size, const char *format, va_list args) __WINE_CRT_PRINTF_ATTR(3, 0);
static inline int __cdecl vsnprintf(char *buffer, size_t size, const char *format, va_list args)
{
int ret = __stdio_common_vsprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR,
buffer, size, format, NULL, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl _vsnprintf(char *buffer, size_t size, const char *format, va_list args) __WINE_CRT_PRINTF_ATTR(3, 0);
static inline int __cdecl _vsnprintf(char *buffer, size_t size, const char *format, va_list args)
{
int ret = __stdio_common_vsprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION,
buffer, size, format, NULL, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl _vsnprintf_s(char *buffer, size_t size, size_t count, const char *format, va_list args) __WINE_CRT_PRINTF_ATTR(4, 0);
static inline int __cdecl _vsnprintf_s(char *buffer, size_t size, size_t count, const char *format, va_list args)
{
int ret = __stdio_common_vsnprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, count, format, NULL, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl _snprintf_s(char *buffer, size_t size, size_t count, const char *format, ...) __WINE_CRT_PRINTF_ATTR(4, 5);
static inline int __cdecl _snprintf_s(char *buffer, size_t size, size_t count, const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vsnprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, count, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl _vscprintf(const char *format, va_list args) __WINE_CRT_PRINTF_ATTR(1, 0);
static inline int __cdecl _vscprintf(const char *format, va_list args)
{
int ret = __stdio_common_vsprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR,
NULL, 0, format, NULL, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl _scprintf(const char *format, ...) __WINE_CRT_PRINTF_ATTR(1, 2);
static inline int __cdecl _scprintf(const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vsprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR,
NULL, 0, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl vsprintf(char *buffer, const char *format, va_list args) __WINE_CRT_PRINTF_ATTR(2, 0);
static inline int __cdecl vsprintf(char *buffer, const char *format, va_list args)
{
int ret = __stdio_common_vsprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION,
buffer, -1, format, NULL, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl vsprintf_s(char *buffer, size_t size, const char *format, va_list args) __WINE_CRT_PRINTF_ATTR(3, 0);
static inline int __cdecl vsprintf_s(char *buffer, size_t size, const char *format, va_list args)
{
int ret = __stdio_common_vsprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, format, NULL, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl sprintf_s(char *buffer, size_t size, const char *format, ...) __WINE_CRT_PRINTF_ATTR(3, 4);
static inline int __cdecl sprintf_s(char *buffer, size_t size, const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vsprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl _vsprintf_p_l(char *buffer, size_t size, const char *format, _locale_t locale, va_list args) __WINE_CRT_PRINTF_ATTR(3, 0);
static inline int __cdecl _vsprintf_p_l(char *buffer, size_t size, const char *format, _locale_t locale, va_list args)
{
int ret = __stdio_common_vsprintf_p(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, buffer, size, format, locale, args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl vfprintf(FILE *file, const char *format, va_list args) __WINE_CRT_PRINTF_ATTR(2, 0);
static inline int __cdecl vfprintf(FILE *file, const char *format, va_list args)
{
return __stdio_common_vfprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, file, format, NULL, args);
}
static inline int __cdecl fprintf(FILE *file, const char *format, ...) __WINE_CRT_PRINTF_ATTR(2, 3);
static inline int __cdecl fprintf(FILE *file, const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, file, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl vfprintf_s(FILE *file, const char *format, va_list args) __WINE_CRT_PRINTF_ATTR(2, 0);
static inline int __cdecl vfprintf_s(FILE *file, const char *format, va_list args)
{
return __stdio_common_vfprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, file, format, NULL, args);
}
static inline int __cdecl fprintf_s(FILE *file, const char *format, ...) __WINE_CRT_PRINTF_ATTR(2, 3);
static inline int __cdecl fprintf_s(FILE *file, const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, file, format, NULL, args);
va_end(args);
return ret;
}
static inline int vprintf(const char *format, va_list args) __WINE_CRT_PRINTF_ATTR(1, 0);
static inline int vprintf(const char *format, va_list args)
{
return __stdio_common_vfprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, stdout, format, NULL, args);
}
static inline int __cdecl printf(const char *format, ...) __WINE_CRT_PRINTF_ATTR(1, 2);
static inline int __cdecl printf(const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, stdout, format, NULL, args);
va_end(args);
return ret;
}
static inline int vprintf_s(const char *format, va_list args) __WINE_CRT_PRINTF_ATTR(1, 0);
static inline int vprintf_s(const char *format, va_list args)
{
return __stdio_common_vfprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, stdout, format, NULL, args);
}
static inline int __cdecl printf_s(const char *format, ...) __WINE_CRT_PRINTF_ATTR(1, 2);
static inline int __cdecl printf_s(const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfprintf_s(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, stdout, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl _sprintf_l(char *buffer, const char *format, _locale_t locale, ...) __WINE_CRT_PRINTF_ATTR(2, 4);
static inline int __cdecl _sprintf_l(char *buffer, const char *format, _locale_t locale, ...)
{
int ret;
va_list args;
va_start(args, locale);
ret = __stdio_common_vsprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION,
buffer, -1, format, locale, args);
va_end(args);
return ret < 0 ? -1 : ret;
}
static inline int __cdecl sscanf(const char *buffer, const char *format, ...) __WINE_CRT_SCANF_ATTR(2, 3);
static inline int __cdecl sscanf(const char *buffer, const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vsscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS, buffer, -1, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl sscanf_s(const char *buffer, const char *format, ...) __WINE_CRT_SCANF_ATTR(2, 3);
static inline int __cdecl sscanf_s(const char *buffer, const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vsscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS | _CRT_INTERNAL_SCANF_SECURECRT, buffer, -1, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl _snscanf_l(const char *buffer, size_t size, const char *format, _locale_t locale, ...) __WINE_CRT_SCANF_ATTR(3, 5);
static inline int __cdecl _snscanf_l(const char *buffer, size_t size, const char *format, _locale_t locale, ...)
{
int ret;
va_list args;
va_start(args, locale);
ret = __stdio_common_vsscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS, buffer, size, format, locale, args);
va_end(args);
return ret;
}
static inline int __cdecl _sscanf_l(const char *buffer, const char *format, _locale_t locale, ...) __WINE_CRT_SCANF_ATTR(2, 4);
static inline int __cdecl _sscanf_l(const char *buffer, const char *format, _locale_t locale, ...)
{
int ret;
va_list args;
va_start(args, locale);
ret = __stdio_common_vsscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS, buffer, -1, format, locale, args);
va_end(args);
return ret;
}
static inline int __cdecl fscanf(FILE *file, const char *format, ...) __WINE_CRT_SCANF_ATTR(2, 3);
static inline int __cdecl fscanf(FILE *file, const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS, file, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl fscanf_s(FILE *file, const char *format, ...) __WINE_CRT_SCANF_ATTR(2, 3);
static inline int __cdecl fscanf_s(FILE *file, const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS | _CRT_INTERNAL_SCANF_SECURECRT, file, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl scanf(const char *format, ...) __WINE_CRT_SCANF_ATTR(1, 2);
static inline int __cdecl scanf(const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS, stdin, format, NULL, args);
va_end(args);
return ret;
}
static inline int __cdecl scanf_s(const char *format, ...) __WINE_CRT_SCANF_ATTR(1, 2);
static inline int __cdecl scanf_s(const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = __stdio_common_vfscanf(_CRT_INTERNAL_LOCAL_SCANF_OPTIONS | _CRT_INTERNAL_SCANF_SECURECRT, stdin, format, NULL, args);
va_end(args);
return ret;
}
#else /* _UCRT && !_NO_CRT_STDIO_INLINE */
_ACRTIMP int __cdecl _scprintf(const char *,...) __WINE_CRT_PRINTF_ATTR(1, 2);
_ACRTIMP int __cdecl _snprintf_s(char*,size_t,size_t,const char*,...) __WINE_CRT_PRINTF_ATTR(4, 5);
_ACRTIMP int __cdecl _vscprintf(const char*,va_list) __WINE_CRT_PRINTF_ATTR(1, 0);
_ACRTIMP int __cdecl _vsnprintf_s(char*,size_t,size_t,const char*,va_list) __WINE_CRT_PRINTF_ATTR(4, 0);
_ACRTIMP int __cdecl _vsprintf_p_l(char*,size_t,const char*,_locale_t,va_list) __WINE_CRT_PRINTF_ATTR(3, 0);
_ACRTIMP int __cdecl fprintf(FILE*,const char*,...) __WINE_CRT_PRINTF_ATTR(2, 3);
_ACRTIMP int __cdecl fprintf_s(FILE*,const char*,...) __WINE_CRT_PRINTF_ATTR(2, 3);
_ACRTIMP int __cdecl printf(const char*,...) __WINE_CRT_PRINTF_ATTR(1, 2);
_ACRTIMP int __cdecl printf_s(const char*,...) __WINE_CRT_PRINTF_ATTR(1, 2);
_ACRTIMP int __cdecl sprintf_s(char*,size_t,const char*,...) __WINE_CRT_PRINTF_ATTR(3, 4);
_ACRTIMP int __cdecl vfprintf(FILE*,const char*,va_list) __WINE_CRT_PRINTF_ATTR(2, 0);
_ACRTIMP int __cdecl vfprintf_s(FILE*,const char*,va_list) __WINE_CRT_PRINTF_ATTR(2, 0);
_ACRTIMP int __cdecl vprintf(const char*,va_list) __WINE_CRT_PRINTF_ATTR(1, 0);
_ACRTIMP int __cdecl vprintf_s(const char*,va_list) __WINE_CRT_PRINTF_ATTR(1, 0);
_ACRTIMP int __cdecl vsprintf(char*,const char*,va_list) __WINE_CRT_PRINTF_ATTR(2, 0);
_ACRTIMP int __cdecl vsprintf_s(char*,size_t,const char*,va_list) __WINE_CRT_PRINTF_ATTR(3, 0);
_ACRTIMP int __cdecl _vsnprintf(char*,size_t,const char*,va_list) __WINE_CRT_PRINTF_ATTR(3, 0);
static inline int vsnprintf(char *buffer, size_t size, const char *format, va_list args) __WINE_CRT_PRINTF_ATTR(3, 0);
static inline int vsnprintf(char *buffer, size_t size, const char *format, va_list args)
{ return _vsnprintf(buffer,size,format,args); }
_ACRTIMP int __cdecl _snscanf_l(const char*,size_t,const char*,_locale_t,...) __WINE_CRT_SCANF_ATTR(3, 5);
_ACRTIMP int __cdecl _sscanf_l(const char *,const char*,_locale_t,...) __WINE_CRT_SCANF_ATTR(2, 4);
_ACRTIMP int __cdecl fscanf(FILE*,const char*,...) __WINE_CRT_SCANF_ATTR(2, 3);
_ACRTIMP int __cdecl fscanf_s(FILE*,const char*,...) __WINE_CRT_SCANF_ATTR(2, 3);
_ACRTIMP int __cdecl scanf(const char*,...) __WINE_CRT_SCANF_ATTR(1, 2);
_ACRTIMP int __cdecl scanf_s(const char*,...) __WINE_CRT_SCANF_ATTR(1, 2);
_ACRTIMP int __cdecl sscanf(const char*,const char*,...) __WINE_CRT_SCANF_ATTR(2, 3);
_ACRTIMP int __cdecl sscanf_s(const char*,const char*,...) __WINE_CRT_SCANF_ATTR(2, 3);
_ACRTIMP int __cdecl vsscanf(const char*, const char*, va_list) __WINE_CRT_SCANF_ATTR(2, 0);
#endif /* _UCRT && !_NO_CRT_STDIO_INLINE */
#endif /* _STDIO_DEFINED */
#ifdef __cplusplus
}
#endif
static inline FILE* fdopen(int fd, const char *mode) { return _fdopen(fd, mode); }
static inline int fgetchar(void) { return _fgetchar(); }
static inline int fileno(FILE* file) { return _fileno(file); }
static inline int fputchar(int c) { return _fputchar(c); }
static inline int pclose(FILE* file) { return _pclose(file); }
static inline FILE* popen(const char* command, const char* mode) { return _popen(command, mode); }
static inline char* tempnam(const char *dir, const char *prefix) { return _tempnam(dir, prefix); }
#ifndef _UNLINK_DEFINED
static inline int unlink(const char* path) { return _unlink(path); }
#define _UNLINK_DEFINED
#endif
#if !defined(_NO_CRT_STDIO_INLINE)
static inline int __cdecl snprintf(char *buffer, size_t size, const char *format, ...) __WINE_CRT_PRINTF_ATTR(3, 4);
static inline int __cdecl snprintf(char *buffer, size_t size, const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = vsnprintf(buffer, size, format, args);
va_end(args);
return ret;
}
static inline int __cdecl _snprintf(char *buffer, size_t size, const char *format, ...) __WINE_CRT_PRINTF_ATTR(3, 4);
static inline int __cdecl _snprintf(char *buffer, size_t size, const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = _vsnprintf(buffer, size, format, args);
va_end(args);
return ret;
}
static inline int __cdecl sprintf(char *buffer, const char *format, ...) __WINE_CRT_PRINTF_ATTR(2, 3);
static inline int __cdecl sprintf(char *buffer, const char *format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = _vsnprintf(buffer, (size_t)_CRT_INT_MAX, format, args);
va_end(args);
return ret;
}
#else /* !_NO_CRT_STDIO_INLINE */
_ACRTIMP int __cdecl snprintf(char*,size_t,const char*,...) __WINE_CRT_PRINTF_ATTR(3, 4);
_ACRTIMP int __cdecl _snprintf(char*,size_t,const char*,...) __WINE_CRT_PRINTF_ATTR(3, 4);
_ACRTIMP int __cdecl sprintf(char*,const char*,...) __WINE_CRT_PRINTF_ATTR(2, 3);
_ACRTIMP int __cdecl _sprintf_l(char*,const char*,_locale_t,...) __WINE_CRT_PRINTF_ATTR(2, 4);
#endif /* !_NO_CRT_STDIO_INLINE */
static inline wint_t fgetwchar(void) { return _fgetwchar(); }
static inline wint_t fputwchar(wint_t wc) { return _fputwchar(wc); }
static inline int getw(FILE* file) { return _getw(file); }
static inline int putw(int val, FILE* file) { return _putw(val, file); }
static inline FILE* wpopen(const wchar_t* command,const wchar_t* mode) { return _wpopen(command, mode); }
#endif /* __WINE_STDIO_H */

326
assets/wine/include/wine/msvcrt/stdlib.h
View File

@@ -1,326 +0,0 @@
/*
* Standard library definitions
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Jon Griffiths and Francois Gouget.
* This file is in the public domain.
*/
#ifndef __WINE_STDLIB_H
#define __WINE_STDLIB_H
#include <corecrt_malloc.h>
#include <corecrt_wstdlib.h>
#include <limits.h>
#pragma pack(push,8)
typedef struct
{
float f;
} _CRT_FLOAT;
typedef struct
{
double x;
} _CRT_DOUBLE;
typedef struct
{
unsigned char ld[10];
} _LDOUBLE;
#define EXIT_SUCCESS 0
#define EXIT_FAILURE -1
#define RAND_MAX 0x7FFF
#ifndef _MAX_PATH
#define _MAX_DRIVE 3
#define _MAX_FNAME 256
#define _MAX_DIR _MAX_FNAME
#define _MAX_EXT _MAX_FNAME
#define _MAX_PATH 260
#endif
/* Make the secure string functions (names end in "_s") truncate their output */
#define _TRUNCATE ((size_t)-1)
typedef struct _div_t {
int quot;
int rem;
} div_t;
typedef struct _ldiv_t {
__msvcrt_long quot;
__msvcrt_long rem;
} ldiv_t;
typedef struct _lldiv_t {
__int64 quot;
__int64 rem;
} lldiv_t;
#define _countof(x) (sizeof(x)/sizeof((x)[0]))
#define __max(a,b) (((a) > (b)) ? (a) : (b))
#define __min(a,b) (((a) < (b)) ? (a) : (b))
#ifndef __cplusplus
#define max(a,b) (((a) > (b)) ? (a) : (b))
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
/* _set_error_mode() constants */
#define _OUT_TO_DEFAULT 0
#define _OUT_TO_STDERR 1
#define _OUT_TO_MSGBOX 2
#define _REPORT_ERRMODE 3
/* _set_abort_behavior codes */
#define _WRITE_ABORT_MSG 1
#define _CALL_REPORTFAULT 2
#ifdef __cplusplus
extern "C" {
#endif
#if defined(__i386__) || defined(_UCRT)
_ACRTIMP unsigned int* __cdecl __p__osver(void);
_ACRTIMP unsigned int* __cdecl __p__winver(void);
_ACRTIMP unsigned int* __cdecl __p__winmajor(void);
_ACRTIMP unsigned int* __cdecl __p__winminor(void);
_ACRTIMP int* __cdecl __p___argc(void);
_ACRTIMP char*** __cdecl __p___argv(void);
_ACRTIMP wchar_t*** __cdecl __p___wargv(void);
_ACRTIMP char*** __cdecl __p__environ(void);
_ACRTIMP wchar_t*** __cdecl __p__wenviron(void);
_ACRTIMP int* __cdecl __p__fmode(void);
#define _osver (*__p__osver())
#define _winver (*__p__winver())
#define _winmajor (*__p__winmajor())
#define _winminor (*__p__winminor())
#define __argc (*__p___argc())
#define __argv (*__p___argv())
#define __wargv (*__p___wargv())
#define _environ (*__p__environ())
#define _wenviron (*__p__wenviron())
#define _fmode (*__p__fmode())
#else /* __i386__ */
extern unsigned int _osver;
extern unsigned int _winver;
extern unsigned int _winmajor;
extern unsigned int _winminor;
extern int __argc;
extern char **__argv;
extern wchar_t **__wargv;
extern char **_environ;
extern wchar_t **_wenviron;
extern unsigned int _fmode;
#endif /* __i386__ */
#ifndef MB_CUR_MAX
_ACRTIMP int __cdecl ___mb_cur_max_func(void);
_ACRTIMP int __cdecl ___mb_cur_max_l_func(_locale_t);
#define __mb_cur_max ___mb_cur_max_func()
#define MB_CUR_MAX ___mb_cur_max_func()
#endif /* MB_CUR_MAX */
_ACRTIMP __msvcrt_ulong* __cdecl __doserrno(void);
#define _doserrno (*__doserrno())
_ACRTIMP int* __cdecl _errno(void);
#define errno (*_errno())
_ACRTIMP int* __cdecl __sys_nerr(void);
#define _sys_nerr (*__sys_nerr())
_ACRTIMP char** __cdecl __sys_errlist(void);
#define _sys_errlist (__sys_errlist())
_ACRTIMP errno_t __cdecl _get_doserrno(int*);
_ACRTIMP errno_t __cdecl _get_errno(int*);
_ACRTIMP errno_t __cdecl _set_doserrno(int);
_ACRTIMP errno_t __cdecl _set_errno(int);
_ACRTIMP errno_t __cdecl _set_fmode(int);
_ACRTIMP errno_t __cdecl _get_fmode(int*);
#ifndef _CRT_ONEXIT_T_DEFINED
#define _CRT_ONEXIT_T_DEFINED
typedef int (__cdecl *_onexit_t)(void);
#endif
_ACRTIMP int __cdecl _atodbl(_CRT_DOUBLE*,char*);
_ACRTIMP int __cdecl _atodbl_l(_CRT_DOUBLE*,char*,_locale_t);
_ACRTIMP int __cdecl _atoflt(_CRT_FLOAT*,char*);
_ACRTIMP int __cdecl _atoflt_l(_CRT_FLOAT*,char*,_locale_t);
_ACRTIMP __int64 __cdecl _atoi64(const char*);
_ACRTIMP int __cdecl _atoldbl(_LDOUBLE*,char*);
_ACRTIMP void __cdecl _beep(unsigned int,unsigned int);
_ACRTIMP unsigned short __cdecl _byteswap_ushort(unsigned short);
_ACRTIMP __msvcrt_ulong __cdecl _byteswap_ulong(__msvcrt_ulong);
_ACRTIMP unsigned __int64 __cdecl _byteswap_uint64(unsigned __int64);
_ACRTIMP errno_t __cdecl _dupenv_s(char**,size_t*,const char*);
_ACRTIMP char* __cdecl _ecvt(double,int,int*,int*);
_ACRTIMP char* __cdecl _fcvt(double,int,int*,int*);
_ACRTIMP char* __cdecl _fullpath(char*,const char*,size_t);
_ACRTIMP char* __cdecl _gcvt(double,int,char*);
_ACRTIMP errno_t __cdecl _gcvt_s(char*, size_t, double, int);
_ACRTIMP char* __cdecl _i64toa(__int64,char*,int);
_ACRTIMP errno_t __cdecl _i64toa_s(__int64, char*, size_t, int);
_ACRTIMP char* __cdecl _itoa(int,char*,int);
_ACRTIMP errno_t __cdecl _itoa_s(int,char*,size_t,int);
_ACRTIMP char* __cdecl _ltoa(__msvcrt_long,char*,int);
_ACRTIMP errno_t __cdecl _ltoa_s(__msvcrt_long, char*, size_t, int);
#ifndef _lrotl
_ACRTIMP __msvcrt_ulong __cdecl _lrotl(__msvcrt_ulong,int);
#endif
#ifndef _lrotr
_ACRTIMP __msvcrt_ulong __cdecl _lrotr(__msvcrt_ulong,int);
#endif
_ACRTIMP void __cdecl _makepath(char*,const char*,const char*,const char*,const char*);
_ACRTIMP int __cdecl _makepath_s(char*,size_t,const char*,const char*,const char*,const char*);
_ACRTIMP size_t __cdecl _mbstrlen(const char*);
_ACRTIMP _onexit_t __cdecl _onexit(_onexit_t);
_ACRTIMP int __cdecl _putenv(const char*);
_ACRTIMP errno_t __cdecl _putenv_s(const char*,const char*);
#ifndef _rotl
_ACRTIMP unsigned int __cdecl _rotl(unsigned int,int);
#endif
#ifndef _rotr
_ACRTIMP unsigned int __cdecl _rotr(unsigned int,int);
#endif
_ACRTIMP void __cdecl _searchenv(const char*,const char*,char*);
_ACRTIMP int __cdecl _set_error_mode(int);
_ACRTIMP void __cdecl _seterrormode(int);
_ACRTIMP void __cdecl _sleep(__msvcrt_ulong);
_ACRTIMP void __cdecl _splitpath(const char*,char*,char*,char*,char*);
_ACRTIMP errno_t __cdecl _splitpath_s(const char*,char*,size_t,char*,size_t,char*,size_t,char*,size_t);
_ACRTIMP void __cdecl _swab(char*,char*,int);
_ACRTIMP char* __cdecl _ui64toa(unsigned __int64,char*,int);
_ACRTIMP errno_t __cdecl _ui64toa_s(unsigned __int64,char*,size_t,int);
_ACRTIMP char* __cdecl _ultoa(__msvcrt_ulong,char*,int);
_ACRTIMP errno_t __cdecl _ultoa_s(__msvcrt_ulong,char*,size_t,int);
_ACRTIMP DECLSPEC_NORETURN void __cdecl _Exit(int);
_ACRTIMP DECLSPEC_NORETURN void __cdecl _exit(int);
_ACRTIMP DECLSPEC_NORETURN void __cdecl abort(void);
_ACRTIMP int __cdecl abs(int);
extern int __cdecl atexit(void (__cdecl *)(void));
_ACRTIMP double __cdecl atof(const char*);
_ACRTIMP int __cdecl atoi(const char*);
_ACRTIMP int __cdecl _atoi_l(const char*,_locale_t);
_ACRTIMP __msvcrt_long __cdecl atol(const char*);
_ACRTIMP __int64 __cdecl atoll(const char*);
#ifndef __i386__
_ACRTIMP div_t __cdecl div(int,int);
_ACRTIMP ldiv_t __cdecl ldiv(__msvcrt_long,__msvcrt_long);
#endif
_ACRTIMP lldiv_t __cdecl lldiv(__int64,__int64);
_ACRTIMP DECLSPEC_NORETURN void __cdecl exit(int);
_ACRTIMP char* __cdecl getenv(const char*);
_ACRTIMP errno_t __cdecl getenv_s(size_t*,char*,size_t,const char*);
_ACRTIMP __msvcrt_long __cdecl labs(__msvcrt_long);
_ACRTIMP __int64 __cdecl llabs(__int64);
_ACRTIMP int __cdecl mblen(const char*,size_t);
_ACRTIMP void __cdecl perror(const char*);
_ACRTIMP int __cdecl rand(void);
_ACRTIMP errno_t __cdecl rand_s(unsigned int*);
_ACRTIMP void __cdecl srand(unsigned int);
_ACRTIMP float __cdecl strtof(const char*,char**);
_ACRTIMP float __cdecl _strtof_l(const char*,char**,_locale_t);
_ACRTIMP double __cdecl strtod(const char*,char**);
_ACRTIMP double __cdecl _strtod_l(const char*,char**,_locale_t);
#if defined(__GNUC__) || _MSVCR_VER < 120
static inline long double strtold(const char *string, char **endptr) { return strtod(string, endptr); }
static inline long double _strtold_l(const char *string, char **endptr, _locale_t locale) { return _strtod_l(string, endptr, locale); }
#else
_ACRTIMP long double __cdecl strtold(const char*,char**);
_ACRTIMP long double __cdecl _strtold_l(const char*,char**,_locale_t);
#endif
_ACRTIMP __msvcrt_long __cdecl strtol(const char*,char**,int);
_ACRTIMP __msvcrt_ulong __cdecl strtoul(const char*,char**,int);
_ACRTIMP __int64 __cdecl _strtoll_l(const char*,char**,int,_locale_t);
_ACRTIMP unsigned __int64 __cdecl _strtoull_l(const char*,char**,int,_locale_t);
_ACRTIMP __int64 __cdecl _strtoi64(const char*,char**,int);
_ACRTIMP __int64 __cdecl _strtoi64_l(const char*,char**,int,_locale_t);
_ACRTIMP unsigned __int64 __cdecl _strtoui64(const char*,char**,int);
_ACRTIMP unsigned __int64 __cdecl _strtoui64_l(const char*,char**,int,_locale_t);
_ACRTIMP int __cdecl system(const char*);
_ACRTIMP void* __cdecl bsearch(const void*,const void*,size_t,size_t,int (__cdecl *)(const void*,const void*));
_ACRTIMP void __cdecl qsort(void*,size_t,size_t,int (__cdecl *)(const void*,const void*));
_ACRTIMP void __cdecl qsort_s(void*,size_t,size_t,int (__cdecl *)(void*,const void*,const void*),void*);
_ACRTIMP unsigned int __cdecl _set_abort_behavior(unsigned int flags, unsigned int mask);
typedef void (__cdecl *_purecall_handler)(void);
_ACRTIMP _purecall_handler __cdecl _set_purecall_handler(_purecall_handler);
_ACRTIMP _purecall_handler __cdecl _get_purecall_handler(void);
typedef void (__cdecl *_invalid_parameter_handler)(const wchar_t*, const wchar_t*, const wchar_t*, unsigned, uintptr_t);
_ACRTIMP _invalid_parameter_handler __cdecl _set_invalid_parameter_handler(_invalid_parameter_handler);
_ACRTIMP _invalid_parameter_handler __cdecl _get_invalid_parameter_handler(void);
_ACRTIMP _invalid_parameter_handler __cdecl _get_thread_local_invalid_parameter_handler(void);
_ACRTIMP _invalid_parameter_handler __cdecl _set_thread_local_invalid_parameter_handler(_invalid_parameter_handler);
void __cdecl _invalid_parameter(const wchar_t *expr, const wchar_t *func, const wchar_t *file,
unsigned int line, uintptr_t arg);
#ifdef __cplusplus
extern "C++" {
template <size_t size>
inline errno_t getenv_s(size_t *ret, char (&buf)[size], const char *var)
{
return getenv_s(ret, buf, size, var);
}
inline long abs(long const x) throw() { return labs(x); }
inline long long abs(long long const x) throw() { return llabs(x); }
} /* extern "C++" */
}
#endif
#define environ _environ
#define onexit_t _onexit_t
static inline char* ecvt(double value, int ndigit, int* decpt, int* sign) { return _ecvt(value, ndigit, decpt, sign); }
static inline char* fcvt(double value, int ndigit, int* decpt, int* sign) { return _fcvt(value, ndigit, decpt, sign); }
static inline char* gcvt(double value, int ndigit, char* buf) { return _gcvt(value, ndigit, buf); }
static inline char* itoa(int value, char* str, int radix) { return _itoa(value, str, radix); }
static inline char* ltoa(__msvcrt_long value, char* str, int radix) { return _ltoa(value, str, radix); }
static inline _onexit_t onexit(_onexit_t func) { return _onexit(func); }
static inline int putenv(const char* str) { return _putenv(str); }
static inline __int64 strtoll(const char *ptr, char **endptr, int base) { return _strtoi64(ptr, endptr, base); }
static inline unsigned __int64 __cdecl strtoull(const char *ptr, char **endptr, int base) { return _strtoui64(ptr, endptr, base); }
static inline void swab(char* src, char* dst, int len) { _swab(src, dst, len); }
static inline char* ultoa(__msvcrt_ulong value, char* str, int radix) { return _ultoa(value, str, radix); }
#ifdef __i386__
static inline div_t __wine_msvcrt_div(int num, int denom)
{
extern unsigned __int64 div(int,int);
div_t ret;
unsigned __int64 res = div(num,denom);
ret.quot = (int)res;
ret.rem = (int)(res >> 32);
return ret;
}
static inline ldiv_t __wine_msvcrt_ldiv(__msvcrt_long num, __msvcrt_long denom)
{
extern unsigned __int64 ldiv(__msvcrt_long,__msvcrt_long);
ldiv_t ret;
unsigned __int64 res = ldiv(num,denom);
ret.quot = (__msvcrt_long)res;
ret.rem = (__msvcrt_long)(res >> 32);
return ret;
}
#define div(num,denom) __wine_msvcrt_div(num,denom)
#define ldiv(num,denom) __wine_msvcrt_ldiv(num,denom)
#endif
#pragma pack(pop)
#endif /* __WINE_STDLIB_H */

100
assets/wine/include/wine/msvcrt/string.h
View File

@@ -1,100 +0,0 @@
/*
* String definitions
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Jon Griffiths and Francois Gouget.
* This file is in the public domain.
*/
#ifndef __WINE_STRING_H
#define __WINE_STRING_H
#include <corecrt_malloc.h>
#include <corecrt_wstring.h>
#ifndef _NLSCMP_DEFINED
#define _NLSCMPERROR ((unsigned int)0x7fffffff)
#define _NLSCMP_DEFINED
#endif
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP size_t __cdecl __strncnt(const char*,size_t);
_ACRTIMP int __cdecl _strcmpi(const char*,const char*);
_ACRTIMP int __cdecl _strcoll_l(const char*, const char*, _locale_t);
_ACRTIMP char* __cdecl _strdup(const char*) __WINE_DEALLOC(free) __WINE_MALLOC;
_ACRTIMP char* __cdecl _strerror(const char*);
_ACRTIMP errno_t __cdecl strerror_s(char*,size_t,int);
_ACRTIMP int __cdecl _stricmp(const char*,const char*);
_ACRTIMP int __cdecl _stricoll(const char*,const char*);
_ACRTIMP int __cdecl _stricoll_l(const char*, const char*, _locale_t);
_ACRTIMP char* __cdecl _strlwr(char*);
_ACRTIMP errno_t __cdecl _strlwr_s(char*,size_t);
_ACRTIMP int __cdecl _strncoll(const char*, const char*, size_t);
_ACRTIMP int __cdecl _strncoll_l(const char*, const char*, size_t, _locale_t);
_ACRTIMP int __cdecl _strnicmp(const char*,const char*,size_t);
_ACRTIMP int __cdecl _strnicmp_l(const char*, const char*, size_t, _locale_t);
_ACRTIMP int __cdecl _strnicoll(const char*, const char*, size_t);
_ACRTIMP int __cdecl _strnicoll_l(const char*, const char*, size_t, _locale_t);
_ACRTIMP char* __cdecl _strnset(char*,int,size_t);
_ACRTIMP char* __cdecl _strrev(char*);
_ACRTIMP char* __cdecl _strset(char*,int);
_ACRTIMP char* __cdecl _strupr(char*);
_ACRTIMP errno_t __cdecl _strupr_s(char *, size_t);
_ACRTIMP size_t __cdecl _strxfrm_l(char*,const char*,size_t,_locale_t);
_ACRTIMP errno_t __cdecl memmove_s(void*,size_t,const void*,size_t);
_ACRTIMP char* __cdecl strcat(char*,const char*);
_ACRTIMP errno_t __cdecl strcat_s(char*,size_t,const char*);
_ACRTIMP char* __cdecl strchr(const char*,int);
_ACRTIMP int __cdecl strcmp(const char*,const char*);
_ACRTIMP int __cdecl strcoll(const char*,const char*);
_ACRTIMP char* __cdecl strcpy(char*,const char*);
_ACRTIMP errno_t __cdecl strcpy_s(char*,size_t,const char*);
_ACRTIMP size_t __cdecl strcspn(const char*,const char*);
_ACRTIMP char* __cdecl strerror(int);
_ACRTIMP size_t __cdecl strlen(const char*);
_ACRTIMP char* __cdecl strncat(char*,const char*,size_t);
_ACRTIMP errno_t __cdecl strncat_s(char*,size_t,const char*,size_t);
_ACRTIMP int __cdecl strncmp(const char*,const char*,size_t);
_ACRTIMP char* __cdecl strncpy(char*,const char*,size_t);
_ACRTIMP errno_t __cdecl strncpy_s(char*,size_t,const char*,size_t);
_ACRTIMP size_t __cdecl strnlen(const char*,size_t);
_ACRTIMP char* __cdecl strpbrk(const char*,const char*);
_ACRTIMP char* __cdecl strrchr(const char*,int);
_ACRTIMP size_t __cdecl strspn(const char*,const char*);
_ACRTIMP char* __cdecl strstr(const char*,const char*);
_ACRTIMP char* __cdecl strtok(char*,const char*);
_ACRTIMP char* __cdecl strtok_s(char*,const char*,char**);
_ACRTIMP size_t __cdecl strxfrm(char*,const char*,size_t);
#ifdef __cplusplus
}
#endif
static inline int strcasecmp(const char* s1, const char* s2) { return _stricmp(s1, s2); }
static inline int strcmpi(const char* s1, const char* s2) { return _strcmpi(s1, s2); }
static inline char* strdup(const char* buf) { return _strdup(buf); }
static inline int stricmp(const char* s1, const char* s2) { return _stricmp(s1, s2); }
static inline int stricoll(const char* s1, const char* s2) { return _stricoll(s1, s2); }
static inline char* strlwr(char* str) { return _strlwr(str); }
static inline int strncasecmp(const char *str1, const char *str2, size_t n) { return _strnicmp(str1, str2, n); }
static inline int strnicmp(const char* s1, const char* s2, size_t n) { return _strnicmp(s1, s2, n); }
static inline char* strnset(char* str, int value, unsigned int len) { return _strnset(str, value, len); }
static inline char* strrev(char* str) { return _strrev(str); }
static inline char* strset(char* str, int value) { return _strset(str, value); }
static inline char* strupr(char* str) { return _strupr(str); }
static inline wchar_t* wcsdup(const wchar_t* str) { return _wcsdup(str); }
static inline int wcsicoll(const wchar_t* str1, const wchar_t* str2) { return _wcsicoll(str1, str2); }
static inline wchar_t* wcslwr(wchar_t* str) { return _wcslwr(str); }
static inline int wcsicmp(const wchar_t* s1, const wchar_t* s2) { return _wcsicmp(s1, s2); }
static inline int wcsnicmp(const wchar_t* str1, const wchar_t* str2, size_t n) { return _wcsnicmp(str1, str2, n); }
static inline wchar_t* wcsnset(wchar_t* str, wchar_t c, size_t n) { return _wcsnset(str, c, n); }
static inline wchar_t* wcsrev(wchar_t* str) { return _wcsrev(str); }
static inline wchar_t* wcsset(wchar_t* str, wchar_t c) { return _wcsset(str, c); }
static inline wchar_t* wcsupr(wchar_t* str) { return _wcsupr(str); }
#endif /* __WINE_STRING_H */

32
assets/wine/include/wine/msvcrt/sys/locking.h
View File

@@ -1,32 +0,0 @@
/*
* _locking constants
*
* Copyright 2002 Bill Medland
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_SYS_LOCKING_H__
#define __WINE_SYS_LOCKING_H__
#ifndef __WINE_USE_MSVCRT
#define __WINE_USE_MSVCRT
#endif
#define _LK_UNLCK 0
#define _LK_LOCK 1
#define _LK_NBLCK 2
#define _LK_RLCK 3
#define _LK_NBRLCK 4
#endif /* __WINE_SYS_LOCKING_H__ : Do not place anything after this #endif */

227
assets/wine/include/wine/msvcrt/sys/stat.h
View File

@@ -1,227 +0,0 @@
/*
* _stat() definitions
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Jon Griffiths and Francois Gouget.
* This file is in the public domain.
*/
#ifndef __WINE_SYS_STAT_H
#define __WINE_SYS_STAT_H
#include <corecrt.h>
#include <sys/types.h>
#pragma pack(push,8)
#ifndef _DEV_T_DEFINED
# ifdef _CRTDLL
typedef unsigned short _dev_t;
# else
typedef unsigned int _dev_t;
# endif
#define _DEV_T_DEFINED
#endif
#ifndef _INO_T_DEFINED
typedef unsigned short _ino_t;
#define _INO_T_DEFINED
#endif
#ifndef _OFF_T_DEFINED
typedef int _off_t;
#define _OFF_T_DEFINED
#endif
#define _S_IEXEC 0x0040
#define _S_IWRITE 0x0080
#define _S_IREAD 0x0100
#define _S_IFIFO 0x1000
#define _S_IFCHR 0x2000
#define _S_IFDIR 0x4000
#define _S_IFREG 0x8000
#define _S_IFMT 0xF000
/* for FreeBSD */
#undef st_atime
#undef st_ctime
#undef st_mtime
#ifndef _STAT_DEFINED
#define _STAT_DEFINED
struct _stat {
_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;
_off_t st_size;
time_t st_atime;
time_t st_mtime;
time_t st_ctime;
};
struct stat {
_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;
_off_t st_size;
time_t st_atime;
time_t st_mtime;
time_t st_ctime;
};
struct _stat32 {
_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;
_off_t st_size;
__time32_t st_atime;
__time32_t st_mtime;
__time32_t st_ctime;
};
struct _stat32i64 {
_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 DECLSPEC_ALIGN(8) st_size;
__time32_t st_atime;
__time32_t st_mtime;
__time32_t st_ctime;
};
struct _stat64i32 {
_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;
_off_t st_size;
__time64_t st_atime;
__time64_t st_mtime;
__time64_t st_ctime;
};
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 DECLSPEC_ALIGN(8) st_size;
time_t st_atime;
time_t st_mtime;
time_t st_ctime;
};
struct _stat64 {
_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 DECLSPEC_ALIGN(8) st_size;
__time64_t st_atime;
__time64_t st_mtime;
__time64_t st_ctime;
};
#endif /* _STAT_DEFINED */
#ifdef __cplusplus
extern "C" {
#endif
#ifdef _UCRT
# ifdef _USE_32BIT_TIME_T
# define _fstat _fstat32
# define _fstati64 _fstat32i64
# define _stat _stat32
# define _stati64 _stat32i64
# define _wstat _wstat32
# define _wstati64 _wstat32i64
# else
# define _fstat _fstat64i32
# define _fstati64 _fstat64
# define _stat _stat64i32
# define _stati64 _stat64
# define _wstat _wstat64i32
# define _wstati64 _wstat64
# endif
#else /* _UCRT */
# ifdef _USE_32BIT_TIME_T
# define _fstat32 _fstat
# define _fstat32i64 _fstati64
# define _stat32i64 _stati64
# define _stat32 _stat
# define _wstat32 _wstat
# define _wstat32i64 _wstati64
# else
# define _fstat64i32 _fstat
# define _fstat64 _fstati64
# define _stat64 _stati64
# define _stat64i32 _stat
# define _wstat64i32 _wstat
# define _wstat64 _wstati64
# endif
#endif
#define __stat64 _stat64
_ACRTIMP int __cdecl _fstat32(int, struct _stat32*);
_ACRTIMP int __cdecl _fstat32i64(int, struct _stat32i64*);
_ACRTIMP int __cdecl _fstat64(int,struct _stat64*);
_ACRTIMP int __cdecl _fstat64i32(int,struct _stat64i32*);
_ACRTIMP int __cdecl _stat32(const char*, struct _stat32*);
_ACRTIMP int __cdecl _stat32i64(const char*, struct _stat32i64*);
_ACRTIMP int __cdecl _stat64(const char*,struct _stat64*);
_ACRTIMP int __cdecl _stat64i32(const char*,struct _stat64i32*);
_ACRTIMP int __cdecl _umask(int);
_ACRTIMP int __cdecl _wstat32(const wchar_t*,struct _stat32*);
_ACRTIMP int __cdecl _wstat32i64(const wchar_t*, struct _stat32i64*);
_ACRTIMP int __cdecl _wstat64(const wchar_t*,struct _stat64*);
_ACRTIMP int __cdecl _wstat64i32(const wchar_t*,struct _stat64i32*);
#ifdef __cplusplus
}
#endif
#define S_IFMT _S_IFMT
#define S_IFDIR _S_IFDIR
#define S_IFCHR _S_IFCHR
#define S_IFREG _S_IFREG
#define S_IREAD _S_IREAD
#define S_IWRITE _S_IWRITE
#define S_IEXEC _S_IEXEC
static inline int fstat(int fd, struct stat* ptr) { return _fstat(fd, (struct _stat*)ptr); }
static inline int stat(const char* path, struct stat* ptr) { return _stat(path, (struct _stat*)ptr); }
#ifndef _UMASK_DEFINED
static inline int umask(int fd) { return _umask(fd); }
#define _UMASK_DEFINED
#endif
#pragma pack(pop)
#endif /* __WINE_SYS_STAT_H */

76
assets/wine/include/wine/msvcrt/sys/timeb.h
View File

@@ -1,76 +0,0 @@
/*
* Path and directory definitions
*
* Copyright 2000 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_SYS_TIMEB_H
#define __WINE_SYS_TIMEB_H
#include <corecrt.h>
#pragma pack(push,8)
#ifndef _TIMEB_DEFINED
#define _TIMEB_DEFINED
struct _timeb
{
time_t time;
unsigned short millitm;
short timezone;
short dstflag;
};
struct __timeb32
{
__time32_t time;
unsigned short millitm;
short timezone;
short dstflag;
};
struct __timeb64
{
__time64_t time;
unsigned short millitm;
short timezone;
short dstflag;
};
#endif /* _TIMEB_DEFINED */
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP void __cdecl _ftime32(struct __timeb32*);
_ACRTIMP void __cdecl _ftime64(struct __timeb64*);
#ifdef __cplusplus
}
#endif
#ifdef _USE_32BIT_TIME_T
static inline void __cdecl _ftime(struct _timeb *tb) { return _ftime32((struct __timeb32*)tb); }
#else
static inline void __cdecl _ftime(struct _timeb *tb) { return _ftime64((struct __timeb64*)tb); }
#endif
#define timeb _timeb
static inline void ftime(struct _timeb* ptr) { return _ftime(ptr); }
#pragma pack(pop)
#endif /* __WINE_SYS_TIMEB_H */

76
assets/wine/include/wine/msvcrt/sys/types.h
View File

@@ -1,76 +0,0 @@
/*
* _stat() definitions
*
* Copyright 2000 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_SYS_TYPES_H
#define __WINE_SYS_TYPES_H
#include <corecrt.h>
#ifndef _DEV_T_DEFINED
# ifdef _CRTDLL
typedef unsigned short _dev_t;
# else
typedef unsigned int _dev_t;
# endif
#define _DEV_T_DEFINED
#endif
#ifndef _INO_T_DEFINED
typedef unsigned short _ino_t;
#define _INO_T_DEFINED
#endif
#ifndef _MODE_T_DEFINED
typedef unsigned short _mode_t;
#define _MODE_T_DEFINED
#endif
#ifndef _OFF_T_DEFINED
typedef int _off_t;
#define _OFF_T_DEFINED
#endif
#ifndef _BSDTYPES_DEFINED
typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef __msvcrt_ulong u_long;
#define _BSDTYPES_DEFINED
#endif
#define dev_t _dev_t
#define ino_t _ino_t
#define mode_t _mode_t
#define off_t _off_t
#ifndef _PID_T_DEFINED
typedef int pid_t;
#define _PID_T_DEFINED
#endif
#ifndef _SSIZE_T_DEFINED
#ifdef _WIN64
typedef __int64 ssize_t;
#else
typedef int ssize_t;
#endif
#define _SSIZE_T_DEFINED
#endif
#endif /* __WINE_SYS_TYPES_H */

1
assets/wine/include/wine/msvcrt/sys/unistd.h
View File

@@ -1 +0,0 @@
#include <unistd.h>

78
assets/wine/include/wine/msvcrt/sys/utime.h
View File

@@ -1,78 +0,0 @@
/*
* Path and directory definitions
*
* Copyright 2000 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_SYS_UTIME_H
#define __WINE_SYS_UTIME_H
#include <corecrt.h>
#pragma pack(push,8)
#ifndef _UTIMBUF_DEFINED
#define _UTIMBUF_DEFINED
struct _utimbuf
{
time_t actime;
time_t modtime;
};
struct __utimbuf32
{
__time32_t actime;
__time32_t modtime;
};
struct __utimbuf64
{
__time64_t actime;
__time64_t modtime;
};
#endif /* _UTIMBUF_DEFINED */
#ifdef __cplusplus
extern "C" {
#endif
_ACRTIMP int __cdecl _futime32(int,struct __utimbuf32*);
_ACRTIMP int __cdecl _futime64(int,struct __utimbuf64*);
_ACRTIMP int __cdecl _utime32(const char*,struct __utimbuf32*);
_ACRTIMP int __cdecl _utime64(const char*,struct __utimbuf64*);
_ACRTIMP int __cdecl _wutime32(const wchar_t*,struct __utimbuf32*);
_ACRTIMP int __cdecl _wutime64(const wchar_t*,struct __utimbuf64*);
#ifdef _USE_32BIT_TIME_T
static inline int _futime(int fd, struct _utimbuf *buf) { return _futime32(fd, (struct __utimbuf32*)buf); }
static inline int _utime(const char *s, struct _utimbuf *buf) { return _utime32(s, (struct __utimbuf32*)buf); }
static inline int _wutime(const wchar_t *s, struct _utimbuf *buf) { return _wutime32(s, (struct __utimbuf32*)buf); }
#else
static inline int _futime(int fd, struct _utimbuf *buf) { return _futime64(fd, (struct __utimbuf64*)buf); }
static inline int _utime(const char *s, struct _utimbuf *buf) { return _utime64(s, (struct __utimbuf64*)buf); }
static inline int _wutime(const wchar_t *s, struct _utimbuf *buf) { return _wutime64(s, (struct __utimbuf64*)buf); }
#endif
#ifdef __cplusplus
}
#endif
#define utimbuf _utimbuf
static inline int utime(const char* path, struct _utimbuf* buf) { return _utime(path, buf); }
#pragma pack(pop)
#endif /* __WINE_SYS_UTIME_H */

142
assets/wine/include/wine/msvcrt/time.h
View File

@@ -1,142 +0,0 @@
/*
* Time definitions
*
* Copyright 2000 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_TIME_H
#define __WINE_TIME_H
#include <corecrt_wtime.h>
#pragma pack(push,8)
#ifndef _CLOCK_T_DEFINED
typedef __msvcrt_long clock_t;
#define _CLOCK_T_DEFINED
#endif
#ifndef CLOCKS_PER_SEC
#define CLOCKS_PER_SEC 1000
#endif
#ifdef __cplusplus
extern "C" {
#endif
struct _timespec32
{
__time32_t tv_sec;
__msvcrt_long tv_nsec;
};
struct _timespec64
{
__time64_t tv_sec;
__msvcrt_long tv_nsec;
};
struct timespec
{
time_t tv_sec;
__msvcrt_long tv_nsec;
};
#ifdef __i386__
#define _daylight (*__p__daylight())
#define _dstbias (*__p__dstbias())
#define _timezone (*__p__timezone())
#define _tzname (__p__tzname())
_ACRTIMP int * __cdecl __p__daylight(void);
_ACRTIMP __msvcrt_long * __cdecl __p__dstbias(void);
_ACRTIMP __msvcrt_long * __cdecl __p__timezone(void);
_ACRTIMP char ** __cdecl __p__tzname(void);
#else
extern int _daylight;
extern __msvcrt_long _dstbias;
extern __msvcrt_long _timezone;
extern char *_tzname;
#endif
#if _MSVCR_VER < 120 && defined(_USE_32BIT_TIME_T)
#define _ctime32 ctime
#define _difftime32 difftime
#define _gmtime32 gmtime
#define _localtime32 localtime
#define _mktime32 mktime
#define _time32 time
#endif
_ACRTIMP unsigned __cdecl _getsystime(struct tm*);
_ACRTIMP unsigned __cdecl _setsystime(struct tm*,unsigned);
_ACRTIMP char* __cdecl _strdate(char*);
_ACRTIMP errno_t __cdecl _strdate_s(char*,size_t);
_ACRTIMP char* __cdecl _strtime(char*);
_ACRTIMP errno_t __cdecl _strtime_s(char*,size_t);
_ACRTIMP void __cdecl _tzset(void);
_ACRTIMP char* __cdecl asctime(const struct tm*);
_ACRTIMP clock_t __cdecl clock(void);
_ACRTIMP char* __cdecl _ctime32(const __time32_t*);
_ACRTIMP errno_t __cdecl _ctime32_s(char*,size_t,const __time32_t*);
_ACRTIMP char* __cdecl _ctime64(const __time64_t*);
_ACRTIMP errno_t __cdecl _ctime64_s(char*,size_t,const __time64_t*);
_ACRTIMP double __cdecl _difftime32(__time32_t,__time32_t);
_ACRTIMP double __cdecl _difftime64(__time64_t,__time64_t);
_ACRTIMP struct tm* __cdecl _gmtime32(const __time32_t*);
_ACRTIMP int __cdecl _gmtime32_s(struct tm *res, const __time32_t *secs);
_ACRTIMP struct tm* __cdecl _gmtime64(const __time64_t*);
_ACRTIMP int __cdecl _gmtime64_s(struct tm *res, const __time64_t *secs);
_ACRTIMP struct tm* __cdecl _localtime32(const __time32_t*);
_ACRTIMP errno_t __cdecl _localtime32_s(struct tm*, const __time32_t*);
_ACRTIMP struct tm* __cdecl _localtime64(const __time64_t*);
_ACRTIMP errno_t __cdecl _localtime64_s(struct tm*, const __time64_t*);
_ACRTIMP __time32_t __cdecl _mktime32(struct tm*);
_ACRTIMP __time64_t __cdecl _mktime64(struct tm*);
_ACRTIMP size_t __cdecl strftime(char*,size_t,const char*,const struct tm*);
_ACRTIMP size_t __cdecl _strftime_l(char*,size_t,const char*,const struct tm*,_locale_t);
_ACRTIMP __time32_t __cdecl _time32(__time32_t*);
_ACRTIMP __time64_t __cdecl _time64(__time64_t*);
#ifndef _USE_32BIT_TIME_T
static inline char* ctime(const time_t *t) { return _ctime64(t); }
static inline errno_t ctime_s(char *res, size_t len, const __time64_t *t) { return _ctime64_s(res, len, t); }
static inline double difftime(time_t t1, time_t t2) { return _difftime64(t1, t2); }
static inline struct tm* gmtime(const time_t *t) { return _gmtime64(t); }
static inline struct tm* localtime(const time_t *t) { return _localtime64(t); }
static inline errno_t localtime_s(struct tm *res, const time_t *t) { return _localtime64_s(res, t); }
static inline time_t mktime(struct tm *tm) { return _mktime64(tm); }
static inline time_t time(time_t *t) { return _time64(t); }
#elif defined(_UCRT)
static inline char* ctime(const time_t *t) { return _ctime32(t); }
static inline errno_t ctime_s(char *res, size_t len, const __time32_t *t) { return _ctime32_s(res, len, t); }
static inline double difftime(time_t t1, time_t t2) { return _difftime32(t1, t2); }
static inline struct tm* gmtime(const time_t *t) { return _gmtime32(t); }
static inline struct tm* localtime(const time_t *t) { return _localtime32(t); }
static inline errno_t localtime_s(struct tm *res, const time_t *t) { return _localtime32_s(res, t); }
static inline time_t mktime(struct tm *tm) { return _mktime32(tm); }
static inline time_t time(time_t *t) { return _time32(t); }
#endif
#ifdef __cplusplus
}
#endif
#pragma pack(pop)
#endif /* __WINE_TIME_H */

72
assets/wine/include/wine/msvcrt/uchar.h
View File

@@ -1,72 +0,0 @@
/**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the mingw-w64 runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
/* ISO C1x Unicode utilities
* Based on ISO/IEC SC22/WG14 9899 TR 19769 (SC22 N1326)
*
* 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.
*
* Date: 2011-09-27
*/
#ifndef __UCHAR_H
#define __UCHAR_H
#include <stddef.h> /* size_t */
#include <stdint.h> /* uint_leastXX_t */
#include <wchar.h> /* mbstate_t */
/* Remember that g++ >= 4.4 defines these types only in c++0x mode */
#if !(defined(__cplusplus) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
!defined(__GNUC__) || \
(!defined(__clang__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 4)))
typedef uint_least16_t char16_t;
typedef uint_least32_t char32_t;
#endif
#ifndef __STDC_UTF_16__
#define __STDC_UTF_16__ 1
#endif
#ifndef __STDC_UTF_32__
#define __STDC_UTF_32__ 1
#endif
#ifdef __cplusplus
extern "C" {
#endif
size_t mbrtoc16 (char16_t *__restrict__ pc16,
const char *__restrict__ s,
size_t n,
mbstate_t *__restrict__ ps);
size_t c16rtomb (char *__restrict__ s,
char16_t c16,
mbstate_t *__restrict__ ps);
size_t mbrtoc32 (char32_t *__restrict__ pc32,
const char *__restrict__ s,
size_t n,
mbstate_t *__restrict__ ps);
size_t c32rtomb (char *__restrict__ s,
char32_t c32,
mbstate_t *__restrict__ ps);
#ifdef __cplusplus
}
#endif
#endif /* __UCHAR_H */

2
assets/wine/include/wine/msvcrt/unistd.h
View File

@@ -1,2 +0,0 @@
#include <io.h>
#include <process.h>

62
assets/wine/include/wine/msvcrt/vadefs.h
View File

@@ -1,62 +0,0 @@
/*
* Variable argument definitions
*
* Copyright 2022 Jacek Caban
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef _INC_VADEFS
#define _INC_VADEFS
#include <corecrt.h>
#ifdef __cplusplus
#define _ADDRESSOF(v) (&reinterpret_cast<const char &>(v))
#else
#define _ADDRESSOF(v) (&(v))
#endif
#if defined (__GNUC__) && defined(__x86_64__)
typedef __builtin_ms_va_list va_list;
#define _crt_va_start(v,l) __builtin_ms_va_start(v,l)
#define _crt_va_arg(v,l) __builtin_va_arg(v,l)
#define _crt_va_end(v) __builtin_ms_va_end(v)
#define _crt_va_copy(d,s) __builtin_ms_va_copy(d,s)
#elif defined(__GNUC__) || defined(__clang__)
typedef __builtin_va_list va_list;
#define _crt_va_start(v,l) __builtin_va_start(v,l)
#define _crt_va_arg(v,l) __builtin_va_arg(v,l)
#define _crt_va_end(v) __builtin_va_end(v)
#define _crt_va_copy(d,s) __builtin_va_copy(d,s)
#else
typedef char *va_list;
#if defined(__i386__)
#define _INTSIZEOF(n) ((sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1))
#define _crt_va_start(v,l) ((v) = (va_list)_ADDRESSOF(l) + _INTSIZEOF(l))
#define _crt_va_arg(v,l) (*(l *)(((v) += _INTSIZEOF(l)) - _INTSIZEOF(l)))
#define _crt_va_end(v) ((v) = (va_list)0)
#define _crt_va_copy(d,s) ((d) = (s))
#endif
#endif
#endif /* _INC_VADEFS */

98
assets/wine/include/wine/msvcrt/wchar.h
View File

@@ -1,98 +0,0 @@
/*
* Unicode definitions
*
* Derived from the mingw header written by Colin Peters.
* Modified for Wine use by Jon Griffiths and Francois Gouget.
* This file is in the public domain.
*/
#ifndef __WINE_WCHAR_H
#define __WINE_WCHAR_H
#include <corecrt_wctype.h>
#include <corecrt_wdirect.h>
#include <corecrt_wio.h>
#include <corecrt_wprocess.h>
#include <corecrt_wstdio.h>
#include <corecrt_wstdlib.h>
#include <corecrt_wstring.h>
#include <corecrt_wtime.h>
#include <sys/stat.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef WCHAR_MIN /* also in stdint.h */
#define WCHAR_MIN 0U
#define WCHAR_MAX 0xffffU
#endif
typedef int mbstate_t;
#ifndef _WLOCALE_DEFINED
#define _WLOCALE_DEFINED
_ACRTIMP wchar_t* __cdecl _wsetlocale(int,const wchar_t*);
#endif /* _WLOCALE_DEFINED */
wchar_t __cdecl btowc(int);
size_t __cdecl mbrlen(const char *,size_t,mbstate_t*);
size_t __cdecl mbrtowc(wchar_t*,const char*,size_t,mbstate_t*);
size_t __cdecl mbsrtowcs(wchar_t*,const char**,size_t,mbstate_t*);
size_t __cdecl wcrtomb(char*,wchar_t,mbstate_t*);
int __cdecl wcrtomb_s(size_t*,char*,size_t,wchar_t,mbstate_t*);
size_t __cdecl wcsrtombs(char*,const wchar_t**,size_t,mbstate_t*);
int __cdecl wctob(wint_t);
_ACRTIMP errno_t __cdecl wmemcpy_s(wchar_t *, size_t, const wchar_t *, size_t);
_ACRTIMP errno_t __cdecl wmemmove_s(wchar_t *, size_t, const wchar_t *, size_t);
static inline _CONST_RETURN wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n)
{
const wchar_t *end;
for (end = s + n; s < end; s++)
if (*s == c) return (_CONST_RETURN wchar_t *)s;
return NULL;
}
#ifdef __cplusplus
extern "C++" inline wchar_t *wmemchr(wchar_t *s, wchar_t c, size_t n)
{
wchar_t const* s_const = s;
return const_cast<wchar_t *>(wmemchr(s_const, c, n));
}
#endif
static inline int wmemcmp(const wchar_t *s1, const wchar_t *s2, size_t n)
{
size_t i;
for (i = 0; i < n; i++)
{
if (s1[i] > s2[i]) return 1;
if (s1[i] < s2[i]) return -1;
}
return 0;
}
static inline wchar_t* __cdecl wmemcpy(wchar_t *dst, const wchar_t *src, size_t n)
{
return (wchar_t*)memcpy(dst, src, n * sizeof(wchar_t));
}
static inline wchar_t* __cdecl wmemmove(wchar_t *dst, const wchar_t *src, size_t n)
{
return (wchar_t*)memmove(dst, src, n * sizeof(wchar_t));
}
static inline wchar_t* __cdecl wmemset(wchar_t *s, wchar_t c, size_t n)
{
size_t i;
for (i = 0; i < n; i++)
s[i] = c;
return s;
}
#ifdef __cplusplus
}
#endif
#endif /* __WINE_WCHAR_H */

82
assets/wine/include/wine/msvcrt/wctype.h
View File

@@ -1,82 +0,0 @@
/*
* Unicode definitions
*
* Copyright 2000 Francois Gouget.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_WCTYPE_H
#define __WINE_WCTYPE_H
#include <corecrt.h>
#pragma pack(push,8)
/* ASCII char classification table - binary compatible */
#define _UPPER 0x0001 /* C1_UPPER */
#define _LOWER 0x0002 /* C1_LOWER */
#define _DIGIT 0x0004 /* C1_DIGIT */
#define _SPACE 0x0008 /* C1_SPACE */
#define _PUNCT 0x0010 /* C1_PUNCT */
#define _CONTROL 0x0020 /* C1_CNTRL */
#define _BLANK 0x0040 /* C1_BLANK */
#define _HEX 0x0080 /* C1_XDIGIT */
#define _LEADBYTE 0x8000
#define _ALPHA (0x0100|_UPPER|_LOWER) /* (C1_ALPHA|_UPPER|_LOWER) */
#ifndef WEOF
#define WEOF (wint_t)(0xFFFF)
#endif
/* FIXME: there's something to do with __p__pctype and __p__pwctype */
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _WCTYPE_DEFINED
#define _WCTYPE_DEFINED
_ACRTIMP int __cdecl is_wctype(wint_t,wctype_t);
_ACRTIMP int __cdecl isleadbyte(int);
_ACRTIMP int __cdecl iswalnum(wint_t);
_ACRTIMP int __cdecl iswalpha(wint_t);
_ACRTIMP int __cdecl iswascii(wint_t);
_ACRTIMP int __cdecl iswcntrl(wint_t);
_ACRTIMP int __cdecl iswctype(wint_t,wctype_t);
_ACRTIMP int __cdecl iswdigit(wint_t);
_ACRTIMP int __cdecl iswgraph(wint_t);
_ACRTIMP int __cdecl iswlower(wint_t);
_ACRTIMP int __cdecl iswprint(wint_t);
_ACRTIMP int __cdecl iswpunct(wint_t);
_ACRTIMP int __cdecl iswspace(wint_t);
_ACRTIMP int __cdecl iswupper(wint_t);
_ACRTIMP int __cdecl iswxdigit(wint_t);
_ACRTIMP wint_t __cdecl towlower(wint_t);
_ACRTIMP wint_t __cdecl towupper(wint_t);
#endif /* _WCTYPE_DEFINED */
typedef wchar_t wctrans_t;
wint_t __cdecl towctrans(wint_t,wctrans_t);
wctrans_t __cdecl wctrans(const char *);
wctype_t __cdecl wctype(const char *);
#ifdef __cplusplus
}
#endif
#pragma pack(pop)
#endif /* __WINE_WCTYPE_H */

697
assets/wine/include/wine/svcctl.h
View File

@@ -1,697 +0,0 @@
/*** Autogenerated by WIDL 10.17 from /home/runner/build_wine/wine/include/wine/svcctl.idl - Do not edit ***/
#ifdef _WIN32
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include <rpc.h>
#include <rpcndr.h>
#endif
#ifndef COM_NO_WINDOWS_H
#include <windows.h>
#include <ole2.h>
#endif
#ifndef __svcctl_h__
#define __svcctl_h__
/* Forward declarations */
/* Headers for imported files */
#include <wtypes.h>
#ifdef __cplusplus
extern "C" {
#endif
#include "winsvc.h"
#define SVCCTL_TRANSPORT {'n','c','a','c','n','_','n','p',0}
#define SVCCTL_TRANSPORTA "ncacn_np"
#define SVCCTL_ENDPOINT {'\\','p','i','p','e','\\','s','v','c','c','t','l',0}
#define SVCCTL_ENDPOINTA "\\pipe\\svcctl"
#define SVCCTL_STARTED_EVENT {'_','_','w','i','n','e','_','S','v','c','c','t','l','S','t','a','r','t','e','d',0}
#define SERVICE_PROTOCOL_MAGIC 0x57494e45
#define SERVICE_CONTROL_START 0
#define SERVICE_CONTROL_FORWARD_FLAG 0x80000000
typedef struct service_start_info_t {
DWORD magic;
DWORD total_size;
DWORD name_size;
DWORD control;
BYTE data[1];
} service_start_info;
/*****************************************************************************
* svcctl interface (v2.0)
*/
#ifndef __svcctl_INTERFACE_DEFINED__
#define __svcctl_INTERFACE_DEFINED__
extern RPC_IF_HANDLE svcctl_v2_0_c_ifspec;
extern RPC_IF_HANDLE svcctl_v2_0_s_ifspec;
typedef LPCWSTR MACHINE_HANDLEW;
typedef LPCSTR MACHINE_HANDLEA;
typedef LPCWSTR SVCCTL_HANDLEW;
typedef void *SC_RPC_HANDLE;
typedef void *SC_RPC_LOCK;
typedef void *SC_NOTIFY_RPC_HANDLE;
#define SERVICE_SET_STATUS 0x8000
#if 0 /* already defined in winsvc.h / winnt.h */
typedef DWORD SECURITY_INFORMATION;
typedef struct _QUERY_SERVICE_CONFIGA {
DWORD dwServiceType;
DWORD dwStartType;
DWORD dwErrorControl;
LPSTR lpBinaryPathName;
LPSTR lpLoadOrderGroup;
DWORD dwTagId;
LPSTR lpDependencies;
LPSTR lpServiceStartName;
LPSTR lpDisplayName;
} QUERY_SERVICE_CONFIGA;
typedef struct _QUERY_SERVICE_CONFIGA *LPQUERY_SERVICE_CONFIGA;
typedef struct _QUERY_SERVICE_CONFIGW {
DWORD dwServiceType;
DWORD dwStartType;
DWORD dwErrorControl;
LPWSTR lpBinaryPathName;
LPWSTR lpLoadOrderGroup;
DWORD dwTagId;
LPWSTR lpDependencies;
LPWSTR lpServiceStartName;
LPWSTR lpDisplayName;
} QUERY_SERVICE_CONFIGW;
typedef struct _QUERY_SERVICE_CONFIGW *LPQUERY_SERVICE_CONFIGW;
typedef struct _SERVICE_STATUS {
DWORD dwServiceType;
DWORD dwCurrentState;
DWORD dwControlsAccepted;
DWORD dwWin32ExitCode;
DWORD dwServiceSpecificExitCode;
DWORD dwCheckPoint;
DWORD dwWaitHint;
} SERVICE_STATUS;
typedef struct _SERVICE_STATUS *LPSERVICE_STATUS;
typedef enum _SC_STATUS_TYPE {
SC_STATUS_PROCESS_INFO = 0
} SC_STATUS_TYPE;
typedef struct _SERVICE_DESCRIPTIONA {
LPSTR lpDescription;
} SERVICE_DESCRIPTIONA;
typedef struct _SERVICE_DESCRIPTIONA *LPSERVICE_DESCRIPTIONA;
typedef struct _SERVICE_DESCRIPTIONW {
LPWSTR lpDescription;
} SERVICE_DESCRIPTIONW;
typedef struct _SERVICE_DESCRIPTIONW *LPSERVICE_DESCRIPTIONW;
typedef enum _SC_ACTION_TYPE {
SC_ACTION_NONE = 0,
SC_ACTION_RESTART = 1,
SC_ACTION_REBOOT = 2,
SC_ACTION_RUN_COMMAND = 3
} SC_ACTION_TYPE;
typedef struct _SC_ACTION {
SC_ACTION_TYPE Type;
DWORD Delay;
} SC_ACTION;
typedef struct _SC_ACTION *LPSC_ACTION;
typedef struct _SERVICE_FAILURE_ACTIONSA {
DWORD dwResetPeriod;
LPSTR lpRebootMsg;
LPSTR lpCommand;
DWORD cActions;
SC_ACTION *lpsaActions;
} SERVICE_FAILURE_ACTIONSA;
typedef struct _SERVICE_FAILURE_ACTIONSA *LPSERVICE_FAILURE_ACTIONSA;
typedef struct _SERVICE_FAILURE_ACTIONSW {
DWORD dwResetPeriod;
LPWSTR lpRebootMsg;
LPWSTR lpCommand;
DWORD cActions;
SC_ACTION *lpsaActions;
} SERVICE_FAILURE_ACTIONSW;
typedef struct _SERVICE_FAILURE_ACTIONSW *LPSERVICE_FAILURE_ACTIONSW;
typedef struct _SERVICE_DELAYED_AUTO_START_INFO {
BOOL fDelayedAutostart;
} SERVICE_DELAYED_AUTO_START_INFO;
typedef struct _SERVICE_FAILURE_ACTIONS_FLAG {
BOOL fFailureActionsOnNonCrashFailures;
} SERVICE_FAILURE_ACTIONS_FLAG;
typedef struct _SERVICE_SID_INFO {
DWORD dwServiceSidType;
} SERVICE_SID_INFO;
typedef struct _SERVICE_PRESHUTDOWN_INFO {
DWORD dwPreshutdownTimeout;
} SERVICE_PRESHUTDOWN_INFO;
typedef struct _SERVICE_PRESHUTDOWN_INFO *LPSERVICE_PRESHUTDOWN_INFO;
typedef struct _ENUM_SERVICE_STATUSW {
LPWSTR lpServiceName;
LPWSTR lpDisplayName;
SERVICE_STATUS ServiceStatus;
} ENUM_SERVICE_STATUSW;
typedef struct _ENUM_SERVICE_STATUSW *LPENUM_SERVICE_STATUSW;
typedef struct _QUERY_SERVICE_LOCK_STATUSA {
DWORD fIsLocked;
LPSTR lpLockOwner;
DWORD dwLockDuration;
} QUERY_SERVICE_LOCK_STATUSA;
typedef struct _QUERY_SERVICE_LOCK_STATUSA *LPQUERY_SERVICE_LOCK_STATUSA;
typedef struct _QUERY_SERVICE_LOCK_STATUSW {
DWORD fIsLocked;
LPWSTR lpLockOwner;
DWORD dwLockDuration;
} QUERY_SERVICE_LOCK_STATUSW;
typedef struct _QUERY_SERVICE_LOCK_STATUSW *LPQUERY_SERVICE_LOCK_STATUSW;
typedef struct _SERVICE_STATUS_PROCESS {
DWORD dwServiceType;
DWORD dwCurrentState;
DWORD dwControlsAccepted;
DWORD dwWin32ExitCode;
DWORD dwServiceSpecificExitCode;
DWORD dwCheckPoint;
DWORD dwWaitHint;
DWORD dwProcessId;
DWORD dwServiceFlags;
} SERVICE_STATUS_PROCESS;
typedef struct _SERVICE_STATUS_PROCESS *LPSERVICE_STATUS_PROCESS;
typedef enum _SC_ENUM_TYPE {
SC_ENUM_PROCESS_INFO = 0
} SC_ENUM_TYPE;
#endif
struct enum_service_status {
DWORD service_name;
DWORD display_name;
SERVICE_STATUS service_status;
};
struct enum_service_status_process {
DWORD service_name;
DWORD display_name;
SERVICE_STATUS_PROCESS service_status_process;
};
struct service_description {
USHORT size;
WCHAR description[1];
};
typedef struct _SERVICE_RPC_REQUIRED_PRIVILEGES_INFO {
DWORD cbRequiredPrivileges;
BYTE *pRequiredPrivileges;
} SERVICE_RPC_REQUIRED_PRIVILEGES_INFO;
typedef struct _SC_RPC_CONFIG_INFOW {
DWORD dwInfoLevel;
__C89_NAMELESS union {
SERVICE_DESCRIPTIONW *descr;
SERVICE_FAILURE_ACTIONSW *actions;
SERVICE_DELAYED_AUTO_START_INFO *delayedstart;
SERVICE_FAILURE_ACTIONS_FLAG *actionsflag;
SERVICE_SID_INFO *sid;
SERVICE_RPC_REQUIRED_PRIVILEGES_INFO *privinfo;
SERVICE_PRESHUTDOWN_INFO *preshutdown;
} __C89_NAMELESSUNIONNAME;
} SC_RPC_CONFIG_INFOW;
typedef struct _SC_RPC_CONFIG_INFOA {
DWORD dwInfoLevel;
__C89_NAMELESS union {
SERVICE_DESCRIPTIONA *descr;
SERVICE_FAILURE_ACTIONSA *actions;
SERVICE_DELAYED_AUTO_START_INFO *delayedstart;
SERVICE_FAILURE_ACTIONS_FLAG *actionsflag;
SERVICE_SID_INFO *sid;
SERVICE_RPC_REQUIRED_PRIVILEGES_INFO *privinfo;
SERVICE_PRESHUTDOWN_INFO *preshutdown;
} __C89_NAMELESSUNIONNAME;
} SC_RPC_CONFIG_INFOA;
typedef struct _SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_1 {
ULONGLONG ullThreadId;
DWORD dwNotifyMask;
UCHAR CallbackAddressArray[16];
UCHAR CallbackParamAddressArray[16];
SERVICE_STATUS_PROCESS ServiceStatus;
DWORD dwNotificationStatus;
DWORD dwSequence;
} SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_1;
typedef struct _SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_1 *PSERVICE_NOTIFY_STATUS_CHANGE_PARAMS_1;
typedef struct _SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_2 {
ULONGLONG ullThreadId;
DWORD dwNotifyMask;
UCHAR CallbackAddressArray[16];
UCHAR CallbackParamAddressArray[16];
SERVICE_STATUS_PROCESS ServiceStatus;
DWORD dwNotificationStatus;
DWORD dwSequence;
DWORD dwNotificationTriggered;
LPWSTR pszServiceNames;
} SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_2;
typedef struct _SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_2 *PSERVICE_NOTIFY_STATUS_CHANGE_PARAMS_2;
typedef struct _SC_RPC_NOTIFY_PARAMS {
DWORD dwInfoLevel;
__C89_NAMELESS union {
SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_1 *params1;
SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_2 *params;
} __C89_NAMELESSUNIONNAME;
} SC_RPC_NOTIFY_PARAMS;
typedef struct _SC_RPC_NOTIFY_PARAMS_LIST {
DWORD cElements;
SC_RPC_NOTIFY_PARAMS NotifyParamsArray[1];
} SC_RPC_NOTIFY_PARAMS_LIST;
typedef struct _SC_RPC_NOTIFY_PARAMS_LIST *PSC_RPC_NOTIFY_PARAMS_LIST;
typedef struct _SERVICE_CONTROL_STATUS_REASON_IN_PARAMSA {
DWORD dwReason;
LPSTR pszComment;
} SERVICE_CONTROL_STATUS_REASON_IN_PARAMSA;
typedef struct _SERVICE_CONTROL_STATUS_REASON_IN_PARAMSA *PSERVICE_CONTROL_STATUS_REASON_IN_PARAMSA;
typedef struct _SERVICE_CONTROL_STATUS_REASON_IN_PARAMSW {
DWORD dwReason;
LPWSTR pszComment;
} SERVICE_CONTROL_STATUS_REASON_IN_PARAMSW;
typedef struct _SERVICE_CONTROL_STATUS_REASON_IN_PARAMSW *PSERVICE_CONTROL_STATUS_REASON_IN_PARAMSW;
typedef union _SC_RPC_SERVICE_CONTROL_IN_PARAMSA {
PSERVICE_CONTROL_STATUS_REASON_IN_PARAMSA psrInParams;
} SC_RPC_SERVICE_CONTROL_IN_PARAMSA;
typedef union _SC_RPC_SERVICE_CONTROL_IN_PARAMSA *PSC_RPC_SERVICE_CONTROL_IN_PARAMSA;
typedef union _SC_RPC_SERVICE_CONTROL_IN_PARAMSW {
PSERVICE_CONTROL_STATUS_REASON_IN_PARAMSW psrInParams;
} SC_RPC_SERVICE_CONTROL_IN_PARAMSW;
typedef union _SC_RPC_SERVICE_CONTROL_IN_PARAMSW *PSC_RPC_SERVICE_CONTROL_IN_PARAMSW;
typedef struct _SERVICE_CONTROL_STATUS_REASON_OUT_PARAMS {
SERVICE_STATUS_PROCESS ServiceStatus;
} SERVICE_CONTROL_STATUS_REASON_OUT_PARAMS;
typedef struct _SERVICE_CONTROL_STATUS_REASON_OUT_PARAMS *PSERVICE_CONTROL_STATUS_REASON_OUT_PARAMS;
typedef union _SC_RPC_SERVICE_CONTROL_OUT_PARAMSA {
PSERVICE_CONTROL_STATUS_REASON_OUT_PARAMS psrOutParams;
} SC_RPC_SERVICE_CONTROL_OUT_PARAMSA;
typedef union _SC_RPC_SERVICE_CONTROL_OUT_PARAMSA *PSC_RPC_SERVICE_CONTROL_OUT_PARAMSA;
typedef union _SC_RPC_SERVICE_CONTROL_OUT_PARAMSW {
PSERVICE_CONTROL_STATUS_REASON_OUT_PARAMS psrOutParams;
} SC_RPC_SERVICE_CONTROL_OUT_PARAMSW;
typedef union _SC_RPC_SERVICE_CONTROL_OUT_PARAMSW *PSC_RPC_SERVICE_CONTROL_OUT_PARAMSW;
DWORD __cdecl svcctl_CloseServiceHandle(
SC_RPC_HANDLE *handle);
DWORD __cdecl svcctl_ControlService(
SC_RPC_HANDLE hService,
DWORD dwControl,
SERVICE_STATUS *lpServiceStatus);
DWORD __cdecl svcctl_DeleteService(
SC_RPC_HANDLE hService);
DWORD __cdecl svcctl_LockServiceDatabase(
SC_RPC_HANDLE hSCManager,
SC_RPC_LOCK *phLock);
DWORD __cdecl svcctl_QueryServiceObjectSecurity(
SC_RPC_HANDLE service,
SECURITY_INFORMATION info,
BYTE *descriptor,
DWORD buf_size,
DWORD *needed_size);
DWORD __cdecl svcctl_SetServiceObjectSecurity(
SC_RPC_HANDLE service,
SECURITY_INFORMATION info,
BYTE *descriptor,
DWORD buf_size);
DWORD __cdecl svcctl_QueryServiceStatus(
SC_RPC_HANDLE service,
SERVICE_STATUS *status);
DWORD __cdecl svcctl_SetServiceStatus(
SC_RPC_HANDLE hServiceStatus,
LPSERVICE_STATUS lpServiceStatus);
DWORD __cdecl svcctl_UnlockServiceDatabase(
SC_RPC_LOCK *phLock);
DWORD __cdecl svcctl_NotifyBootConfigStatus(
SVCCTL_HANDLEW machinename,
DWORD boot_acceptable);
DWORD __cdecl svcctl_SCSetServiceBitsW(
void);
DWORD __cdecl svcctl_ChangeServiceConfigW(
SC_RPC_HANDLE hService,
DWORD dwServiceType,
DWORD dwStartType,
DWORD dwErrorControl,
LPCWSTR lpBinaryPathName,
LPCWSTR lpLoadOrderGroupKey,
DWORD *lpdwTagId,
const BYTE *lpDependencies,
DWORD dwDependenciesSize,
LPCWSTR lpServiceStartName,
const BYTE *lpPassword,
DWORD dwPasswordSize,
LPCWSTR lpDisplayName);
DWORD __cdecl svcctl_CreateServiceW(
SC_RPC_HANDLE hSCManager,
LPCWSTR lpServiceName,
LPCWSTR lpDisplayName,
DWORD dwDesiredAccess,
DWORD dwServiceType,
DWORD dwStartType,
DWORD dwErrorControl,
LPCWSTR lpBinaryPathName,
LPCWSTR lpLoadOrderGroup,
DWORD *lpdwTagId,
const BYTE *lpDependencies,
DWORD dwDependenciesSize,
LPCWSTR lpServiceStartName,
const BYTE *lpPassword,
DWORD dwPasswordSize,
SC_RPC_HANDLE *phService);
DWORD __cdecl svcctl_EnumDependentServicesW(
SC_RPC_HANDLE service,
DWORD state,
BYTE *services,
DWORD buf_size,
DWORD *needed_size,
DWORD *services_ret);
DWORD __cdecl svcctl_EnumServicesStatusW(
SC_RPC_HANDLE hmngr,
DWORD type,
DWORD state,
BYTE *buffer,
DWORD size,
LPDWORD needed,
LPDWORD returned,
LPDWORD resume);
DWORD __cdecl svcctl_OpenSCManagerW(
MACHINE_HANDLEW MachineName,
LPCWSTR DatabaseName,
DWORD dwAccessMask,
SC_RPC_HANDLE *handle);
DWORD __cdecl svcctl_OpenServiceW(
SC_RPC_HANDLE hSCManager,
LPCWSTR lpServiceName,
DWORD dwDesiredAccess,
SC_RPC_HANDLE *phService);
DWORD __cdecl svcctl_QueryServiceConfigW(
SC_RPC_HANDLE hService,
QUERY_SERVICE_CONFIGW *config,
DWORD buf_size,
DWORD *needed_size);
DWORD __cdecl svcctl_QueryServiceLockStatusW(
SC_RPC_HANDLE scmanager,
QUERY_SERVICE_LOCK_STATUSW *status,
DWORD buf_size,
DWORD *needed_size);
DWORD __cdecl svcctl_StartServiceW(
SC_RPC_HANDLE hService,
DWORD dwNumServiceArgs,
LPCWSTR *lpServiceArgVectors);
DWORD __cdecl svcctl_GetServiceDisplayNameW(
SC_RPC_HANDLE hSCManager,
LPCWSTR lpServiceName,
WCHAR lpBuffer[],
DWORD *cchBufSize);
DWORD __cdecl svcctl_GetServiceKeyNameW(
SC_RPC_HANDLE hSCManager,
LPCWSTR lpServiceDisplayName,
WCHAR lpBuffer[],
DWORD *cchBufSize);
DWORD __cdecl svcctl_SCSetServiceBitsA(
void);
DWORD __cdecl svcctl_ChangeServiceConfigA(
SC_RPC_HANDLE service,
DWORD service_type,
DWORD start_type,
DWORD error_control,
LPSTR binarypath,
LPSTR loadordergroup,
DWORD *tagid,
BYTE *dependencies,
DWORD depend_size,
LPSTR startname,
BYTE *password,
DWORD password_size,
LPSTR displayname);
DWORD __cdecl svcctl_CreateServiceA(
SC_RPC_HANDLE scmanager,
LPCSTR servicename,
LPCSTR displayname,
DWORD desiredaccess,
DWORD service_type,
DWORD start_type,
DWORD error_control,
LPCSTR binarypath,
LPCSTR loadordergroup,
DWORD *tagid,
const BYTE *dependencies,
DWORD depend_size,
LPCSTR startname,
const BYTE *password,
DWORD password_size,
SC_RPC_HANDLE *service);
DWORD __cdecl svcctl_EnumDependentServicesA(
SC_RPC_HANDLE service,
DWORD state,
BYTE *services,
DWORD buf_size,
DWORD *needed_size,
DWORD *services_ret);
DWORD __cdecl svcctl_EnumServicesStatusA(
SC_RPC_HANDLE hmngr,
DWORD type,
DWORD state,
BYTE *buffer,
DWORD size,
DWORD *needed,
DWORD *returned,
DWORD *resume);
DWORD __cdecl svcctl_OpenSCManagerA(
MACHINE_HANDLEA MachineName,
LPCSTR DatabaseName,
DWORD dwAccessMask,
SC_RPC_HANDLE *handle);
DWORD __cdecl svcctl_OpenServiceA(
SC_RPC_HANDLE hSCManager,
LPCSTR lpServiceName,
DWORD dwDesiredAccess,
SC_RPC_HANDLE *phService);
DWORD __cdecl svcctl_QueryServiceConfigA(
SC_RPC_HANDLE hService,
QUERY_SERVICE_CONFIGA *config,
DWORD buf_size,
DWORD *needed_size);
DWORD __cdecl svcctl_QueryServiceLockStatusA(
SC_RPC_HANDLE scmanager,
QUERY_SERVICE_LOCK_STATUSA *status,
DWORD buf_size,
DWORD *needed_size);
DWORD __cdecl svcctl_StartServiceA(
SC_RPC_HANDLE service,
DWORD argc,
LPCSTR *args);
DWORD __cdecl svcctl_GetServiceDisplayNameA(
SC_RPC_HANDLE hSCManager,
LPCSTR servicename,
CHAR buffer[],
DWORD *buf_size);
DWORD __cdecl svcctl_GetServiceKeyNameA(
SC_RPC_HANDLE hSCManager,
LPCSTR servicename,
CHAR buffer[],
DWORD *buf_size);
DWORD __cdecl svcctl_GetCurrentGroupStateW(
void);
DWORD __cdecl svcctl_EnumServiceGroupW(
SC_RPC_HANDLE scmanager,
DWORD service_type,
DWORD service_state,
BYTE *buffer,
DWORD buf_size,
DWORD *needed_size,
DWORD *returned_size,
DWORD *resume_index,
LPCWSTR groupname);
DWORD __cdecl svcctl_ChangeServiceConfig2A(
SC_RPC_HANDLE service,
SC_RPC_CONFIG_INFOA info);
DWORD __cdecl svcctl_ChangeServiceConfig2W(
SC_RPC_HANDLE service,
SC_RPC_CONFIG_INFOW info);
DWORD __cdecl svcctl_QueryServiceConfig2A(
SC_RPC_HANDLE service,
DWORD info_level,
BYTE *buffer,
DWORD buf_size,
DWORD *needed_size);
DWORD __cdecl svcctl_QueryServiceConfig2W(
SC_RPC_HANDLE hService,
DWORD InfoLevel,
BYTE lpBuffer[],
DWORD cbBufSize,
LPDWORD pcbBytesNeeded);
DWORD __cdecl svcctl_QueryServiceStatusEx(
SC_RPC_HANDLE hService,
SC_STATUS_TYPE InfoLevel,
BYTE *lpBuffer,
DWORD cbBufSize,
LPDWORD pcbBytesNeeded);
DWORD __cdecl svcctl_EnumServicesStatusExA(
SC_RPC_HANDLE scmanager,
SC_ENUM_TYPE info_level,
DWORD service_type,
DWORD service_state,
BYTE *buffer,
DWORD buf_size,
DWORD *needed_size,
DWORD *services_count,
DWORD *resume_index,
LPCSTR groupname);
DWORD __cdecl svcctl_EnumServicesStatusExW(
SC_RPC_HANDLE scmanager,
SC_ENUM_TYPE info_level,
DWORD service_type,
DWORD service_state,
BYTE *buffer,
DWORD buf_size,
DWORD *needed_size,
DWORD *services_count,
DWORD *resume_index,
LPCWSTR groupname);
DWORD __cdecl svcctl_unknown43(
void);
DWORD __cdecl svcctl_CreateServiceWOW64A(
SC_RPC_HANDLE scmanager,
LPCSTR servicename,
LPCSTR displayname,
DWORD accessmask,
DWORD service_type,
DWORD start_type,
DWORD error_control,
LPCSTR imagepath,
LPCSTR loadordergroup,
DWORD *tagid,
const BYTE *dependencies,
DWORD depend_size,
LPCSTR start_name,
const BYTE *password,
DWORD password_size,
SC_RPC_HANDLE *service);
DWORD __cdecl svcctl_CreateServiceWOW64W(
SC_RPC_HANDLE scmanager,
LPCWSTR servicename,
LPCWSTR displayname,
DWORD accessmask,
DWORD service_type,
DWORD start_type,
DWORD error_control,
LPCWSTR imagepath,
LPCWSTR loadordergroup,
DWORD *tagid,
const BYTE *dependencies,
DWORD depend_size,
LPCWSTR start_name,
const BYTE *password,
DWORD password_size,
SC_RPC_HANDLE *service);
DWORD __cdecl svcctl_unknown46(
void);
DWORD __cdecl svcctl_NotifyServiceStatusChange(
SC_RPC_HANDLE service,
SC_RPC_NOTIFY_PARAMS params,
GUID *clientprocessguid,
GUID *scmprocessguid,
BOOL *createremotequeue,
SC_NOTIFY_RPC_HANDLE *notify);
DWORD __cdecl svcctl_GetNotifyResults(
SC_NOTIFY_RPC_HANDLE notify,
SC_RPC_NOTIFY_PARAMS_LIST **params);
DWORD __cdecl svcctl_CloseNotifyHandle(
SC_NOTIFY_RPC_HANDLE *notify,
BOOL *apc_fired);
DWORD __cdecl svcctl_ControlServiceExA(
SC_RPC_HANDLE service,
DWORD control,
DWORD info_level,
SC_RPC_SERVICE_CONTROL_IN_PARAMSA *in_params,
SC_RPC_SERVICE_CONTROL_OUT_PARAMSA *out_params);
DWORD __cdecl svcctl_ControlServiceExW(
SC_RPC_HANDLE service,
DWORD control,
DWORD info_level,
SC_RPC_SERVICE_CONTROL_IN_PARAMSW *in_params,
SC_RPC_SERVICE_CONTROL_OUT_PARAMSW *out_params);
DWORD __cdecl svcctl_unknown52(
void);
DWORD __cdecl svcctl_unknown53(
void);
DWORD __cdecl svcctl_unknown54(
void);
DWORD __cdecl svcctl_unknown55(
void);
DWORD __cdecl svcctl_QueryServiceConfigEx(
SC_RPC_HANDLE service,
DWORD info_level,
SC_RPC_CONFIG_INFOW *info);
#endif /* __svcctl_INTERFACE_DEFINED__ */
/* Begin additional prototypes for all interfaces */
handle_t __RPC_USER SVCCTL_HANDLEW_bind(SVCCTL_HANDLEW);
void __RPC_USER SVCCTL_HANDLEW_unbind(SVCCTL_HANDLEW, handle_t);
handle_t __RPC_USER MACHINE_HANDLEW_bind(MACHINE_HANDLEW);
void __RPC_USER MACHINE_HANDLEW_unbind(MACHINE_HANDLEW, handle_t);
handle_t __RPC_USER MACHINE_HANDLEA_bind(MACHINE_HANDLEA);
void __RPC_USER MACHINE_HANDLEA_unbind(MACHINE_HANDLEA, handle_t);
void __RPC_USER SC_RPC_HANDLE_rundown(SC_RPC_HANDLE);
void __RPC_USER SC_RPC_LOCK_rundown(SC_RPC_LOCK);
void __RPC_USER SC_NOTIFY_RPC_HANDLE_rundown(SC_NOTIFY_RPC_HANDLE);
/* End additional prototypes */
#ifdef __cplusplus
}
#endif
#endif /* __svcctl_h__ */

812
assets/wine/include/wine/svcctl.idl
View File

@@ -1,812 +0,0 @@
/*
* svcctl interface definitions - exported by services.exe to access the
* services database
*
* Copyright 2007 Google (Mikolaj Zalewski)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#if 0
#pragma makedep header install
#endif
import "wtypes.idl";
/*
* some defined for the C code
*/
cpp_quote("#include \"winsvc.h\"")
cpp_quote("#define SVCCTL_TRANSPORT {'n','c','a','c','n','_','n','p',0}")
cpp_quote("#define SVCCTL_TRANSPORTA \"ncacn_np\"")
cpp_quote("#define SVCCTL_ENDPOINT {'\\\\','p','i','p','e','\\\\','s','v','c','c','t','l',0}")
cpp_quote("#define SVCCTL_ENDPOINTA \"\\\\pipe\\\\svcctl\"")
/* Not the Windows event name - if needed the true one can be found in Inside Windows */
cpp_quote("#define SVCCTL_STARTED_EVENT {'_','_','w','i','n','e','_','S','v','c','c','t','l','S','t','a','r','t','e','d',0}")
/* Service startup protocol over control pipe - not compatible with Windows */
cpp_quote("#define SERVICE_PROTOCOL_MAGIC 0x57494e45")
cpp_quote("#define SERVICE_CONTROL_START 0")
cpp_quote("#define SERVICE_CONTROL_FORWARD_FLAG 0x80000000")
typedef struct service_start_info_t
{
DWORD magic; /* protocol magic */
DWORD total_size; /* total request size */
DWORD name_size; /* size of name in data buffer */
DWORD control; /* control code */
BYTE data[1];
} service_start_info;
[
uuid(367abb81-9844-35f1-ad32-98f038001003),
version(2.0),
pointer_default(unique),
endpoint("ncacn_np:[\\pipe\\svcctl]")
]
interface svcctl
{
/* handle types */
typedef [handle] LPCWSTR MACHINE_HANDLEW;
typedef [handle] LPCSTR MACHINE_HANDLEA;
typedef [handle] LPCWSTR SVCCTL_HANDLEW;
typedef [context_handle] void *SC_RPC_HANDLE;
typedef [context_handle] void *SC_RPC_LOCK;
typedef [context_handle] void *SC_NOTIFY_RPC_HANDLE;
/* undocumented access rights */
cpp_quote("#define SERVICE_SET_STATUS 0x8000")
cpp_quote("#if 0 /* already defined in winsvc.h / winnt.h */")
typedef DWORD SECURITY_INFORMATION;
typedef struct _QUERY_SERVICE_CONFIGA {
DWORD dwServiceType;
DWORD dwStartType;
DWORD dwErrorControl;
LPSTR lpBinaryPathName;
LPSTR lpLoadOrderGroup;
DWORD dwTagId;
LPSTR lpDependencies;
LPSTR lpServiceStartName;
LPSTR lpDisplayName;
} QUERY_SERVICE_CONFIGA, *LPQUERY_SERVICE_CONFIGA;
typedef struct _QUERY_SERVICE_CONFIGW {
DWORD dwServiceType;
DWORD dwStartType;
DWORD dwErrorControl;
[unique] LPWSTR lpBinaryPathName;
[unique] LPWSTR lpLoadOrderGroup;
DWORD dwTagId;
[unique] LPWSTR lpDependencies;
[unique] LPWSTR lpServiceStartName;
[unique] LPWSTR lpDisplayName;
} QUERY_SERVICE_CONFIGW, *LPQUERY_SERVICE_CONFIGW;
typedef struct _SERVICE_STATUS {
DWORD dwServiceType;
DWORD dwCurrentState;
DWORD dwControlsAccepted;
DWORD dwWin32ExitCode;
DWORD dwServiceSpecificExitCode;
DWORD dwCheckPoint;
DWORD dwWaitHint;
} SERVICE_STATUS, *LPSERVICE_STATUS;
typedef enum _SC_STATUS_TYPE {
SC_STATUS_PROCESS_INFO = 0
} SC_STATUS_TYPE;
typedef struct _SERVICE_DESCRIPTIONA {
LPSTR lpDescription;
} SERVICE_DESCRIPTIONA,*LPSERVICE_DESCRIPTIONA;
typedef struct _SERVICE_DESCRIPTIONW {
LPWSTR lpDescription;
} SERVICE_DESCRIPTIONW,*LPSERVICE_DESCRIPTIONW;
typedef enum _SC_ACTION_TYPE {
SC_ACTION_NONE = 0,
SC_ACTION_RESTART = 1,
SC_ACTION_REBOOT = 2,
SC_ACTION_RUN_COMMAND = 3
} SC_ACTION_TYPE;
typedef struct _SC_ACTION {
SC_ACTION_TYPE Type;
DWORD Delay;
} SC_ACTION,*LPSC_ACTION;
typedef struct _SERVICE_FAILURE_ACTIONSA {
DWORD dwResetPeriod;
[unique] LPSTR lpRebootMsg;
[unique] LPSTR lpCommand;
DWORD cActions;
[size_is(cActions)] SC_ACTION *lpsaActions;
} SERVICE_FAILURE_ACTIONSA,*LPSERVICE_FAILURE_ACTIONSA;
typedef struct _SERVICE_FAILURE_ACTIONSW {
DWORD dwResetPeriod;
[unique] LPWSTR lpRebootMsg;
[unique] LPWSTR lpCommand;
DWORD cActions;
[size_is(cActions)] SC_ACTION *lpsaActions;
} SERVICE_FAILURE_ACTIONSW,*LPSERVICE_FAILURE_ACTIONSW;
typedef struct _SERVICE_DELAYED_AUTO_START_INFO {
BOOL fDelayedAutostart;
} SERVICE_DELAYED_AUTO_START_INFO;
typedef struct _SERVICE_FAILURE_ACTIONS_FLAG {
BOOL fFailureActionsOnNonCrashFailures;
} SERVICE_FAILURE_ACTIONS_FLAG;
typedef struct _SERVICE_SID_INFO {
DWORD dwServiceSidType;
} SERVICE_SID_INFO;
typedef struct _SERVICE_PRESHUTDOWN_INFO {
DWORD dwPreshutdownTimeout;
} SERVICE_PRESHUTDOWN_INFO,*LPSERVICE_PRESHUTDOWN_INFO;
#define SERVICE_CONFIG_DESCRIPTION 1
#define SERVICE_CONFIG_FAILURE_ACTIONS 2
#define SERVICE_CONFIG_DELAYED_AUTO_START_INFO 3
#define SERVICE_CONFIG_FAILURE_ACTIONS_FLAG 4
#define SERVICE_CONFIG_SERVICE_SID_INFO 5
#define SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO 6
#define SERVICE_CONFIG_PRESHUTDOWN_INFO 7
#define SERVICE_NOTIFY_STATUS_CHANGE_1 1
#define SERVICE_NOTIFY_STATUS_CHANGE_2 2
typedef struct _ENUM_SERVICE_STATUSW {
LPWSTR lpServiceName;
LPWSTR lpDisplayName;
SERVICE_STATUS ServiceStatus;
} ENUM_SERVICE_STATUSW, *LPENUM_SERVICE_STATUSW;
typedef struct _QUERY_SERVICE_LOCK_STATUSA
{
DWORD fIsLocked;
LPSTR lpLockOwner;
DWORD dwLockDuration;
} QUERY_SERVICE_LOCK_STATUSA, *LPQUERY_SERVICE_LOCK_STATUSA;
typedef struct _QUERY_SERVICE_LOCK_STATUSW
{
DWORD fIsLocked;
LPWSTR lpLockOwner;
DWORD dwLockDuration;
} QUERY_SERVICE_LOCK_STATUSW, *LPQUERY_SERVICE_LOCK_STATUSW;
typedef struct _SERVICE_STATUS_PROCESS
{
DWORD dwServiceType;
DWORD dwCurrentState;
DWORD dwControlsAccepted;
DWORD dwWin32ExitCode;
DWORD dwServiceSpecificExitCode;
DWORD dwCheckPoint;
DWORD dwWaitHint;
DWORD dwProcessId;
DWORD dwServiceFlags;
} SERVICE_STATUS_PROCESS, *LPSERVICE_STATUS_PROCESS;
typedef enum _SC_ENUM_TYPE {
SC_ENUM_PROCESS_INFO = 0
} SC_ENUM_TYPE;
cpp_quote("#endif")
/* internal version of ENUM_SERVICE_STATUSA/W that doesn't depend on pointer size */
struct enum_service_status
{
DWORD service_name;
DWORD display_name;
SERVICE_STATUS service_status;
};
struct enum_service_status_process
{
DWORD service_name;
DWORD display_name;
SERVICE_STATUS_PROCESS service_status_process;
};
struct service_description
{
USHORT size;
WCHAR description[1];
};
typedef struct _SERVICE_RPC_REQUIRED_PRIVILEGES_INFO {
DWORD cbRequiredPrivileges;
[size_is(cbRequiredPrivileges)] BYTE *pRequiredPrivileges;
} SERVICE_RPC_REQUIRED_PRIVILEGES_INFO;
typedef struct _SC_RPC_CONFIG_INFOW {
DWORD dwInfoLevel;
[switch_is(dwInfoLevel)] union {
[case(SERVICE_CONFIG_DESCRIPTION)] SERVICE_DESCRIPTIONW *descr;
[case(SERVICE_CONFIG_FAILURE_ACTIONS)] SERVICE_FAILURE_ACTIONSW *actions;
[case(SERVICE_CONFIG_DELAYED_AUTO_START_INFO)] SERVICE_DELAYED_AUTO_START_INFO *delayedstart;
[case(SERVICE_CONFIG_FAILURE_ACTIONS_FLAG)] SERVICE_FAILURE_ACTIONS_FLAG *actionsflag;
[case(SERVICE_CONFIG_SERVICE_SID_INFO)] SERVICE_SID_INFO *sid;
[case(SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO)] SERVICE_RPC_REQUIRED_PRIVILEGES_INFO *privinfo;
[case(SERVICE_CONFIG_PRESHUTDOWN_INFO)] SERVICE_PRESHUTDOWN_INFO *preshutdown;
};
} SC_RPC_CONFIG_INFOW;
typedef struct _SC_RPC_CONFIG_INFOA {
DWORD dwInfoLevel;
[switch_is(dwInfoLevel)] union {
[case(SERVICE_CONFIG_DESCRIPTION)] SERVICE_DESCRIPTIONA *descr;
[case(SERVICE_CONFIG_FAILURE_ACTIONS)] SERVICE_FAILURE_ACTIONSA *actions;
[case(SERVICE_CONFIG_DELAYED_AUTO_START_INFO)] SERVICE_DELAYED_AUTO_START_INFO *delayedstart;
[case(SERVICE_CONFIG_FAILURE_ACTIONS_FLAG)] SERVICE_FAILURE_ACTIONS_FLAG *actionsflag;
[case(SERVICE_CONFIG_SERVICE_SID_INFO)] SERVICE_SID_INFO *sid;
[case(SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO)] SERVICE_RPC_REQUIRED_PRIVILEGES_INFO *privinfo;
[case(SERVICE_CONFIG_PRESHUTDOWN_INFO)] SERVICE_PRESHUTDOWN_INFO *preshutdown;
};
} SC_RPC_CONFIG_INFOA;
typedef struct _SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_1 {
ULONGLONG ullThreadId;
DWORD dwNotifyMask;
UCHAR CallbackAddressArray[16];
UCHAR CallbackParamAddressArray[16];
SERVICE_STATUS_PROCESS ServiceStatus;
DWORD dwNotificationStatus;
DWORD dwSequence;
} SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_1, *PSERVICE_NOTIFY_STATUS_CHANGE_PARAMS_1;
typedef struct _SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_2 {
ULONGLONG ullThreadId;
DWORD dwNotifyMask;
UCHAR CallbackAddressArray[16];
UCHAR CallbackParamAddressArray[16];
SERVICE_STATUS_PROCESS ServiceStatus;
DWORD dwNotificationStatus;
DWORD dwSequence;
DWORD dwNotificationTriggered;
[string] LPWSTR pszServiceNames;
} SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_2, *PSERVICE_NOTIFY_STATUS_CHANGE_PARAMS_2;
typedef struct _SC_RPC_NOTIFY_PARAMS {
DWORD dwInfoLevel;
[switch_is(dwInfoLevel)] union {
[case(SERVICE_NOTIFY_STATUS_CHANGE_1)] SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_1 *params1;
[case(SERVICE_NOTIFY_STATUS_CHANGE_2)] SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_2 *params;
};
} SC_RPC_NOTIFY_PARAMS;
typedef struct _SC_RPC_NOTIFY_PARAMS_LIST {
DWORD cElements;
[size_is(cElements)] SC_RPC_NOTIFY_PARAMS NotifyParamsArray[];
} SC_RPC_NOTIFY_PARAMS_LIST, *PSC_RPC_NOTIFY_PARAMS_LIST;
typedef struct _SERVICE_CONTROL_STATUS_REASON_IN_PARAMSA {
DWORD dwReason;
[string] LPSTR pszComment;
} SERVICE_CONTROL_STATUS_REASON_IN_PARAMSA, *PSERVICE_CONTROL_STATUS_REASON_IN_PARAMSA;
typedef struct _SERVICE_CONTROL_STATUS_REASON_IN_PARAMSW {
DWORD dwReason;
[string] LPWSTR pszComment;
} SERVICE_CONTROL_STATUS_REASON_IN_PARAMSW, *PSERVICE_CONTROL_STATUS_REASON_IN_PARAMSW;
typedef [switch_type(DWORD)] union _SC_RPC_SERVICE_CONTROL_IN_PARAMSA {
[case(1)] PSERVICE_CONTROL_STATUS_REASON_IN_PARAMSA psrInParams;
} SC_RPC_SERVICE_CONTROL_IN_PARAMSA, *PSC_RPC_SERVICE_CONTROL_IN_PARAMSA;
typedef [switch_type(DWORD)] union _SC_RPC_SERVICE_CONTROL_IN_PARAMSW {
[case(1)] PSERVICE_CONTROL_STATUS_REASON_IN_PARAMSW psrInParams;
} SC_RPC_SERVICE_CONTROL_IN_PARAMSW, *PSC_RPC_SERVICE_CONTROL_IN_PARAMSW;
typedef struct _SERVICE_CONTROL_STATUS_REASON_OUT_PARAMS {
SERVICE_STATUS_PROCESS ServiceStatus;
} SERVICE_CONTROL_STATUS_REASON_OUT_PARAMS, *PSERVICE_CONTROL_STATUS_REASON_OUT_PARAMS;
typedef [switch_type(DWORD)] union _SC_RPC_SERVICE_CONTROL_OUT_PARAMSA {
[case(1)] PSERVICE_CONTROL_STATUS_REASON_OUT_PARAMS psrOutParams;
} SC_RPC_SERVICE_CONTROL_OUT_PARAMSA, *PSC_RPC_SERVICE_CONTROL_OUT_PARAMSA;
typedef [switch_type(DWORD)] union _SC_RPC_SERVICE_CONTROL_OUT_PARAMSW {
[case(1)] PSERVICE_CONTROL_STATUS_REASON_OUT_PARAMS psrOutParams;
} SC_RPC_SERVICE_CONTROL_OUT_PARAMSW, *PSC_RPC_SERVICE_CONTROL_OUT_PARAMSW;
/* Function 0 */
DWORD svcctl_CloseServiceHandle(
[in,out] SC_RPC_HANDLE *handle
);
/* Function 1 */
DWORD svcctl_ControlService(
[in] SC_RPC_HANDLE hService,
[in] DWORD dwControl,
[out] SERVICE_STATUS *lpServiceStatus
);
/* Function 2 */
DWORD svcctl_DeleteService(
[in] SC_RPC_HANDLE hService
);
/* Function 3 */
DWORD svcctl_LockServiceDatabase(
[in] SC_RPC_HANDLE hSCManager,
[out] SC_RPC_LOCK *phLock
);
/* Function 4 */
DWORD svcctl_QueryServiceObjectSecurity(
[in] SC_RPC_HANDLE service,
[in] SECURITY_INFORMATION info,
[out, size_is(buf_size)] BYTE *descriptor,
[in] DWORD buf_size,
[out] DWORD *needed_size
);
/* Function 5 */
DWORD svcctl_SetServiceObjectSecurity(
[in] SC_RPC_HANDLE service,
[in] SECURITY_INFORMATION info,
[in, size_is(buf_size)] BYTE *descriptor,
[in] DWORD buf_size
);
/* Function 6 */
DWORD svcctl_QueryServiceStatus(
[in] SC_RPC_HANDLE service,
[out] SERVICE_STATUS *status
);
/* Function 7 */
DWORD svcctl_SetServiceStatus(
[in] SC_RPC_HANDLE hServiceStatus,
[in] LPSERVICE_STATUS lpServiceStatus
);
/* Function 8 */
DWORD svcctl_UnlockServiceDatabase(
[in,out] SC_RPC_LOCK *phLock
);
/* Function 9 */
DWORD svcctl_NotifyBootConfigStatus(
[in, string, unique] SVCCTL_HANDLEW machinename,
[in] DWORD boot_acceptable
);
/* Not compatible with Windows function 10 */
DWORD svcctl_SCSetServiceBitsW(/* FIXME */);
/* Function 11 */
DWORD svcctl_ChangeServiceConfigW(
[in] SC_RPC_HANDLE hService,
[in] DWORD dwServiceType,
[in] DWORD dwStartType,
[in] DWORD dwErrorControl,
[in,unique] LPCWSTR lpBinaryPathName,
[in,unique] LPCWSTR lpLoadOrderGroupKey,
[in,out,unique] DWORD *lpdwTagId,
[in,unique,size_is(dwDependenciesSize)] const BYTE *lpDependencies,
[in] DWORD dwDependenciesSize,
[in,unique] LPCWSTR lpServiceStartName,
[in,unique,size_is(dwPasswordSize)] const BYTE *lpPassword,
[in] DWORD dwPasswordSize,
[in,unique] LPCWSTR lpDisplayName
);
/* Function 12 */
DWORD svcctl_CreateServiceW(
[in] SC_RPC_HANDLE hSCManager,
[in] LPCWSTR lpServiceName,
[in,unique] LPCWSTR lpDisplayName,
[in] DWORD dwDesiredAccess,
[in] DWORD dwServiceType,
[in] DWORD dwStartType,
[in] DWORD dwErrorControl,
[in] LPCWSTR lpBinaryPathName,
[in,unique] LPCWSTR lpLoadOrderGroup,
[in,out,unique] DWORD *lpdwTagId,
[in,unique,size_is(dwDependenciesSize)] const BYTE *lpDependencies,
[in] DWORD dwDependenciesSize,
[in,unique] LPCWSTR lpServiceStartName,
[in,unique,size_is(dwPasswordSize)] const BYTE *lpPassword,
[in] DWORD dwPasswordSize,
[out] SC_RPC_HANDLE *phService
);
/* Function 13 */
DWORD svcctl_EnumDependentServicesW(
[in] SC_RPC_HANDLE service,
[in] DWORD state,
[out, size_is(buf_size)] BYTE *services,
[in] DWORD buf_size,
[out] DWORD *needed_size,
[out] DWORD *services_ret
);
/* Function 14 */
DWORD svcctl_EnumServicesStatusW(
[in] SC_RPC_HANDLE hmngr,
[in] DWORD type,
[in] DWORD state,
[out,size_is(size)] BYTE *buffer,
[in] DWORD size,
[out] LPDWORD needed,
[out] LPDWORD returned,
[in,out,unique] LPDWORD resume
);
/* Function 15 */
DWORD svcctl_OpenSCManagerW(
[in,unique] MACHINE_HANDLEW MachineName,
[in,unique] LPCWSTR DatabaseName,
[in] DWORD dwAccessMask,
[out] SC_RPC_HANDLE *handle
);
/* Function 16 */
DWORD svcctl_OpenServiceW(
[in] SC_RPC_HANDLE hSCManager,
[in] LPCWSTR lpServiceName,
[in] DWORD dwDesiredAccess,
[out] SC_RPC_HANDLE *phService
);
/* Function 17 */
DWORD svcctl_QueryServiceConfigW(
[in] SC_RPC_HANDLE hService,
[out] QUERY_SERVICE_CONFIGW *config,
[in] DWORD buf_size,
[out] DWORD *needed_size);
/* Function 18 */
DWORD svcctl_QueryServiceLockStatusW(
[in] SC_RPC_HANDLE scmanager,
[out] QUERY_SERVICE_LOCK_STATUSW *status,
[in] DWORD buf_size,
[out] DWORD *needed_size
);
/* Function 19 */
DWORD svcctl_StartServiceW(
[in] SC_RPC_HANDLE hService,
[in] DWORD dwNumServiceArgs,
[in,unique,size_is(dwNumServiceArgs)] LPCWSTR *lpServiceArgVectors
);
/* Function 20 */
DWORD svcctl_GetServiceDisplayNameW(
[in] SC_RPC_HANDLE hSCManager,
[in] LPCWSTR lpServiceName,
[out,string,size_is(*cchBufSize+1)] WCHAR lpBuffer[],
[in,out] DWORD *cchBufSize);
/* Function 21 */
DWORD svcctl_GetServiceKeyNameW(
[in] SC_RPC_HANDLE hSCManager,
[in] LPCWSTR lpServiceDisplayName,
[out,string,size_is(*cchBufSize+1)] WCHAR lpBuffer[],
[in,out] DWORD *cchBufSize);
/* Not compatible with Windows function 22 */
DWORD svcctl_SCSetServiceBitsA(/* FIXME */);
/* Function 23 */
DWORD svcctl_ChangeServiceConfigA(
[in] SC_RPC_HANDLE service,
[in] DWORD service_type,
[in] DWORD start_type,
[in] DWORD error_control,
[in, string, unique] LPSTR binarypath,
[in, string, unique] LPSTR loadordergroup,
[in, out, unique] DWORD *tagid,
[in, unique, size_is(depend_size)] BYTE *dependencies,
[in] DWORD depend_size,
[in, string, unique] LPSTR startname,
[in, unique, size_is(password_size)] BYTE *password,
[in] DWORD password_size,
[in, string, unique] LPSTR displayname
);
/* Function 24 */
DWORD svcctl_CreateServiceA(
[in] SC_RPC_HANDLE scmanager,
[in] LPCSTR servicename,
[in, unique] LPCSTR displayname,
[in] DWORD desiredaccess,
[in] DWORD service_type,
[in] DWORD start_type,
[in] DWORD error_control,
[in] LPCSTR binarypath,
[in, unique] LPCSTR loadordergroup,
[in, out, unique] DWORD *tagid,
[in, unique, size_is(depend_size)] const BYTE *dependencies,
[in] DWORD depend_size,
[in, unique] LPCSTR startname,
[in, unique, size_is(password_size)] const BYTE *password,
[in] DWORD password_size,
[out] SC_RPC_HANDLE *service
);
/* Function 25 */
DWORD svcctl_EnumDependentServicesA(
[in] SC_RPC_HANDLE service,
[in] DWORD state,
[out, size_is(buf_size)] BYTE *services,
[in] DWORD buf_size,
[out] DWORD *needed_size,
[out] DWORD *services_ret
);
/* Function 26 */
DWORD svcctl_EnumServicesStatusA(
[in] SC_RPC_HANDLE hmngr,
[in] DWORD type,
[in] DWORD state,
[out, size_is(size)] BYTE *buffer,
[in] DWORD size,
[out] DWORD *needed,
[out] DWORD *returned,
[in,out,unique] DWORD *resume
);
/* Function 27 */
DWORD svcctl_OpenSCManagerA(
[in,unique] MACHINE_HANDLEA MachineName,
[in,unique] LPCSTR DatabaseName,
[in] DWORD dwAccessMask,
[out] SC_RPC_HANDLE *handle
);
/* Function 28 */
DWORD svcctl_OpenServiceA(
[in] SC_RPC_HANDLE hSCManager,
[in] LPCSTR lpServiceName,
[in] DWORD dwDesiredAccess,
[out] SC_RPC_HANDLE *phService
);
/* Function 29 */
DWORD svcctl_QueryServiceConfigA(
[in] SC_RPC_HANDLE hService,
[out] QUERY_SERVICE_CONFIGA *config,
[in] DWORD buf_size,
[out] DWORD *needed_size);
/* Function 30 */
DWORD svcctl_QueryServiceLockStatusA(
[in] SC_RPC_HANDLE scmanager,
[out] QUERY_SERVICE_LOCK_STATUSA *status,
[in] DWORD buf_size,
[out] DWORD *needed_size
);
/* Function 31 */
DWORD svcctl_StartServiceA(
[in] SC_RPC_HANDLE service,
[in] DWORD argc,
[in, unique, size_is(argc)] LPCSTR *args
);
/* Function 32 */
DWORD svcctl_GetServiceDisplayNameA(
[in] SC_RPC_HANDLE hSCManager,
[in] LPCSTR servicename,
[out, string, size_is(*buf_size+1)] CHAR buffer[],
[in, out] DWORD *buf_size);
/* Function 33 */
DWORD svcctl_GetServiceKeyNameA(
[in] SC_RPC_HANDLE hSCManager,
[in] LPCSTR servicename,
[out, string, size_is(*buf_size+1)] CHAR buffer[],
[in, out] DWORD *buf_size);
/* Not compatible with Windows function 34 */
DWORD svcctl_GetCurrentGroupStateW(/* FIXME */);
/* Function 35 */
DWORD svcctl_EnumServiceGroupW(
[in] SC_RPC_HANDLE scmanager,
[in] DWORD service_type,
[in] DWORD service_state,
[out, size_is(buf_size)] BYTE *buffer,
[in] DWORD buf_size,
[out] DWORD *needed_size,
[out] DWORD *returned_size,
[in, out, unique] DWORD *resume_index,
[in, string, unique] LPCWSTR groupname
);
/* Function 36 */
DWORD svcctl_ChangeServiceConfig2A(
[in] SC_RPC_HANDLE service,
[in] SC_RPC_CONFIG_INFOA info
);
/* Function 37 */
DWORD svcctl_ChangeServiceConfig2W(
[in] SC_RPC_HANDLE service,
[in] SC_RPC_CONFIG_INFOW info
);
/* Function 38 */
DWORD svcctl_QueryServiceConfig2A(
[in] SC_RPC_HANDLE service,
[in] DWORD info_level,
[out, size_is(buf_size)] BYTE *buffer,
[in] DWORD buf_size,
[out] DWORD *needed_size
);
/* Function 39 */
DWORD svcctl_QueryServiceConfig2W(
[in] SC_RPC_HANDLE hService,
[in] DWORD InfoLevel,
[out,size_is(cbBufSize)] BYTE lpBuffer[],
[in] DWORD cbBufSize,
[out] LPDWORD pcbBytesNeeded
);
/* Function 40 */
DWORD svcctl_QueryServiceStatusEx(
[in] SC_RPC_HANDLE hService,
[in] SC_STATUS_TYPE InfoLevel,
[out,size_is(cbBufSize)] BYTE *lpBuffer,
[in] DWORD cbBufSize,
[out] LPDWORD pcbBytesNeeded
);
/* Function 41 */
DWORD svcctl_EnumServicesStatusExA(
[in] SC_RPC_HANDLE scmanager,
[in] SC_ENUM_TYPE info_level,
[in] DWORD service_type,
[in] DWORD service_state,
[out, size_is(buf_size)] BYTE *buffer,
[in] DWORD buf_size,
[out] DWORD *needed_size,
[out] DWORD *services_count,
[in, out, unique] DWORD *resume_index,
[in, string, unique] LPCSTR groupname
);
/* Function 42 */
DWORD svcctl_EnumServicesStatusExW(
[in] SC_RPC_HANDLE scmanager,
[in] SC_ENUM_TYPE info_level,
[in] DWORD service_type,
[in] DWORD service_state,
[out, size_is(buf_size)] BYTE *buffer,
[in] DWORD buf_size,
[out] DWORD *needed_size,
[out] DWORD *services_count,
[in, out, unique] DWORD *resume_index,
[in, string, unique] LPCWSTR groupname
);
/* Not compatible with Windows function 43 */
DWORD svcctl_unknown43(/*FIXME*/);
/* Function 44 */
DWORD svcctl_CreateServiceWOW64A(
[in] SC_RPC_HANDLE scmanager,
[in, string] LPCSTR servicename,
[in, string, unique] LPCSTR displayname,
[in] DWORD accessmask,
[in] DWORD service_type,
[in] DWORD start_type,
[in] DWORD error_control,
[in, string] LPCSTR imagepath,
[in, string, unique] LPCSTR loadordergroup,
[in, out, unique] DWORD *tagid,
[in, unique, size_is(depend_size)] const BYTE *dependencies,
[in] DWORD depend_size,
[in, string, unique] LPCSTR start_name,
[in, unique, size_is(password_size)] const BYTE *password,
[in] DWORD password_size,
[out] SC_RPC_HANDLE *service
);
/* Function 45 */
DWORD svcctl_CreateServiceWOW64W(
[in] SC_RPC_HANDLE scmanager,
[in, string] LPCWSTR servicename,
[in, string, unique] LPCWSTR displayname,
[in] DWORD accessmask,
[in] DWORD service_type,
[in] DWORD start_type,
[in] DWORD error_control,
[in, string] LPCWSTR imagepath,
[in, string, unique] LPCWSTR loadordergroup,
[in, out, unique] DWORD *tagid,
[in, unique, size_is(depend_size)] const BYTE *dependencies,
[in] DWORD depend_size,
[in, string, unique] LPCWSTR start_name,
[in, unique, size_is(password_size)] const BYTE *password,
[in] DWORD password_size,
[out] SC_RPC_HANDLE *service
);
/* Not compatible with Windows function 46 */
DWORD svcctl_unknown46(/*FIXME*/);
/* Function 47 */
DWORD svcctl_NotifyServiceStatusChange(
[in] SC_RPC_HANDLE service,
[in] SC_RPC_NOTIFY_PARAMS params,
[in] GUID *clientprocessguid,
[out] GUID *scmprocessguid,
[out] BOOL *createremotequeue,
[out] SC_NOTIFY_RPC_HANDLE *notify
);
/* Function 48 */
DWORD svcctl_GetNotifyResults(
[in] SC_NOTIFY_RPC_HANDLE notify,
[out] SC_RPC_NOTIFY_PARAMS_LIST **params
);
/* Function 49 */
DWORD svcctl_CloseNotifyHandle(
[in, out] SC_NOTIFY_RPC_HANDLE *notify,
[out] BOOL *apc_fired
);
/* Function 50 */
DWORD svcctl_ControlServiceExA(
[in] SC_RPC_HANDLE service,
[in] DWORD control,
[in] DWORD info_level,
[in, switch_is(info_level)] SC_RPC_SERVICE_CONTROL_IN_PARAMSA *in_params,
[out, switch_is(info_level)] SC_RPC_SERVICE_CONTROL_OUT_PARAMSA *out_params
);
/* Function 51 */
DWORD svcctl_ControlServiceExW(
[in] SC_RPC_HANDLE service,
[in] DWORD control,
[in] DWORD info_level,
[in, switch_is(info_level)] SC_RPC_SERVICE_CONTROL_IN_PARAMSW *in_params,
[out, switch_is(info_level)] SC_RPC_SERVICE_CONTROL_OUT_PARAMSW *out_params
);
/* Not compatible with Windows function 52 */
DWORD svcctl_unknown52();
/* Not compatible with Windows function 53 */
DWORD svcctl_unknown53();
/* Not compatible with Windows function 54 */
DWORD svcctl_unknown54();
/* Not compatible with Windows function 55 */
DWORD svcctl_unknown55();
/* Function 56 */
DWORD svcctl_QueryServiceConfigEx(
[in] SC_RPC_HANDLE service,
[in] DWORD info_level,
[out] SC_RPC_CONFIG_INFOW *info
);
}

452
assets/wine/include/wine/windows/accctrl.h
View File

@@ -1,452 +0,0 @@
/*
* Copyright (C) 2002 Alexandre Julliard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_ACCCTRL_H
#define __WINE_ACCCTRL_H
#include <wtypes.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef enum _SE_OBJECT_TYPE
{
SE_UNKNOWN_OBJECT_TYPE = 0,
SE_FILE_OBJECT,
SE_SERVICE,
SE_PRINTER,
SE_REGISTRY_KEY,
SE_LMSHARE,
SE_KERNEL_OBJECT,
SE_WINDOW_OBJECT,
SE_DS_OBJECT,
SE_DS_OBJECT_ALL,
SE_PROVIDER_DEFINED_OBJECT,
SE_WMIGUID_OBJECT,
SE_REGISTRY_WOW64_32KEY,
SE_REGISTRY_WOW64_64KEY,
} SE_OBJECT_TYPE;
typedef enum _TRUSTEE_TYPE
{
TRUSTEE_IS_UNKNOWN,
TRUSTEE_IS_USER,
TRUSTEE_IS_GROUP,
TRUSTEE_IS_DOMAIN,
TRUSTEE_IS_ALIAS,
TRUSTEE_IS_WELL_KNOWN_GROUP,
TRUSTEE_IS_DELETED,
TRUSTEE_IS_INVALID,
TRUSTEE_IS_COMPUTER
} TRUSTEE_TYPE;
typedef enum _TRUSTEE_FORM
{
TRUSTEE_IS_SID,
TRUSTEE_IS_NAME,
TRUSTEE_BAD_FORM,
TRUSTEE_IS_OBJECTS_AND_SID,
TRUSTEE_IS_OBJECTS_AND_NAME
} TRUSTEE_FORM;
typedef enum _MULTIPLE_TRUSTEE_OPERATION
{
NO_MULTIPLE_TRUSTEE,
TRUSTEE_IS_IMPERSONATE,
} MULTIPLE_TRUSTEE_OPERATION;
typedef struct _OBJECTS_AND_SID
{
DWORD ObjectsPresent;
GUID ObjectTypeGuid;
GUID InheritedObjectTypeGuid;
SID *pSid;
} OBJECTS_AND_SID, *POBJECTS_AND_SID;
typedef struct _OBJECTS_AND_NAME_A
{
DWORD ObjectsPresent;
SE_OBJECT_TYPE ObjectType;
LPSTR ObjectTypeName;
LPSTR InheritedObjectTypeName;
LPSTR ptstrName;
} OBJECTS_AND_NAME_A, *POBJECTS_AND_NAME_A;
typedef struct _OBJECTS_AND_NAME_W
{
DWORD ObjectsPresent;
SE_OBJECT_TYPE ObjectType;
LPWSTR ObjectTypeName;
LPWSTR InheritedObjectTypeName;
LPWSTR ptstrName;
} OBJECTS_AND_NAME_W, *POBJECTS_AND_NAME_W;
DECL_WINELIB_TYPE_AW(OBJECTS_AND_NAME_)
DECL_WINELIB_TYPE_AW(POBJECTS_AND_NAME_)
typedef struct _TRUSTEE_A
{
struct _TRUSTEE_A *pMultipleTrustee;
MULTIPLE_TRUSTEE_OPERATION MultipleTrusteeOperation;
TRUSTEE_FORM TrusteeForm;
TRUSTEE_TYPE TrusteeType;
LPSTR ptstrName;
} TRUSTEE_A, *PTRUSTEE_A, TRUSTEEA, *PTRUSTEEA;
typedef struct _TRUSTEE_W
{
struct _TRUSTEE_W *pMultipleTrustee;
MULTIPLE_TRUSTEE_OPERATION MultipleTrusteeOperation;
TRUSTEE_FORM TrusteeForm;
TRUSTEE_TYPE TrusteeType;
LPWSTR ptstrName;
} TRUSTEE_W, *PTRUSTEE_W, TRUSTEEW, *PTRUSTEEW;
DECL_WINELIB_TYPE_AW(TRUSTEE_)
DECL_WINELIB_TYPE_AW(PTRUSTEE_)
DECL_WINELIB_TYPE_AW(TRUSTEE)
DECL_WINELIB_TYPE_AW(PTRUSTEE)
typedef enum _ACCESS_MODE
{
NOT_USED_ACCESS = 0,
GRANT_ACCESS,
SET_ACCESS,
DENY_ACCESS,
REVOKE_ACCESS,
SET_AUDIT_SUCCESS,
SET_AUDIT_FAILURE
} ACCESS_MODE;
#define NO_INHERITANCE 0x0
#define SUB_OBJECTS_ONLY_INHERIT 0x1
#define SUB_CONTAINERS_ONLY_INHERIT 0x2
#define SUB_CONTAINERS_AND_OBJECTS_INHERIT 0x3
#define INHERIT_NO_PROPAGATE 0x4
#define INHERIT_ONLY 0x8
#define INHERITED_ACCESS_ENTRY 0x10
#define INHERITED_PARENT 0x10000000
#define INHERITED_GRANDPARENT 0x20000000
typedef struct _EXPLICIT_ACCESS_A
{
DWORD grfAccessPermissions;
ACCESS_MODE grfAccessMode;
DWORD grfInheritance;
TRUSTEE_A Trustee;
} EXPLICIT_ACCESS_A, *PEXPLICIT_ACCESS_A, EXPLICIT_ACCESSA, *PEXPLICIT_ACCESSA;
typedef struct _EXPLICIT_ACCESS_W
{
DWORD grfAccessPermissions;
ACCESS_MODE grfAccessMode;
DWORD grfInheritance;
TRUSTEE_W Trustee;
} EXPLICIT_ACCESS_W, *PEXPLICIT_ACCESS_W, EXPLICIT_ACCESSW, *PEXPLICIT_ACCESSW;
DECL_WINELIB_TYPE_AW(EXPLICIT_ACCESS_)
DECL_WINELIB_TYPE_AW(PEXPLICIT_ACCESS_)
DECL_WINELIB_TYPE_AW(EXPLICIT_ACCESS)
DECL_WINELIB_TYPE_AW(PEXPLICIT_ACCESS)
typedef ULONG ACCESS_RIGHTS, *PACCESS_RIGHTS;
typedef ULONG INHERIT_FLAGS, *PINHERIT_FLAGS;
typedef struct _ACTRL_ACCESS_ENTRYA
{
TRUSTEE_A Trustee;
ULONG fAccessFlags;
ACCESS_RIGHTS Access;
ACCESS_RIGHTS ProvSpecificAccess;
INHERIT_FLAGS Inheritance;
LPSTR lpInheritProperty;
} ACTRL_ACCESS_ENTRYA, *PACTRL_ACCESS_ENTRYA;
typedef struct _ACTRL_ACCESS_ENTRYW
{
TRUSTEE_W Trustee;
ULONG fAccessFlags;
ACCESS_RIGHTS Access;
ACCESS_RIGHTS ProvSpecificAccess;
INHERIT_FLAGS Inheritance;
LPWSTR lpInheritProperty;
} ACTRL_ACCESS_ENTRYW, *PACTRL_ACCESS_ENTRYW;
DECL_WINELIB_TYPE_AW(ACTRL_ACCESS_ENTRY)
DECL_WINELIB_TYPE_AW(PACTRL_ACCESS_ENTRY)
typedef struct _ACTRL_ACCESS_ENTRY_LISTA
{
ULONG cEntries;
ACTRL_ACCESS_ENTRYA *pAccessList;
} ACTRL_ACCESS_ENTRY_LISTA, *PACTRL_ACCESS_ENTRY_LISTA;
typedef struct _ACTRL_ACCESS_ENTRY_LISTW
{
ULONG cEntries;
ACTRL_ACCESS_ENTRYW *pAccessList;
} ACTRL_ACCESS_ENTRY_LISTW, *PACTRL_ACCESS_ENTRY_LISTW;
DECL_WINELIB_TYPE_AW(ACTRL_ACCESS_ENTRY_LIST)
DECL_WINELIB_TYPE_AW(PACTRL_ACCESS_ENTRY_LIST)
typedef struct _ACTRL_PROPERTY_ENTRYA
{
LPSTR lpProperty;
PACTRL_ACCESS_ENTRY_LISTA pAccessEntryList;
ULONG fListFlags;
} ACTRL_PROPERTY_ENTRYA, *PACTRL_PROPERTY_ENTRYA;
typedef struct _ACTRL_PROPERTY_ENTRYW
{
LPWSTR lpProperty;
PACTRL_ACCESS_ENTRY_LISTW pAccessEntryList;
ULONG fListFlags;
} ACTRL_PROPERTY_ENTRYW, *PACTRL_PROPERTY_ENTRYW;
DECL_WINELIB_TYPE_AW(ACTRL_PROPERTY_ENTRY)
DECL_WINELIB_TYPE_AW(PACTRL_PROPERTY_ENTRY)
typedef struct _ACTRL_ALISTA
{
ULONG cEntries;
PACTRL_PROPERTY_ENTRYA pPropertyAccessList;
} ACTRL_ACCESSA, *PACTRL_ACCESSA, ACTRL_AUDITA, *PACTRL_AUDITA;
typedef struct _ACTRL_ALISTW
{
ULONG cEntries;
PACTRL_PROPERTY_ENTRYW pPropertyAccessList;
} ACTRL_ACCESSW, *PACTRL_ACCESSW, ACTRL_AUDITW, *PACTRL_AUDITW;
DECL_WINELIB_TYPE_AW(ACTRL_ACCESS)
DECL_WINELIB_TYPE_AW(PACTRL_ACCESS)
DECL_WINELIB_TYPE_AW(ACTRL_AUDIT)
DECL_WINELIB_TYPE_AW(PACTRL_AUDIT)
#define TRUSTEE_ACCESS_ALLOWED 0x00000001
#define TRUSTEE_ACCESS_READ 0x00000002
#define TRUSTEE_ACCESS_WRITE 0x00000004
#define TRUSTEE_ACCESS_EXPLICIT 0x00000001
#define TRUSTEE_ACCESS_READ_WRITE (TRUSTEE_ACCESS_READ|TRUSTEE_ACCESS_WRITE)
#define TRUSTEE_ACCESS_ALL 0xFFFFFFFF
typedef struct _TRUSTEE_ACCESSA
{
LPSTR lpProperty;
ACCESS_RIGHTS Access;
ULONG fAccessFlags;
ULONG fReturnedAccess;
} TRUSTEE_ACCESSA, *PTRUSTEE_ACCESSA;
typedef struct _TRUSTEE_ACCESSW
{
LPWSTR lpProperty;
ACCESS_RIGHTS Access;
ULONG fAccessFlags;
ULONG fReturnedAccess;
} TRUSTEE_ACCESSW, *PTRUSTEE_ACCESSW;
DECL_WINELIB_TYPE_AW(TRUSTEE_ACCESS)
DECL_WINELIB_TYPE_AW(PTRUSTEE_ACCESS)
#define ACTRL_RESERVED 0x00000000
#define ACTRL_PERM_1 0x00000001
#define ACTRL_PERM_2 0x00000002
#define ACTRL_PERM_3 0x00000004
#define ACTRL_PERM_4 0x00000008
#define ACTRL_PERM_5 0x00000010
#define ACTRL_PERM_6 0x00000020
#define ACTRL_PERM_7 0x00000040
#define ACTRL_PERM_8 0x00000080
#define ACTRL_PERM_9 0x00000100
#define ACTRL_PERM_10 0x00000200
#define ACTRL_PERM_11 0x00000400
#define ACTRL_PERM_12 0x00000800
#define ACTRL_PERM_13 0x00001000
#define ACTRL_PERM_14 0x00002000
#define ACTRL_PERM_15 0x00004000
#define ACTRL_PERM_16 0x00008000
#define ACTRL_PERM_17 0x00010000
#define ACTRL_PERM_18 0x00020000
#define ACTRL_PERM_19 0x00040000
#define ACTRL_PERM_20 0x00080000
#define ACTRL_ACCESS_ALLOWED 0x00000001
#define ACTRL_ACCESS_DENIED 0x00000002
#define ACTRL_AUDIT_SUCCESS 0x00000004
#define ACTRL_AUDIT_FAILURE 0x00000008
#define ACTRL_ACCESS_PROTECTED 0x00000001
#define ACTRL_SYSTEM_ACCESS 0x04000000
#define ACTRL_DELETE 0x08000000
#define ACTRL_READ_CONTROL 0x10000000
#define ACTRL_CHANGE_ACCESS 0x20000000
#define ACTRL_CHANGE_OWNER 0x40000000
#define ACTRL_SYNCHRONIZE 0x80000000
#define ACTRL_STD_RIGHTS_ALL 0xf8000000
#define ACTRL_STD_RIGHT_REQUIRED (ACTRL_STD_RIGHTS_ALL & ~ACTRL_SYNCHRONIZE)
#define ACTRL_DS_OPEN ACTRL_RESERVED
#define ACTRL_DS_CREATE_CHILD ACTRL_PERM_1
#define ACTRL_DS_DELETE_CHILD ACTRL_PERM_2
#define ACTRL_DS_LIST ACTRL_PERM_3
#define ACTRL_DS_SELF ACTRL_PERM_4
#define ACTRL_DS_READ_PROP ACTRL_PERM_5
#define ACTRL_DS_WRITE_PROP ACTRL_PERM_6
#define ACTRL_DS_DELETE_TREE ACTRL_PERM_7
#define ACTRL_DS_LIST_OBJECT ACTRL_PERM_8
#define ACTRL_DS_CONTROL_ACCESS ACTRL_PERM_9
#define ACTRL_FILE_READ ACTRL_PERM_1
#define ACTRL_FILE_WRITE ACTRL_PERM_2
#define ACTRL_FILE_APPEND ACTRL_PERM_3
#define ACTRL_FILE_READ_PROP ACTRL_PERM_4
#define ACTRL_FILE_WRITE_PROP ACTRL_PERM_5
#define ACTRL_FILE_EXECUTE ACTRL_PERM_6
#define ACTRL_FILE_READ_ATTRIB ACTRL_PERM_8
#define ACTRL_FILE_WRITE_ATTRIB ACTRL_PERM_9
#define ACTRL_FILE_CREATE_PIPE ACTRL_PERM_10
#define ACTRL_DIR_LIST ACTRL_PERM_1
#define ACTRL_DIR_CREATE_OBJECT ACTRL_PERM_2
#define ACTRL_DIR_CREATE_CHILD ACTRL_PERM_3
#define ACTRL_DIR_DELETE_CHILD ACTRL_PERM_7
#define ACTRL_DIR_TRAVERSE ACTRL_PERM_6
#define ACTRL_KERNEL_TERMINATE ACTRL_PERM_1
#define ACTRL_KERNEL_THREAD ACTRL_PERM_2
#define ACTRL_KERNEL_VM ACTRL_PERM_3
#define ACTRL_KERNEL_VM_READ ACTRL_PERM_4
#define ACTRL_KERNEL_VM_WRITE ACTRL_PERM_5
#define ACTRL_KERNEL_DUP_HANDLE ACTRL_PERM_6
#define ACTRL_KERNEL_PROCESS ACTRL_PERM_7
#define ACTRL_KERNEL_SET_INFO ACTRL_PERM_8
#define ACTRL_KERNEL_GET_INFO ACTRL_PERM_9
#define ACTRL_KERNEL_CONTROL ACTRL_PERM_10
#define ACTRL_KERNEL_ALERT ACTRL_PERM_11
#define ACTRL_KERNEL_GET_CONTEXT ACTRL_PERM_12
#define ACTRL_KERNEL_SET_CONTEXT ACTRL_PERM_13
#define ACTRL_KERNEL_TOKEN ACTRL_PERM_14
#define ACTRL_KERNEL_IMPERSONATE ACTRL_PERM_15
#define ACTRL_KERNEL_DIMPERSONATE ACTRL_PERM_16
#define ACTRL_PRINT_SADMIN ACTRL_PERM_1
#define ACTRL_PRINT_SLIST ACTRL_PERM_2
#define ACTRL_PRINT_PADMIN ACTRL_PERM_3
#define ACTRL_PRINT_PUSE ACTRL_PERM_4
#define ACTRL_PRINT_JADMIN ACTRL_PERM_5
#define ACTRL_SVC_GET_INFO ACTRL_PERM_1
#define ACTRL_SVC_SET_INFO ACTRL_PERM_2
#define ACTRL_SVC_STATUS ACTRL_PERM_3
#define ACTRL_SVC_LIST ACTRL_PERM_4
#define ACTRL_SVC_START ACTRL_PERM_5
#define ACTRL_SVC_STOP ACTRL_PERM_6
#define ACTRL_SVC_PAUSE ACTRL_PERM_7
#define ACTRL_SVC_INTERROGATE ACTRL_PERM_8
#define ACTRL_SVC_UCONTROL ACTRL_PERM_9
#define ACTRL_REG_QUERY ACTRL_PERM_1
#define ACTRL_REG_SET ACTRL_PERM_2
#define ACTRL_REG_CREATE_CHILD ACTRL_PERM_3
#define ACTRL_REG_LIST ACTRL_PERM_4
#define ACTRL_REG_NOTIFY ACTRL_PERM_5
#define ACTRL_REG_LINK ACTRL_PERM_6
#define ACTRL_WIN_CLIPBRD ACTRL_PERM_1
#define ACTRL_WIN_GLOBAL_ATOMS ACTRL_PERM_2
#define ACTRL_WIN_CREATE ACTRL_PERM_3
#define ACTRL_WIN_LIST_DESK ACTRL_PERM_4
#define ACTRL_WIN_LIST ACTRL_PERM_5
#define ACTRL_WIN_READ_ATTRIBS ACTRL_PERM_6
#define ACTRL_WIN_WRITE_ATTRIBS ACTRL_PERM_7
#define ACTRL_WIN_SCREEN ACTRL_PERM_8
#define ACTRL_WIN_EXIT ACTRL_PERM_9
#define ACTRL_ACCESS_NO_OPTIONS 0x00000000
#define ACTRL_ACCESS_SUPPORTS_OBJECT_ENTRIES 0x00000001
typedef struct _ACTRL_OVERLAPPED
{
union {
PVOID Provider;
ULONG Reserved1;
} DUMMYUNIONNAME;
ULONG Reserved2;
HANDLE hEvent;
} ACTRL_OVERLAPPED, *PACTRL_OVERLAPPED;
typedef struct _ACTRL_ACCESS_INFOA
{
ULONG fAccessPermission;
LPSTR lpAccessPermissionName;
} ACTRL_ACCESS_INFOA, *PACTRL_ACCESS_INFOA;
typedef struct _ACTRL_ACCESS_INFOW
{
ULONG fAccessPermission;
LPWSTR lpAccessPermissionName;
} ACTRL_ACCESS_INFOW, *PACTRL_ACCESS_INFOW;
DECL_WINELIB_TYPE_AW(ACTRL_ACCESS_INFO)
DECL_WINELIB_TYPE_AW(PACTRL_ACCESS_INFO)
typedef struct _ACTRL_CONTROL_INFOA
{
LPSTR lpControlId;
LPSTR lpControlName;
} ACTRL_CONTROL_INFOA, *PACTRL_CONTROL_INFOA;
typedef struct _ACTRL_CONTROL_INFOW
{
LPWSTR lpControlId;
LPWSTR lpControlName;
} ACTRL_CONTROL_INFOW, *PACTRL_CONTROL_INFOW;
DECL_WINELIB_TYPE_AW(ACTRL_CONTROL_INFO)
DECL_WINELIB_TYPE_AW(PACTRL_CONTROL_INFO)
typedef enum _PROGRESS_INVOKE_SETTING {
ProgressInvokeNever = 1,
ProgressInvokeEveryObject,
ProgressInvokeOnError,
ProgressCancelOperation,
ProgressRetryOperation
} PROG_INVOKE_SETTING, *PPROG_INVOKE_SETTING;
typedef struct _INHERITED_FROMA
{
LONG GenerationGap;
LPSTR AncestorName;
} INHERITED_FROMA, *PINHERITED_FROMA;
typedef struct _INHERITED_FROMW
{
LONG GenerationGap;
LPWSTR AncestorName;
} INHERITED_FROMW, *PINHERITED_FROMW;
DECL_WINELIB_TYPE_AW(INHERITED_FROM)
DECL_WINELIB_TYPE_AW(PINHERITED_FROM)
#define AccFree LocalFree
#ifdef __cplusplus
}
#endif
#endif /* __WINE_ACCCTRL_H */

104
assets/wine/include/wine/windows/access.idl
View File

@@ -1,104 +0,0 @@
/*
* Copyright (C) 2009 Huw Davies
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#if 0
#pragma makedep install
#endif
[
object,
uuid(0c733a8c-2a1c-11ce-ade5-00aa0044773d),
pointer_default(unique)
]
interface IAccessor : IUnknown
{
typedef DWORD DBACCESSORFLAGS;
typedef DWORD DBBINDSTATUS;
enum DBACCESSORFLAGSENUM
{
DBACCESSOR_INVALID = 0x00,
DBACCESSOR_PASSBYREF = 0x01,
DBACCESSOR_ROWDATA = 0x02,
DBACCESSOR_PARAMETERDATA = 0x04,
DBACCESSOR_OPTIMIZED = 0x08,
DBACCESSOR_INHERITED = 0x10,
};
enum DBBINDSTATUSENUM
{
DBBINDSTATUS_OK = 0,
DBBINDSTATUS_BADORDINAL = 1,
DBBINDSTATUS_UNSUPPORTEDCONVERSION = 2,
DBBINDSTATUS_BADBINDINFO = 3,
DBBINDSTATUS_BADSTORAGEFLAGS = 4,
DBBINDSTATUS_NOINTERFACE = 5,
DBBINDSTATUS_MULTIPLESTORAGE = 6,
};
[local]
HRESULT AddRefAccessor([in] HACCESSOR hAccessor,
[in, out, unique, annotation("__out_opt")] DBREFCOUNT *pcRefCount);
[call_as(AddRefAccessor)]
HRESULT RemoteAddRefAccessor([in] HACCESSOR hAccessor,
[in, out, unique] DBREFCOUNT *pcRefCount,
[out] IErrorInfo **ppErrorInfoRem);
[local]
HRESULT CreateAccessor([in] DBACCESSORFLAGS dwAccessorFlags,
[in] DBCOUNTITEM cBindings,
[in, size_is(cBindings), annotation("__in_ecount(cBindings)")] const DBBINDING rgBindings[],
[in] DBLENGTH cbRowSize,
[out, annotation("__out")] HACCESSOR *phAccessor,
[out, size_is(cBindings), annotation("__out_ecount_opt(cBindings)")] DBBINDSTATUS rgStatus[]);
[call_as(CreateAccessor)]
HRESULT RemoteCreateAccessor([in] DBACCESSORFLAGS dwAccessorFlags,
[in] DBCOUNTITEM cBindings,
[in, unique, size_is((ULONG)cBindings)] DBBINDING *rgBindings,
[in] DBLENGTH cbRowSize,
[out] HACCESSOR *phAccessor,
[in, out, unique, size_is((ULONG)cBindings)] DBBINDSTATUS *rgStatus,
[out] IErrorInfo **ppErrorInfoRem);
[local]
HRESULT GetBindings([in] HACCESSOR hAccessor,
[out, annotation("__out")] DBACCESSORFLAGS *pdwAccessorFlags,
[in, out, annotation("__out_opt")] DBCOUNTITEM *pcBindings,
[out, size_is(,*pcBindings), annotation("__deref_out_ecount_opt(*pcBindings)")] DBBINDING **prgBindings);
[call_as(GetBindings)]
HRESULT RemoteGetBindings([in] HACCESSOR hAccessor,
[out] DBACCESSORFLAGS *pdwAccessorFlags,
[in, out] DBCOUNTITEM *pcBindings,
[out, size_is(,(ULONG)*pcBindings)] DBBINDING **prgBindings,
[out] IErrorInfo **ppErrorInfoRem);
[local]
HRESULT ReleaseAccessor([in] HACCESSOR hAccessor,
[in, out, unique, annotation("__out_opt")] DBREFCOUNT *pcRefCount);
[call_as(ReleaseAccessor)]
HRESULT RemoteReleaseAccessor([in] HACCESSOR hAccessor,
[in, out, unique] DBREFCOUNT *pcRefCount,
[out] IErrorInfo **ppErrorInfoRem);
}

83
assets/wine/include/wine/windows/aclapi.h
View File

@@ -1,83 +0,0 @@
/*
* Copyright (C) 2004 Mike McCormack
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_ACLAPI_H
#define __WINE_ACLAPI_H
#include <windows.h>
#include <accctrl.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef void (*FN_PROGRESS)(LPWSTR,DWORD,PPROG_INVOKE_SETTING,PVOID,BOOL);
WINADVAPI DWORD WINAPI GetExplicitEntriesFromAclA( PACL, PULONG, PEXPLICIT_ACCESS_A* );
WINADVAPI DWORD WINAPI GetExplicitEntriesFromAclW( PACL, PULONG, PEXPLICIT_ACCESS_W* );
#define GetExplicitEntriesFromAcl WINELIB_NAME_AW(GetExplicitEntriesFromAcl)
WINADVAPI DWORD WINAPI GetSecurityInfo( HANDLE, SE_OBJECT_TYPE, SECURITY_INFORMATION, PSID*, PSID*, PACL*, PACL*, PSECURITY_DESCRIPTOR*);
WINADVAPI DWORD WINAPI GetSecurityInfoExA(HANDLE, SE_OBJECT_TYPE, SECURITY_INFORMATION, LPCSTR, LPCSTR, PACTRL_ACCESSA*, PACTRL_AUDITA*, LPSTR*, LPSTR*);
WINADVAPI DWORD WINAPI GetSecurityInfoExW(HANDLE, SE_OBJECT_TYPE, SECURITY_INFORMATION, LPCWSTR, LPCWSTR, PACTRL_ACCESSW*, PACTRL_AUDITW*, LPWSTR*, LPWSTR*);
#define GetSecurityInfoEx WINELIB_NAME_AW(GetSecurityInfoEx)
WINADVAPI DWORD WINAPI GetNamedSecurityInfoA(const char *, SE_OBJECT_TYPE, SECURITY_INFORMATION, PSID*, PSID*, PACL*, PACL*, PSECURITY_DESCRIPTOR*);
WINADVAPI DWORD WINAPI GetNamedSecurityInfoW(const WCHAR *, SE_OBJECT_TYPE, SECURITY_INFORMATION, PSID*, PSID*, PACL*, PACL*, PSECURITY_DESCRIPTOR*);
#define GetNamedSecurityInfo WINELIB_NAME_AW(GetNamedSecurityInfo)
WINADVAPI DWORD WINAPI SetNamedSecurityInfoA(LPSTR, SE_OBJECT_TYPE, SECURITY_INFORMATION, PSID, PSID, PACL, PACL);
WINADVAPI DWORD WINAPI SetNamedSecurityInfoW(LPWSTR, SE_OBJECT_TYPE, SECURITY_INFORMATION, PSID, PSID, PACL, PACL);
#define SetNamedSecurityInfo WINELIB_NAME_AW(SetNamedSecurityInfo)
WINADVAPI DWORD WINAPI SetEntriesInAclA( ULONG, PEXPLICIT_ACCESSA, PACL, PACL*);
WINADVAPI DWORD WINAPI SetEntriesInAclW( ULONG, PEXPLICIT_ACCESSW, PACL, PACL*);
#define SetEntriesInAcl WINELIB_NAME_AW(SetEntriesInAcl)
WINADVAPI DWORD WINAPI SetSecurityInfo(HANDLE, SE_OBJECT_TYPE, SECURITY_INFORMATION, PSID, PSID, PACL, PACL);
WINADVAPI TRUSTEE_FORM WINAPI GetTrusteeFormA( PTRUSTEEA );
WINADVAPI TRUSTEE_FORM WINAPI GetTrusteeFormW( PTRUSTEEW );
#define GetTrusteeForm WINELIB_NAME_AW(GetTrusteeForm)
WINADVAPI LPSTR WINAPI GetTrusteeNameA( PTRUSTEEA );
WINADVAPI LPWSTR WINAPI GetTrusteeNameW( PTRUSTEEW );
#define GetTrusteeName WINELIB_NAME_AW(GetTrusteeName)
WINADVAPI TRUSTEE_TYPE WINAPI GetTrusteeTypeA( PTRUSTEEA );
WINADVAPI TRUSTEE_TYPE WINAPI GetTrusteeTypeW( PTRUSTEEW );
#define GetTrusteeType WINELIB_NAME_AW(GetTrusteeType)
WINADVAPI DWORD WINAPI BuildSecurityDescriptorA( PTRUSTEEA, PTRUSTEEA, ULONG, PEXPLICIT_ACCESS_A, ULONG, PEXPLICIT_ACCESS_A, PSECURITY_DESCRIPTOR, PULONG, PSECURITY_DESCRIPTOR* );
WINADVAPI DWORD WINAPI BuildSecurityDescriptorW( PTRUSTEEW, PTRUSTEEW, ULONG, PEXPLICIT_ACCESS_W, ULONG, PEXPLICIT_ACCESS_W, PSECURITY_DESCRIPTOR, PULONG, PSECURITY_DESCRIPTOR* );
#define BuildSecurityDescriptor WINELIB_NAME_AW(BuildSecurityDescriptor)
WINADVAPI void WINAPI BuildTrusteeWithNameA( PTRUSTEEA, LPSTR );
WINADVAPI void WINAPI BuildTrusteeWithNameW( PTRUSTEEW, LPWSTR );
#define BuildTrusteeWithName WINELIB_NAME_AW(BuildTrusteeWithName)
WINADVAPI void WINAPI BuildTrusteeWithObjectsAndNameA(PTRUSTEEA, POBJECTS_AND_NAME_A, SE_OBJECT_TYPE, LPSTR, LPSTR, LPSTR);
WINADVAPI void WINAPI BuildTrusteeWithObjectsAndNameW(PTRUSTEEW, POBJECTS_AND_NAME_W, SE_OBJECT_TYPE, LPWSTR, LPWSTR, LPWSTR);
#define BuildTrusteeWithObjectsAndName WINELIB_NAME_AW(BuildTrusteeWithObjectsAndName)
WINADVAPI void WINAPI BuildTrusteeWithObjectsAndSidA(PTRUSTEEA, POBJECTS_AND_SID, GUID*, GUID*, PSID);
WINADVAPI void WINAPI BuildTrusteeWithObjectsAndSidW(PTRUSTEEW, POBJECTS_AND_SID, GUID*, GUID*, PSID);
#define BuildTrusteeWithObjectsAndSid WINELIB_NAME_AW(BuildTrusteeWithObjectsAndSid)
WINADVAPI void WINAPI BuildExplicitAccessWithNameA(PEXPLICIT_ACCESSA, LPSTR, DWORD, ACCESS_MODE, DWORD);
WINADVAPI void WINAPI BuildExplicitAccessWithNameW(PEXPLICIT_ACCESSW, LPWSTR, DWORD, ACCESS_MODE, DWORD);
#define BuildExplicitAccessWithName WINELIB_NAME_AW(BuildExplicitAccessWithName)
WINADVAPI void WINAPI BuildTrusteeWithSidA(PTRUSTEEA pTrustee, PSID pSid);
WINADVAPI void WINAPI BuildTrusteeWithSidW(PTRUSTEEW pTrustee, PSID pSid);
#define BuildTrusteeWithSid WINELIB_NAME_AW(BuildTrusteeWithSid)
WINADVAPI DWORD WINAPI GetEffectiveRightsFromAclA(PACL,PTRUSTEE_A,PACCESS_MASK);
WINADVAPI DWORD WINAPI GetEffectiveRightsFromAclW(PACL,PTRUSTEE_W,PACCESS_MASK);
#define GetEffectiveRightsFromAcl WINELIB_NAME_AW(GetEffectiveRightsFromAcl)
#ifdef __cplusplus
}
#endif
#endif /* __WINE_ACLAPI_H */

238
assets/wine/include/wine/windows/aclui.h
View File

@@ -1,238 +0,0 @@
/*
* Copyright (C) 2009 Nikolay Sivov
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_ACLUI_H
#define __WINE_ACLUI_H
#include <objbase.h>
#include <commctrl.h>
#include <accctrl.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
typedef struct _SI_OBJECT_INFO
{
DWORD dwFlags;
HINSTANCE hInstance;
LPWSTR pszServerName;
LPWSTR pszObjectName;
LPWSTR pszPageTitle;
GUID guidObjectType;
} SI_OBJECT_INFO, *PSI_OBJECT_INFO;
#define SI_EDIT_PERMS 0x00000000
#define SI_EDIT_OWNER 0x00000001
#define SI_EDIT_AUDITS 0x00000002
#define SI_CONTAINER 0x00000004
#define SI_READONLY 0x00000008
#define SI_ADVANCED 0x00000010
#define SI_RESET 0x00000020
#define SI_OWNER_READONLY 0x00000040
#define SI_EDIT_PROPERTIES 0x00000080
#define SI_OWNER_RECURSE 0x00000100
#define SI_NO_ACL_PROTECT 0x00000200
#define SI_NO_TREE_APPLY 0x00000400
#define SI_PAGE_TITLE 0x00000800
#define SI_SERVER_IS_DC 0x00001000
#define SI_RESET_DACL_TREE 0x00004000
#define SI_RESET_SACL_TREE 0x00008000
#define SI_OBJECT_GUID 0x00010000
#define SI_EDIT_EFFECTIVE 0x00020000
#define SI_RESET_DACL 0x00040000
#define SI_RESET_SACL 0x00080000
#define SI_RESET_OWNER 0x00100000
#define SI_NO_ADDITIONAL_PERMISSION 0x00200000
#define SI_VIEW_ONLY 0x00400000
#define SI_PERMS_ELEVATION_REQUIRED 0x01000000
#define SI_AUDITS_ELEVATION_REQUIRED 0x02000000
#define SI_OWNER_ELEVATION_REQUIRED 0x04000000
#define SI_MAY_WRITE 0x10000000
#define SI_EDIT_ALL (SI_EDIT_PERMS | SI_EDIT_OWNER | SI_EDIT_AUDITS)
typedef struct _SI_ACCESS
{
const GUID *pguid;
ACCESS_MASK mask;
LPCWSTR pszName;
DWORD dwFlags;
} SI_ACCESS, *PSI_ACCESS;
#define SI_ACCESS_SPECIFIC 0x00010000
#define SI_ACCESS_GENERAL 0x00020000
#define SI_ACCESS_CONTAINER 0x00040000
#define SI_ACCESS_PROPERTY 0x00080000
typedef struct _SI_INHERIT_TYPE
{
const GUID *pguid;
ULONG dwFlags;
LPCWSTR pszName;
} SI_INHERIT_TYPE, *PSI_INHERIT_TYPE;
typedef enum _SI_PAGE_TYPE
{
SI_PAGE_PERM,
SI_PAGE_ADVPERM,
SI_PAGE_AUDIT,
SI_PAGE_OWNER,
SI_PAGE_EFFECTIVE,
SI_PAGE_TAKEOWNERSHIP
} SI_PAGE_TYPE;
#define PSPCB_SI_INITDIALOG (WM_USER + 1)
#undef INTERFACE
#define INTERFACE ISecurityInformation
DECLARE_INTERFACE_IID_(ISecurityInformation, IUnknown, "965fc360-16ff-11d0-91cb-00aa00bbb723")
{
/* IUnknown methods */
STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID * ppvObj) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;
/* ISecurityInformation methods */
STDMETHOD(GetObjectInformation) (THIS_ PSI_OBJECT_INFO pObjectInfo ) PURE;
STDMETHOD(GetSecurity) (THIS_ SECURITY_INFORMATION RequestedInformation,
PSECURITY_DESCRIPTOR *ppSecurityDescriptor,
BOOL fDefault ) PURE;
STDMETHOD(SetSecurity) (THIS_ SECURITY_INFORMATION SecurityInformation,
PSECURITY_DESCRIPTOR pSecurityDescriptor ) PURE;
STDMETHOD(GetAccessRights) (THIS_ const GUID* pguidObjectType,
DWORD dwFlags,
PSI_ACCESS *ppAccess,
ULONG *pcAccesses,
ULONG *piDefaultAccess ) PURE;
STDMETHOD(MapGeneric) (THIS_ const GUID *pguidObjectType,
UCHAR *pAceFlags,
ACCESS_MASK *pMask) PURE;
STDMETHOD(GetInheritTypes) (THIS_ PSI_INHERIT_TYPE *ppInheritTypes,
ULONG *pcInheritTypes ) PURE;
STDMETHOD(PropertySheetPageCallback)(THIS_ HWND hwnd, UINT uMsg, SI_PAGE_TYPE uPage ) PURE;
};
#undef INTERFACE
typedef ISecurityInformation *LPSECURITYINFO;
#define INTERFACE ISecurityInformation2
DECLARE_INTERFACE_IID_(ISecurityInformation2, IUnknown, "c3ccfdb4-6f88-11d2-a3ce-00c04fb1782a")
{
/* IUnknown methods */
STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID * ppvObj) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;
/* ISecurityInformation2 methods */
STDMETHOD_(BOOL,IsDaclCanonical) (THIS_ PACL pDacl) PURE;
STDMETHOD(LookupSids) (THIS_ ULONG cSids, PSID *rgpSids, LPDATAOBJECT *ppdo) PURE;
};
#undef INTERFACE
typedef ISecurityInformation2 *LPSECURITYINFO2;
#define CFSTR_ACLUI_SID_INFO_LIST TEXT("CFSTR_ACLUI_SID_INFO_LIST")
typedef struct _SID_INFO
{
PSID pSid;
PWSTR pwzCommonName;
PWSTR pwzClass;
PWSTR pwzUPN;
} SID_INFO, *PSID_INFO;
typedef struct _SID_INFO_LIST
{
ULONG cItems;
SID_INFO aSidInfo[ANYSIZE_ARRAY];
} SID_INFO_LIST, *PSID_INFO_LIST;
#define INTERFACE IEffectivePermission
DECLARE_INTERFACE_IID_(IEffectivePermission, IUnknown, "3853dc76-9f35-407c-88a1-d19344365fbc")
{
/* IUnknown methods */
STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID * ppvObj) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;
/* ISecurityInformation methods */
STDMETHOD(GetEffectivePermission) (THIS_
const GUID* pguidObjectType,
PSID pUserSid,
LPCWSTR pszServerName,
PSECURITY_DESCRIPTOR pSD,
POBJECT_TYPE_LIST *ppObjectTypeList,
ULONG *pcObjectTypeListLength,
PACCESS_MASK *ppGrantedAccessList,
ULONG *pcGrantedAccessListLength) PURE;
};
#undef INTERFACE
typedef IEffectivePermission *LPEFFECTIVEPERMISSION;
#define INTERFACE ISecurityObjectTypeInfo
DECLARE_INTERFACE_IID_(ISecurityObjectTypeInfo, IUnknown, "fc3066eb-79ef-444b-9111-d18a75ebf2fa")
{
/* IUnknown methods */
STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID * ppvObj) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;
/* ISecurityInformation methods */
STDMETHOD(GetInheritSource)(THIS_ SECURITY_INFORMATION si,
PACL pACL,
#ifndef WINE_NO_UNICODE_MACROS
PINHERITED_FROM *ppInheritArray
#else
PINHERITED_FROMW *ppInheritArray
#endif
) PURE;
};
#undef INTERFACE
typedef ISecurityObjectTypeInfo *LPSecurityObjectTypeInfo;
#define INTERFACE ISecurityInformation3
DECLARE_INTERFACE_IID_(ISecurityInformation3, IUnknown, "e2cdc9cc-31bd-4f8f-8c8b-b641af516a1a")
{
/* IUnknown methods */
STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID * ppvObj) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;
/* ISecurityInformation3 methods */
STDMETHOD(GetFullResourceName) (THIS_ LPWSTR *ppszResourceName) PURE;
STDMETHOD(OpenElevatedEditor) (THIS_ HWND hWnd, SI_PAGE_TYPE uPage) PURE;
};
#undef INTERFACE
typedef ISecurityInformation3 *LPSECURITYINFO3;
DEFINE_GUID(IID_ISecurityInformation, 0x965fc360, 0x16ff, 0x11d0, 0x91, 0xcb, 0x0, 0xaa, 0x0, 0xbb, 0xb7, 0x23);
DEFINE_GUID(IID_ISecurityInformation2, 0xc3ccfdb4, 0x6f88, 0x11d2, 0xa3, 0xce, 0x0, 0xc0, 0x4f, 0xb1, 0x78, 0x2a);
DEFINE_GUID(IID_IEffectivePermission, 0x3853dc76, 0x9f35, 0x407c, 0x88, 0xa1, 0xd1, 0x93, 0x44, 0x36, 0x5f, 0xbc);
DEFINE_GUID(IID_ISecurityObjectTypeInfo, 0xfc3066eb, 0x79ef, 0x444b, 0x91, 0x11, 0xd1, 0x8a, 0x75, 0xeb, 0xf2, 0xfa);
DEFINE_GUID(IID_ISecurityInformation3, 0xe2cdc9cc, 0x31bd, 0x4f8f, 0x8c, 0x8b, 0xb6, 0x41, 0xaf, 0x51, 0x6a, 0x1a);
HPROPSHEETPAGE WINAPI CreateSecurityPage(LPSECURITYINFO psi);
BOOL WINAPI EditSecurity(HWND owner, LPSECURITYINFO psi);
HRESULT WINAPI EditSecurityAdvanced(HWND owner, LPSECURITYINFO psi, SI_PAGE_TYPE uSIPage);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __WINE_ACLUI_H */

151
assets/wine/include/wine/windows/activation.h
View File

@@ -1,151 +0,0 @@
/*** Autogenerated by WIDL 10.17 from /home/runner/build_wine/wine/include/activation.idl - Do not edit ***/
#ifdef _WIN32
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include <rpc.h>
#include <rpcndr.h>
#endif
#ifndef COM_NO_WINDOWS_H
#include <windows.h>
#include <ole2.h>
#endif
#ifndef __activation_h__
#define __activation_h__
/* Forward declarations */
#ifndef __IActivationFactory_FWD_DEFINED__
#define __IActivationFactory_FWD_DEFINED__
typedef interface IActivationFactory IActivationFactory;
#ifdef __cplusplus
interface IActivationFactory;
#endif /* __cplusplus */
#endif
/* Headers for imported files */
#include <inspectable.h>
#ifdef __cplusplus
extern "C" {
#endif
/*****************************************************************************
* IActivationFactory interface
*/
#ifndef __IActivationFactory_INTERFACE_DEFINED__
#define __IActivationFactory_INTERFACE_DEFINED__
DEFINE_GUID(IID_IActivationFactory, 0x00000035, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("00000035-0000-0000-c000-000000000046")
IActivationFactory : public IInspectable
{
virtual HRESULT STDMETHODCALLTYPE ActivateInstance(
IInspectable **instance) = 0;
};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IActivationFactory, 0x00000035, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46)
#endif
#else
typedef struct IActivationFactoryVtbl {
BEGIN_INTERFACE
/*** IUnknown methods ***/
HRESULT (STDMETHODCALLTYPE *QueryInterface)(
IActivationFactory *This,
REFIID riid,
void **ppvObject);
ULONG (STDMETHODCALLTYPE *AddRef)(
IActivationFactory *This);
ULONG (STDMETHODCALLTYPE *Release)(
IActivationFactory *This);
/*** IInspectable methods ***/
HRESULT (STDMETHODCALLTYPE *GetIids)(
IActivationFactory *This,
ULONG *iidCount,
IID **iids);
HRESULT (STDMETHODCALLTYPE *GetRuntimeClassName)(
IActivationFactory *This,
HSTRING *className);
HRESULT (STDMETHODCALLTYPE *GetTrustLevel)(
IActivationFactory *This,
TrustLevel *trustLevel);
/*** IActivationFactory methods ***/
HRESULT (STDMETHODCALLTYPE *ActivateInstance)(
IActivationFactory *This,
IInspectable **instance);
END_INTERFACE
} IActivationFactoryVtbl;
interface IActivationFactory {
CONST_VTBL IActivationFactoryVtbl* lpVtbl;
};
#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IActivationFactory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IActivationFactory_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IActivationFactory_Release(This) (This)->lpVtbl->Release(This)
/*** IInspectable methods ***/
#define IActivationFactory_GetIids(This,iidCount,iids) (This)->lpVtbl->GetIids(This,iidCount,iids)
#define IActivationFactory_GetRuntimeClassName(This,className) (This)->lpVtbl->GetRuntimeClassName(This,className)
#define IActivationFactory_GetTrustLevel(This,trustLevel) (This)->lpVtbl->GetTrustLevel(This,trustLevel)
/*** IActivationFactory methods ***/
#define IActivationFactory_ActivateInstance(This,instance) (This)->lpVtbl->ActivateInstance(This,instance)
#else
/*** IUnknown methods ***/
static inline HRESULT IActivationFactory_QueryInterface(IActivationFactory* This,REFIID riid,void **ppvObject) {
return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static inline ULONG IActivationFactory_AddRef(IActivationFactory* This) {
return This->lpVtbl->AddRef(This);
}
static inline ULONG IActivationFactory_Release(IActivationFactory* This) {
return This->lpVtbl->Release(This);
}
/*** IInspectable methods ***/
static inline HRESULT IActivationFactory_GetIids(IActivationFactory* This,ULONG *iidCount,IID **iids) {
return This->lpVtbl->GetIids(This,iidCount,iids);
}
static inline HRESULT IActivationFactory_GetRuntimeClassName(IActivationFactory* This,HSTRING *className) {
return This->lpVtbl->GetRuntimeClassName(This,className);
}
static inline HRESULT IActivationFactory_GetTrustLevel(IActivationFactory* This,TrustLevel *trustLevel) {
return This->lpVtbl->GetTrustLevel(This,trustLevel);
}
/*** IActivationFactory methods ***/
static inline HRESULT IActivationFactory_ActivateInstance(IActivationFactory* This,IInspectable **instance) {
return This->lpVtbl->ActivateInstance(This,instance);
}
#endif
#endif
#endif
#endif /* __IActivationFactory_INTERFACE_DEFINED__ */
/* Begin additional prototypes for all interfaces */
/* End additional prototypes */
#ifdef __cplusplus
}
#endif
#endif /* __activation_h__ */

29
assets/wine/include/wine/windows/activation.idl
View File

@@ -1,29 +0,0 @@
/*
* Copyright 2016 Michael Müller
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
import "inspectable.idl";
[
object,
uuid(00000035-0000-0000-c000-000000000046),
pointer_default(unique)
]
interface IActivationFactory : IInspectable
{
HRESULT ActivateInstance([out] IInspectable **instance);
}

43
assets/wine/include/wine/windows/activaut.h
View File

@@ -1,43 +0,0 @@
/*** Autogenerated by WIDL 10.17 from /home/runner/build_wine/wine/include/activaut.idl - Do not edit ***/
#ifdef _WIN32
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include <rpc.h>
#include <rpcndr.h>
#endif
#ifndef COM_NO_WINDOWS_H
#include <windows.h>
#include <ole2.h>
#endif
#ifndef __activaut_h__
#define __activaut_h__
/* Forward declarations */
/* Headers for imported files */
#include <ocidl.h>
#include <oleidl.h>
#include <oaidl.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _NO_AUTHOR_GUIDS
DEFINE_GUID(CATID_ActiveScriptAuthor, 0xaee2a92,0xbcbb,0x11d0,0x8c,0x72,0x0,0xc0,0x4f,0xc2,0xb0,0x85);
#endif
/* Begin additional prototypes for all interfaces */
/* End additional prototypes */
#ifdef __cplusplus
}
#endif
#endif /* __activaut_h__ */

29
assets/wine/include/wine/windows/activaut.idl
View File

@@ -1,29 +0,0 @@
/*
* Copyright 2008 Jacek Caban for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef DO_NO_IMPORTS
import "ocidl.idl";
import "oleidl.idl";
import "oaidl.idl";
#endif
cpp_quote("#ifndef _NO_AUTHOR_GUIDS")
cpp_quote("DEFINE_GUID(CATID_ActiveScriptAuthor, 0xaee2a92,0xbcbb,0x11d0,0x8c,0x72,0x0,0xc0,0x4f,0xc2,0xb0,0x85);")
cpp_quote("#endif")

2452
assets/wine/include/wine/windows/activdbg.h
View File

File diff suppressed because it is too large Load Diff

581
assets/wine/include/wine/windows/activdbg.idl
View File

@@ -1,581 +0,0 @@
/*
* Copyright 2008 Jacek Caban for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
import "ocidl.idl";
import "activscp.idl";
/* import "dbgprop.idl"; */
interface IDebugDocumentContext;
interface IRemoteDebugApplication;
interface IEnumDebugCodeContexts;
/* FIXME: */
interface IEnumDebugStackFrames;
interface IDebugStackFrame;
interface IApplicationDebugger;
interface IEnumRemoteDebugApplicationThreads;
interface IDebugApplicationNode;
interface IEnumDebugExpressionContexts;
interface IDebugApplicationThread;
interface IDebugSyncOperation;
interface IDebugAsyncOperation;
interface IDebugStackFrameSniffer;
interface IDebugThreadCall32;
interface IActiveScriptErrorDebug;
interface IProvideExpressionContexts;
typedef enum tagBREAKPOINT_STATE {
BREAKPOINT_DELETED,
BREAKPOINT_DISABLED,
BREAKPOINT_ENABLED
} BREAKPOINT_STATE;
typedef DWORD APPBREAKFLAGS;
typedef enum tagBREAKREASON {
BREAKREASON_STEP,
BREAKREASON_BREAKPOINT,
BREAKREASON_DEBUGGER_BLOCK,
BREAKREASON_HOST_INITIATED,
BREAKREASON_LANGUAGE_INITIATED,
BREAKREASON_DEBUGGER_HALT,
BREAKREASON_ERROR,
BREAKREASON_JIT
} BREAKREASON;
typedef enum tagBREAKRESUME_ACTION {
BREAKRESUMEACTION_ABORT,
BREAKRESUMEACTION_CONTINUE,
BREAKRESUMEACTION_STEP_INTO,
BREAKRESUMEACTION_STEP_OVER,
BREAKRESUMEACTION_STEP_OUT,
BREAKRESUMEACTION_IGNORE
} BREAKRESUMEACTION;
typedef enum tagDOCUMENTNAMETYPE {
DOCUMENTNAMETYPE_APPNODE,
DOCUMENTNAMETYPE_TITLE,
DOCUMENTNAMETYPE_FILE_TAIL,
DOCUMENTNAMETYPE_URL
} DOCUMENTNAMETYPE;
typedef enum tagERRORRESUMEACTION {
ERRORRESUMEACTION_ReexecuteErrorStatement,
ERRORRESUMEACTION_AbortCallAndReturnErrorToCaller,
ERRORRESUMEACTION_SkipErrorStatement,
} ERRORRESUMEACTION;
typedef WORD SOURCE_TEXT_ATTR;
#ifdef INTEROPLIB
enum enum_SOURCE_TEXT_ATTR
{
SOURCETEXT_ATTR_KEYWORD = 0x01,
SOURCETEXT_ATTR_COMMENT = 0x02,
SOURCETEXT_ATTR_NONSOURCE = 0x04,
SOURCETEXT_ATTR_OPERATOR = 0x08,
SOURCETEXT_ATTR_NUMBER = 0x10,
SOURCETEXT_ATTR_STRING = 0x20,
SOURCETEXT_ATTR_FUNCTION_START = 0x40
};
#endif
const SOURCE_TEXT_ATTR SOURCETEXT_ATTR_KEYWORD = 0x01;
const SOURCE_TEXT_ATTR SOURCETEXT_ATTR_COMMENT = 0x02;
const SOURCE_TEXT_ATTR SOURCETEXT_ATTR_NONSOURCE = 0x04;
const SOURCE_TEXT_ATTR SOURCETEXT_ATTR_OPERATOR = 0x08;
const SOURCE_TEXT_ATTR SOURCETEXT_ATTR_NUMBER = 0x10;
const SOURCE_TEXT_ATTR SOURCETEXT_ATTR_STRING = 0x20;
const SOURCE_TEXT_ATTR SOURCETEXT_ATTR_FUNCTION_START = 0x40;
/************************************************************
* interface IActiveScriptDebug32
*/
[
object,
uuid(51973c10-cb0c-11d0-b5c9-00a0244a0e7a),
pointer_default(unique)
]
interface IActiveScriptDebug32 : IUnknown
{
HRESULT GetScriptTextAttributes(
[in, size_is(uNumCodeChars)] LPCOLESTR pstrCode,
[in] ULONG uNumCodeChars,
[in] LPCOLESTR pstrDelimiter,
[in] DWORD dwFlags,
[in, out, size_is(uNumCodeChars)] SOURCE_TEXT_ATTR *pattr);
HRESULT GetScriptletTextAttributes(
[in, size_is(uNumCodeChars)] LPCOLESTR pstrCode,
[in] ULONG uNumCodeChars,
[in] LPCOLESTR pstrDelimiter,
[in] DWORD dwFlags,
[in, out, size_is(uNumCodeChars)] SOURCE_TEXT_ATTR *pattr);
HRESULT EnumCodeContextsOfPosition(
[in] DWORD dwSourceContext,
[in] ULONG uCharacterOffset,
[in] ULONG uNumChars,
[out] IEnumDebugCodeContexts **ppescc);
}
[
object,
uuid(bc437e23-f5b8-47f4-bb79-7d1ce5483b86),
pointer_default(unique)
]
interface IActiveScriptDebug64 : IUnknown
{
HRESULT GetScriptTextAttributes(
[in, size_is(uNumCodeChars)] LPCOLESTR pstrCode,
[in] ULONG uNumCodeChars,
[in] LPCOLESTR pstrDelimiter,
[in] DWORD dwFlags,
[in, out, size_is(uNumCodeChars)] SOURCE_TEXT_ATTR *pattr);
HRESULT GetScriptletTextAttributes(
[in, size_is(uNumCodeChars)] LPCOLESTR pstrCode,
[in] ULONG uNumCodeChars,
[in] LPCOLESTR pstrDelimiter,
[in] DWORD dwFlags,
[in, out, size_is(uNumCodeChars)] SOURCE_TEXT_ATTR *pattr);
HRESULT EnumCodeContextsOfPosition(
[in] DWORDLONG dwSourceContext,
[in] ULONG uCharacterOffset,
[in] ULONG uNumChars,
[out] IEnumDebugCodeContexts **ppescc);
}
/************************************************************
* interface IDebugDocumentInfo
*/
[
object,
uuid(51973c1f-cb0c-11d0-b5c9-00a0244a0e7a),
pointer_default(unique)
]
interface IDebugDocumentInfo : IUnknown
{
HRESULT GetName(
[in] DOCUMENTNAMETYPE dnt,
[out] BSTR *pbstrName);
HRESULT GetDocumentClassId(
[out] CLSID *pclsidDocument);
}
/************************************************************
* interface IDebugDocument
*/
[
object,
uuid(51973c21-cb0c-11d0-b5c9-00a0244a0e7a),
pointer_default(unique)
]
interface IDebugDocument : IDebugDocumentInfo
{
}
/************************************************************
* interface IDebugCodeContext
*/
[
object,
uuid(51973c13-cb0c-11d0-b5c9-00a0244a0e7a),
pointer_default(unique)
]
interface IDebugCodeContext : IUnknown
{
HRESULT GetDocumentContext(
[out] IDebugDocumentContext **ppsc);
HRESULT SetBreakPoint(
[in] BREAKPOINT_STATE bps);
}
/************************************************************
* interface IEnumDebugCodeContexts
*/
[
object,
uuid(51973c1d-cb0c-11d0-b5c9-00a0244a0e7a),
pointer_default(unique)
]
interface IEnumDebugCodeContexts : IUnknown
{
HRESULT Next(
[in] ULONG celt,
[out] IDebugCodeContext **pscc,
[out] ULONG *pceltFetched);
HRESULT Skip(
[in] ULONG celt);
HRESULT Reset();
HRESULT Clone(
[out] IEnumDebugCodeContexts **ppescc);
}
/************************************************************
* interface IDebugDocumentContext
*/
[
object,
uuid(51973c28-cb0c-11d0-b5c9-00a0244a0e7a),
pointer_default(unique)
]
interface IDebugDocumentContext : IUnknown
{
HRESULT GetDocument(
[out] IDebugDocument **ppsd);
HRESULT EnumCodeContexts(
[out] IEnumDebugCodeContexts **ppescc);
}
/************************************************************
* interface IRemoteDebugApplicationThread
*/
[
object,
uuid(51973c37-cb0c-11d0-b5c9-00a0244a0e7a),
pointer_default(unique)
]
interface IRemoteDebugApplicationThread : IUnknown
{
HRESULT GetSystemThreadId(
[out] DWORD *dwThreadId);
HRESULT GetApplication(
[out] IRemoteDebugApplication **pprda);
HRESULT EnumStackFrames(
[out] IEnumDebugStackFrames **ppedsf);
HRESULT GetDescription(
[out] BSTR *pbstrDescription,
[out] BSTR *pbstrState);
HRESULT SetNextStatement(
[in] IDebugStackFrame *pStackFrame,
[in] IDebugCodeContext *pCodeContext);
HRESULT GetState(
[out] DWORD *pState);
HRESULT Suspend(
[out] DWORD *pdwCount);
HRESULT Resume(
[out] DWORD *pdwCount);
HRESULT GetSuspendCount(
[out] DWORD *pdwCount);
}
/************************************************************
* interface IRemoteDebugApplication
*/
[
object,
uuid(51973c30-cb0c-11d0-b5c9-00a0244a0e7a),
pointer_default(unique)
]
interface IRemoteDebugApplication : IUnknown
{
HRESULT ResumeFromBreakPoint(
[in] IRemoteDebugApplicationThread *prptFocus,
[in] BREAKRESUMEACTION bra,
[in] ERRORRESUMEACTION era);
HRESULT CauseBreak();
HRESULT ConnectDebugger(
[in] IApplicationDebugger *pad);
HRESULT DisconnectDebugger();
HRESULT GetDebugger(
[out] IApplicationDebugger **pad);
HRESULT CreateInstanceAtApplication(
[in] REFCLSID rclsid,
[in] IUnknown *pUnkOuter,
[in] DWORD dwClsContext,
[in] REFIID riid,
[out, iid_is(riid)] IUnknown **ppvObject);
HRESULT QueryAlive();
HRESULT EnumThreads(
[out] IEnumRemoteDebugApplicationThreads **pperdat);
HRESULT GetName(
[out] BSTR *pbstrName);
HRESULT GetRootNode(
[out] IDebugApplicationNode **ppdanRoot);
HRESULT EnumGlobalExpressionContexts(
[out] IEnumDebugExpressionContexts **ppedec);
}
/************************************************************
* interface IDebugApplication32
*/
[
object,
uuid(51973c32-cb0c-11d0-b5c9-00a0244a0e7a),
pointer_default(unique),
local
]
interface IDebugApplication32 : IRemoteDebugApplication
{
HRESULT SetName(
[in] LPCOLESTR pstrName);
HRESULT StepOutComplete();
HRESULT DebugOutput(
[in] LPCOLESTR pstr);
HRESULT StartDebugSession();
HRESULT HandleBreakPoint(
[in] BREAKREASON br,
[out] BREAKRESUMEACTION *pbra);
HRESULT Close();
HRESULT GetBreakFlags(
[out] APPBREAKFLAGS *pabf,
[out] IRemoteDebugApplicationThread **pprdatSteppingThread);
cpp_quote("#undef GetCurrentThread")
HRESULT GetCurrentThread(
[out] IDebugApplicationThread **pat);
HRESULT CreateAsyncDebugOperation(
[in] IDebugSyncOperation *psdo,
[out] IDebugAsyncOperation **ppado);
HRESULT AddStackFrameSniffer(
[in] IDebugStackFrameSniffer *pdsfs,
[out] DWORD *pdwCookie);
HRESULT RemoveStackFrameSniffer(
[in] DWORD dwCookie);
HRESULT QueryCurrentThreadIsDebuggerThread();
HRESULT SynchronousCallInDebuggerThread(
[in] IDebugThreadCall32 *pptc,
[in] DWORD dwParam1,
[in] DWORD dwParam2,
[in] DWORD dwParam3);
HRESULT CreateApplicationNode(
[out] IDebugApplicationNode **ppdanNew);
HRESULT FireDebuggerEvent(
[in] REFGUID riid,
[in] IUnknown *punk);
HRESULT HandleRuntimeError(
[in] IActiveScriptErrorDebug *pErrorDebug,
[in] IActiveScriptSite *pScriptSite,
[out] BREAKRESUMEACTION *pbra,
[out] ERRORRESUMEACTION *perra,
[out] BOOL *pfCallOnScriptError);
BOOL FCanJitDebug();
BOOL FIsAutoJitDebugEnabled();
HRESULT AddGlobalExpressionContextProvider(
[in] IProvideExpressionContexts *pdsfs,
[out] DWORD *pdwCookie);
HRESULT RemoveGlobalExpressionContextProvider(
[in] DWORD dwCookie);
}
/************************************************************
* interface IDebugApplication64
*/
[
object,
uuid(4dedc754-04c7-4f10-9e60-16a390fe6e62),
pointer_default(unique),
local
]
interface IDebugApplication64 : IRemoteDebugApplication
{
HRESULT SetName(
[in] LPCOLESTR pstrName);
HRESULT StepOutComplete();
HRESULT DebugOutput(
[in] LPCOLESTR pstr);
HRESULT StartDebugSession();
HRESULT HandleBreakPoint(
[in] BREAKREASON br,
[out] BREAKRESUMEACTION *pbra);
HRESULT Close();
HRESULT GetBreakFlags(
[out] APPBREAKFLAGS *pabf,
[out] IRemoteDebugApplicationThread **pprdatSteppingThread);
HRESULT GetCurrentThread(
[out] IDebugApplicationThread **pat);
HRESULT CreateAsyncDebugOperation(
[in] IDebugSyncOperation *psdo,
[out] IDebugAsyncOperation **ppado);
HRESULT AddStackFrameSniffer(
[in] IDebugStackFrameSniffer *pdsfs,
[out] DWORD *pdwCookie);
HRESULT RemoveStackFrameSniffer(
[in] DWORD dwCookie);
HRESULT QueryCurrentThreadIsDebuggerThread();
HRESULT SynchronousCallInDebuggerThread(
[in] IDebugThreadCall32 *pptc,
[in] DWORDLONG dwParam1,
[in] DWORDLONG dwParam2,
[in] DWORDLONG dwParam3);
HRESULT CreateApplicationNode(
[out] IDebugApplicationNode **ppdanNew);
HRESULT FireDebuggerEvent(
[in] REFGUID riid,
[in] IUnknown *punk);
HRESULT HandleRuntimeError(
[in] IActiveScriptErrorDebug *pErrorDebug,
[in] IActiveScriptSite *pScriptSite,
[out] BREAKRESUMEACTION *pbra,
[out] ERRORRESUMEACTION *perra,
[out] BOOL *pfCallOnScriptError);
BOOL FCanJitDebug();
BOOL FIsAutoJitDebugEnabled();
HRESULT AddGlobalExpressionContextProvider(
[in] IProvideExpressionContexts *pdsfs,
[out] DWORDLONG *pdwCookie);
HRESULT RemoveGlobalExpressionContextProvider(
[in] DWORDLONG dwCookie);
}
/************************************************************
* interface IActiveScriptSiteDebug32
*/
[
object,
uuid(51973c11-cb0c-11d0-b5c9-00a0244a0e7a),
pointer_default(unique),
local
]
interface IActiveScriptSiteDebug32 : IUnknown
{
HRESULT GetDocumentContextFromPosition(
[in] DWORD dwSourceContext,
[in] ULONG uCharacterOffset,
[in] ULONG uNumChars,
[out] IDebugDocumentContext **ppsc);
HRESULT GetApplication(
[out] IDebugApplication32 **ppda);
HRESULT GetRootApplicationNode(
[out] IDebugApplicationNode **ppdanRoot);
HRESULT OnScriptErrorDebug(
[in] IActiveScriptErrorDebug *pErrorDebug,
[out] BOOL *pfEnterDebugger,
[out] BOOL *pfCallOnScriptErrorWhenContinuing);
}
/************************************************************
* interface IActiveScriptSiteDebug64
*/
[
object,
uuid(d6b96b0a-7463-402c-92ac-89984226942f),
pointer_default(unique),
local
]
interface IActiveScriptSiteDebug64 : IUnknown
{
HRESULT GetDocumentContextFromPosition(
[in] DWORDLONG dwSourceContext,
[in] ULONG uCharacterOffset,
[in] ULONG uNumChars,
[out] IDebugDocumentContext **ppsc);
HRESULT GetApplication(
[out] IDebugApplication64 **ppda);
HRESULT GetRootApplicationNode(
[out] IDebugApplicationNode **ppdanRoot);
HRESULT OnScriptErrorDebug(
[in] IActiveScriptErrorDebug *pErrorDebug,
[out] BOOL *pfEnterDebugger,
[out] BOOL *pfCallOnScriptErrorWhenContinuing);
}
cpp_quote("#ifndef DISABLE_ACTIVDBG_INTERFACE_WRAPPERS")
cpp_quote("#ifdef _WIN64")
cpp_quote("#define IActiveScriptDebug IActiveScriptDebug64")
cpp_quote("#define IID_IActiveScriptDebug IID_IActiveScriptDebug64")
cpp_quote("#define IActiveScriptSiteDebug IActiveScriptSiteDebug64")
cpp_quote("#define IID_IActiveScriptSiteDebug IID_IActiveScriptSiteDebug64")
cpp_quote("#define IDebugApplication IDebugApplication64")
cpp_quote("#define IID_IDebugApplication IID_IDebugApplication64")
cpp_quote("#else")
cpp_quote("#define IActiveScriptDebug IActiveScriptDebug32")
cpp_quote("#define IID_IActiveScriptDebug IID_IActiveScriptDebug32")
cpp_quote("#define IActiveScriptSiteDebug IActiveScriptSiteDebug32")
cpp_quote("#define IID_IActiveScriptSiteDebug IID_IActiveScriptSiteDebug32")
cpp_quote("#define IDebugApplication IDebugApplication32")
cpp_quote("#define IID_IDebugApplication IID_IDebugApplication32")
cpp_quote("#endif")
cpp_quote("#endif")

21
assets/wine/include/wine/windows/activeds.h
View File

@@ -1,21 +0,0 @@
/*
* Copyright 2023 Vitaly Lipatov
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <iads.h>
#include <adshlp.h>
#include <adserr.h>

2229
assets/wine/include/wine/windows/activscp.h
View File

File diff suppressed because it is too large Load Diff

578
assets/wine/include/wine/windows/activscp.idl
View File

@@ -1,578 +0,0 @@
/*
* Copyright 2004 Kevin Koltzau
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef DO_NO_IMPORTS
import "ocidl.idl";
import "oleidl.idl";
import "oaidl.idl";
#endif
cpp_quote("#ifndef _NO_SCRIPT_GUIDS")
cpp_quote("DEFINE_GUID(CATID_ActiveScript, 0xf0b7a1a1,0x9847,0x11cf,0x8f,0x20,0x00,0x80,0x5f,0x2c,0xd0,0x64);")
cpp_quote("DEFINE_GUID(CATID_ActiveScriptParse, 0xf0b7a1a2,0x9847,0x11cf,0x8f,0x20,0x00,0x80,0x5f,0x2c,0xd0,0x64);")
cpp_quote("DEFINE_GUID(CATID_ActiveScriptEncode, 0xf0b7a1a3,0x9847,0x11cf,0x8f,0x20,0x00,0x80,0x5f,0x2c,0xd0,0x64);")
cpp_quote("#endif")
cpp_quote("#define SCRIPTPROP_NAME 0x00000000")
cpp_quote("#define SCRIPTPROP_MAJORVERSION 0x00000001")
cpp_quote("#define SCRIPTPROP_MINORVERSION 0x00000002")
cpp_quote("#define SCRIPTPROP_BUILDNUMBER 0x00000003")
cpp_quote("#define SCRIPTPROP_DELAYEDEVENTSINKING 0x00001000")
cpp_quote("#define SCRIPTPROP_CATCHEXCEPTION 0x00001001")
cpp_quote("#define SCRIPTPROP_CONVERSIONLCID 0x00001002")
cpp_quote("#define SCRIPTPROP_HOSTSTACKREQUIRED 0x00001003")
cpp_quote("#define SCRIPTPROP_DEBUGGER 0x00001100")
cpp_quote("#define SCRIPTPROP_JITDEBUG 0x00001101")
cpp_quote("#define SCRIPTPROP_INVOKEVERSIONING 0x00004000")
cpp_quote("#define SCRIPTPROP_HACK_FIBERSUPPORT 0x70000000")
cpp_quote("#define SCRIPTPROP_HACK_TRIDENTEVENTSINK 0x70000001")
cpp_quote("#define SCRIPTPROP_ABBREVIATE_GLOBALNAME_RESOLUTION 0x70000002")
typedef enum tagSCRIPTLANGUAGEVERSION {
SCRIPTLANGUAGEVERSION_DEFAULT = 0,
SCRIPTLANGUAGEVERSION_5_7 = 1,
SCRIPTLANGUAGEVERSION_5_8 = 2,
SCRIPTLANGUAGEVERSION_MAX = 255
} SCRIPTLANGUAGEVERSION;
typedef enum tagSCRIPTSTATE {
SCRIPTSTATE_UNINITIALIZED = 0,
SCRIPTSTATE_STARTED = 1,
SCRIPTSTATE_CONNECTED = 2,
SCRIPTSTATE_DISCONNECTED = 3,
SCRIPTSTATE_CLOSED = 4,
SCRIPTSTATE_INITIALIZED = 5
} SCRIPTSTATE;
typedef enum tagSCRIPTTHREADSTATE {
SCRIPTTHREADSTATE_NOTINSCRIPT = 0,
SCRIPTTHREADSTATE_RUNNING = 1
} SCRIPTTHREADSTATE;
typedef enum tagSCRIPTUICITEM {
SCRIPTUICITEM_INPUTBOX = 1,
SCRIPTUICITEM_MSGBOX = 2
} SCRIPTUICITEM;
typedef enum tagSCRIPTUICHANDLING {
SCRIPTUICHANDLING_ALLOW = 0,
SCRIPTUICHANDLING_NOUIERROR = 1,
SCRIPTUICHANDLING_NOUIDEFAULT = 2
} SCRIPTUICHANDLING;
typedef enum tagSCRIPTGCTYPE {
SCRIPTGCTYPE_NORMAL = 0,
SCRIPTGCTYPE_EXHAUSTIVE = 1
} SCRIPTGCTYPE;
typedef DWORD SCRIPTTHREADID;
cpp_quote("#define SCRIPTTHREADID_CURRENT ((SCRIPTTHREADID)-1)")
cpp_quote("#define SCRIPTTHREADID_BASE ((SCRIPTTHREADID)-2)")
cpp_quote("#define SCRIPTTHREADID_ALL ((SCRIPTTHREADID)-3)")
cpp_quote("#define SCRIPTITEM_ISVISIBLE 0x00000002")
cpp_quote("#define SCRIPTITEM_ISSOURCE 0x00000004")
cpp_quote("#define SCRIPTITEM_GLOBALMEMBERS 0x00000008")
cpp_quote("#define SCRIPTITEM_ISPERSISTENT 0x00000040")
cpp_quote("#define SCRIPTITEM_CODEONLY 0x00000200")
cpp_quote("#define SCRIPTITEM_NOCODE 0x00000400")
cpp_quote("#define SCRIPTITEM_ALL_FLAGS (SCRIPTITEM_ISSOURCE | \\")
cpp_quote(" SCRIPTITEM_ISVISIBLE | \\")
cpp_quote(" SCRIPTITEM_ISPERSISTENT | \\")
cpp_quote(" SCRIPTITEM_GLOBALMEMBERS | \\")
cpp_quote(" SCRIPTITEM_NOCODE | \\")
cpp_quote(" SCRIPTITEM_CODEONLY)")
cpp_quote("#define SCRIPTTYPELIB_ISCONTROL 0x00000010")
cpp_quote("#define SCRIPTTYPELIB_ISPERSISTENT 0x00000040")
cpp_quote("#define SCRIPTTYPELIB_ALL_FLAGS (SCRIPTTEXT_ISCONTROL | SCRIPTTYPELIB_ISPERSISTENT)")
cpp_quote("#define SCRIPTTEXT_DELAYEXECUTION 0x00000001")
cpp_quote("#define SCRIPTTEXT_ISVISIBLE 0x00000002")
cpp_quote("#define SCRIPTTEXT_ISEXPRESSION 0x00000020")
cpp_quote("#define SCRIPTTEXT_ISPERSISTENT 0x00000040")
cpp_quote("#define SCRIPTTEXT_HOSTMANAGESSOURCE 0x00000080")
cpp_quote("#define SCRIPTTEXT_ALL_FLAGS (SCRIPTTEXT_DELAYEXECUTION | \\")
cpp_quote(" SCRIPTTEXT_ISVISIBLE | \\")
cpp_quote(" SCRIPTTEXT_ISEXPRESSION | \\")
cpp_quote(" SCRIPTTEXT_ISPERSISTENT | \\")
cpp_quote(" SCRIPTTEXT_HOSTMANAGESSOURCE)")
cpp_quote("#define SCRIPTPROC_ISEXPRESSION 0x00000020")
cpp_quote("#define SCRIPTPROC_HOSTMANAGESSOURCE 0x00000080")
cpp_quote("#define SCRIPTPROC_IMPLICIT_THIS 0x00000100")
cpp_quote("#define SCRIPTPROC_IMPLICIT_PARENTS 0x00000200")
cpp_quote("#define SCRIPTPROC_ALL_FLAGS (SCRIPTPROC_ISEXPRESSION | \\")
cpp_quote(" SCRIPTPROC_HOSTMANAGESSOURCE | \\")
cpp_quote(" SCRIPTPROC_IMPLICIT_THIS | \\")
cpp_quote(" SCRIPTPROC_IMPLICIT_PARENTS)")
cpp_quote("#define SCRIPTINFO_IUNKNOWN 0x00000001")
cpp_quote("#define SCRIPTINFO_ITYPEINFO 0x00000002")
cpp_quote("#define SCRIPTINFO_ALL_FLAGS (SCRIPTINFO_IUNKNOWN | SCRIPTINFO_ITYPEINFO)")
cpp_quote("#define SCRIPTINTERRUPT_DEBUG 0x00000001")
cpp_quote("#define SCRIPTINTERRUPT_RAISEEXCEPTION 0x00000002")
cpp_quote("#define SCRIPTINTERRUPT_ALL_FLAGS (SCRIPTINTERRUPT_DEBUG | SCRIPTINTERRUPT_RAISEEXCEPTION)")
cpp_quote("#define SCRIPTSTAT_STATEMENT_COUNT 1")
cpp_quote("#define SCRIPTSTAT_INSTRUCTION_COUNT 2")
cpp_quote("#define SCRIPTSTAT_INTSTRUCTION_TIME 3")
cpp_quote("#define SCRIPTSTAT_TOTAL_TIME 4")
cpp_quote("#define SCRIPT_E_RECORDED 0x86664004")
cpp_quote("#define SCRIPT_E_REPORTED 0x80020101")
cpp_quote("#define SCRIPT_E_PROPAGATE 0x80020102")
[
object,
uuid(EAE1BA61-A4ED-11cf-8F20-00805F2CD064),
pointer_default(unique)
]
interface IActiveScriptError : IUnknown
{
HRESULT GetExceptionInfo(
[out] EXCEPINFO *pexcepinfo
);
HRESULT GetSourcePosition(
[out] DWORD *pdwSourceContext,
[out] ULONG *pulLineNumber,
[out] LONG *plCharacterPosition
);
HRESULT GetSourceLineText(
[out] BSTR *pbstrSourceLine
);
}
[
object,
uuid(DB01A1E3-A42B-11cf-8F20-00805F2CD064),
pointer_default(unique)
]
interface IActiveScriptSite : IUnknown
{
HRESULT GetLCID(
[out] LCID *plcid);
HRESULT GetItemInfo(
[in] LPCOLESTR pstrName,
[in] DWORD dwReturnMask,
[out] IUnknown **ppiunkItem,
[out] ITypeInfo **ppti
);
HRESULT GetDocVersionString(
[out] BSTR *pbstrVersion
);
HRESULT OnScriptTerminate(
[in] const VARIANT *pvarResult,
[in] const EXCEPINFO *pexcepinfo
);
HRESULT OnStateChange(
[in] SCRIPTSTATE ssScriptState
);
HRESULT OnScriptError(
[in] IActiveScriptError *pscripterror
);
HRESULT OnEnterScript(void);
HRESULT OnLeaveScript(void);
}
cpp_quote("typedef IActiveScriptSite *PIActiveScriptSite;")
[
object,
uuid(D10F6761-83E9-11cf-8F20-00805F2CD064),
pointer_default(unique)
]
interface IActiveScriptSiteWindow : IUnknown
{
HRESULT GetWindow(
[out] HWND *phwnd
);
HRESULT EnableModeless(
[in] BOOL fEnable
);
}
[
object,
uuid(aedae97e-d7ee-4796-b960-7f092ae844ab),
pointer_default(unique)
]
interface IActiveScriptSiteUIControl : IUnknown
{
HRESULT GetUIBehavior(
[in] SCRIPTUICITEM UicItem,
[out] SCRIPTUICHANDLING *pUicHandling);
}
[
object,
uuid(539698A0-CDCA-11CF-A5EB-00AA0047A063),
pointer_default(unique)
]
interface IActiveScriptSiteInterruptPoll : IUnknown
{
HRESULT QueryContinue();
}
[
object,
uuid(BB1A2AE1-A4F9-11cf-8F20-00805F2CD064),
pointer_default(unique)
]
interface IActiveScript : IUnknown
{
HRESULT SetScriptSite(
[in] IActiveScriptSite *pass
);
HRESULT GetScriptSite(
[in] REFIID riid,
[out, iid_is(riid)] void **ppvObject
);
HRESULT SetScriptState(
[in] SCRIPTSTATE ss
);
HRESULT GetScriptState(
[out] SCRIPTSTATE *pssState
);
HRESULT Close(void);
HRESULT AddNamedItem(
[in] LPCOLESTR pstrName,
[in] DWORD dwFlags
);
HRESULT AddTypeLib(
[in] REFGUID rguidTypeLib,
[in] DWORD dwMajor,
[in] DWORD dwMinor,
[in] DWORD dwFlags
);
HRESULT GetScriptDispatch(
[in] LPCOLESTR pstrItemName,
[out] IDispatch **ppdisp
);
HRESULT GetCurrentScriptThreadID(
[out] SCRIPTTHREADID *pstidThread
);
HRESULT GetScriptThreadID(
[in] DWORD dwWin32ThreadId,
[out] SCRIPTTHREADID *pstidThread
);
HRESULT GetScriptThreadState(
[in] SCRIPTTHREADID stidThread,
[out] SCRIPTTHREADSTATE *pstsState
);
HRESULT InterruptScriptThread(
[in] SCRIPTTHREADID stidThread,
[in] const EXCEPINFO *pexcepinfo,
[in] DWORD dwFlags
);
HRESULT Clone(
[out] IActiveScript **ppscript
);
}
cpp_quote("typedef IActiveScript *PIActiveScript;")
[
object,
uuid(BB1A2AE2-A4F9-11cf-8F20-00805F2CD064),
pointer_default(unique)
]
interface IActiveScriptParse32 : IUnknown
{
HRESULT InitNew(void);
HRESULT AddScriptlet(
[in] LPCOLESTR pstrDefaultName,
[in] LPCOLESTR pstrCode,
[in] LPCOLESTR pstrItemName,
[in] LPCOLESTR pstrSubItemName,
[in] LPCOLESTR pstrEventName,
[in] LPCOLESTR pstrDelimiter,
[in] DWORD dwSourceContextCookie,
[in] ULONG ulStartingLineNumber,
[in] DWORD dwFlags,
[out] BSTR *pbstrName,
[out] EXCEPINFO *pexcepinfo
);
HRESULT ParseScriptText(
[in] LPCOLESTR pstrCode,
[in] LPCOLESTR pstrItemName,
[in] IUnknown *punkContext,
[in] LPCOLESTR pstrDelimiter,
[in] DWORD dwSourceContextCookie,
[in] ULONG ulStartingLineNumber,
[in] DWORD dwFlags,
[out] VARIANT *pvarResult,
[out] EXCEPINFO *pexcepinfo
);
}
[
object,
uuid(c7ef7658-e1ee-480e-97ea-d52cb4d76d17),
pointer_default(unique)
]
interface IActiveScriptParse64 : IUnknown
{
HRESULT InitNew(void);
HRESULT AddScriptlet(
[in] LPCOLESTR pstrDefaultName,
[in] LPCOLESTR pstrCode,
[in] LPCOLESTR pstrItemName,
[in] LPCOLESTR pstrSubItemName,
[in] LPCOLESTR pstrEventName,
[in] LPCOLESTR pstrDelimiter,
[in] DWORDLONG dwSourceContextCookie,
[in] ULONG ulStartingLineNumber,
[in] DWORD dwFlags,
[out] BSTR *pbstrName,
[out] EXCEPINFO *pexcepinfo
);
HRESULT ParseScriptText(
[in] LPCOLESTR pstrCode,
[in] LPCOLESTR pstrItemName,
[in] IUnknown *punkContext,
[in] LPCOLESTR pstrDelimiter,
[in] DWORDLONG dwSourceContextCookie,
[in] ULONG ulStartingLineNumber,
[in] DWORD dwFlags,
[out] VARIANT *pvarResult,
[out] EXCEPINFO *pexcepinfo
);
}
cpp_quote("#ifdef _WIN64")
cpp_quote("#define IActiveScriptParse IActiveScriptParse64")
cpp_quote("#define IID_IActiveScriptParse IID_IActiveScriptParse64")
cpp_quote("#else")
cpp_quote("#define IActiveScriptParse IActiveScriptParse32")
cpp_quote("#define IID_IActiveScriptParse IID_IActiveScriptParse32")
cpp_quote("#endif")
cpp_quote("typedef IActiveScriptParse *PIActiveScriptParse;")
[
object,
uuid(1CFF0050-6FDD-11d0-9328-00A0C90DCAA9),
pointer_default(unique)
]
interface IActiveScriptParseProcedureOld32 : IUnknown
{
HRESULT ParseProcedureText(
[in] LPCOLESTR pstrCode,
[in] LPCOLESTR pstrFormalParams,
[in] LPCOLESTR pstrItemName,
[in] IUnknown *punkContext,
[in] LPCOLESTR pstrDelimiter,
[in] DWORD dwSourceContextCookie,
[in] ULONG ulStartingLineNumber,
[in] DWORD dwFlags,
[out] IDispatch **ppdisp
);
}
[
object,
uuid(21f57128-08c9-4638-ba12-22d15d88dc5c),
pointer_default(unique)
]
interface IActiveScriptParseProcedureOld64 : IUnknown
{
HRESULT ParseProcedureText(
[in] LPCOLESTR pstrCode,
[in] LPCOLESTR pstrFormalParams,
[in] LPCOLESTR pstrItemName,
[in] IUnknown *punkContext,
[in] LPCOLESTR pstrDelimiter,
[in] DWORDLONG dwSourceContextCookie,
[in] ULONG ulStartingLineNumber,
[in] DWORD dwFlags,
[out] IDispatch **ppdisp
);
}
cpp_quote("#ifdef _WIN64")
cpp_quote("#define IActiveScriptParseProcedureOld IActiveScriptParseProcedureOld64")
cpp_quote("#define IID_IActiveScriptParseProcedureOld IID_IActiveScriptParseProcedureOld64")
cpp_quote("#else")
cpp_quote("#define IActiveScriptParseProcedureOld IActiveScriptParseProcedureOld32")
cpp_quote("#define IID_IActiveScriptParseProcedureOld IID_IActiveScriptParseProcedureOld32")
cpp_quote("#endif")
[
object,
uuid(AA5B6A80-B834-11d0-932F-00A0C90DCAA9),
pointer_default(unique)
]
interface IActiveScriptParseProcedure32 : IUnknown
{
HRESULT ParseProcedureText(
[in] LPCOLESTR pstrCode,
[in] LPCOLESTR pstrFormalParams,
[in] LPCOLESTR pstrProcedureName,
[in] LPCOLESTR pstrItemName,
[in] IUnknown *punkContext,
[in] LPCOLESTR pstrDelimiter,
[in] DWORD dwSourceContextCookie,
[in] ULONG ulStartingLineNumber,
[in] DWORD dwFlags,
[out] IDispatch **ppdisp
);
}
[
object,
uuid(c64713b6-e029-4cc5-9200-438b72890b6a),
pointer_default(unique)
]
interface IActiveScriptParseProcedure64 : IUnknown
{
HRESULT ParseProcedureText(
[in] LPCOLESTR pstrCode,
[in] LPCOLESTR pstrFormalParams,
[in] LPCOLESTR pstrProcedureName,
[in] LPCOLESTR pstrItemName,
[in] IUnknown *punkContext,
[in] LPCOLESTR pstrDelimiter,
[in] DWORDLONG dwSourceContextCookie,
[in] ULONG ulStartingLineNumber,
[in] DWORD dwFlags,
[out] IDispatch **ppdisp
);
}
cpp_quote("#ifdef _WIN64")
cpp_quote("#define IActiveScriptParseProcedure IActiveScriptParseProcedure64")
cpp_quote("#define IID_IActiveScriptParseProcedure IID_IActiveScriptParseProcedure64")
cpp_quote("#else")
cpp_quote("#define IActiveScriptParseProcedure IActiveScriptParseProcedure32")
cpp_quote("#define IID_IActiveScriptParseProcedure IID_IActiveScriptParseProcedure32")
cpp_quote("#endif")
[
object,
uuid(71ee5b20-fb04-11d1-b3a8-00a0c911e8b2),
pointer_default(unique)
]
interface IActiveScriptParseProcedure2_32 : IActiveScriptParseProcedure32
{
}
[
object,
uuid(fe7c4271-210c-448d-9f54-76dab7047b28),
pointer_default(unique)
]
interface IActiveScriptParseProcedure2_64 : IActiveScriptParseProcedure64
{
}
cpp_quote("#ifdef _WIN64")
cpp_quote("#define IActiveScriptParseProcedure2 IActiveScriptParseProcedure2_64")
cpp_quote("#define IID_IActiveScriptParseProcedure2 IID_IActiveScriptParseProcedure2_64")
cpp_quote("#else")
cpp_quote("#define IActiveScriptParseProcedure2 IActiveScriptParseProcedure2_32")
cpp_quote("#define IID_IActiveScriptParseProcedure2 IID_IActiveScriptParseProcedure2_32")
cpp_quote("#endif")
[
object,
uuid(63CDBCB0-C1B1-11d0-9336-00A0C90DCAA9),
pointer_default(unique)
]
interface IBindEventHandler : IUnknown
{
HRESULT BindHandler(
[in] LPCOLESTR pstrEvent,
[in] IDispatch *pdisp
);
}
[
object,
uuid(B8DA6310-E19B-11d0-933C-00A0C90DCAA9),
pointer_default(unique)
]
interface IActiveScriptStats : IUnknown
{
HRESULT GetStat(
[in] DWORD stid,
[out] ULONG *pluHi,
[out] ULONG *pluLo
);
HRESULT GetStatEx(
[in] REFGUID guid,
[out] ULONG *pluHi,
[out] ULONG *pluLo
);
HRESULT ResetStats(void);
}
[
object,
uuid(4954e0d0-fbc7-11d1-8410-006008c3fbfc),
pointer_default(unique)
]
interface IActiveScriptProperty : IUnknown
{
HRESULT GetProperty(
[in] DWORD dwProperty,
[in] VARIANT *pvarIndex,
[out] VARIANT *pvarValue);
HRESULT SetProperty(
[in] DWORD dwProperty,
[in] VARIANT *pvarIndex,
[in] VARIANT *pvarValue);
}
[
object,
uuid(6aa2c4a0-2b53-11d4-a2a0-00104bd35090),
pointer_default(unique)
]
interface IActiveScriptGarbageCollector : IUnknown
{
HRESULT CollectGarbage(
[in] SCRIPTGCTYPE gctype);
}

50
assets/wine/include/wine/windows/adserr.h
View File

@@ -1,50 +0,0 @@
/*
* Copyright (C) 2019 Dmitry Timoshkov
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __ADSERR_H
#define __ADSERR_H
#ifdef RC_INVOKED
#define _HRESULT_TYPEDEF_(x) (x)
#else
#define _HRESULT_TYPEDEF_(x) ((HRESULT)x)
#endif
#define E_ADS_BAD_PATHNAME _HRESULT_TYPEDEF_(0x80005000)
#define E_ADS_INVALID_DOMAIN_OBJECT _HRESULT_TYPEDEF_(0x80005001)
#define E_ADS_INVALID_USER_OBJECT _HRESULT_TYPEDEF_(0x80005002)
#define E_ADS_INVALID_COMPUTER_OBJECT _HRESULT_TYPEDEF_(0x80005003)
#define E_ADS_UNKNOWN_OBJECT _HRESULT_TYPEDEF_(0x80005004)
#define E_ADS_PROPERTY_NOT_SET _HRESULT_TYPEDEF_(0x80005005)
#define E_ADS_PROPERTY_NOT_SUPPORTED _HRESULT_TYPEDEF_(0x80005006)
#define E_ADS_PROPERTY_INVALID _HRESULT_TYPEDEF_(0x80005007)
#define E_ADS_BAD_PARAMETER _HRESULT_TYPEDEF_(0x80005008)
#define E_ADS_OBJECT_UNBOUND _HRESULT_TYPEDEF_(0x80005009)
#define E_ADS_PROPERTY_NOT_MODIFIED _HRESULT_TYPEDEF_(0x8000500A)
#define E_ADS_PROPERTY_MODIFIED _HRESULT_TYPEDEF_(0x8000500B)
#define E_ADS_CANT_CONVERT_DATATYPE _HRESULT_TYPEDEF_(0x8000500C)
#define E_ADS_PROPERTY_NOT_FOUND _HRESULT_TYPEDEF_(0x8000500D)
#define E_ADS_OBJECT_EXISTS _HRESULT_TYPEDEF_(0x8000500E)
#define E_ADS_SCHEMA_VIOLATION _HRESULT_TYPEDEF_(0x8000500F)
#define E_ADS_COLUMN_NOT_SET _HRESULT_TYPEDEF_(0x80005010)
#define S_ADS_ERRORSOCCURRED _HRESULT_TYPEDEF_(0x00005011)
#define S_ADS_NOMORE_ROWS _HRESULT_TYPEDEF_(0x00005012)
#define S_ADS_NOMORE_COLUMNS _HRESULT_TYPEDEF_(0x00005013)
#define E_ADS_INVALID_FILTER _HRESULT_TYPEDEF_(0x80005014)
#endif /* __ADSERR_H */

43
assets/wine/include/wine/windows/adshlp.h
View File

@@ -1,43 +0,0 @@
/*
* Copyright (C) 2005 Francois Gouget
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_ADSHLP_H
#define __WINE_ADSHLP_H
#ifdef __cplusplus
extern "C" {
#endif
BOOL WINAPI FreeADsMem(void*);
void* WINAPI AllocADsMem(DWORD) __WINE_ALLOC_SIZE(1) __WINE_DEALLOC(FreeADsMem) __WINE_MALLOC;
void* WINAPI ReallocADsMem(void*,DWORD,DWORD) __WINE_ALLOC_SIZE(3) __WINE_DEALLOC(FreeADsMem);
BOOL WINAPI FreeADsStr(WCHAR*);
WCHAR* WINAPI AllocADsStr(WCHAR*) __WINE_DEALLOC(FreeADsStr) __WINE_MALLOC;
HRESULT WINAPI ADsBuildEnumerator(IADsContainer*,IEnumVARIANT**);
HRESULT WINAPI ADsBuildVarArrayStr(LPWSTR*,DWORD,VARIANT*);
HRESULT WINAPI ADsBuildVarArrayInt(LPDWORD,DWORD,VARIANT*);
HRESULT WINAPI ADsEnumerateNext(IEnumVARIANT*,ULONG,VARIANT*,ULONG*);
HRESULT WINAPI ADsGetObject(LPCWSTR,REFIID,VOID**);
HRESULT WINAPI ADsOpenObject(LPCWSTR,LPCWSTR,LPCWSTR,DWORD,REFIID,VOID**);
#ifdef __cplusplus
}
#endif
#endif

284
assets/wine/include/wine/windows/advpub.h
View File

@@ -1,284 +0,0 @@
/*
* Copyright 2004 Huw D M Davies
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_ADVPUB_H
#define __WINE_ADVPUB_H
#include <setupapi.h>
#include <cfgmgr32.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifndef S_ASYNCHRONOUS
#define S_ASYNCHRONOUS _HRESULT_TYPEDEF_(0x401E8)
#endif
typedef struct _CabInfoA
{
LPSTR pszCab;
LPSTR pszInf;
LPSTR pszSection;
CHAR szSrcPath[MAX_PATH];
DWORD dwFlags;
} CABINFOA, *PCABINFOA;
typedef struct _CabInfoW
{
LPWSTR pszCab;
LPWSTR pszInf;
LPWSTR pszSection;
WCHAR szSrcPath[MAX_PATH];
DWORD dwFlags;
} CABINFOW, *PCABINFOW;
DECL_WINELIB_TYPE_AW(CABINFO)
DECL_WINELIB_TYPE_AW(PCABINFO)
typedef struct _PERUSERSECTIONA
{
CHAR szGUID[39 /*MAX_GUID_STRING_LEN*/ + 20];
CHAR szDispName[128];
CHAR szLocale[10];
CHAR szStub[MAX_PATH * 4];
CHAR szVersion[32];
CHAR szCompID[128];
DWORD dwIsInstalled;
BOOL bRollback;
} PERUSERSECTIONA, *PPERUSERSECTIONA;
typedef struct _PERUSERSECTIONW
{
WCHAR szGUID[39 /*MAX_GUID_STRING_LEN*/ + 20];
WCHAR szDispName[128];
WCHAR szLocale[10];
WCHAR szStub[MAX_PATH * 4];
WCHAR szVersion[32];
WCHAR szCompID[128];
DWORD dwIsInstalled;
BOOL bRollback;
} PERUSERSECTIONW, *PPERUSERSECTIONW;
DECL_WINELIB_TYPE_AW(PERUSERSECTION)
DECL_WINELIB_TYPE_AW(PPERUSERSECTION)
typedef struct _StrEntryA
{
LPSTR pszName;
LPSTR pszValue;
} STRENTRYA, *LPSTRENTRYA;
typedef struct _StrEntryW
{
LPWSTR pszName;
LPWSTR pszValue;
} STRENTRYW, *LPSTRENTRYW;
DECL_WINELIB_TYPE_AW(STRENTRY)
DECL_WINELIB_TYPE_AW(LPSTRENTRY)
typedef struct _StrTableA
{
DWORD cEntries;
STRENTRYA* pse;
} STRTABLEA, *LPSTRTABLEA;
typedef const STRTABLEA CSTRTABLEA, *LPCSTRTABLEA;
typedef struct _StrTableW
{
DWORD cEntries;
STRENTRYW* pse;
} STRTABLEW, *LPSTRTABLEW;
typedef const STRTABLEW CSTRTABLEW, *LPCSTRTABLEW;
DECL_WINELIB_TYPE_AW(STRTABLE)
DECL_WINELIB_TYPE_AW(CSTRTABLE)
DECL_WINELIB_TYPE_AW(LPSTRTABLE)
DECL_WINELIB_TYPE_AW(LPCSTRTABLE)
/* Flags for AddDelBackupEntry */
#define AADBE_ADD_ENTRY 0x01
#define AADBE_DEL_ENTRY 0x02
/* Flags for AdvInstallFile */
#define AIF_WARNIFSKIP 0x00000001
#define AIF_NOSKIP 0x00000002
#define AIF_NOVERSIONCHECK 0x00000004
#define AIF_FORCE_FILE_IN_USE 0x00000008
#define AIF_NOOVERWRITE 0x00000010
#define AIF_NO_VERSION_DIALOG 0x00000020
#define AIF_REPLACEONLY 0x00000400
#define AIF_NOLANGUAGECHECK 0x10000000
#define AIF_QUIET 0x20000000
/* Flags for RunSetupCommand */
#define RSC_FLAG_INF 0x00000001
#define RSC_FLAG_SKIPDISKSPACECHECK 0x00000002
#define RSC_FLAG_QUIET 0x00000004
#define RSC_FLAG_NGCONV 0x00000008
#define RSC_FLAG_UPDHLPDLLS 0x00000010
#define RSC_FLAG_DELAYREGISTEROCX 0x00000200
#define RSC_FLAG_SETUPAPI 0x00000400
/* Flags for LaunchINFSection */
#define LIS_QUIET 0x00000001
#define LIS_NOGRPCONV 0x00000002
/* Flags for DelNode */
#define ADN_DEL_IF_EMPTY 0x00000001
#define ADN_DONT_DEL_SUBDIRS 0x00000002
#define ADN_DONT_DEL_DIR 0x00000004
#define ADN_DEL_UNC_PATHS 0x00000008
/* Flags for RegRestoreAll, RegSaveRestore, RegSaveRestoreOnINF */
#define IE4_RESTORE 0x00000001
#define IE4_BACKNEW 0x00000002
#define IE4_NODELETENEW 0x00000004
#define IE4_NOMESSAGES 0x00000008
#define IE4_NOPROGRESS 0x00000010
#define IE4_NOENUMKEY 0x00000020
#define IE4_NO_CRC_MAPPING 0x00000040
#define IE4_REGSECTION 0x00000080
#define IE4_FRDOALL 0x00000100
#define IE4_UPDREFCNT 0x00000200
#define IE4_USEREFCNT 0x00000400
#define IE4_EXTRAINCREFCNT 0x00000800
/* Flags for file save and restore functions */
#define AFSR_RESTORE IE4_RESTORE
#define AFSR_BACKNEW IE4_BACKNEW
#define AFSR_NODELETENEW IE4_NODELETENEW
#define AFSR_NOMESSAGES IE4_NOMESSAGES
#define AFSR_NOPROGRESS IE4_NOPROGRESS
#define AFSR_UPDREFCNT IE4_UPDREFCNT
#define AFSR_USEREFCNT IE4_USEREFCNT
#define AFSR_EXTRAINCREFCNT IE4_EXTRAINCREFCNT
HRESULT WINAPI AddDelBackupEntryA(LPCSTR lpcszFileList, LPCSTR lpcszBackupDir,
LPCSTR lpcszBaseName, DWORD dwFlags);
HRESULT WINAPI AddDelBackupEntryW(LPCWSTR lpcszFileList, LPCWSTR lpcszBackupDir,
LPCWSTR lpcszBaseName, DWORD dwFlags);
#define AddDelBackupEntry WINELIB_NAME_AW(AddDelBackupEntry)
HRESULT WINAPI AdvInstallFileA(HWND hwnd, LPCSTR lpszSourceDir,
LPCSTR lpszSourceFile, LPCSTR lpszDestDir, LPCSTR lpszDestFile,
DWORD dwFlags, DWORD dwReserved);
HRESULT WINAPI AdvInstallFileW(HWND hwnd, LPCWSTR lpszSourceDir,
LPCWSTR lpszSourceFile, LPCWSTR lpszDestDir, LPCWSTR lpszDestFile,
DWORD dwFlags, DWORD dwReserved);
#define AdvInstallFile WINELIB_NAME_AW(AdvInstallFile)
HRESULT WINAPI CloseINFEngine(HINF hInf);
HRESULT WINAPI DelNodeA(LPCSTR pszFileOrDirName, DWORD dwFlags);
HRESULT WINAPI DelNodeW(LPCWSTR pszFileOrDirName, DWORD dwFlags);
#define DelNode WINELIB_NAME_AW(DelNode)
HRESULT WINAPI DelNodeRunDLL32A(HWND,HINSTANCE,LPSTR,INT);
HRESULT WINAPI DelNodeRunDLL32W(HWND,HINSTANCE,LPWSTR,INT);
#define DelNodeRunDLL32 WINELIB_NAME_AW(DelNodeRunDLL32)
HRESULT WINAPI ExecuteCabA( HWND hwnd, CABINFOA* pCab, LPVOID pReserved );
HRESULT WINAPI ExecuteCabW( HWND hwnd, CABINFOW* pCab, LPVOID pReserved );
#define ExecuteCab WINELIB_NAME_AW(ExecuteCab)
HRESULT WINAPI ExtractFilesA(LPCSTR,LPCSTR,DWORD,LPCSTR,LPVOID,DWORD);
HRESULT WINAPI ExtractFilesW(LPCWSTR,LPCWSTR,DWORD,LPCWSTR,LPVOID,DWORD);
#define ExtractFiles WINELIB_NAME_AW(ExtractFiles)
HRESULT WINAPI FileSaveMarkNotExistA(LPSTR pszFileList, LPSTR pszDir, LPSTR pszBaseName);
HRESULT WINAPI FileSaveMarkNotExistW(LPWSTR pszFileList, LPWSTR pszDir, LPWSTR pszBaseName);
#define FileSaveMarkNotExist WINELIB_NAME_AW(FileSaveMarkNotExist)
HRESULT WINAPI FileSaveRestoreA(HWND hDlg, LPSTR pszFileList, LPSTR pszDir,
LPSTR pszBaseName, DWORD dwFlags);
HRESULT WINAPI FileSaveRestoreW(HWND hDlg, LPWSTR pszFileList, LPWSTR pszDir,
LPWSTR pszBaseName, DWORD dwFlags);
#define FileSaveRestore WINELIB_NAME_AW(FileSaveRestore)
HRESULT WINAPI FileSaveRestoreOnINFA(HWND hWnd, LPCSTR pszTitle, LPCSTR pszINF,
LPCSTR pszSection, LPCSTR pszBackupDir, LPCSTR pszBaseBackupFile, DWORD dwFlags);
HRESULT WINAPI FileSaveRestoreOnINFW(HWND hWnd, LPCWSTR pszTitle, LPCWSTR pszINF,
LPCWSTR pszSection, LPCWSTR pszBackupDir, LPCWSTR pszBaseBackupFile, DWORD dwFlags);
#define FileSaveRestoreOnINF WINELIB_NAME_AW(FileSaveRestoreOnINF)
HRESULT WINAPI GetVersionFromFileA(LPCSTR lpszFilename, LPDWORD pdwMSVer, LPDWORD pdwLSVer, BOOL bVersion);
HRESULT WINAPI GetVersionFromFileW(LPCWSTR lpszFilename, LPDWORD pdwMSVer, LPDWORD pdwLSVer, BOOL bVersion);
#define GetVersionFromFile WINELIB_NAME_AW(GetVersionFromFile)
HRESULT WINAPI GetVersionFromFileExA(LPCSTR lpszFilename, LPDWORD pdwMSVer, LPDWORD pdwLSVer, BOOL bVersion);
HRESULT WINAPI GetVersionFromFileExW(LPCWSTR lpszFilename, LPDWORD pdwMSVer, LPDWORD pdwLSVer, BOOL bVersion);
#define GetVersionFromFileEx WINELIB_NAME_AW(GetVersionFromFileEx)
BOOL WINAPI IsNTAdmin(DWORD,LPDWORD);
INT WINAPI LaunchINFSectionA(HWND,HINSTANCE,LPSTR,INT);
INT WINAPI LaunchINFSectionW(HWND,HINSTANCE,LPWSTR,INT);
#define LaunchINFSection WINELIB_NAME_AW(LaunchINFSection)
HRESULT WINAPI LaunchINFSectionExA(HWND,HINSTANCE,LPSTR,INT);
HRESULT WINAPI LaunchINFSectionExW(HWND,HINSTANCE,LPWSTR,INT);
#define LaunchINFSectionEx WINELIB_NAME_AW(LaunchINFSectionEx)
DWORD WINAPI NeedRebootInit(VOID);
BOOL WINAPI NeedReboot(DWORD dwRebootCheck);
HRESULT WINAPI OpenINFEngineA(LPCSTR pszInfFilename, LPCSTR pszInstallSection,
DWORD dwFlags, HINF *phInf, PVOID pvReserved);
HRESULT WINAPI OpenINFEngineW(LPCWSTR pszInfFilename, LPCWSTR pszInstallSection,
DWORD dwFlags, HINF *phInf, PVOID pvReserved);
#define OpenINFEngine WINELIB_NAME_AW(OpenINFEngine)
HRESULT WINAPI RebootCheckOnInstallA(HWND hWnd, LPCSTR pszINF, LPCSTR pszSec, DWORD dwReserved);
HRESULT WINAPI RebootCheckOnInstallW(HWND hWnd, LPCWSTR pszINF, LPCWSTR pszSec, DWORD dwReserved);
#define RebootCheckOnInstall WINELIB_NAME_AW(RebootCheckOnInstall)
HRESULT WINAPI RegInstallA(HMODULE hm, LPCSTR pszSection, const STRTABLEA* pstTable);
HRESULT WINAPI RegInstallW(HMODULE hm, LPCWSTR pszSection, const STRTABLEW* pstTable);
#define RegInstall WINELIB_NAME_AW(RegInstall)
HRESULT WINAPI RegRestoreAllA(HWND hWnd, LPSTR pszTitleString, HKEY hkBackupKey);
HRESULT WINAPI RegRestoreAllW(HWND hWnd, LPWSTR pszTitleString, HKEY hkBackupKey);
#define RegRestoreAll WINELIB_NAME_AW(RegRestoreAll)
HRESULT WINAPI RegSaveRestoreA(HWND hWnd, LPCSTR pszTitleString, HKEY hkBackupKey,
LPCSTR pcszRootKey, LPCSTR pcszSubKey, LPCSTR pcszValueName, DWORD dwFlags);
HRESULT WINAPI RegSaveRestoreW(HWND hWnd, LPCWSTR pszTitleString, HKEY hkBackupKey,
LPCWSTR pcszRootKey, LPCWSTR pcszSubKey, LPCWSTR pcszValueName, DWORD dwFlags);
#define RegSaveRestore WINELIB_NAME_AW(RegSaveRestore)
HRESULT WINAPI RegSaveRestoreOnINFA(HWND hWnd, LPCSTR pszTitle, LPCSTR pszINF,
LPCSTR pszSection, HKEY hHKLMBackKey, HKEY hHKCUBackKey, DWORD dwFlags);
HRESULT WINAPI RegSaveRestoreOnINFW(HWND hWnd, LPCWSTR pszTitle, LPCWSTR pszINF,
LPCWSTR pszSection, HKEY hHKLMBackKey, HKEY hHKCUBackKey, DWORD dwFlags);
#define RegSaveRestoreOnINF WINELIB_NAME_AW(RegSaveRestoreOnINF)
HRESULT WINAPI RunSetupCommandA(HWND hWnd,
LPCSTR szCmdName, LPCSTR szInfSection, LPCSTR szDir, LPCSTR lpszTitle,
HANDLE *phEXE, DWORD dwFlags, LPVOID pvReserved);
HRESULT WINAPI RunSetupCommandW(HWND hWnd,
LPCWSTR szCmdName, LPCWSTR szInfSection, LPCWSTR szDir, LPCWSTR lpszTitle,
HANDLE *phEXE, DWORD dwFlags, LPVOID pvReserved);
#define RunSetupCommand WINELIB_NAME_AW(RunSetupCommand)
HRESULT WINAPI SetPerUserSecValuesA(PERUSERSECTIONA* pPerUser);
HRESULT WINAPI SetPerUserSecValuesW(PERUSERSECTIONW* pPerUser);
#define SetPerUserSecValues WINELIB_NAME_AW(SetPerUserSecValues)
HRESULT WINAPI TranslateInfStringA(LPCSTR pszInfFilename, LPCSTR pszInstallSection,
LPCSTR pszTranslateSection, LPCSTR pszTranslateKey, LPSTR pszBuffer,
DWORD dwBufferSize, PDWORD pdwRequiredSize, PVOID pvReserved);
HRESULT WINAPI TranslateInfStringW(LPCWSTR pszInfFilename, LPCWSTR pszInstallSection,
LPCWSTR pszTranslateSection, LPCWSTR pszTranslateKey, LPWSTR pszBuffer,
DWORD dwBufferSize, PDWORD pdwRequiredSize, PVOID pvReserved);
#define TranslateInfString WINELIB_NAME_AW(TranslateInfString)
HRESULT WINAPI TranslateInfStringExA(HINF hInf, LPCSTR pszInfFilename,
LPCSTR pszTranslateSection, LPCSTR pszTranslateKey, LPSTR pszBuffer,
DWORD dwBufferSize, PDWORD pdwRequiredSize, PVOID pvReserved);
HRESULT WINAPI TranslateInfStringExW(HINF hInf, LPCWSTR pszInfFilename,
LPCWSTR pszTranslateSection, LPCWSTR pszTranslateKey, LPWSTR pszBuffer,
DWORD dwBufferSize, PDWORD pdwRequiredSize, PVOID pvReserved);
#define TranslateInfStringEx WINELIB_NAME_AW(TranslateInfStringEx)
HRESULT WINAPI UserInstStubWrapperA(HWND hWnd, HINSTANCE hInstance, LPSTR pszParms, INT nShow);
HRESULT WINAPI UserInstStubWrapperW(HWND hWnd, HINSTANCE hInstance, LPWSTR pszParms, INT nShow);
#define UserInstStubWrapper WINELIB_NAME_AW(UserInstStubWrapper)
HRESULT WINAPI UserUnInstStubWrapperA(HWND hWnd, HINSTANCE hInstance, LPSTR pszParms, INT nShow);
HRESULT WINAPI UserUnInstStubWrapperW(HWND hWnd, HINSTANCE hInstance, LPWSTR pszParms, INT nShow);
#define UserUnInstStubWrapper WINELIB_NAME_AW(UserUnInstStubWrapper)
#ifdef __cplusplus
}
#endif
#endif /* __WINE_ADVPUB_H */

100
assets/wine/include/wine/windows/af_irda.h
View File

@@ -1,100 +0,0 @@
/*
* Copyright 2009 Juan Lang
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef AF_IRDA_H
#define AF_IRDA_H
typedef struct _IRDA_DEVICE_INFO
{
UCHAR irdaDeviceID[4];
char irdaDeviceName[22];
UCHAR irdaDeviceHints1;
UCHAR irdaDeviceHints2;
UCHAR irdaCharSet;
} IRDA_DEVICE_INFO, *PIRDA_DEVICE_INFO;
typedef struct _DEVICELIST
{
ULONG numDevice;
IRDA_DEVICE_INFO Device[1];
} DEVICELIST, *PDEVICELIST;
typedef struct _SOCKADDR_IRDA
{
USHORT irdaAddressFamily;
UCHAR irdaDeviceID[4];
char irdaServiceName[25];
} SOCKADDR_IRDA, *PSOCKADDR_IRDA, *LPSOCKADDR_IRDA;
#ifdef USE_WS_PREFIX
/* Socket levels and options */
#define WS_SOL_IRLMP 0xff
#define WS_IRLMP_ENUMDEVICES ((ULONG)0x10)
#define WS_IRLMP_IAS_SET ((ULONG)0x11)
#define WS_IRLMP_IAS_QUERY ((ULONG)0x12)
#define WS_IRLMP_SEND_PDU_LEN ((ULONG)0x13)
#define WS_IRLMP_EXCLUSIVE_MODE ((ULONG)0x14)
#define WS_IRLMP_IRLPT_MODE ((ULONG)0x15)
#define WS_IRLMP_9WIRE_MODE ((ULONG)0x16)
#define WS_IRLMP_TINYTP_MODE ((ULONG)0x17)
#define WS_IRLMP_PARAMETERS ((ULONG)0x18)
#define WS_IRLMP_DISCOVER_MODE ((ULONG)0x19)
#define WS_IRLMP_SHARP_MODE ((ULONG)0x20)
#define WS_IAS_MAX_CLASSNAME 64
#define WS_IAS_MAX_ATTRIBNAME 256
#else
/* Socket levels and options */
#define SOL_IRLMP 0xff
#define IRLMP_ENUMDEVICES ((ULONG)0x10)
#define IRLMP_IAS_SET ((ULONG)0x11)
#define IRLMP_IAS_QUERY ((ULONG)0x12)
#define IRLMP_SEND_PDU_LEN ((ULONG)0x13)
#define IRLMP_EXCLUSIVE_MODE ((ULONG)0x14)
#define IRLMP_IRLPT_MODE ((ULONG)0x15)
#define IRLMP_9WIRE_MODE ((ULONG)0x16)
#define IRLMP_TINYTP_MODE ((ULONG)0x17)
#define IRLMP_PARAMETERS ((ULONG)0x18)
#define IRLMP_DISCOVER_MODE ((ULONG)0x19)
#define IRLMP_SHARP_MODE ((ULONG)0x20)
#define IAS_MAX_CLASSNAME 64
#define IAS_MAX_ATTRIBNAME 256
#endif
#define IAS_MAX_OCTET_STRING 1024
#define IAS_MAX_USER_STRING 256
#define LmCharSetASCII 0x00
#define LmCharSetISO_8859_1 0x01
#define LmCharSetISO_8859_2 0x02
#define LmCharSetISO_8859_3 0x03
#define LmCharSetISO_8859_4 0x04
#define LmCharSetISO_8859_5 0x05
#define LmCharSetISO_8859_6 0x06
#define LmCharSetISO_8859_7 0x07
#define LmCharSetISO_8859_8 0x08
#define LmCharSetISO_8859_9 0x09
#define LmCharSetUNICODE 0xff
#endif /* AF_IRDA_H */

36
assets/wine/include/wine/windows/afunix.h
View File

@@ -1,36 +0,0 @@
/*
* Copyright 2023 Ally Sommers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef _WS2AFUNIX_
#define _WS2AFUNIX_
#ifdef USE_WS_PREFIX
# define WS(x) WS_##x
#else
# define WS(x) x
#endif
#define UNIX_PATH_MAX 108
typedef struct WS(sockaddr_un)
{
ADDRESS_FAMILY sun_family;
char sun_path[UNIX_PATH_MAX];
} SOCKADDR_UN, *PSOCKADDR_UN;
#endif /* _WS2AFUNIX_ */

47
assets/wine/include/wine/windows/amaudio.h
View File

@@ -1,47 +0,0 @@
/*
* Copyright (C) 2010 Maarten Lankhorst for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __AMAUDIO__
#define __AMAUDIO__
#include <mmsystem.h>
#include <dsound.h>
#undef INTERFACE
#define INTERFACE IAMDirectSound
DECLARE_INTERFACE_(IAMDirectSound,IUnknown)
{
/*** IUnknown methods ***/
STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
STDMETHOD_(ULONG,AddRef)(THIS) PURE;
STDMETHOD_(ULONG,Release)(THIS) PURE;
/*** IAMDirectSound methods ***/
STDMETHOD(GetDirectSoundInterface)(THIS_ IDirectSound **ds) PURE;
STDMETHOD(GetPrimaryBufferInterface)(THIS_ IDirectSoundBuffer **buf) PURE;
STDMETHOD(GetSecondaryBufferInterface)(THIS_ IDirectSoundBuffer **buf) PURE;
STDMETHOD(ReleaseDirectSoundInterface)(THIS_ IDirectSound *ds) PURE;
STDMETHOD(ReleasePrimaryBufferInterface)(THIS_ IDirectSoundBuffer *buf) PURE;
STDMETHOD(ReleaseSecondaryBufferInterface)(THIS_ IDirectSoundBuffer *buf) PURE;
STDMETHOD(SetFocusWindow)(THIS_ HWND hwnd, BOOL bgaudible) PURE;
STDMETHOD(GetFocusWindow)(THIS_ HWND *hwnd, BOOL *bgaudible) PURE;
};
#undef INTERFACE
#endif

52
assets/wine/include/wine/windows/amsi.h
View File

@@ -1,52 +0,0 @@
/*** Autogenerated by WIDL 10.17 from /home/runner/build_wine/wine/include/amsi.idl - Do not edit ***/
#ifdef _WIN32
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include <rpc.h>
#include <rpcndr.h>
#endif
#ifndef COM_NO_WINDOWS_H
#include <windows.h>
#include <ole2.h>
#endif
#ifndef __amsi_h__
#define __amsi_h__
/* Forward declarations */
/* Headers for imported files */
#ifdef __cplusplus
extern "C" {
#endif
DECLARE_HANDLE(HAMSICONTEXT);
DECLARE_HANDLE(HAMSISESSION);
typedef enum AMSI_RESULT {
AMSI_RESULT_CLEAN = 0x0,
AMSI_RESULT_NOT_DETECTED = 0x1,
AMSI_RESULT_BLOCKED_BY_ADMIN_START = 0x4000,
AMSI_RESULT_BLOCKED_BY_ADMIN_END = 0x4fff,
AMSI_RESULT_DETECTED = 0x8000
} AMSI_RESULT;
void WINAPI AmsiCloseSession(HAMSICONTEXT,HAMSISESSION);
HRESULT WINAPI AmsiInitialize(const WCHAR*,HAMSICONTEXT*);
HRESULT WINAPI AmsiOpenSession(HAMSICONTEXT,HAMSISESSION*);
HRESULT WINAPI AmsiScanBuffer(HAMSICONTEXT,void*,ULONG,const WCHAR*,HAMSISESSION,AMSI_RESULT*);
HRESULT WINAPI AmsiScanString(HAMSICONTEXT,const WCHAR*,const WCHAR *,HAMSISESSION,AMSI_RESULT*);
void WINAPI AmsiUninitialize(HAMSICONTEXT);
/* Begin additional prototypes for all interfaces */
/* End additional prototypes */
#ifdef __cplusplus
}
#endif
#endif /* __amsi_h__ */

36
assets/wine/include/wine/windows/amsi.idl
View File

@@ -1,36 +0,0 @@
/*
* Copyright 2019 Hans Leidekker for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
cpp_quote("DECLARE_HANDLE(HAMSICONTEXT);")
cpp_quote("DECLARE_HANDLE(HAMSISESSION);")
typedef [v1_enum] enum AMSI_RESULT
{
AMSI_RESULT_CLEAN = 0x00,
AMSI_RESULT_NOT_DETECTED = 0x01,
AMSI_RESULT_BLOCKED_BY_ADMIN_START = 0x4000,
AMSI_RESULT_BLOCKED_BY_ADMIN_END = 0x4fff,
AMSI_RESULT_DETECTED = 0x8000,
} AMSI_RESULT;
cpp_quote("void WINAPI AmsiCloseSession(HAMSICONTEXT,HAMSISESSION);")
cpp_quote("HRESULT WINAPI AmsiInitialize(const WCHAR*,HAMSICONTEXT*);")
cpp_quote("HRESULT WINAPI AmsiOpenSession(HAMSICONTEXT,HAMSISESSION*);")
cpp_quote("HRESULT WINAPI AmsiScanBuffer(HAMSICONTEXT,void*,ULONG,const WCHAR*,HAMSISESSION,AMSI_RESULT*);")
cpp_quote("HRESULT WINAPI AmsiScanString(HAMSICONTEXT,const WCHAR*,const WCHAR *,HAMSISESSION,AMSI_RESULT*);")
cpp_quote("void WINAPI AmsiUninitialize(HAMSICONTEXT);")

1757
assets/wine/include/wine/windows/amstream.h
View File

File diff suppressed because it is too large Load Diff

318
assets/wine/include/wine/windows/amstream.idl
View File

@@ -1,318 +0,0 @@
/*
* Copyright 2004 Christian Costa
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
import "unknwn.idl";
import "mmstream.idl";
import "strmif.idl";
cpp_quote("#include <ddraw.h>")
cpp_quote("#include <mmsystem.h>")
cpp_quote("#include <mmstream.h>")
cpp_quote("#include <ddstream.h>")
cpp_quote("#include <austream.h>")
cpp_quote("#if 0")
interface IDirectDraw;
interface IDirectDrawSurface;
cpp_quote("#endif")
interface IAMMultiMediaStream;
interface IAMMediaStream;
interface IMediaStreamFilter;
interface IAMMediaTypeStream;
interface IAMMediaTypeSample;
enum {
AMMSF_NOGRAPHTHREAD = 0x00000001
};
enum {
AMMSF_ADDDEFAULTRENDERER = 0x00000001,
AMMSF_CREATEPEER = 0x00000002,
AMMSF_STOPIFNOSAMPLES = 0x00000004,
AMMSF_NOSTALL = 0x00000008
};
enum {
AMMSF_RENDERTYPEMASK = 0x00000003,
AMMSF_RENDERTOEXISTING = 0x00000000,
AMMSF_RENDERALLSTREAMS = 0x00000001,
AMMSF_NORENDER = 0x00000002,
AMMSF_NOCLOCK = 0x00000004,
AMMSF_RUN = 0x00000008
};
typedef [v1_enum] enum {
Disabled = 0,
ReadData = 1,
RenderData = 2
} OUTPUT_STATE;
[
object,
uuid(7DB01C96-C0C3-11d0-8FF1-00C04FD9189D),
dual,
helpstring("IDirectShowStream Interface"),
pointer_default(unique)
]
interface IDirectShowStream : IDispatch
{
[propget, id(1), helpstring("property FileName")] HRESULT FileName([out, retval] BSTR *pVal);
[propput, id(1), helpstring("property FileName")] HRESULT FileName([in] BSTR newVal);
[propget, id(2), helpstring("property Video")] HRESULT Video([out, retval] OUTPUT_STATE *pVal);
[propput, id(2), helpstring("property Video")] HRESULT Video([in] OUTPUT_STATE newVal);
[propget, id(3), helpstring("property Audio")] HRESULT Audio([out, retval] OUTPUT_STATE *pVal);
[propput, id(3), helpstring("property Audio")] HRESULT Audio([in] OUTPUT_STATE newVal);
}
[
object,
uuid(BEBE595C-9A6F-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IAMMultiMediaStream : IMultiMediaStream
{
HRESULT Initialize(
[in] STREAM_TYPE StreamType,
[in] DWORD dwFlags,
[in] IGraphBuilder *pFilterGraph);
HRESULT GetFilterGraph(
[out] IGraphBuilder **ppGraphBuilder);
HRESULT GetFilter(
[out] IMediaStreamFilter **ppFilter);
HRESULT AddMediaStream(
[in] IUnknown *pStreamObject,
[in] const MSPID *PurposeId,
[in] DWORD dwFlags,
[out] IMediaStream **ppNewStream);
HRESULT OpenFile(
[in] LPCWSTR pszFileName,
[in] DWORD dwFlags);
HRESULT OpenMoniker(
[in] IBindCtx *pCtx,
[in] IMoniker *pMoniker,
[in] DWORD dwFlags);
HRESULT Render(
[in] DWORD dwFlags);
}
[
object,
uuid(BEBE595D-9A6F-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IAMMediaStream : IMediaStream
{
HRESULT Initialize(
[in] IUnknown *pSourceObject,
[in] DWORD dwFlags,
[in] REFMSPID PurposeId,
[in] const STREAM_TYPE StreamType);
HRESULT SetState(
[in] FILTER_STATE State);
HRESULT JoinAMMultiMediaStream(
[in] IAMMultiMediaStream *pAMMultiMediaStream);
HRESULT JoinFilter(
[in] IMediaStreamFilter *pMediaStreamFilter);
HRESULT JoinFilterGraph(
[in] IFilterGraph *pFilterGraph);
}
[
object,
local,
uuid(BEBE595E-9A6F-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IMediaStreamFilter : IBaseFilter
{
HRESULT AddMediaStream(
[in] IAMMediaStream *pAMMediaStream);
HRESULT GetMediaStream(
[in] REFMSPID idPurpose,
[out] IMediaStream **ppMediaStream);
HRESULT EnumMediaStreams(
[in] long Index,
[out] IMediaStream **ppMediaStream);
HRESULT SupportSeeking(
[in] BOOL bRenderer);
HRESULT ReferenceTimeToStreamTime(
[in] [out] REFERENCE_TIME *pTime);
HRESULT GetCurrentStreamTime(
[out] REFERENCE_TIME *pCurrentStreamTime);
HRESULT WaitUntil(
[in] REFERENCE_TIME WaitStreamTime);
HRESULT Flush(
[in] BOOL bCancelEOS);
HRESULT EndOfStream();
}
[
object,
local,
uuid(AB6B4AFC-F6E4-11d0-900D-00C04FD9189D),
pointer_default(unique)
]
interface IDirectDrawMediaSampleAllocator : IUnknown
{
HRESULT GetDirectDraw(IDirectDraw **ppDirectDraw);
}
[
object,
local,
uuid(AB6B4AFE-F6E4-11d0-900D-00C04FD9189D),
pointer_default(unique)
]
interface IDirectDrawMediaSample : IUnknown
{
HRESULT GetSurfaceAndReleaseLock(
[out] IDirectDrawSurface **ppDirectDrawSurface,
[out] RECT * pRect);
HRESULT LockMediaSamplePointer(void);
}
[
object,
local,
uuid(AB6B4AFA-F6E4-11d0-900D-00C04FD9189D),
pointer_default(unique)
]
interface IAMMediaTypeStream : IMediaStream
{
HRESULT GetFormat(
[out] AM_MEDIA_TYPE * pMediaType,
[in] DWORD dwFlags);
HRESULT SetFormat(
[in] AM_MEDIA_TYPE * pMediaType,
[in] DWORD dwFlags);
HRESULT CreateSample(
[in] long lSampleSize,
[in] BYTE * pbBuffer,
[in] DWORD dwFlags,
[in] IUnknown *pUnkOuter,
[out] IAMMediaTypeSample ** ppAMMediaTypeSample);
HRESULT GetStreamAllocatorRequirements(
[out] ALLOCATOR_PROPERTIES *pProps);
HRESULT SetStreamAllocatorRequirements(
[in] ALLOCATOR_PROPERTIES *pProps);
}
[
object,
local,
uuid(AB6B4AFB-F6E4-11d0-900D-00C04FD9189D),
pointer_default(unique)
]
interface IAMMediaTypeSample : IStreamSample
{
HRESULT SetPointer(
[in] BYTE *pBuffer,
[in] long lSize);
HRESULT GetPointer(
[out] BYTE ** ppBuffer);
long GetSize(void);
HRESULT GetTime(
[out] REFERENCE_TIME * pTimeStart,
[out] REFERENCE_TIME * pTimeEnd);
HRESULT SetTime(
[in] REFERENCE_TIME * pTimeStart,
[in] REFERENCE_TIME * pTimeEnd);
HRESULT IsSyncPoint(void);
HRESULT SetSyncPoint(
BOOL bIsSyncPoint);
HRESULT IsPreroll(void);
HRESULT SetPreroll(
BOOL bIsPreroll);
long GetActualDataLength(void);
HRESULT SetActualDataLength(long Len);
HRESULT GetMediaType(
AM_MEDIA_TYPE **ppMediaType);
HRESULT SetMediaType(
AM_MEDIA_TYPE *pMediaType);
HRESULT IsDiscontinuity(void);
HRESULT SetDiscontinuity(
BOOL bDiscontinuity);
HRESULT GetMediaTime(
[out] LONGLONG * pTimeStart,
[out] LONGLONG * pTimeEnd);
HRESULT SetMediaTime(
[in] LONGLONG * pTimeStart,
[in] LONGLONG * pTimeEnd);
}
[
uuid(49C47CE5-9BA4-11d0-8212-00C04FC32C45)
]
coclass AMMultiMediaStream
{
[default] dispinterface IDirectShowStream;
}
cpp_quote("DEFINE_GUID(CLSID_AMDirectDrawStream, 0x49c47ce4, 0x9ba4, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
cpp_quote("DEFINE_GUID(CLSID_AMAudioStream, 0x8496e040, 0xaf4c, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
cpp_quote("DEFINE_GUID(CLSID_AMAudioData, 0xf2468580, 0xaf8a, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
cpp_quote("DEFINE_GUID(CLSID_AMMediaTypeStream, 0xcf0f2f7c, 0xf7bf, 0x11d0, 0x90, 0x0d, 0x00, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);")
cpp_quote("DEFINE_GUID(CLSID_MediaStreamFilter, 0x49c47ce0, 0x9ba4, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")

74
assets/wine/include/wine/windows/amva.h
View File

@@ -1,74 +0,0 @@
/*
* Copyright (C) 2022 Zebediah Figura for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __AMVA_INCLUDED__
#define __AMVA_INCLUDED__
typedef struct _tag_AMVABeginFrameInfo
{
DWORD dwDestSurfaceIndex;
void *pInputData;
DWORD dwSizeInputData;
void *pOutputData;
DWORD dwSizeOutputData;
} AMVABeginFrameInfo, *LPAMVABeginFrameInfo;
typedef struct _tag_AMVABUFFERINFO
{
DWORD dwTypeIndex;
DWORD dwBufferIndex;
DWORD dwDataOffset;
DWORD dwDataSize;
} AMVABUFFERINFO, *LPAMVABUFFERINFO;
typedef struct _tag_AMVACompBufferInfo
{
DWORD dwNumCompBuffers;
DWORD dwWidthToCreate;
DWORD dwHeightToCreate;
DWORD dwBytesToAllocate;
DDSCAPS2 ddCompCaps;
DDPIXELFORMAT ddPixelFormat;
} AMVACompBufferInfo, *LPAMVACompBufferInfo;
typedef struct _tag_AMVAEndFrameInfo
{
DWORD dwSizeMiscData;
void *pMiscData;
} AMVAEndFrameInfo, *LPAMVAEndFrameInfo;
typedef struct _tag_AMVAInternalMemInfo
{
DWORD dwScratchMemAlloc;
} AMVAInternalMemInfo, *LPAMVAInternalMemInfo;
typedef struct _tag_AMVAUncompBufferInfo
{
DWORD dwMinNumSurfaces;
DWORD dwMaxNumSurfaces;
DDPIXELFORMAT ddUncompPixelFormat;
} AMVAUncompBufferInfo, *LPAMVAUncompBufferInfo;
typedef struct _tag_AMVAUncompDataInfo
{
DWORD dwUncompWidth;
DWORD dwUncompHeight;
DDPIXELFORMAT ddUncompPixelFormat;
} AMVAUncompDataInfo, *LPAMVAUncompDataInfo;
#endif

1195
assets/wine/include/wine/windows/amvideo.h
View File

File diff suppressed because it is too large Load Diff

241
assets/wine/include/wine/windows/amvideo.idl
View File

@@ -1,241 +0,0 @@
/*
* Copyright (C) 2003 Robert Shearman
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
import "objidl.idl";
/* trick widl into thinking that it knows the DirectDraw types
* as there is no IDL file for them (yet) */
cpp_quote("#if 0")
interface IDirectDraw;
typedef void DDSURFACEDESC,DDCAPS;
typedef DWORD RGBQUAD;
typedef LONGLONG REFERENCE_TIME;
typedef struct
{
DWORD biSize;
LONG biWidth;
LONG biHeight;
WORD biPlanes;
WORD biBitCount;
DWORD biCompression;
DWORD biSizeImage;
LONG biXPelsPerMeter;
LONG biYPelsPerMeter;
DWORD biClrUsed;
DWORD biClrImportant;
} BITMAPINFOHEADER, *PBITMAPINFOHEADER, *LPBITMAPINFOHEADER;
cpp_quote("#endif")
cpp_quote("#include <ddraw.h>")
cpp_quote("#define AMDDS_NONE 0x00")
cpp_quote("#define AMDDS_DCIPS 0x01")
cpp_quote("#define AMDDS_PS 0x02")
cpp_quote("#define AMDDS_RGBOVR 0x04")
cpp_quote("#define AMDDS_YUVOVR 0x08")
cpp_quote("#define AMDDS_RGBOFF 0x10")
cpp_quote("#define AMDDS_YUVOFF 0x20")
cpp_quote("#define AMDDS_RGBFLP 0x40")
cpp_quote("#define AMDDS_YUVFLP 0x80")
cpp_quote("#define AMDDS_ALL 0xFF")
cpp_quote("#define AMDDS_DEFAULT AMDDS_ALL")
cpp_quote("#define AMDDS_YUV (AMDDS_YUVOFF | AMDDS_YUVOVR | AMDDS_YUVFLP)")
cpp_quote("#define AMDDS_RGB (AMDDS_RGBOFF | AMDDS_RGBOVR | AMDDS_RGBFLP)")
cpp_quote("#define AMDSS_PRIMARY (AMDDS_DCIPS | AMDDS_PS)")
[
object,
/* uuid(36d39eb0-dd75-11ce-bf0e-00aa0055595a) conflicts with uuids.h */
pointer_default(unique),
local
]
interface IDirectDrawVideo : IUnknown
{
HRESULT GetSwitches([out] DWORD * pSwitches);
HRESULT SetSwitches([in] DWORD Switches);
HRESULT GetCaps([out] DDCAPS * pCaps);
HRESULT GetEmulatedCaps([out] DDCAPS *pCaps);
HRESULT GetSurfaceDesc([out] DDSURFACEDESC * pSurfaceDesc);
HRESULT GetFourCCCodes([out] DWORD * pCount, [out] DWORD * pCodes);
HRESULT SetDirectDraw([in] IDirectDraw *ddraw);
HRESULT GetDirectDraw([out] IDirectDraw **ddraw);
HRESULT GetSurfaceType([out] DWORD * pSurfaceType);
HRESULT SetDefault();
HRESULT UseScanLine([in] long UseScanLine);
HRESULT CanUseScanLine([out] long * UseScanLine);
HRESULT UseOverlayStretch([in] long UseOverlayStretch);
HRESULT CanUseOverlayStretch([out] long * UseOverlayStretch);
HRESULT UseWhenFullScreen([in] long UseWhenFullScreen);
HRESULT WillUseFullScreen([out] long * UseWhenFullScreen);
}
[
object,
/* uuid(1bd0ecb0-f8e2-11ce-aac6-0020af0b99a3) conflicts with uuids.h */
pointer_default(unique),
local
]
interface IQualProp : IUnknown
{
[propget] HRESULT FramesDroppedInRenderer([out] int * pcFrames);
[propget] HRESULT FramesDrawn([out] int * pcFramesDrawn);
[propget] HRESULT AvgFrameRate([out] int * piAvgFrameRate);
[propget] HRESULT Jitter([out] int * iJitter);
[propget] HRESULT AvgSyncOffset([out] int * piAvg);
[propget] HRESULT DevSyncOffset([out] int * piDev);
}
[
object,
/* uuid(dd1d7110-7836-11cf-bf47-00aa0055595a) conflicts with uuids.h */
pointer_default(unique)
]
interface IFullScreenVideo : IUnknown
{
HRESULT CountModes([out] long * pModes);
HRESULT GetModeInfo([in] long Mode, [out] long * pWidth, [out] long * pHeight, [out] long * pDepth);
HRESULT GetCurrentMode([out] long * pMode);
HRESULT IsModeAvailable([in] long Mode);
HRESULT IsModeEnabled([in] long Mode);
HRESULT SetEnabled([in] long Mode, [in] long bEnabled);
HRESULT GetClipFactor([out] long * pClipFactor);
HRESULT SetClipFactor([in] long ClipFactor);
HRESULT SetMessageDrain([in] HWND hwnd);
HRESULT GetMessageDrain([out] HWND * hwnd);
HRESULT SetMonitor([in] long Monitor);
HRESULT GetMonitor([out] long * Monitor);
HRESULT HideOnDeactivate([in] long Hide);
HRESULT IsHideOnDeactivate();
HRESULT SetCaption([in] BSTR strCaption);
HRESULT GetCaption([out] BSTR * pstrCaption);
HRESULT SetDefault();
}
[
object,
/* uuid(53479470-f1dd-11cf-bc42-00aa00ac74f6) conflicts with uuids.h */
pointer_default(unique),
local
]
interface IFullScreenVideoEx : IFullScreenVideo
{
HRESULT SetAcceleratorTable([in] HWND hwnd, [in] HACCEL hAccel);
HRESULT GetAcceleratorTable([out] HWND * phwnd, [out] HACCEL * phAccel);
HRESULT KeepPixelAspectRatio([in] long KeepAspect);
/* FIXME: not sure is this next method is an [out] */
HRESULT IsKeepPixelAspectRatio([out] long * pKeepAspect);
}
[
object,
/* uuid(61ded640-e912-11ce-a099-00aa00479a58) conflicts with uuids.h */
pointer_default(unique),
local
]
interface IBaseVideoMixer : IUnknown
{
HRESULT SetLeadPin([in] int iPin);
HRESULT GetLeadPin([out] int * piPin);
HRESULT GetInputPinCount([out] int * piPinCount);
HRESULT IsUsingClock([out] int * pbValue);
HRESULT SetUsingClock([in] int bValue);
HRESULT GetClockPeriod([out] int * pbValue);
HRESULT SetClockPeriod([in] int bValue);
}
#define iPALETTE_COLORS 256
#define iMASK_COLORS 3
cpp_quote("#define iPALETTE_COLORS 256")
cpp_quote("#define iEGA_COLORS 16")
cpp_quote("#define iMASK_COLORS 3")
cpp_quote("#define iTRUECOLOR 16")
cpp_quote("#define iRED 0")
cpp_quote("#define iGREEN 1")
cpp_quote("#define iBLUE 2")
cpp_quote("#define iPALETTE 8")
cpp_quote("#define iMAXBITS 8")
typedef struct tag_TRUECOLORINFO
{
DWORD dwBitMasks[iMASK_COLORS];
RGBQUAD bmiColors[iPALETTE_COLORS];
} TRUECOLORINFO;
typedef struct tagVIDEOINFOHEADER
{
RECT rcSource;
RECT rcTarget;
DWORD dwBitRate;
DWORD dwBitErrorRate;
REFERENCE_TIME AvgTimePerFrame;
BITMAPINFOHEADER bmiHeader;
} VIDEOINFOHEADER;
typedef struct tagVIDEOINFO
{
RECT rcSource;
RECT rcTarget;
DWORD dwBitRate;
DWORD dwBitErrorRate;
REFERENCE_TIME AvgTimePerFrame;
BITMAPINFOHEADER bmiHeader;
union
{
RGBQUAD bmiColors[iPALETTE_COLORS];
DWORD dwBitMasks[iMASK_COLORS];
TRUECOLORINFO TrueColorInfo;
};
} VIDEOINFO;
typedef struct tagMPEG1VIDEOINFO
{
VIDEOINFOHEADER hdr;
DWORD dwStartTimeCode;
DWORD cbSequenceHeader;
BYTE bSequenceHeader[1];
} MPEG1VIDEOINFO;
cpp_quote("#define MAX_SIZE_MPEG1_SEQUENCE_INFO 140")
cpp_quote("#define MPEG1_SEQUENCE_INFO(pv) ((const BYTE *)(pv)->bSequenceHeader)")
typedef struct tagAnalogVideoInfo
{
RECT rcSource;
RECT rcTarget;
DWORD dwActiveWidth;
DWORD dwActiveHeight;
REFERENCE_TIME AvgTimePerFrame;
} ANALOGVIDEOINFO;
typedef enum
{
AM_PROPERTY_FRAMESTEP_STEP = 0x01,
AM_PROPERTY_FRAMESTEP_CANCEL = 0x02,
AM_PROPERTY_FRAMESTEP_CANSTEP = 0x03,
AM_PROPERTY_FRAMESTEP_CANSTEPMULTIPLE = 0x04
} AM_PROPERTY_FRAMESTEP;
typedef struct _AM_FRAMESTEP_STEP
{
DWORD dwFramesToStep;
} AM_FRAMESTEP_STEP;

32
assets/wine/include/wine/windows/appcompatapi.h
View File

@@ -1,32 +0,0 @@
/*
* Copyright 2012 Detlef Riekenberg
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __APPCOMPAT_H
#define __APPCOMPAT_H
#ifdef __cplusplus
extern "C" {
#endif
BOOL WINAPI ApphelpCheckShellObject(REFCLSID, BOOL, ULONGLONG *);
#ifdef __cplusplus
}
#endif
#endif /* __APPCOMPAT_H */

54
assets/wine/include/wine/windows/appmgmt.h
View File

@@ -1,54 +0,0 @@
/*
* Copyright (C) 2005 Mike McCormack
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef _APPMGMT_H
#define _APPMGMT_H
typedef struct _MANAGEDAPPLICATION
{
LPWSTR pszPackageName;
LPWSTR pszPublisher;
DWORD dwVersionHi;
DWORD dwVersionLo;
DWORD dwRevision;
GUID GpoId;
LPWSTR pszPolicyName;
GUID ProductId;
LANGID Language;
LPWSTR pszOwner;
LPWSTR pszCompany;
LPWSTR pszComments;
LPWSTR pszContact;
LPWSTR pszSupportUrl;
DWORD dwPathType;
BOOL bInstalled;
} MANAGEDAPPLICATION, *PMANAGEDAPPLICATION;
#ifdef __cplusplus
extern "C" {
#endif
DWORD WINAPI CommandLineFromMsiDescriptor(WCHAR*,WCHAR*,DWORD*);
DWORD WINAPI GetManagedApplications(GUID*,DWORD,DWORD,LPDWORD,PMANAGEDAPPLICATION*);
#ifdef __cplusplus
}
#endif
#endif /* _APPMGMT_H */

Some files were not shown because too many files have changed in this diff Show More